threading.c

#include "threading.h"
#include "dbug_mem.h"




int
thread_create(T_THREAD *thread, T_THREADATTR *attr, void *(*routine)(void *), void *arg)
{
#ifdef WITH_PTHREADS
   return pthread_create(thread, attr, routine, arg);
#elif defined(WITH_SDLTHREADS)
   *thread = SDL_CreateThread((int(*)(void *))routine, arg);
   if(*thread != NULL) {
      return 0;
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_join(T_THREAD thread, void **ret)
{
#ifdef WITH_PTHREADS
   return pthread_join(thread, ret);
#elif defined(WITH_SDLTHREADS)
   return -1;
#else
   return 0;
#endif
}


int
thread_exit(void *ret)
{
#ifdef WITH_PTHREADS
   pthread_exit(ret);
   return 0;
#elif defined(WITH_SDLTHREADS)
   return 0;
#else
   return 0;
#endif
}


int
thread_cancel(T_THREAD thread)
{
#ifdef WITH_PTHREADS
   return pthread_cancel(thread);
#elif defined(WITH_SDLTHREADS)
   SDL_KillThread(thread);
   return 0;
#else
   return 0;
#endif
}




int
thread_cond_init(T_COND *cond, T_CONDATTR *cond_attr)
{
#ifdef WITH_PTHREADS
   return pthread_cond_init(cond, cond_attr);
#elif defined(WITH_SDLTHREADS)
   *cond = SDL_CreateCond();
   if(*cond != NULL) {
      return 0;
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_cond_signal(T_COND *cond)
{
#ifdef WITH_PTHREADS
   return pthread_cond_signal(cond);
#elif defined(WITH_SDLTHREADS)
   if(*cond != NULL) {
      return SDL_CondSignal(*cond);
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_cond_broadcast(T_COND *cond)
{
#ifdef WITH_PTHREADS
   return pthread_cond_broadcast(cond);
#elif defined(WITH_SDLTHREADS)
   if(*cond != NULL) {
      return SDL_CondBroadcast(*cond);
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_cond_wait(T_COND *cond, T_MUTEX *mutex)
{
#ifdef WITH_PTHREADS
   return pthread_cond_wait(cond, mutex);
#elif defined(WITH_SDLTHREADS)
   if(*cond != NULL) {
      return SDL_CondWait(*cond, *mutex);
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_cond_timedwait(T_COND *cond, T_MUTEX *mutex, unsigned int timeout)
{
#ifdef WITH_PTHREADS
   struct timeval now;
   struct timespec to;

   gettimeofday(&now, NULL);
   to.tv_sec = now.tv_sec + (long)(timeout/1000);
   to.tv_nsec = now.tv_usec * 1000 * (long)((timeout%1000)*1000);
   if (pthread_cond_timedwait(cond, mutex, &to) != 0) {
      if (errno == ETIMEDOUT) {
         return 1;
      }
      return -1;
   }
   return 0;
#elif defined(WITH_SDLTHREADS)
   int retcode = 0;
   
   if(*cond != NULL) {
      retcode = SDL_CondWaitTimeout(*cond, *mutex, timeout);
      if (retcode == SDL_MUTEX_TIMEDOUT) {
         return 1;
      }
      return retcode;
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_cond_destroy(T_COND *cond)
{
#ifdef WITH_PTHREADS
   return pthread_cond_destroy(cond);
#elif defined(WITH_SDLTHREADS)
   if(*cond != NULL) {
      SDL_DestroyCond(*cond);
      return 0;
   }
   return -1;
#else
   return 0;
#endif
}




int
thread_mutex_init(T_MUTEX *mutex, T_MUTEXATTR *mutexattr)
{
#ifdef WITH_PTHREADS
   return pthread_mutex_init(mutex, mutexattr);
#elif defined(WITH_SDLTHREADS)
   *mutex = SDL_CreateMutex();
   if(*mutex != NULL) {
      return 0;
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_mutex_lock(T_MUTEX *mutex)
{
#ifdef WITH_PTHREADS
   return pthread_mutex_lock(mutex);
#elif defined(WITH_SDLTHREADS)
   if(*mutex != NULL) {
      return SDL_mutexP(*mutex);
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_mutex_trylock(T_MUTEX *mutex)
{
#ifdef WITH_PTHREADS
   return pthread_mutex_trylock(mutex);
#elif defined(WITH_SDLTHREADS)
   if(*mutex != NULL) {
      return SDL_mutexP(*mutex);
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_mutex_unlock(T_MUTEX *mutex)
{
#ifdef WITH_PTHREADS
   return pthread_mutex_unlock(mutex);
#elif defined(WITH_SDLTHREADS)
   if(*mutex != NULL) {
      return SDL_mutexV(*mutex);
   }
   return -1;
#else
   return 0;
#endif
}


int
thread_mutex_destroy(T_MUTEX *mutex)
{
#ifdef WITH_PTHREADS
   return pthread_mutex_destroy(mutex);
#elif defined(WITH_SDLTHREADS)
   if(*mutex != NULL) {
      SDL_DestroyMutex(*mutex);
      return 0;
   }
   return -1;
#else
   return 0;
#endif
}




int
thread_rdwr_init_np(T_RDWR *rdwrp, T_RDWRATTR *attrp)
{
#ifdef WITH_PTHREADS
    rdwrp->readers_reading = 0;
    rdwrp->writer_writing = 0;
    T_MUTEX_INIT(&(rdwrp->mutex), NULL);
    T_COND_INIT(&(rdwrp->lock_free), NULL);
   return 0;
#elif defined(WITH_SDLTHREADS)
   return 0;
#else
   return 0;
#endif
}


int
thread_rdwr_rlock_np(T_RDWR *rdwrp)
{
#ifdef WITH_PTHREADS
    T_MUTEX_LOCK(&(rdwrp->mutex));
    while(rdwrp->writer_writing) {
        T_COND_WAIT(&(rdwrp->lock_free), &(rdwrp->mutex));
    }
    rdwrp->readers_reading++;
    T_MUTEX_UNLOCK(&(rdwrp->mutex));
   return 0;
#elif defined(WITH_SDLTHREADS)
   return 0;
#else
   return 0;
#endif
}


int
thread_rdwr_runlock_np(T_RDWR *rdwrp)
{
#ifdef WITH_PTHREADS
    T_MUTEX_LOCK(&(rdwrp->mutex));
    if (rdwrp->readers_reading == 0) {
        T_MUTEX_UNLOCK(&(rdwrp->mutex));
        return -1;
    } else {
        rdwrp->readers_reading--;
        if (rdwrp->readers_reading == 0) {
            T_COND_SIGNAL(&(rdwrp->lock_free));
        }
        T_MUTEX_UNLOCK(&(rdwrp->mutex));
        return 0;
    }
#elif defined(WITH_SDLTHREADS)
   return 0;
#else
   return 0;
#endif
}


int
thread_rdwr_wlock_np(T_RDWR *rdwrp)
{
#ifdef WITH_PTHREADS
    T_MUTEX_LOCK(&(rdwrp->mutex));
    while(rdwrp->writer_writing || rdwrp->readers_reading) {
        T_COND_WAIT(&(rdwrp->lock_free), &(rdwrp->mutex));
    }
    rdwrp->writer_writing++;
    T_MUTEX_UNLOCK(&(rdwrp->mutex));
   return 0;
#elif defined(WITH_SDLTHREADS)
   return 0;
#else
   return 0;
#endif
}


int
thread_rdwr_wunlock_np(T_RDWR *rdwrp)
{
#ifdef WITH_PTHREADS
    T_MUTEX_LOCK(&(rdwrp->mutex));
    if (rdwrp->writer_writing == 0) {
        T_MUTEX_UNLOCK(&(rdwrp->mutex));
        return -1;
    }
    else {
        rdwrp->writer_writing = 0;
        T_COND_BROADCAST(&(rdwrp->lock_free));
        T_MUTEX_UNLOCK(&(rdwrp->mutex));
        return 0;
    }
#elif defined(WITH_SDLTHREADS)
   return 0;
#else
   return 0;
#endif
}

---