Migrate Win32 C/C++ applications to Linux on POWER, Part 3: Semaphores

http://www.ibm.com/developerworks/systems/library/es-win32linux-sem.html

Introduction

This article, third in a series, is about migrating the Win32 C/C++
application to Linux on POWER with respect to semaphore APIs. Part 1 of this series addressed Win32 API mapping and Part 2 focused on how to map Win32 to Linux with respect to mutex
APIs. You are encouraged to read Part 1 and Part 2 of this series before
proceeding further.

Semaphores

A semaphore is a resource that contains an integer value. Semaphores allow
synchronization of processes by testing and setting the integer value in a
single atomic operation. Usually, the main use of a semaphore is to
synchronize a thread?s action with other threads. This is also a useful
technique for coordinating or synchronizing activities in which multiple
processes compete for the same operating system resources.

Linux provides Portable Operating System Interface (POSIX) semaphores, as
well as pthread conditional variables to map the Win32 semaphore APIs.
Both have their share of pros and cons. It is up to your discretion to use
either one based on application logic. The various points to consider in
the mapping process of the event semaphore are:

Type of semaphore: Win32 supports both named and un-named
event semaphores. The named semaphores are shared across processes.
Linux does not support this option. An Inter-Process Communication
(IPC) message queues sample code listed in this article to show you
how to work around it.

Initial state: In Win32, the semaphore might have an initial
value. In Linux, the POSIX semaphore supports this functionality, but
the pthreads do not. You need to consider this when using
pthreads.

Timeout: Win32 event semaphores support timed wait. In Linux,
the POSIX semaphore implementation only supports indefinite wait
(blocking). The pthreads implementation supports both blocking and
timeouts. The pthread_cond_timedwait() call provides a
timeout value during wait, and the pthread_cond_wait() is
used for indefinite wait.

Signaling: In Win32, signaling a semaphore wakes up all the
threads that are waiting on the semaphore. In Linux, the POSIX thread
implementation wakes up only one thread at a time. The pthreads
implementation has a pthread_cond_signal() call that
wakes up one thread and a pthread_cond_broadcast() call
that signals all the threads waiting on the semaphore.

Table 1. Semaphore
mapping table

Win32	pthread Linux	POSIX
CreateSemaphore	pthread_mutex_init(&(token)->mutex, NULL)) pthread_cond_init(&(token)->condition, NULL))	sem_init
CloseHandle (semHandle)	pthread_mutex_destroy(&(token->mutex)) pthread_cond_destroy(&(token->condition))	sem_destroy
ReleaseSemaphore(semHandle, 1, NULL)	pthread_cond_signal(&(token->condition))	sem_post
WaitForSingleObject(semHandle, INFINITE) WaitForSingleObject(semHandle, timelimit)	pthread_cond_wait(&(token->condition), &(token->mutex)) pthread_cond_timedwait(&(token ->condition), &(token->mutex))	sem_wait sem_trywait

Back to top

Condition variable

A condition variable enables developers to implement a condition in which a
thread executes and then blocked. The Microsoft? Win32 interface does
not support condition variables natively. To work around this omission, I
use the POSIX condition variable emulations synchronization primitives,
which are outlined in the series of articles. In Linux, it guarantees the
threads blocked on the condition will be unblocked when the condition
changes. It also allows you to unlock the mutex and wait on the condition
variable atomically, without the possible intervention of another thread.
However, a mutex should accompany each condition variable. Table 1 above displays the pthread condition
variable for synchronization between threads.

Back to top

Creating a semaphore

In Win32, the CreateSemaphore function creates a named or
unnamed semaphore object. Linux does not support named semaphores.

Listing 1. Creating a
semaphore

HANDLE CreateSemaphore (
LPSECURITY_ATTRIBUTES	lpSemaphoreAttributes,
LONG			lInitialCount,
LONG			lMaximunCount,
LPCTSTR			lpName
);

In Linux, the call sem_init() also creates a POSIX
semaphore:

Listing 2. POSIX semaphore

int sem_init(sem_t *sem, int pshared, unsigned int value

Linux uses the pthread_condition_init call to create a
semaphore object within the current process that maintains a count between
zero and a maximum value. The count is decremented each time a thread
completes a wait for the semaphore object and incremented each time a
thread releases the semaphore. When the count reaches zero, the state of
the semaphore object becomes non-signaled.

Listing 3. pthread_condition_init call to create a semaphore object

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

Listing 4. Win32 sample code

HANDLE semHandle;

semHandle = CreateSemaphore(NULL, 0, 256000, NULL);
/* Default security descriptor     */
if( semHandle == (HANDLE) NULL)
/* Semaphore object without a name */
{
return RC_OBJECT_NOT_CREATED;
}

Listing 5. Equivalent Linux code

typedef struct
{
pthread_mutex_t	mutex;
pthread_cond_t		condition;
int			semCount;
}sem_private_struct, *sem_private;

sem_private    token;

token = (sem_private) malloc(sizeof(sem_private_struct));

if(rc = pthread_mutex_init(&(token->mutex), NULL))
{
free(token);
return RC_OBJECT_NOT_CREATED;
}

if(rc = pthread_cond_init(&(token->condition), NULL))
{
pthread_mutex_destroy( &(token->mutex) );
free(token);
return RC_OBJECT_NOT_CREATED;
}

token->semCount = 0;

Back to top

Destroying an event
semaphore

Win32 uses CloseHandle to delete the semaphore object created
by the CreateSemaphore.

Listing 6. Destroying an event
semaphore

BOOL CloseHandle (HANDLE hObject);

Linux POSIX semaphores use sem_destroy() to destroy the
unnamed semaphore.

Listing 7. sem_destroy()

int sem_destroy(sem_t *sem);

In Linux pthreads, the pthread_cond_destroy() is used to
destroy the conditional variable.

Listing 8. pthread_cond_destroy()

int pthread_cond_destroy(pthread_cond_t *cond);

Listing 9. Win32 code and
euivalent Linux code

Win32 code	Equivalent Linux code
CloseHandle(semHandle);	pthread_mutex_destroy(&(token->mutex)); pthread_cond_destroy(&(token->condition)); free (token);

Back to top

Posting an event semaphore

In Win32, the ReleaseSemaphore function increases the count of
the specified semaphore object by a specified amount.

Listing 10. ReleaseSemaphore function

BOOL ReleaseSemaphore(
HANDLE hSemaphore,
LONG 	lReleaseCount,
LPLONG	lpPreviousCount
);

Linux POSIX semaphores use sem_post() to post an event
semaphore. This wakes up any of the threads blocked on the
semaphore.

Listing 11. sem_post()

int sem_post(sem_t * sem);

In Linux, pthread_cond_signal wakes up a thread waiting on a
conditional variable. Linux calls this function to post one event
completion for the semaphore identified by the object. The calling thread
increments the semaphore. If the semaphore value is incremented from zero
and there is any threads blocked in the pthread_cond, wait
for the semaphore because one of them is awakened. By default, the
implementation can choose any of the waiting threads.

Listing 12. pthread_cond_signal

int pthread_cond_signal(pthread_cond_t *cond);

Listing 13. Win32 code and
equivalent Linux code

Win32 code	Equivalent Linux code
ReleaseSemaphore(semHandle, 1, NULL)	if (rc = pthread_mutex_lock(&(token->mutex))) return RC_SEM_POST_ERROR; token->semCount ++; if (rc = pthread_mutex_unlock(&(token->mutex))) return RC_SEM_POST_ERROR; if (rc = pthread_cond_signal(&(token->condition))) return RC_SEM_POST_ERROR;

Back to top

Waiting an event semaphore

Win32 calls the WaitForSingleObject function to wait for an
event completion on the indicated semaphore. You can use this method when
waiting on a single thread synchronization object. The method is signaled
when the object is set to signal or the time out interval is finished. If
the time interval is INFINITE, it waits infinitely.

Listing 14. WaitForSingleObject function

DWORD WaitForSingleObject(
HANDLE hHANDLE,
DWORD	dwMilliseconds
);

Use the WaitForMultipleObjects function to wait for multiple
objects signaled. In the Semaphore thread synchronization object, the
object is non-signaled when the counters go to zero.

Listing 15. WaitForMultipleObjects function

DWORD WaitForMultipleObjects(
DWORD	nCount,
Const	HANDLE* lpHandles,
BOOL	bWaitAll,
DWORD	dwMilliseconds
);

Linux POSIX semaphores use sem_wait() to suspend the calling
thread until the semaphore has a non-zero count. Then it atomically
decreases the semaphore count.

Listing 16. sem_wait() function

int sem_wait(sem_t * sem);

The timeout option is not available in the POSIX semaphore. However, you
can achieve this by issuing a non-blocking sem_trywait() within a loop, which counts the timeout value.

Listing 17. sem_trywait() function

int sem_trywait(sem_t  * sem);

In Linux, the pthread_cond_wait() blocks the calling thread.
The calling thread decrements the semaphore. If the semaphore is zero when
the pthread_cond_wait is called, the pthread_cond_wait() blocks until another thread increments
the semaphore.

Listing 18. pthread_cond_wait() function

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t  *mutex);

The pthread_cond_wait function first releases the associated external_mutex of type pthread_mutex_t, which must be held
when the caller checks the condition expression.

Listing 19. Win32 code and
equivalent Linux code

Win32 code	Equivalent Linux code
DWORD retVal; retVal = WaitForSingleObject(semHandle, INFINITE); if (retVal == WAIT_FAILED) return RC_SEM_WAIT_ERROR	if (rc = pthread_mutex_lock(&(token->mutex))) return RC_SEM_WAIT_ERROR; while (token->semCount <= 0) { rc = pthread_cond_wait(&(token->condition), &(token->mutex)); if (rc &&errno != EINTR ) break; } token->semCount--; if (rc = pthread_mutex_unlock(&(token->mutex))) return RC_SEM_WAIT_ERROR;

If you need to block the calling thread for a specific time, then use the pthread_cond_timewait to block the thread. This method is
called to wait for an event completion on the indicated semaphore, with a
specified time.

Listing 20. pthread_cond_timewait

int pthread_cond_timewait(
pthread_cond_t		*cond,
pthread_mutex_t		*mutex,
timespec		*tm
);

Listing 21. Win32 code and
equivalent Linux code

Win32 code

Equivalent Linux code

retVal = WaitForSingleObject(SemHandle, timelimit); if (retVal == WAIT_FAILED) return RC_SEM_WAIT_ERROR; if (retVal == WAIT_TIMEOUT) return RC_TIMEOUT;

int rc; struct timespec tm; struct timeb tp; long sec, millisec; if (rc = pthread_mutex_lock(&(token->mutex))) return RC_SEM_WAIT_ERROR; sec = timelimit / 1000; millisec = timelimit % 1000; ftime( &tp ); tp.time += sec; tp.millitm += millisec; if( tp.millitm > 999 ) { tp.millitm -= 1000; tp.time++; } tm.tv_sec = tp.time; tm.tv_nsec = tp.millitm * 1000000 ; while (token->semCount <= 0) { rc = pthread_cond_timedwait(&(token->condition), &(token->mutex), &tm); if (rc && (errno != EINTR) ) break; } if ( rc ) { if ( pthread_mutex_unlock(&(token->mutex)) ) return RC_SEM_WAIT_ERROR ); if ( rc == ETIMEDOUT) /* we have a time out */ return RC_TIMEOUT ); return RC_SEM_WAIT_ERROR ); } token->semCount--; if (rc = pthread_mutex_unlock(&(token->mutex))) return RC_SEM_WAIT_ERROR;

Back to top

POSIX semaphore sample code

Listing 22 uses POSIX semaphores to implement
synchronization between threads A and B:

Listing 22. POSIX semaphore sample
code

sem_t sem; /* semaphore object */
int irc;   /* return code */

/* Initialize the semaphore - count is set to 1*/
irc = sem_init (sem, 0,1)

...

/* In Thread A */

/* Wait for event to be posted */

sem_wait (&sem);

/* Unblocks immediately as semaphore initial count was set to 1 */

.......

/* Wait again for event to be posted */

sem_wait (&sem);

/* Blocks till event is posted */

/* In Thread B */
/* Post the semaphore */
...

irc = sem_post (&sem);

/* Destroy the semaphore */
irc = sem_destroy(&sem);

Back to top

Intra-process semaphore sample
code

Listing 23. Win32 intra-process semaphore
sample code

#include
#include
#include

void thrdproc      (void   *data);  // the thread procedure (function)
to be executed

HANDLE   semHandle;

int
main( int argc, char **argv )
{
HANDLE    *threadId1;
HANDLE    *threadId2;
int        hThrd;
unsigned   stacksize;
int	    arg1;

if( argc < 2 )
arg1 = 7;
else
arg1 = atoi( argv[1] );

printf( "Intra Process Semaphor test.\n" );
printf( "Start.\n" );

semHandle = CreateSemaphore(NULL, 1, 65536, NULL);
if( semHandle == (HANDLE) NULL)
{
printf("CreateSemaphore error: %d\n", GetLastError());
}

printf( "Semaphor created.\n" );

if( stacksize < 8192 )
stacksize = 8192;
else
stacksize = (stacksize/4096+1)*4096;

hThrd = _beginthread( thrdproc, // Definition of a thread entry
NULL,
stacksize,
"Thread 1");

if (hThrd == -1)
return RC_THREAD_NOT_CREATED);

*threadId1 = (HANDLE) hThrd;

hThrd = _beginthread( thrdproc, // Definition of a thread entry
NULL,
stacksize,
?Thread 2");

if (hThrd == -1)
return RC_THREAD_NOT_CREATED);

*threadId2 = (HANDLE) hThrd;

printf( "Main thread sleeps 5 sec.\n" );

sleep(5);

if( ! ReleaseSemaphore(semHandle, 1, NULL) )
printf("ReleaseSemaphore error: %d\n", GetLastError());

printf( "Semaphor released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );

sleep (arg1);

if( ! ReleaseSemaphore(semHandle, 1, NULL) )
printf("ReleaseSemaphore error: %d\n", GetLastError());

printf( "Semaphor released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );
sleep (arg1);

CloseHandle(semHandle);

printf( "Semaphor deleted.\n" );
printf( "Main thread sleeps 5 sec.\n" );

sleep (5);
printf( "Stop.\n" );

return OK;
}

void
thread_proc( void *pParam )
{

DWORD  retVal;

printf( "\t%s created.\n", pParam );

retVal = WaitForSingleObject(semHandle, INFINITE);

if (retVal == WAIT_FAILED)
return RC_SEM_WAIT_ERROR;

printf( "\tSemaphor blocked by %s. (%lx)\n", pParam, retVal);
printf( "\t%s sleeps for 5 sec.\n", pParam );
sleep(5);

if( ! ReleaseSemaphore(semHandle, 1, NULL) )
printf("ReleaseSemaphore error: %d\n", GetLastError());

printf( "\tSemaphor released by %s.)\n", pParam);
}

Listing 24. Equivalent Linux intra-process
semaphore sample code

#include
#include
#include
#include
#include
#include

void  thread_proc (void * data);

pthread_mutexattr_t     attr;
pthread_mutex_t         mutex;

typedef struct
{
pthread_mutex_t         mutex;
pthread_cond_t          condition;
int                     semCount;
}sem_private_struct, *sem_private;

sem_private     token;

int main( int argc, char **argv )
{
pthread_t             threadId1;
pthread_t             threadId2;
pthread_attr_t        pthread_attr;
pthread_attr_t        pthread_attr2;

int			arg1;
int                   rc;

if( argc < 2 )
arg1 = 7;
else
arg1 = atoi( argv[1] );

printf( "Intra Process Semaphor test.\n" );
printf( "Start.\n" );

token =(sem_private)  malloc (sizeof (sem_private_struct));

if(rc = pthread_mutex_init( &(token->mutex), NULL))
{
free(token);
return 1;
}

if(rc = pthread_cond_init(&(token->condition), NULL))
{
printf( "pthread_condition ERROR.\n" );
pthread_mutex_destroy( &(token->mutex) );
free(token);
return 1;
}

token->semCount = 0;

printf( "Semaphor created.\n" );

if (rc = pthread_attr_init(&pthread_attr))
{
printf( "pthread_attr_init ERROR.\n" );
exit;
}

if (rc = pthread_attr_setstacksize(&pthread_attr, 120*1024))
{
printf( "pthread_attr_setstacksize ERROR.\n" );
exit;
}

if (rc = pthread_create(&threadId1,
&pthread_attr,
(void*(*)(void*))thread_proc,
"Thread 1" ))
{
printf( "pthread_create ERROR.\n" );
exit;
}

if (rc = pthread_attr_init(&pthread_attr2))
{
printf( "pthread_attr_init2 ERROR.\n" );
exit;
}

if (rc = pthread_attr_setstacksize(&pthread_attr2, 120*1024))
{
printf( "pthread_attr_setstacksize2 ERROR.\n" );
exit;
}

if (rc = pthread_create(&threadId2,
&pthread_attr2,
(void*(*)(void*))thread_proc,
"Thread 2" ))
{
printf( "pthread_CREATE ERROR2.\n" );
exit ;  // EINVAL, ENOMEM
}

printf( "Main thread sleeps 5 sec.\n" );
sleep( 5 );

if (rc =  pthread_mutex_lock(&(token->mutex)))
{
printf( "pthread_mutex_lock ERROR 1.\n" );
return 1;
}

token->semCount ++;

if (rc = pthread_mutex_unlock&(token->mutex)))
{
printf( "pthread_mutex_unlock ERROR 1.\n" );
return 1;
}

if (rc = pthread_cond_signal(&(token->condition)))
{
printf( "pthread_cond_signal ERROR1.\n" );
return 1;
}

printf( "Semaphor released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );
sleep( arg1 );

if (rc =  pthread_mutex_lock(&(token->mutex)))
{
printf( "pthread_mutex_lock ERROR.\n" );
return 1;
}

token->semCount ++;

if (rc = pthread_mutex_unlock(&(token->mutex)))
{
printf( "pthread_mutex_lock ERROR.\n" );
return 1;
}

if (rc = pthread_cond_signal(&(token->condition)))
{
printf( "pthread_cond_signal ERROR.\n" );
return 1;
}

printf( "Semaphor released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );
sleep( arg1 );

pthread_mutex_destroy(&(token->mutex));
pthread_cond_destroy(&(token->condition));

printf( "Semaphor deleted.\n" );
printf( "Main thread sleeps 5 sec.\n" );
sleep( 5 );
printf( "Stop.\n" );

return 0;
}

void
thread_proc( void *pParam )
{
int	rc;

printf( "\t%s created.\n", pParam );

if (token == (sem_private) NULL)
return ;

if (rc =  pthread_mutex_lock(&(token->mutex)))
{
printf( "pthread_mutex_lock ERROR2.\n" );
return ;
}

while (token->semCount <= 0)
{
rc = pthread_cond_wait(&(token->condition), &(token->mutex));
if (rc && errno != EINTR )
break;
}
if( rc )
{
pthread_mutex_unlock(&(token->mutex));
printf( "pthread_mutex_unlock ERROR3.\n" );
return;
}
token->semCount--;

if (rc = pthread_mutex_unlock(&(token->mutex)))
{
printf( "pthread_mutex_lock ERROR.\n" );
return ;
}

printf( "\tSemaphor blocked by %s. (%lx)\n", pParam, rc );
printf( "\t%s sleeps for 5 sec.\n", pParam );
sleep( 5 );

if (rc =  pthread_mutex_lock(&(token->mutex)))
{
printf( "pthread_mutex_lock ERROR.\n" );
return ;
}

token->semCount ++;

if (rc = pthread_mutex_unlock(&(token->mutex)))
{
printf( "pthread_mutex_unlock ERROR.\n" );
return ;
}

if (rc = pthread_cond_signal(&(token->condition)))
{
printf( "pthread_cond_signal ERROR.\n" );
return ;
}

printf( "\tSemaphor released by %s. (%lx)\n", pParam, rc );

Back to top

Inter-process semaphore sample
code

Listing 25. Win32 Inter-process semaphore
process 1 sample code

#include
#include

#define WAIT_FOR_ENTER  printf( "Press ENTER\n" );getchar()

int main()
{
HANDLE		semaphore;
int		nRet;
DWORD          retVal;

SECURITY_ATTRIBUTES		sec_attr;

printf( "Inter Process Semaphore test - Process 1.\n" );
printf( "Start.\n" );

sec_attr.nLength              = sizeof( SECURITY_ATTRIBUTES );
sec_attr.lpSecurityDescriptor = NULL;
sec_attr.bInheritHandle       = TRUE;

semaphore = CreateSemaphore( &sec_attr, 1, 65536, ?456789" );
if( semaphore == (HANDLE) NULL )
return RC_OBJECT_NOT_CREATED;

printf( "Semaphore created. (%lx)\n", nRet );

WAIT_FOR_ENTER;

if( ! ReleaseSemaphore(semaphore, 1, NULL) )
return SEM_POST_ERROR;

printf( "Semaphore Posted. \n");

WAIT_FOR_ENTER;

retVal = WaitForSingleObject (semaphore, INFINITE );
if (retVal == WAIT_FAILED)
return SEM_WAIT_ERROR;

printf( "Wait for Semaphore. \n");

WAIT_FOR_ENTER;

CloseHandle (semaphore);
printf( "Semaphore deleted.\n" );
printf( "Stop.\n" );

return 0;
}

Listing 26 illustrates the message IPC codes as an
example to support the named semaphore shared in the processes.

Listing 26. Equivalent Linux
inter-process sempahore process 1 sample code

#include
#include
#include
#include
#include
#include

#define WAIT_FOR_ENTER  printf( "Press ENTER\n" );getchar()

struct msgbuf {
long mtype;         /* type of message */
char mtext[1];      /* message text */
};

int main()
{
key_t           msgKey;
int             flag;
struct msgbuf   buff;
int             sem;
int             nRet =0;

printf( "Inter Process Semaphore test - Process 1.\n" );
printf( "Start.\n" );

flag = IPC_CREAT|IPC_EXCL;

if( ( msgKey = (key_t) atol( "456789" ) ) <= 0 )
return 1;

flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
sem  = (int) msgget( msgKey, flag );

if (sem == -1)
if( errno == EEXIST )
{
flag &= ~IPC_EXCL;
sem = (int) msgget( msgKey, flag );
if (msgctl(sem, IPC_RMID, NULL ) != 0)
return 1;

sem = (int) msgget( msgKey, flag );
if (sem == -1)
return 1;
}
else
return 1;

printf( "Semaphore created. \n" );

WAIT_FOR_ENTER;

buff.mtype = 123;

if( msgsnd( sem, &buff, 1, 0 ) < 0 )
return 1;

printf( "Semaphore Posted. \n" );

WAIT_FOR_ENTER;

if( msgrcv( sem, &buff, 1, 0, 0 ) < 0 )
return 1;

printf( "Wait for Semaphore. \n" );

WAIT_FOR_ENTER;

msgctl(sem, 0, IPC_RMID );

printf( "Semaphore deleted.\n" );
printf( "Stop.\n" );

return 0;
}

Listing 27. Win32 Inter-process semaphore
process 2 sample code

#include
#include

int main()
{
HANDLE	semaphore;
DWORD   retVal;

printf( "Inter Process Semaphore test - Process 2.\n" );
printf( "Start.\n" );

SECURITY_ATTRIBUTES		sec_attr;

sec_attr.nLength              = sizeof( SECURITY_ATTRIBUTES );
sec_attr.lpSecurityDescriptor = NULL;
sec_attr.bInheritHandle       = TRUE;

semaphore = CreateSemaphore( &sec_attr, 0, 65536, ?456789" );
if( semaphore == (HANDLE) NULL )
return RC_OBJECT_NOT_CREATED;

printf( "Semaphore opened. (%lx)\n", nRet );

printf( "Try to wait for semaphore.\n" );

while( ( retVal = WaitForSingleObject( semaphore, 250 ) ) == WAIT_TIMEOUT)
printf( "Timeout. \n");

printf( "Semaphore acquired. \n");
printf( "Try to post the semaphore.\n" );

if( ! ReleaseSemaphore(semaphore, 1, NULL) )
return RC_SEM_POST_ERROR;

printf( "Semaphore posted. \n");

CloseHandle(semaphore);

printf( "Semaphore closed. \n");
printf( "Stop.\n" );

return 0;
}

Listing 28. Equivalent Linux inter-process
sempahore process 2 sample code

#include
#include
#include
#include
#include
#include
#include

#define RC_TIMEOUT = 3

struct msgbuf {
long mtype;         /* type of message */
char mtext[1];      /* message text */
};

int main()
{
key_t           msgKey;
int             flag=0;
struct msgbuf   buff;
int             sem;
int             nRet =0;

printf( "Inter Process Semaphore test - Process 2.\n" );
printf( "Start.\n" );

if( ( msgKey = (key_t) atol( "456789" ) ) <= 0 )
return 1;

flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;

sem = (int) msgget( msgKey, flag );
if (sem == -1)
if( errno == EEXIST )
{
flag &= ~IPC_EXCL;
sem = (int) msgget( msgKey, flag );
if (msgctl(sem, IPC_RMID, NULL ) != 0)
return 1;

sem = (int) msgget( msgKey, flag );
if (sem == -1)
return 1;
}
else
return 1;

printf( "Semaphore opened. (%lx)\n", nRet );

if( nRet != 0 )
return 0;

printf( "Try to wait for semaphore.\n" );

while( ( nRet = sem_shared_wait_timed( sem, 250 ) ) == 3)

printf( "Timeout. (%lx)\n", nRet );
printf( "Semaphore acquired. (%lx)\n", nRet );
printf( "Try to post the semaphore.\n" );

buff.mtype = 123;
if( msgsnd( sem, &buff, 1, 0 ) < 0 )
return 1;

printf( "Semaphore posted. (%lx)\n", nRet );

if( nRet != 0 )
return 0;

printf( "Semaphore closed. (%lx)\n", nRet );
printf( "Stop.\n" );

return 0;
}

int sem_shared_wait_timed( int sem, unsigned long timelimit)
{
struct msgbuf           buff;
struct timeval          timeOut;
int                     msg[1];
int                     nRet=0;

timeOut.tv_sec  = timelimit / 1000;
timeOut.tv_usec = (timelimit % 1000) * 1000;

msg[0] = sem;

nRet = select( 0x1000, (fd_set *)msg, NULL, NULL, &timeOut );

if(nRet == 0)
return 3;

if( msgrcv( sem, &buff, 1, 0, 0 ) < 0 )
return 1;
}

Back to top

Conclusion

This third article in a series covered the mapping of Win32 to Linux with
respect to semaphore APIs, along with semaphore sample codes for your
reference. The threaded, synchronized systems present significant
challenges not only in the design and implementation, but also in all
stages of quality assurance. Use these articles as a reference when you
undertake the migration activity involving Win32 to Linux. Be sure to read
the previous articles in this series.