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 static mpdm_t t_new_val(int flags, void *ptr, int size)
  52 {
  53         mpdm_t r = NULL;
  54
  55         if (ptr != NULL) {
  56                 char *ptr2 = malloc(size);
  57                 memcpy(ptr2, ptr, size);
  58
  59                 r = mpdm_new(MPDM_FREE | flags, ptr2, size);
  60         }
  61
  62         return r;
  63 }
  64
  65
  66 /**
  67  * mpdm_sleep - Sleeps a number of milliseconds.
  68  * @msecs: the milliseconds to sleep
  69  *
  70  * Sleeps a number of milliseconds.
  71  * [Threading]
  72  */
  73 void mpdm_sleep(int msecs)
  74 {
  75 #ifdef CONFOPT_WIN32
  76
  77     Sleep(msecs);
  78
  79 #endif
  80
  81 #ifdef CONFOPT_NANOSLEEP
  82     struct timespec ts;
  83
  84     ts.tv_sec   = msecs / 1000;
  85     ts.tv_nsec  = (msecs % 1000) * 1000000;
  86
  87     nanosleep(&ts, NULL);
  88 #endif
  89 }
  90
  91
  92 /** mutexes **/
  93
  94 /**
  95  * mpdm_new_mutex - Creates a new mutex.
  96  *
  97  * Creates a new mutex.
  98  * [Threading]
  99  */
 100 mpdm_t mpdm_new_mutex(void)
 101 {
 102         mpdm_t r = NULL;
 103         char *ptr = NULL;
 104         int size = 0;
 105
 106 #ifdef CONFOPT_WIN32
 107         HANDLE h;
 108
 109         h = CreateMutex(NULL, FALSE, NULL);
 110
 111         if (h != NULL) {
 112                 size = sizeof(h);
 113                 ptr = (char *)&h;
 114         }
 115 #endif
 116
 117 #ifdef CONFOPT_PTHREADS
 118     pthread_mutex_t m;
 119
 120     if (pthread_mutex_init(&m, NULL) == 0) {
 121         size = sizeof(m);
 122         ptr = (char *)&m;
 123     }
 124
 125 #endif
 126
 127         r = t_new_val(0, ptr, size);
 128
 129     return r;
 130 }
 131
 132
 133 /**
 134  * mpdm_mutex_lock - Locks a mutex.
 135  * @mutex: the mutex to be locked
 136  *
 137  * Locks a mutex. If the mutex is not already locked,
 138  * it waits until it is.
 139  * [Threading]
 140  */
 141 void mpdm_mutex_lock(mpdm_t mutex)
 142 {
 143 #ifdef CONFOPT_WIN32
 144         HANDLE *h = (HANDLE *)mutex->data;
 145
 146         WaitForSingleObject(*h, INFINITE);
 147 #endif
 148
 149 #ifdef CONFOPT_PTHREADS
 150     pthread_mutex_t *m = (pthread_mutex_t *)mutex->data;
 151
 152     pthread_mutex_lock(m);
 153 #endif
 154 }
 155
 156
 157 /**
 158  * mpdm_mutex_unlock - Unlocks a mutex.
 159  * @mutex: the mutex to be unlocked
 160  *
 161  * Unlocks a previously locked mutex. The thread
 162  * unlocking the mutex must be the one who locked it.
 163  * [Threading]
 164  */
 165 void mpdm_mutex_unlock(mpdm_t mutex)
 166 {
 167 #ifdef CONFOPT_WIN32
 168         HANDLE *h = (HANDLE *)mutex->data;
 169
 170         ReleaseMutex(*h);
 171 #endif
 172
 173 #ifdef CONFOPT_PTHREADS
 174     pthread_mutex_t *m = (pthread_mutex_t *)mutex->data;
 175
 176     pthread_mutex_unlock(m);
 177 #endif
 178 }
 179
 180
 181 /** semaphores **/
 182
 183 /**
 184  * mpdm_new_semaphore - Creates a new semaphore.
 185  * @init_value: the initial value of the semaphore.
 186  *
 187  * Creates a new semaphore with an @init_value.
 188  * [Threading]
 189  */
 190 mpdm_t mpdm_new_sem(int init_value)
 191 {
 192     char *ptr = NULL;
 193     int size = 0;
 194
 195 #ifdef CONFOPT_WIN32
 196     HANDLE h;
 197
 198     if ((h = CreateSemaphore(NULL, init_value, 0x7fffffff, NULL)) != NULL) {
 199         size = sizeof(h);
 200         ptr = (char *)&h;
 201     }
 202
 203 #endif
 204
 205 #ifdef CONFOPT_POSIXSEMS
 206     sem_t s;
 207
 208     if (sem_init(&s, 0, init_value) == 0) {
 209         size = sizeof(s);
 210         ptr = (char *)&s;
 211     }
 212
 213 #endif
 214
 215     return t_new_val(0, ptr, size);
 216 }
 217
 218
 219 /**
 220  * mpdm_sem_wait - Waits for a semaphore to be ready.
 221  * @sem: the semaphore to wait onto
 222  *
 223  * Waits for the value of a semaphore to be > 0. If it's
 224  * not, the thread waits until it is.
 225  * [Threading]
 226  */
 227 void mpdm_sem_wait(mpdm_t sem)
 228 {
 229 #ifdef CONFOPT_WIN32
 230         HANDLE *h = (HANDLE *)sem->data;
 231
 232         WaitForSingleObject(*h, INFINITE);
 233 #endif
 234
 235 #ifdef CONFOPT_POSIXSEMS
 236     sem_t *s = (sem_t *)sem->data;
 237
 238     sem_wait(s);
 239 #endif
 240 }
 241
 242
 243 /**
 244  * mpdm_sem_post - Increments the value of a semaphore.
 245  * @sem: the semaphore to increment
 246  *
 247  * Increments by 1 the value of a semaphore.
 248  * [Threading]
 249  */
 250 void mpdm_sem_post(mpdm_t sem)
 251 {
 252 #ifdef CONFOPT_WIN32
 253         HANDLE *h = (HANDLE *)sem->data;
 254
 255     ReleaseSemaphore(*h, 1, NULL);
 256 #endif
 257
 258 #ifdef CONFOPT_POSIXSEMS
 259     sem_t *s = (sem_t *)sem->data;
 260
 261     sem_post(s);
 262 #endif
 263 }
 264
 265
 266 /** threads **/
 267
 268 static void thread_caller(mpdm_t a)
 269 {
 270         /* ignore return value */
 271         mpdm_unref(
 272         mpdm_ref(
 273             mpdm_exec(mpdm_aget(a, 0), mpdm_aget(a, 1), mpdm_aget(a, 2))
 274         )
 275     );
 276
 277         /* was referenced in mpdm_exec_thread() */
 278         mpdm_unref(a);
 279 }
 280
 281
 282 #ifdef CONFOPT_WIN32
 283 DWORD WINAPI win32_thread(LPVOID param)
 284 {
 285     thread_caller((mpdm_t) param);
 286
 287         return 0;
 288 }
 289 #endif
 290
 291 #ifdef CONFOPT_PTHREADS
 292 void *pthreads_thread(void *args)
 293 {
 294     thread_caller((mpdm_t) args);
 295
 296     return NULL;
 297 }
 298 #endif
 299
 300 /**
 301  * mpdm_exec_thread - Runs an executable value in a new thread.
 302  * @c: the executable value
 303  * @args: executable arguments
 304  * @ctxt: the context
 305  *
 306  * Runs the @c executable value in a new thread. The code
 307  * starts executing immediately. The @args and @ctxt arguments
 308  * are sent to the executable value as arguments.
 309  *
 310  * Returns a handle for the thread.
 311  * [Threading]
 312  */
 313 mpdm_t mpdm_exec_thread(mpdm_t c, mpdm_t args, mpdm_t ctxt)
 314 {
 315         mpdm_t a;
 316         mpdm_t r = NULL;
 317         char *ptr = NULL;
 318         int size = 0;
 319
 320         if (ctxt == NULL)
 321                 ctxt = MPDM_A(0);
 322
 323         /* to be unreferenced at thread stop */
 324         a = mpdm_ref(MPDM_A(3));
 325
 326         mpdm_aset(a, c, 0);
 327         mpdm_aset(a, args, 1);
 328         mpdm_aset(a, ctxt, 2);
 329
 330 #ifdef CONFOPT_WIN32
 331         HANDLE t;
 332
 333         t = CreateThread(NULL, 0, win32_thread, a, 0, NULL);
 334
 335         if (t != NULL) {
 336                 size = sizeof(t);
 337                 ptr = (char *)&t;
 338         }
 339
 340 #endif
 341
 342 #ifdef CONFOPT_PTHREADS
 343     pthread_t pt;
 344
 345     if (pthread_create(&pt, NULL, pthreads_thread, a) == 0) {
 346         size = sizeof(pthread_t);
 347         ptr = (char *)&pt;
 348     }
 349
 350 #endif
 351
 352         r = t_new_val(0, ptr, size);
 353
 354         return r;
 355 }