threading.h

#ifndef __HELPER_THREADING_H__
#define __HELPER_THREADING_H__

#ifdef HAVE_CONFIG_H
    #include "config.h"
#endif

#ifdef WITH_PTHREADS
   #include <sys/time.h>
   #include <pthread.h>
   #include <errno.h>
   extern int errno;
#elif defined(WITH_SDLTHREADS)
   #include <SDL_thread.h>
#endif
#include <stdlib.h>
#include "errmanager.h"


/*
 * public defines
 */


typedef void * thread_rdwrattr_t;                   
#define thread_rdwrattr_default NULL;           
#define T_RDWR thread_rdwr_t                    
#define T_RDWRATTR thread_rdwrattr_t            
#ifdef WITH_PTHREADS
   #define T_MUTEX pthread_mutex_t              
   #define T_MUTEXATTR pthread_mutexattr_t      
   #define T_COND pthread_cond_t                
   #define T_CONDATTR pthread_condattr_t        
   #define T_THREAD pthread_t                   
   #define T_THREADATTR pthread_attr_t          
#elif defined(WITH_SDLTHREADS)
   #define T_MUTEX SDL_mutex *                  
   #define T_MUTEXATTR int                      
   #define T_COND SDL_cond *                    
   #define T_CONDATTR int                       
   #define T_THREAD SDL_Thread *                
   #define T_THREADATTR int                     
#else
   #define T_MUTEX int                          
   #define T_MUTEXATTR int                      
   #define T_COND int                           
   #define T_CONDATTR int                       
   #define T_THREAD int                         
   #define T_THREADATTR int                     
#endif

#define T_MUTEX_INIT(mutex, attr) thread_mutex_init(mutex, attr)           
#define T_MUTEX_LOCK(mutex) thread_mutex_lock(mutex)                       
#define T_MUTEX_TRYLOCK(mutex) thread_mutex_trylock(mutex)                 
#define T_MUTEX_UNLOCK(mutex) thread_mutex_unlock(mutex)                   
#define T_MUTEX_DESTROY(mutex) thread_mutex_destroy(mutex)                 
#define T_COND_INIT(cond, attr) thread_cond_init(cond, attr);              
#define T_COND_SIGNAL(cond) thread_cond_signal(cond)                       
#define T_COND_BROADCAST(cond) thread_cond_broadcast(cond)                 
#define T_COND_WAIT(cond, mutex) thread_cond_wait(cond, mutex)             
#define T_COND_TIMEDWAIT(c, m, t) thread_cond_timedwait(c, m, t)           
#define T_COND_DESTROY(cond) thread_cond_destroy(cond)                     
#define T_RDWR_INIT(rdwrp, attrp) thread_rdwr_init_np(rdwrp, attrp)        
#define T_RDWR_RLOCK(rdwrp) thread_rdwr_rlock_np(rdwrp)                    
#define T_RDWR_RUNLOCK(rdwrp) thread_rdwr_runlock_np(rdwrp)                
#define T_RDWR_WLOCK(rdwrp) thread_rdwr_wlock_np(rdwrp)                    
#define T_RDWR_WUNLOCK(rdwrp) thread_rdwr_wunlock_np(rdwrp)                
#define T_CREATE(t, attr, func, arg) thread_create(t, attr, func, arg)     
#define T_JOIN(t, ret) thread_join(t, ret)                                 
#define T_EXIT(ret) thread_exit(ret)                                       
#define T_CANCEL(t) thread_cancel(t)                                       
/*
 * public structs
 */


typedef struct rdwr_var {
    int readers_reading;          
    int writer_writing;           
    T_MUTEX mutex;                
    T_COND lock_free;             
} T_RDWR;


/*
 * public methods
 */




int thread_create(T_THREAD *thread, T_THREADATTR *attr, void *(*routine)(void *), void *arg);


int thread_join(T_THREAD thread, void **ret);


int thread_exit(void *ret);


int thread_cancel(T_THREAD thread);




int thread_cond_init(T_COND *cond, T_CONDATTR *cond_attr);


int thread_cond_signal(T_COND *cond);


int thread_cond_broadcast(T_COND *cond);


int thread_cond_wait(T_COND *cond, T_MUTEX *mutex);


int thread_cond_timedwait(T_COND *cond, T_MUTEX *mutex, unsigned int timeout);


int thread_cond_destroy(T_COND *cond);




int thread_mutex_init(T_MUTEX *mutex, T_MUTEXATTR *mutexattr);


int thread_mutex_lock(T_MUTEX *mutex);


int thread_mutex_trylock(T_MUTEX *mutex);


int thread_mutex_unlock(T_MUTEX *mutex);


int thread_mutex_destroy(T_MUTEX *mutex);




int thread_rdwr_init_np(T_RDWR *rdwrp, T_RDWRATTR *attrp);


int thread_rdwr_rlock_np(T_RDWR *rdwrp);


int thread_rdwr_runlock_np(T_RDWR *rdwrp);


int thread_rdwr_wlock_np(T_RDWR *rdwrp);


int thread_rdwr_wunlock_np(T_RDWR *rdwrp);


/*
 * private methods
 */




#endif

---