/simpletypesystem/trunk

#include "Thread.h"

/*

  Utility functions associated with threads.

 */

void

s_usleep (slong us) {

#if __WIN32__ || __WIN64__

  /* We are a windows system, so we have to implement our own little sleeper.*/

  Sleep (us / 1000)

#else

  /* We are not a windows system, so lets assume that we have posix's nanosleep

   * Taken from:

   */

  struct timespec req = {0};

  req.tv_sec = (int)(us / 1000);

  req.tv_nsec = us * 1000000L;

  nanosleep(&req, (struct timespec *)NULL);

#endif

}

char *

s_thread_status_get_name (SThreadStatus status) {

  switch (status) {

    case (S_THREAD_STATUS_SUCCESS):

      return SThreadStatusName[0];

      break;

    case (S_THREAD_STATUS_TIMEOUT):

      return SThreadStatusName[1];

      break;

    case (S_THREAD_STATUS_ERROR):

      return SThreadStatusName[2];

      break;

    case (S_THREAD_STATUS_BUSY):

      return SThreadStatusName[3];

      break;

    case (S_THREAD_STATUS_NO_MEM):

      return SThreadStatusName[4];

      break;

    case (S_THREAD_STATUS_LAST):

      return SThreadStatusName[5];

      break;

    default:

      return NULL;

  }

}

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

 ********************************** SMutex ************************************

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

struct SMutex {

  mtx_t *  mutex;

  _Atomic(sboolean) locked;

};

schar *

s_mutex_flag_get_name (SMutexFlag flag) {

  switch (flag) {

    case (S_MUTEX_FLAG_PLAIN):

      return SMutexFlagName[0];

      break;

    case (S_MUTEX_FLAG_TIMED):

      return SMutexFlagName[1];

      break;

    case (S_MUTEX_FLAG_RECURSIVE):

      return SMutexFlagName[2];

      break;

    case (S_MUTEX_FLAG_LAST):

      return SMutexFlagName[3];

      break;

    default:

      return NULL;

  }

}

SMutex *

s_mutex_new () {

  SMutex * self = s_malloc (sizeof (SMutex));

  self->mutex = s_malloc (sizeof (mtx_t));

  atomic_init(&(self->locked), FALSE);

  sint status = mtx_init (self->mutex, mtx_plain);

  if (status == thrd_success) {

    return self;

  }

  s_free (self);

  s_err_print ("Could not create thrad. Error: %s.\n",

               s_thread_status_get_name (status));

  print_backtrace ();

  return NULL;

}

void

s_mutex_free (SMutex * self) {

  mtx_destroy (self->mutex);

  s_free (self->mutex);

  s_free (self);

}

SThreadStatus

s_mutex_lock (SMutex * self) {

  sint ret_val = mtx_lock (self->mutex);

  atomic_store(&(self->locked), TRUE);

  return ret_val;

}

SThreadStatus

s_mutex_unlock (SMutex * self) {

  sint ret_val = mtx_unlock (self->mutex);

  atomic_store(&(self->locked), FALSE);

  return ret_val;

}

SThreadStatus

s_mutex_check_lock (SMutex * self) {

  return atomic_load(&(self->locked));

}

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

 ********************************** SThread ***********************************

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

/*

 * Since SThread are, effectivaly, the same as thrd_t, we can cast it

 * back and forth without any real problems...?

 */

struct SThread {

  thrd_t thread;

  RunFunc func;

  _Atomic(sboolean) is_running;

};

SThread *

s_thread_new (RunFunc func) {

  SThread * self = s_malloc (sizeof (SThread));

  self->func = func;

  atomic_store (&(self->is_running), FALSE);

  return self;

}

void

s_thread_free (SThread * self) {

  assert (!(atomic_load(&(self->is_running))));

  s_free (self);

}

SThreadStatus

s_thread_run (SThread * self, spointer user_data) {

  if (atomic_load(&(self->is_running)) == TRUE ) {

    s_err_print ("Trying to run a thread that allready is running."

                  "Returning.\n");

    return S_THREAD_STATUS_ERROR;

  }

  atomic_store(&(self->is_running), TRUE);

  return thrd_create ((thrd_t *)self, (thrd_start_t)self->func, user_data);

}

void

s_thread_stop (SThread * self, sint res) {

  if (!thrd_equal (self->thread, thrd_current ())) {

    s_err_print ("Trying to exit thread that is not owned by current thread.\n"

                  "Can only be called from running thread.\n");

    return;

  }

  atomic_store (&(self->is_running), FALSE);

  thrd_exit (res);

}