128 lines
3.0 KiB
C
128 lines
3.0 KiB
C
/*
|
|
SST_Semaphore_Solaris.c
|
|
Author: Patrick Baggett <ptbaggett@762studios.com>
|
|
Created: 4/11/2012
|
|
|
|
Purpose:
|
|
|
|
libsst-concurrency semaphore functions using native Solaris semaphores
|
|
|
|
License:
|
|
|
|
This program is free software. It comes without any warranty, to
|
|
the extent permitted by applicable law. You can redistribute it
|
|
and/or modify it under the terms of the Do What The Fuck You Want
|
|
To Public License, Version 2, as published by Sam Hocevar. See
|
|
http://sam.zoy.org/wtfpl/COPYING for more details.
|
|
|
|
*/
|
|
|
|
#include <SST/SST_Concurrency.h>
|
|
#include <SST/SST_Semaphore.h>
|
|
#include <synch.h> /* native Solaris semaphores */
|
|
#include <time.h>
|
|
#include <stdlib.h> /* malloc()/free() */
|
|
#include <errno.h> /* errno */
|
|
#include "timespecadd.h" /* add struct timespec */
|
|
|
|
/******************************************************************************/
|
|
|
|
SST_Semaphore SST_Concurrency_CreateSemaphore(uint32_t _initialCount)
|
|
{
|
|
|
|
sema_t* sema = (sema_t*)malloc(sizeof(sema_t));
|
|
|
|
if(sema)
|
|
{
|
|
if(sema_init(sema, (unsigned int)_initialCount, USYNC_THREAD, NULL) == 0)
|
|
return (SST_Semaphore)sema;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void SST_Concurrency_DestroySemaphore(SST_Semaphore _sema)
|
|
{
|
|
sema_t* sema = (sema_t*)_sema;
|
|
sema_destroy(sema);
|
|
free(sema);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
void SST_Concurrency_PostSemaphore(SST_Semaphore _sema, uint32_t _count)
|
|
{
|
|
sema_t* sema = (sema_t*)_sema;
|
|
while(_count)
|
|
{
|
|
/* sema_post() only allows 1 increment, so loop */
|
|
sema_post(sema);
|
|
_count--;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
int SST_Concurrency_WaitSemaphore(SST_Semaphore _sema, uint32_t _ticks)
|
|
{
|
|
int result = 0;
|
|
sema_t* sema = (sema_t*)_sema;
|
|
int ok;
|
|
|
|
if(_ticks == SST_WAIT_INFINITE)
|
|
{
|
|
/* Wait in a loop until we get a value OTHER than EINTR,
|
|
or the function succeeds.
|
|
Basically, EINTR means a signal interrupted this function,
|
|
so we can retry the wait */
|
|
do
|
|
{
|
|
ok = sema_wait(sema);
|
|
if(ok == 0)
|
|
break;
|
|
|
|
} while(errno == EINTR);
|
|
|
|
/* sema_wait() returns 0 on success, so see if successful */
|
|
result = (ok == 0);
|
|
}
|
|
else /* Maximum wait measured in milliseconds */
|
|
{
|
|
struct timespec ts, tswait;
|
|
|
|
/* get absolute time in the future */
|
|
clock_gettime(CLOCK_REALTIME, &ts);
|
|
tswait.tv_sec = (_ticks / 1000);
|
|
tswait.tv_nsec = (_ticks % 1000) * 1000 * 1000;
|
|
|
|
_sst_add_timespec(&ts, &tswait);
|
|
/* EINTR = signal interrupted the function. Loop until we get
|
|
something other than a signal interruption */
|
|
do
|
|
{
|
|
ok = sema_timedwait(sema, &ts);
|
|
if(ok == 0)
|
|
break;
|
|
} while(errno == EINTR);
|
|
|
|
/* Either success or timeout, trap legitimate errors (which
|
|
are due to invalid conditions -> bug) */
|
|
if(ok < 0 && errno != ETIMEDOUT)
|
|
{
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
/* If this returned success, then save that result
|
|
as TRUE */
|
|
result = (ok == 0);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|