mpdm_t.c

   1 /*
   2
   3     MPDM - Minimum Profit Data Manager
   4     Copyright (C) 2003/2010 Angel Ortega <angel@triptico.com>
   5
   6     mpdm_t.c - Threading primitives
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <locale.h>
  32 #include <time.h>
  33
  34 #ifdef CONFOPT_WIN32
  35 #include <windows.h>
  36 #endif
  37
  38 #ifdef CONFOPT_PTHREADS
  39 #include <pthread.h>
  40 #endif
  41
  42 #ifdef CONFOPT_POSIXSEMS
  43 #include <semaphore.h>
  44 #endif
  45
  46 #include "mpdm.h"
  47
  48
  49 /** code **/
  50
  51 /**
  52  * mpdm_sleep - Sleeps a number of milliseconds.
  53  * @msecs: the milliseconds to sleep
  54  *
  55  * Sleeps a number of milliseconds.
  56  * [Threading]
  57  */
  58 void mpdm_sleep(int msecs)
  59 {
  60 #ifdef CONFOPT_WIN32
  61
  62     Sleep(msecs);
  63
  64 #endif
  65
  66 #ifdef CONFOPT_NANOSLEEP
  67     struct timespec ts;
  68
  69     ts.tv_sec = msecs / 1000;
  70     ts.tv_nsec = (msecs % 1000) * 1000000;
  71
  72     nanosleep(&ts, NULL);
  73 #endif
  74 }
  75
  76
  77 /** mutexes **/
  78
  79 /**
  80  * mpdm_new_mutex - Creates a new mutex.
  81  *
  82  * Creates a new mutex.
  83  * [Threading]
  84  */
  85 mpdm_t mpdm_new_mutex(void)
  86 {
  87     char *ptr = NULL;
  88     int size = 0;
  89
  90 #ifdef CONFOPT_WIN32
  91     HANDLE h;
  92
  93     h = CreateMutex(NULL, FALSE, NULL);
  94
  95     if (h != NULL) {
  96         size = sizeof(h);
  97         ptr = (char *) &h;
  98     }
  99 #endif
 100
 101 #ifdef CONFOPT_PTHREADS
 102     pthread_mutex_t m;
 103
 104     if (pthread_mutex_init(&m, NULL) == 0) {
 105         size = sizeof(m);
 106         ptr = (char *) &m;
 107     }
 108
 109 #endif
 110
 111     return MPDM_C(MPDM_MUTEX, ptr, size);
 112 }
 113
 114
 115 /**
 116  * mpdm_mutex_lock - Locks a mutex.
 117  * @mutex: the mutex to be locked
 118  *
 119  * Locks a mutex. If the mutex is not already locked,
 120  * it waits until it is.
 121  * [Threading]
 122  */
 123 void mpdm_mutex_lock(mpdm_t mutex)
 124 {
 125 #ifdef CONFOPT_WIN32
 126     HANDLE *h = (HANDLE *) mutex->data;
 127
 128     WaitForSingleObject(*h, INFINITE);
 129 #endif
 130
 131 #ifdef CONFOPT_PTHREADS
 132     pthread_mutex_t *m = (pthread_mutex_t *) mutex->data;
 133
 134     pthread_mutex_lock(m);
 135 #endif
 136 }
 137
 138
 139 /**
 140  * mpdm_mutex_unlock - Unlocks a mutex.
 141  * @mutex: the mutex to be unlocked
 142  *
 143  * Unlocks a previously locked mutex. The thread
 144  * unlocking the mutex must be the one who locked it.
 145  * [Threading]
 146  */
 147 void mpdm_mutex_unlock(mpdm_t mutex)
 148 {
 149 #ifdef CONFOPT_WIN32
 150     HANDLE *h = (HANDLE *) mutex->data;
 151
 152     ReleaseMutex(*h);
 153 #endif
 154
 155 #ifdef CONFOPT_PTHREADS
 156     pthread_mutex_t *m = (pthread_mutex_t *) mutex->data;
 157
 158     pthread_mutex_unlock(m);
 159 #endif
 160 }
 161
 162
 163 /** semaphores **/
 164
 165 /**
 166  * mpdm_new_semaphore - Creates a new semaphore.
 167  * @init_value: the initial value of the semaphore.
 168  *
 169  * Creates a new semaphore with an @init_value.
 170  * [Threading]
 171  */
 172 mpdm_t mpdm_new_semaphore(int init_value)
 173 {
 174     char *ptr = NULL;
 175     int size = 0;
 176
 177 #ifdef CONFOPT_WIN32
 178     HANDLE h;
 179
 180     if ((h = CreateSemaphore(NULL, init_value, 0x7fffffff, NULL)) != NULL) {
 181         size = sizeof(h);
 182         ptr = (char *) &h;
 183     }
 184
 185 #endif
 186
 187 #ifdef CONFOPT_POSIXSEMS
 188     sem_t s;
 189
 190     if (sem_init(&s, 0, init_value) == 0) {
 191         size = sizeof(s);
 192         ptr = (char *) &s;
 193     }
 194
 195 #endif
 196
 197     return MPDM_C(MPDM_SEMAPHORE, ptr, size);
 198 }
 199
 200
 201 /**
 202  * mpdm_semaphore_wait - Waits for a semaphore to be ready.
 203  * @sem: the semaphore to wait onto
 204  *
 205  * Waits for the value of a semaphore to be > 0. If it's
 206  * not, the thread waits until it is.
 207  * [Threading]
 208  */
 209 void mpdm_semaphore_wait(mpdm_t sem)
 210 {
 211 #ifdef CONFOPT_WIN32
 212     HANDLE *h = (HANDLE *) sem->data;
 213
 214     WaitForSingleObject(*h, INFINITE);
 215 #endif
 216
 217 #ifdef CONFOPT_POSIXSEMS
 218     sem_t *s = (sem_t *) sem->data;
 219
 220     sem_wait(s);
 221 #endif
 222 }
 223
 224
 225 /**
 226  * mpdm_semaphore_post - Increments the value of a semaphore.
 227  * @sem: the semaphore to increment
 228  *
 229  * Increments by 1 the value of a semaphore.
 230  * [Threading]
 231  */
 232 void mpdm_semaphore_post(mpdm_t sem)
 233 {
 234 #ifdef CONFOPT_WIN32
 235     HANDLE *h = (HANDLE *) sem->data;
 236
 237     ReleaseSemaphore(*h, 1, NULL);
 238 #endif
 239
 240 #ifdef CONFOPT_POSIXSEMS
 241     sem_t *s = (sem_t *) sem->data;
 242
 243     sem_post(s);
 244 #endif
 245 }
 246
 247
 248 /** threads **/
 249
 250 static void thread_caller(mpdm_t a)
 251 {
 252     /* ignore return value */
 253     mpdm_void(mpdm_exec
 254               (mpdm_aget(a, 0), mpdm_aget(a, 1), mpdm_aget(a, 2)));
 255
 256     /* was referenced in mpdm_exec_thread() */
 257     mpdm_unref(a);
 258 }
 259
 260
 261 #ifdef CONFOPT_WIN32
 262 DWORD WINAPI win32_thread(LPVOID param)
 263 {
 264     thread_caller((mpdm_t) param);
 265
 266     return 0;
 267 }
 268 #endif
 269
 270 #ifdef CONFOPT_PTHREADS
 271 void *pthreads_thread(void *args)
 272 {
 273     thread_caller((mpdm_t) args);
 274
 275     return NULL;
 276 }
 277 #endif
 278
 279 /**
 280  * mpdm_exec_thread - Runs an executable value in a new thread.
 281  * @c: the executable value
 282  * @args: executable arguments
 283  * @ctxt: the context
 284  *
 285  * Runs the @c executable value in a new thread. The code
 286  * starts executing immediately. The @args and @ctxt arguments
 287  * are sent to the executable value as arguments.
 288  *
 289  * Returns a handle for the thread.
 290  * [Threading]
 291  */
 292 mpdm_t mpdm_exec_thread(mpdm_t c, mpdm_t args, mpdm_t ctxt)
 293 {
 294     mpdm_t a;
 295     char *ptr = NULL;
 296     int size = 0;
 297
 298     if (ctxt == NULL)
 299         ctxt = MPDM_A(0);
 300
 301     /* to be unreferenced at thread stop */
 302     a = mpdm_ref(MPDM_A(3));
 303
 304     mpdm_aset(a, c, 0);
 305     mpdm_aset(a, args, 1);
 306     mpdm_aset(a, ctxt, 2);
 307
 308 #ifdef CONFOPT_WIN32
 309     HANDLE t;
 310
 311     t = CreateThread(NULL, 0, win32_thread, a, 0, NULL);
 312
 313     if (t != NULL) {
 314         size = sizeof(t);
 315         ptr = (char *) &t;
 316     }
 317
 318 #endif
 319
 320 #ifdef CONFOPT_PTHREADS
 321     pthread_t pt;
 322
 323     if (pthread_create(&pt, NULL, pthreads_thread, a) == 0) {
 324         size = sizeof(pthread_t);
 325         ptr = (char *) &pt;
 326     }
 327
 328 #endif
 329
 330     return MPDM_C(MPDM_THREAD, ptr, size);
 331 }