thirdparty/paho.mqtt.c/src/Thread.c - nifi-minifi-cpp - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 2017 IBM Corp.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * and Eclipse Distribution License v1.0 which accompany this distribution.
  *
  * The Eclipse Public License is available at
  *    http://www.eclipse.org/legal/epl-v10.html
  * and the Eclipse Distribution License is available at
  *   http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * Contributors:
  *    Ian Craggs - initial implementation
  *    Ian Craggs, Allan Stockdill-Mander - async client updates
  *    Ian Craggs - bug #415042 - start Linux thread as disconnected
  *    Ian Craggs - fix for bug #420851
  *    Ian Craggs - change MacOS semaphore implementation
  *******************************************************************************/

 /**
  * @file
  * \brief Threading related functions
  *
  * Used to create platform independent threading functions
  */


 #include "Thread.h"
 #if defined(THREAD_UNIT_TESTS)
 #define NOSTACKTRACE
 #endif
 #include "StackTrace.h"

 #undef malloc
 #undef realloc
 #undef free

 #if !defined(WIN32) && !defined(WIN64)
 #include <errno.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <limits.h>
 #endif
 #include <stdlib.h>

 #include "OsWrapper.h"

 /**
  * Start a new thread
  * @param fn the function to run, must be of the correct signature
  * @param parameter pointer to the function parameter, can be NULL
  * @return the new thread
  */
 thread_type Thread_start(thread_fn fn, void* parameter)
 {
 #if defined(WIN32) || defined(WIN64)
 	thread_type thread = NULL;
 #else
 	thread_type thread = 0;
 	pthread_attr_t attr;
 #endif

 	FUNC_ENTRY;
 #if defined(WIN32) || defined(WIN64)
 	thread = CreateThread(NULL, 0, fn, parameter, 0, NULL);
 #else
 	pthread_attr_init(&attr);
 	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 	if (pthread_create(&thread, &attr, fn, parameter) != 0)
 		thread = 0;
 	pthread_attr_destroy(&attr);
 #endif
 	FUNC_EXIT;
 	return thread;
 }


 /**
  * Create a new mutex
  * @return the new mutex
  */
 mutex_type Thread_create_mutex(void)
 {
 	mutex_type mutex = NULL;
 	int rc = 0;

 	FUNC_ENTRY;
 	#if defined(WIN32) || defined(WIN64)
 		mutex = CreateMutex(NULL, 0, NULL);
 		if (mutex == NULL)
 			rc = GetLastError();
 	#else
 		mutex = malloc(sizeof(pthread_mutex_t));
 		rc = pthread_mutex_init(mutex, NULL);
 	#endif
 	FUNC_EXIT_RC(rc);
 	return mutex;
 }


 /**
  * Lock a mutex which has alrea
  * @return completion code, 0 is success
  */
 int Thread_lock_mutex(mutex_type mutex)
 {
 	int rc = -1;

 	/* don't add entry/exit trace points as the stack log uses mutexes - recursion beckons */
 	#if defined(WIN32) || defined(WIN64)
 		/* WaitForSingleObject returns WAIT_OBJECT_0 (0), on success */
 		rc = WaitForSingleObject(mutex, INFINITE);
 	#else
 		rc = pthread_mutex_lock(mutex);
 	#endif

 	return rc;
 }


 /**
  * Unlock a mutex which has already been locked
  * @param mutex the mutex
  * @return completion code, 0 is success
  */
 int Thread_unlock_mutex(mutex_type mutex)
 {
 	int rc = -1;

 	/* don't add entry/exit trace points as the stack log uses mutexes - recursion beckons */
 	#if defined(WIN32) || defined(WIN64)
 		/* if ReleaseMutex fails, the return value is 0 */
 		if (ReleaseMutex(mutex) == 0)
 			rc = GetLastError();
 		else
 			rc = 0;
 	#else
 		rc = pthread_mutex_unlock(mutex);
 	#endif

 	return rc;
 }


 /**
  * Destroy a mutex which has already been created
  * @param mutex the mutex
  */
 void Thread_destroy_mutex(mutex_type mutex)
 {
 	int rc = 0;

 	FUNC_ENTRY;
 	#if defined(WIN32) || defined(WIN64)
 		rc = CloseHandle(mutex);
 	#else
 		rc = pthread_mutex_destroy(mutex);
 		free(mutex);
 	#endif
 	FUNC_EXIT_RC(rc);
 }


 /**
  * Get the thread id of the thread from which this function is called
  * @return thread id, type varying according to OS
  */
 thread_id_type Thread_getid(void)
 {
 	#if defined(WIN32) || defined(WIN64)
 		return GetCurrentThreadId();
 	#else
 		return pthread_self();
 	#endif
 }


 /**
  * Create a new semaphore
  * @return the new condition variable
  */
 sem_type Thread_create_sem(void)
 {
 	sem_type sem = NULL;
 	int rc = 0;

 	FUNC_ENTRY;
 	#if defined(WIN32) || defined(WIN64)
 		sem = CreateEvent(
 		        NULL,               /* default security attributes */
 		        FALSE,              /* manual-reset event? */
 		        FALSE,              /* initial state is nonsignaled */
 		        NULL                /* object name */
 		        );
 	#elif defined(OSX)
 		sem = dispatch_semaphore_create(0L);
 		rc = (sem == NULL) ? -1 : 0;
 	#else
 		sem = malloc(sizeof(sem_t));
 		rc = sem_init(sem, 0, 0);
 	#endif
 	FUNC_EXIT_RC(rc);
 	return sem;
 }


 /**
  * Wait for a semaphore to be posted, or timeout.
  * @param sem the semaphore
  * @param timeout the maximum time to wait, in milliseconds
  * @return completion code
  */
 int Thread_wait_sem(sem_type sem, int timeout)
 {
 /* sem_timedwait is the obvious call to use, but seemed not to work on the Viper,
  * so I've used trywait in a loop instead. Ian Craggs 23/7/2010
  */
 	int rc = -1;
 #if !defined(WIN32) && !defined(WIN64) && !defined(OSX)
 #define USE_TRYWAIT
 #if defined(USE_TRYWAIT)
 	int i = 0;
 	int interval = 10000; /* 10000 microseconds: 10 milliseconds */
 	int count = (1000 * timeout) / interval; /* how many intervals in timeout period */
 #else
 	struct timespec ts;
 #endif
 #endif

 	FUNC_ENTRY;
 	#if defined(WIN32) || defined(WIN64)
 		rc = WaitForSingleObject(sem, timeout < 0 ? 0 : timeout);
   #elif defined(OSX)
 		rc = (int)dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, (int64_t)timeout*1000000L));
 	#elif defined(USE_TRYWAIT)
 		while (++i < count && (rc = sem_trywait(sem)) != 0)
 		{
 			if (rc == -1 && ((rc = errno) != EAGAIN))
 			{
 				rc = 0;
 				break;
 			}
 			usleep(interval); /* microseconds - .1 of a second */
 		}
 	#else
 		if (clock_gettime(CLOCK_REALTIME, &ts) != -1)
 		{
 			ts.tv_sec += timeout;
 			rc = sem_timedwait(sem, &ts);
 		}
 	#endif

  	FUNC_EXIT_RC(rc);
  	return rc;
 }


 /**
  * Check to see if a semaphore has been posted, without waiting.
  * @param sem the semaphore
  * @return 0 (false) or 1 (true)
  */
 int Thread_check_sem(sem_type sem)
 {
 #if defined(WIN32) || defined(WIN64)
 	return WaitForSingleObject(sem, 0) == WAIT_OBJECT_0;
 #elif defined(OSX)
   return dispatch_semaphore_wait(sem, DISPATCH_TIME_NOW) == 0;
 #else
 	int semval = -1;
 	sem_getvalue(sem, &semval);
 	return semval > 0;
 #endif
 }


 /**
  * Post a semaphore
  * @param sem the semaphore
  * @return completion code
  */
 int Thread_post_sem(sem_type sem)
 {
 	int rc = 0;

 	FUNC_ENTRY;
 	#if defined(WIN32) || defined(WIN64)
 		if (SetEvent(sem) == 0)
 			rc = GetLastError();
 	#elif defined(OSX)
 		rc = (int)dispatch_semaphore_signal(sem);
 	#else
 		if (sem_post(sem) == -1)
 			rc = errno;
 	#endif

  	FUNC_EXIT_RC(rc);
   return rc;
 }


 /**
  * Destroy a semaphore which has already been created
  * @param sem the semaphore
  */
 int Thread_destroy_sem(sem_type sem)
 {
 	int rc = 0;

 	FUNC_ENTRY;
 	#if defined(WIN32) || defined(WIN64)
 		rc = CloseHandle(sem);
   #elif defined(OSX)
 	  dispatch_release(sem);
 	#else
 		rc = sem_destroy(sem);
 		free(sem);
 	#endif
 	FUNC_EXIT_RC(rc);
 	return rc;
 }


 #if !defined(WIN32) && !defined(WIN64)
 /**
  * Create a new condition variable
  * @return the condition variable struct
  */
 cond_type Thread_create_cond(void)
 {
 	cond_type condvar = NULL;
 	int rc = 0;

 	FUNC_ENTRY;
 	condvar = malloc(sizeof(cond_type_struct));
 	rc = pthread_cond_init(&condvar->cond, NULL);
 	rc = pthread_mutex_init(&condvar->mutex, NULL);

 	FUNC_EXIT_RC(rc);
 	return condvar;
 }

 /**
  * Signal a condition variable
  * @return completion code
  */
 int Thread_signal_cond(cond_type condvar)
 {
 	int rc = 0;

 	pthread_mutex_lock(&condvar->mutex);
 	rc = pthread_cond_signal(&condvar->cond);
 	pthread_mutex_unlock(&condvar->mutex);

 	return rc;
 }

 /**
  * Wait with a timeout (seconds) for condition variable
  * @return completion code
  */
 int Thread_wait_cond(cond_type condvar, int timeout)
 {
 	FUNC_ENTRY;
 	int rc = 0;
 	struct timespec cond_timeout;
 	struct timeval cur_time;

 	gettimeofday(&cur_time, NULL);

 	cond_timeout.tv_sec = cur_time.tv_sec + timeout;
 	cond_timeout.tv_nsec = cur_time.tv_usec * 1000;

 	pthread_mutex_lock(&condvar->mutex);
 	rc = pthread_cond_timedwait(&condvar->cond, &condvar->mutex, &cond_timeout);
 	pthread_mutex_unlock(&condvar->mutex);

 	FUNC_EXIT_RC(rc);
 	return rc;
 }

 /**
  * Destroy a condition variable
  * @return completion code
  */
 int Thread_destroy_cond(cond_type condvar)
 {
 	int rc = 0;

 	rc = pthread_mutex_destroy(&condvar->mutex);
 	rc = pthread_cond_destroy(&condvar->cond);
 	free(condvar);

 	return rc;
 }
 #endif


 #if defined(THREAD_UNIT_TESTS)

 #include <stdio.h>

 thread_return_type secondary(void* n)
 {
 	int rc = 0;

 	/*
 	cond_type cond = n;

 	printf("Secondary thread about to wait\n");
 	rc = Thread_wait_cond(cond);
 	printf("Secondary thread returned from wait %d\n", rc);*/

 	sem_type sem = n;

 	printf("Secondary thread about to wait\n");
 	rc = Thread_wait_sem(sem);
 	printf("Secondary thread returned from wait %d\n", rc);

 	printf("Secondary thread about to wait\n");
 	rc = Thread_wait_sem(sem);
 	printf("Secondary thread returned from wait %d\n", rc);
 	printf("Secondary check sem %d\n", Thread_check_sem(sem));

 	return 0;
 }


 int main(int argc, char *argv[])
 {
 	int rc = 0;

 	sem_type sem = Thread_create_sem();

 	printf("check sem %d\n", Thread_check_sem(sem));

 	printf("post secondary\n");
 	rc = Thread_post_sem(sem);
 	printf("posted secondary %d\n", rc);

 	printf("check sem %d\n", Thread_check_sem(sem));

 	printf("Starting secondary thread\n");
 	Thread_start(secondary, (void*)sem);

 	sleep(3);
 	printf("check sem %d\n", Thread_check_sem(sem));

 	printf("post secondary\n");
 	rc = Thread_post_sem(sem);
 	printf("posted secondary %d\n", rc);

 	sleep(3);

 	printf("Main thread ending\n");
 }

 #endif
	/*******************************************************************************
	* Copyright (c) 2009, 2017 IBM Corp.
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* and Eclipse Distribution License v1.0 which accompany this distribution.
	*
	* The Eclipse Public License is available at
	* http://www.eclipse.org/legal/epl-v10.html
	* and the Eclipse Distribution License is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* Contributors:
	* Ian Craggs - initial implementation
	* Ian Craggs, Allan Stockdill-Mander - async client updates
	* Ian Craggs - bug #415042 - start Linux thread as disconnected
	* Ian Craggs - fix for bug #420851
	* Ian Craggs - change MacOS semaphore implementation
	*******************************************************************************/

	/**
	* @file
	* \brief Threading related functions
	*
	* Used to create platform independent threading functions
	*/


	#include "Thread.h"
	#if defined(THREAD_UNIT_TESTS)
	#define NOSTACKTRACE
	#endif
	#include "StackTrace.h"

	#undef malloc
	#undef realloc
	#undef free

	#if !defined(WIN32) && !defined(WIN64)
	#include <errno.h>
	#include <unistd.h>
	#include <sys/time.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <sys/stat.h>
	#include <limits.h>
	#endif
	#include <stdlib.h>

	#include "OsWrapper.h"

	/**
	* Start a new thread
	* @param fn the function to run, must be of the correct signature
	* @param parameter pointer to the function parameter, can be NULL
	* @return the new thread
	*/
	thread_type Thread_start(thread_fn fn, void* parameter)
	{
	#if defined(WIN32) \|\| defined(WIN64)
	thread_type thread = NULL;
	#else
	thread_type thread = 0;
	pthread_attr_t attr;
	#endif

	FUNC_ENTRY;
	#if defined(WIN32) \|\| defined(WIN64)
	thread = CreateThread(NULL, 0, fn, parameter, 0, NULL);
	#else
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	if (pthread_create(&thread, &attr, fn, parameter) != 0)
	thread = 0;
	pthread_attr_destroy(&attr);
	#endif
	FUNC_EXIT;
	return thread;
	}


	/**
	* Create a new mutex
	* @return the new mutex
	*/
	mutex_type Thread_create_mutex(void)
	{
	mutex_type mutex = NULL;
	int rc = 0;

	FUNC_ENTRY;
	#if defined(WIN32) \|\| defined(WIN64)
	mutex = CreateMutex(NULL, 0, NULL);
	if (mutex == NULL)
	rc = GetLastError();
	#else
	mutex = malloc(sizeof(pthread_mutex_t));
	rc = pthread_mutex_init(mutex, NULL);
	#endif
	FUNC_EXIT_RC(rc);
	return mutex;
	}


	/**
	* Lock a mutex which has alrea
	* @return completion code, 0 is success
	*/
	int Thread_lock_mutex(mutex_type mutex)
	{
	int rc = -1;

	/* don't add entry/exit trace points as the stack log uses mutexes - recursion beckons */
	#if defined(WIN32) \|\| defined(WIN64)
	/* WaitForSingleObject returns WAIT_OBJECT_0 (0), on success */
	rc = WaitForSingleObject(mutex, INFINITE);
	#else
	rc = pthread_mutex_lock(mutex);
	#endif

	return rc;
	}


	/**
	* Unlock a mutex which has already been locked
	* @param mutex the mutex
	* @return completion code, 0 is success
	*/
	int Thread_unlock_mutex(mutex_type mutex)
	{
	int rc = -1;

	/* don't add entry/exit trace points as the stack log uses mutexes - recursion beckons */
	#if defined(WIN32) \|\| defined(WIN64)
	/* if ReleaseMutex fails, the return value is 0 */
	if (ReleaseMutex(mutex) == 0)
	rc = GetLastError();
	else
	rc = 0;
	#else
	rc = pthread_mutex_unlock(mutex);
	#endif

	return rc;
	}


	/**
	* Destroy a mutex which has already been created
	* @param mutex the mutex
	*/
	void Thread_destroy_mutex(mutex_type mutex)
	{
	int rc = 0;

	FUNC_ENTRY;
	#if defined(WIN32) \|\| defined(WIN64)
	rc = CloseHandle(mutex);
	#else
	rc = pthread_mutex_destroy(mutex);
	free(mutex);
	#endif
	FUNC_EXIT_RC(rc);
	}


	/**
	* Get the thread id of the thread from which this function is called
	* @return thread id, type varying according to OS
	*/
	thread_id_type Thread_getid(void)
	{
	#if defined(WIN32) \|\| defined(WIN64)
	return GetCurrentThreadId();
	#else
	return pthread_self();
	#endif
	}


	/**
	* Create a new semaphore
	* @return the new condition variable
	*/
	sem_type Thread_create_sem(void)
	{
	sem_type sem = NULL;
	int rc = 0;

	FUNC_ENTRY;
	#if defined(WIN32) \|\| defined(WIN64)
	sem = CreateEvent(
	NULL, /* default security attributes */
	FALSE, /* manual-reset event? */
	FALSE, /* initial state is nonsignaled */
	NULL /* object name */
	);
	#elif defined(OSX)
	sem = dispatch_semaphore_create(0L);
	rc = (sem == NULL) ? -1 : 0;
	#else
	sem = malloc(sizeof(sem_t));
	rc = sem_init(sem, 0, 0);
	#endif
	FUNC_EXIT_RC(rc);
	return sem;
	}


	/**
	* Wait for a semaphore to be posted, or timeout.
	* @param sem the semaphore
	* @param timeout the maximum time to wait, in milliseconds
	* @return completion code
	*/
	int Thread_wait_sem(sem_type sem, int timeout)
	{
	/* sem_timedwait is the obvious call to use, but seemed not to work on the Viper,
	* so I've used trywait in a loop instead. Ian Craggs 23/7/2010
	*/
	int rc = -1;
	#if !defined(WIN32) && !defined(WIN64) && !defined(OSX)
	#define USE_TRYWAIT
	#if defined(USE_TRYWAIT)
	int i = 0;
	int interval = 10000; /* 10000 microseconds: 10 milliseconds */
	int count = (1000 * timeout) / interval; /* how many intervals in timeout period */
	#else
	struct timespec ts;
	#endif
	#endif

	FUNC_ENTRY;
	#if defined(WIN32) \|\| defined(WIN64)
	rc = WaitForSingleObject(sem, timeout < 0 ? 0 : timeout);
	#elif defined(OSX)
	rc = (int)dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, (int64_t)timeout*1000000L));
	#elif defined(USE_TRYWAIT)
	while (++i < count && (rc = sem_trywait(sem)) != 0)
	{
	if (rc == -1 && ((rc = errno) != EAGAIN))
	{
	rc = 0;
	break;
	}
	usleep(interval); /* microseconds - .1 of a second */
	}
	#else
	if (clock_gettime(CLOCK_REALTIME, &ts) != -1)
	{
	ts.tv_sec += timeout;
	rc = sem_timedwait(sem, &ts);
	}
	#endif

	FUNC_EXIT_RC(rc);
	return rc;
	}


	/**
	* Check to see if a semaphore has been posted, without waiting.
	* @param sem the semaphore
	* @return 0 (false) or 1 (true)
	*/
	int Thread_check_sem(sem_type sem)
	{
	#if defined(WIN32) \|\| defined(WIN64)
	return WaitForSingleObject(sem, 0) == WAIT_OBJECT_0;
	#elif defined(OSX)
	return dispatch_semaphore_wait(sem, DISPATCH_TIME_NOW) == 0;
	#else
	int semval = -1;
	sem_getvalue(sem, &semval);
	return semval > 0;
	#endif
	}


	/**
	* Post a semaphore
	* @param sem the semaphore
	* @return completion code
	*/
	int Thread_post_sem(sem_type sem)
	{
	int rc = 0;

	FUNC_ENTRY;
	#if defined(WIN32) \|\| defined(WIN64)
	if (SetEvent(sem) == 0)
	rc = GetLastError();
	#elif defined(OSX)
	rc = (int)dispatch_semaphore_signal(sem);
	#else
	if (sem_post(sem) == -1)
	rc = errno;
	#endif

	FUNC_EXIT_RC(rc);
	return rc;
	}


	/**
	* Destroy a semaphore which has already been created
	* @param sem the semaphore
	*/
	int Thread_destroy_sem(sem_type sem)
	{
	int rc = 0;

	FUNC_ENTRY;
	#if defined(WIN32) \|\| defined(WIN64)
	rc = CloseHandle(sem);
	#elif defined(OSX)
	dispatch_release(sem);
	#else
	rc = sem_destroy(sem);
	free(sem);
	#endif
	FUNC_EXIT_RC(rc);
	return rc;
	}


	#if !defined(WIN32) && !defined(WIN64)
	/**
	* Create a new condition variable
	* @return the condition variable struct
	*/
	cond_type Thread_create_cond(void)
	{
	cond_type condvar = NULL;
	int rc = 0;

	FUNC_ENTRY;
	condvar = malloc(sizeof(cond_type_struct));
	rc = pthread_cond_init(&condvar->cond, NULL);
	rc = pthread_mutex_init(&condvar->mutex, NULL);

	FUNC_EXIT_RC(rc);
	return condvar;
	}

	/**
	* Signal a condition variable
	* @return completion code
	*/
	int Thread_signal_cond(cond_type condvar)
	{
	int rc = 0;

	pthread_mutex_lock(&condvar->mutex);
	rc = pthread_cond_signal(&condvar->cond);
	pthread_mutex_unlock(&condvar->mutex);

	return rc;
	}

	/**
	* Wait with a timeout (seconds) for condition variable
	* @return completion code
	*/
	int Thread_wait_cond(cond_type condvar, int timeout)
	{
	FUNC_ENTRY;
	int rc = 0;
	struct timespec cond_timeout;
	struct timeval cur_time;

	gettimeofday(&cur_time, NULL);

	cond_timeout.tv_sec = cur_time.tv_sec + timeout;
	cond_timeout.tv_nsec = cur_time.tv_usec * 1000;

	pthread_mutex_lock(&condvar->mutex);
	rc = pthread_cond_timedwait(&condvar->cond, &condvar->mutex, &cond_timeout);
	pthread_mutex_unlock(&condvar->mutex);

	FUNC_EXIT_RC(rc);
	return rc;
	}

	/**
	* Destroy a condition variable
	* @return completion code
	*/
	int Thread_destroy_cond(cond_type condvar)
	{
	int rc = 0;

	rc = pthread_mutex_destroy(&condvar->mutex);
	rc = pthread_cond_destroy(&condvar->cond);
	free(condvar);

	return rc;
	}
	#endif


	#if defined(THREAD_UNIT_TESTS)

	#include <stdio.h>

	thread_return_type secondary(void* n)
	{
	int rc = 0;

	/*
	cond_type cond = n;

	printf("Secondary thread about to wait\n");
	rc = Thread_wait_cond(cond);
	printf("Secondary thread returned from wait %d\n", rc);*/

	sem_type sem = n;

	printf("Secondary thread about to wait\n");
	rc = Thread_wait_sem(sem);
	printf("Secondary thread returned from wait %d\n", rc);

	printf("Secondary thread about to wait\n");
	rc = Thread_wait_sem(sem);
	printf("Secondary thread returned from wait %d\n", rc);
	printf("Secondary check sem %d\n", Thread_check_sem(sem));

	return 0;
	}


	int main(int argc, char *argv[])
	{
	int rc = 0;

	sem_type sem = Thread_create_sem();

	printf("check sem %d\n", Thread_check_sem(sem));

	printf("post secondary\n");
	rc = Thread_post_sem(sem);
	printf("posted secondary %d\n", rc);

	printf("check sem %d\n", Thread_check_sem(sem));

	printf("Starting secondary thread\n");
	Thread_start(secondary, (void*)sem);

	sleep(3);
	printf("check sem %d\n", Thread_check_sem(sem));

	printf("post secondary\n");
	rc = Thread_post_sem(sem);
	printf("posted secondary %d\n", rc);

	sleep(3);

	printf("Main thread ending\n");
	}

	#endif