Initial commit

libsst-concurrency/SST_Semaphore_Solaris.c

@@ -0,0 +1,127 @@
+/*
+	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;
+}
+
+