Subversion Repositories HomeAutomation

/***************************************************************************

                           wthread.c  -  description

                              -------------------

     begin                : Sun Jan 02 2000

     copyright            : (C) 2001 by Rainer Lehrig

     email                : lehrig@t-online.de

  ***************************************************************************/

 /***************************************************************************

  *                                                                         *

  *   This library is free software; you can redistribute it and/or modify  *

  *   it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as        *

  *   published by the Free Software Foundation                             *

  *                                                                         *

  ***************************************************************************/

 /***********************************************************************************

 Wrapper for posix threads (UNIX,VMS,windows)

 (C) Rainer Lehrig 2000                                       lehrig@t-online.de

 ***********************************************************************************/

 #include <errno.h>

 #include "rlwthread.h"

 #ifdef unix

 #include <sys/time.h>

 #include <sys/socket.h>

 #include <netinet/in.h>

 #include <netdb.h>

 #include <pthread.h>

 #endif

 /***************************************/

 /* init attributes with default values */

 /***************************************/

 int rlwthread_attr_init(pthread_attr_t *attr)

 {

 #ifdef _WIN32

   memset(attr,0,sizeof(pthread_attr_t));

   return 0;

 #else

   return pthread_attr_init(attr);

 #endif

 }

 /* #pdoku headerlevel 2 ^^wthread_create */

 /*******************************************/

 /* create a thread                         */

 /* tid:  returned thread_id                */

 /* attr: thread creation attributes        */

 /* func: thread start routine              */

 /* arg:  parameter to thread start routine */

 /*******************************************/

 int rlwthread_create(pthread_t *tid, const pthread_attr_t *attr,

                       void *(*func)(void*), void *arg)

 {

 #ifdef _WIN32

   HANDLE handle;

   int ThreadId;

   int dwStackSize = 0;

   if(attr != NULL) dwStackSize = attr->__stacksize;

   handle = CreateThread( NULL,                    /* pointer to thread security attributes */

                          dwStackSize,             /* initial thread stack size, in bytes   */

  (LPTHREAD_START_ROUTINE)func,                    /* pointer to thread function            */

                          arg,                     /* argument for new thread               */

                          0,                       /* creation flags                        */

        (unsigned long *) &ThreadId                /* pointer to returned thread identifier */

                        );

   *tid = (pthread_t) handle;

   if(handle == NULL) return -1;

   else               return 0;

 #else

   return pthread_create(tid,attr,func,arg);

 #endif

 }

 void rlwthread_close_handle(pthread_t *tid)

 {

 #ifdef _WIN32

   CloseHandle((HANDLE) *tid);

 #else

   if(tid == NULL) return;

 #endif

 }

 /**************************************************************/

 /* terminate a thread                                         */

 /* call this function within a thread to terminate the thead  */

 /* or return from the thread start routine                    */

 /* status: return value from the thread (see wthread_join)    */

 /**************************************************************/

 void rlwthread_exit(void *status)

 {

 #ifdef _WIN32

   DWORD *ptr;

   ptr = (DWORD *) status;

   if(status == NULL) ExitThread((DWORD) 0);

   else               ExitThread(*ptr);

 #else

   pthread_exit(status);

 #endif

 }

 /* #pdoku headerlevel 2 ^^wthread_join */

 /************************************/

 /* wait for termination of thread   */

 /* tid:    thread id                */

 /* status: return value from thread */

 /************************************/

 int rlwthread_join(pthread_t tid, void **status)

 {

 #ifdef _WIN32

   DWORD exitcode;

   while(1)

   {

     GetExitCodeThread((HANDLE) tid,&exitcode);

     if(exitcode != STILL_ACTIVE) return exitcode;

     Sleep(10); /* sleep 10 msec */

   }

 #else

   return pthread_join(tid,status);

 #endif

 }

 /**************************/

 /* init a mutex           */

 /* mptr: pointer to mutex */

 /* atrr: mutex atrributes */

 /**************************/

 int rlwthread_mutex_init(pthread_mutex_t *mptr,

                           const pthread_mutexattr_t *attr)

 {

 #ifdef _WIN32

   HANDLE handle = CreateMutex(NULL, FALSE, NULL);

   if(handle) *mptr = handle;

   //old InitializeCriticalSection(mptr);

   return 0;

 #else

   return pthread_mutex_init(mptr,attr);

 #endif

 }

 /**************************/

 /* destroy a mutex        */

 /* mptr: pointer to mutex */

 /**************************/

 int rlwthread_mutex_destroy(pthread_mutex_t *mptr)

 {

 #ifdef _WIN32

   CloseHandle(*mptr);

   //old DeleteCriticalSection(mptr);

   return 0;

 #else

   return pthread_mutex_destroy(mptr);

 #endif

 }

 /**************************/

 /* lock a mutex           */

 /* mptr: pointer to mutex */

 /**************************/

 int rlwthread_mutex_lock(pthread_mutex_t *mptr)

 {

 #ifdef _WIN32

   if(WaitForSingleObject(*mptr, INFINITE) == WAIT_OBJECT_0) return 0;

   //old EnterCriticalSection(mptr); // pointer to critical section object

   return 0;

 #else

   return pthread_mutex_lock(mptr);

 #endif

 }

 /********************************/

 /* try to lock a mutex          */

 /* mptr: pointer to mutex       */

 /* return 0 if already locked   */

 /* return !0 if lock sucessfull */

 /********************************/

 #ifdef _WIN32

 WINBASEAPI BOOL WINAPI TryEnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection);

 #endif

 int rlwthread_mutex_trylock(pthread_mutex_t *mptr)

 {

 #ifdef _WIN32

   DWORD ret;

   ret = WaitForSingleObject(*mptr, 0);

   if(ret == WAIT_OBJECT_0) return 1;

   return 0;

   //old ret = TryEnterCriticalSection(mptr); // pointer to critical section object

   return ret;

 #else

   int ret;

   ret = pthread_mutex_trylock(mptr);

   if(ret == EBUSY) return 0;

   return 1;

 #endif

 }

 /**************************/

 /* unlock a mutex         */

 /* mptr: pointer to mutex */

 /**************************/

 int rlwthread_mutex_unlock(pthread_mutex_t *mptr)

 {

 #ifdef _WIN32

   ReleaseMutex(*mptr);

   //old LeaveCriticalSection(mptr);

   return 0;

 #else

   return pthread_mutex_unlock(mptr);

 #endif

 }

 /**************************/

 /* kill a thread          */

 /* tid handel of thread   */

 /**************************/

 int rlwthread_cancel(pthread_t tid)

 {

 #ifdef _WIN32

   return (int) CloseHandle((HANDLE) tid);

 #else

   return pthread_cancel(tid);

 #endif

 }

 /***********************************************/

 /* initialize a semaphore                      */

 /* s is a pointer to a WSEMAPHORE struct       */

 /* cmax is the maximum number of the semaphore */

 /* return 0                                    */

 /***********************************************/

 int rlwrapinit_semaphore(WSEMAPHORE *s, int cmax)

 {

 /* Create a semaphore with initial count=0 max. counts of cmax. */

 #ifdef _WIN32

   s->cmax = cmax;

   s->hSemaphore = CreateSemaphore(

     NULL,   /* no security attributes */

     0,      /* initial count */

     cmax,   /* maximum count */

     NULL);  /* unnamed semaphore */

   if(s->hSemaphore == NULL) return -1; /* Check for error. */

   return 0;

 #else

   s->cmax   = cmax;

   s->nready = 0;

   rlwthread_mutex_init(&s->mutex, NULL);

   pthread_cond_init(&s->cond, NULL);

   return 0;

 #endif

 }

 int rlwrapdestroy_semaphore(WSEMAPHORE *s)

 {

 #ifdef _WIN32

   CloseHandle(s->hSemaphore);

 #else

   rlwthread_mutex_destroy(&s->mutex);

 #endif

   return 0;

 }

 /***********************************************************************/

 /* increment a semaphore                                               */

 /* s is a pointer to a WSEMAPHORE struct                               */

 /* the producer will call this function whenever new data is available */

 /* return 0=OK -1=error                                                */

 /***********************************************************************/

 int rlwrapincrement_semaphore(WSEMAPHORE *s)

 {

 /* Increment the count of the semaphore. */

 #ifdef _WIN32

   if(!ReleaseSemaphore(

         s->hSemaphore,  /* handle of semaphore */

         1,              /* increase count by one */

         NULL) )         /* not interested in previous count */

   {

     return -1; /* Deal with the error. */

   }

   return 0;

 #else

   pthread_mutex_lock(&s->mutex);

   if(s->nready == 0) pthread_cond_signal(&s->cond);

   s->nready++;

   pthread_mutex_unlock(&s->mutex);

   return 0;

 #endif

 }

 /*********************************************************************************/

 /* wait for a semaphore                                                          */

 /* s is a pointer to a WSEMAPHORE struct                                         */

 /* the consumer will call this function to wait for new data to become available */

 /* return 0                                                                      */

 /*********************************************************************************/

 int rlwrapwait_semaphore(WSEMAPHORE *s)

 {

 #ifdef _WIN32

   int ret;

   ret = WaitForSingleObject(

         s->hSemaphore,   /* handle of semaphore */

         INFINITE);       /* infinite time-out interval */

   if(ret) return 0;

   return 0;

 #else

   pthread_mutex_lock(&s->mutex);

   while(s->nready == 0)

   {

     pthread_cond_wait(&s->cond,&s->mutex);

   }  

   s->nready--;

   pthread_mutex_unlock(&s->mutex);

   return 0;

 #endif

 }

 int rlwthread_sleep(long msec)

 {

 #ifdef _WIN32

   Sleep(msec);

   return 0;

 #endif

 #ifdef unix

   fd_set wset,rset,eset;

   struct timeval timeout;

   FD_ZERO(&rset);

   FD_ZERO(&wset);

   FD_ZERO(&eset);

   timeout.tv_sec  = msec / 1000;

   timeout.tv_usec = (msec % 1000) * 1000;

   select(1,&rset,&wset,&eset,&timeout);

   return 0;

 #endif

 #ifdef __VMS

   struct timespec interval;

   interval.tv_sec  =  msec / 1000;

   interval.tv_nsec = (msec % 1000) * 1000 * 1000; /* wait msec msec */

   pthread_delay_np(&interval);

   return 0;

 #endif

 }

 void rlsleep(long msec)

 {

   rlwthread_sleep(msec);

 }

 /*** test routine ***/

 /**************************************************************/

 /* This is an example how to use the wthread_xxx functions    */

 /**************************************************************/

 #define TESTINGx

 #ifdef  TESTING

 #include "stdio.h"

 #include "stdlib.h"

 #ifndef _WIN32

 #include "unistd.h"

 #endif

 /******************************************/

 /* here we define 2 mutexes (semaphores)  */

 /* the mutexes are global two all threads */

 /******************************************/

 pthread_mutex_t mutex1, mutex2;

 WSEMAPHORE semaphore;

 /************************************************************************/

 /* this is the tread function                                           */

 /* it's name is given as parameter to wthread_create                    */

 /* *arg is an argument given by the last parameter of wthread_create    */

 /* you can get the return value by pthread_join (status)                */

 /************************************************************************/

 void *thread(void *arg)

 {

   int i=0;

   printf("thread start : %s\n",(const char *) arg);

   while(i++ < 50)

   {

     rlwrapwait_semaphore(&semaphore);

     printf("thread %d\n",i);

     /* sleep(1); */

   }

   return NULL;

 }

 int main()

 {

   pthread_t tid; /* this is the thread_id */

   void *status;  /* this is the return value of the tread */

   int i;

   /*****************************************************************************/

   /* here we initialize 2 mutexes                                              */

   /* the mutexes are defined global to all threads                             */

   /* for compatibility with MSWINDOWS the second parameter should be NULL      */

   /*                                                                           */

   /* in order to mark critical sections we can now use the following functions */

   /* wthread_mutex_lock                                                        */

   /* wthread_mutex_unlock                                                      */

   /* if a mutex is locked by a thread and an other thread is calling           */

   /* wthread_mutex_lock it will be blocked until the first thread calls        */

   /* the wthread_mutex_unlock function                                         */

   /*                                                                           */

   /* this function is the reverse of wthread_mutex_init                        */

   /* wthread_mutex_destroy                                                     */

   /*****************************************************************************/

   rlwthread_mutex_init(&mutex1, NULL);

   rlwthread_mutex_init(&mutex2, NULL);

   rlwrapinit_semaphore(&semaphore, 1000);

   printf("create a thread\n");

   /****************************************************************/

   /* this call will create a new thread                           */

   /* tid is the returned thread_id                                */

   /*     you can use this id for example in wthread_join          */

   /* in this example the second parameter is NULL                 */

   /*     you can call wthread_attr_init(pthread_attr_t *attr)     */

   /*     to initialize the start attributes                       */

   /*     pthread_attr_t attr;                                     */

   /*     wthread_attr_init(&attr);                                */

   /*     wthread_create(&tid, &attr, thread, "hello thread");     */

   /* thread is the name of the thread function (see above)        */

   /* the last parameter is given to the thread function           */

   /****************************************************************/

   rlwthread_create(&tid, NULL, thread, "hello thread");

   i=0;

   while(i++ < 50)

   {

     printf("main %d\n",i);

     rlwrapincrement_semaphore(&semaphore);

     if(i%4 == 0) Sleep(10);

   }

   printf("waiting for thread\n");

   /*****************************************************/

   /* this call waits for the termination of thread tid */

   /* the return value of the thread is given to status */

   /*****************************************************/

   rlwthread_join(tid, &status);

   printf("finish\n");

   return 0;

 }

 #endif