Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Use xbt_thread_yield explicitely instead of Sleep(0). This is the same effect, but...
[simgrid.git] / src / xbt / xbt_thread.c
1 /* $Id$ */
2
3 /* xbt_thread -- portability layer over the pthread API                     */
4
5 /* Copyright 2006,2007 Malek Cherier, Martin Quinson          
6  * All right reserved.                                                      */
7
8 /* This program is free software; you can redistribute it and/or modify it
9  * under the terms of the license (GNU LGPL) which comes with this package. */
10
11 #include "xbt/sysdep.h"
12 #include "xbt/ex.h"
13 #include "portable.h"
14 #include "xbt/xbt_thread.h" /* This module */
15 #include "xbt_modinter.h" /* Initialization/finalization of this module */
16
17
18
19 /* ********************************* PTHREAD IMPLEMENTATION ************************************ */
20 #ifdef HAVE_PTHREAD_H
21 #include <pthread.h>
22
23 typedef struct xbt_thread_ {
24    pthread_t t;
25    void *param;
26    pvoid_f_pvoid_t *start_routine;
27 } s_xbt_thread_t ;
28
29 /* thread-specific data containing the xbt_thread_t structure */
30 static pthread_key_t xbt_self_thread_key;
31
32 /* frees the xbt_thread_t corresponding to the current thread */
33 static void xbt_thread_free_thread_data(void*d){
34    free(d);
35 }
36
37 void xbt_thread_mod_init(void) {
38    int errcode;
39    
40    if ((errcode=pthread_key_create(&xbt_self_thread_key, NULL)))
41      THROW0(system_error,errcode,"pthread_key_create failed for xbt_self_thread_key");
42 }
43 void xbt_thread_mod_exit(void) {
44    /* FIXME: don't try to free our key on shutdown. Valgrind detects no leak if we don't, and whine if we try to */
45 //   int errcode;
46    
47 //   if ((errcode=pthread_key_delete(xbt_self_thread_key)))
48 //     THROW0(system_error,errcode,"pthread_key_delete failed for xbt_self_thread_key");
49 }
50
51 static void * wrapper_start_routine(void *s) {
52   xbt_thread_t t = s;   
53   int errcode;
54
55   if ((errcode=pthread_setspecific(xbt_self_thread_key,t)))
56     THROW0(system_error,errcode,"pthread_setspecific failed for xbt_self_thread_key");   
57   return t->start_routine(t->param);
58 }
59
60 xbt_thread_t xbt_thread_create(pvoid_f_pvoid_t start_routine,
61                                void* param)  {
62    int errcode;
63
64    xbt_thread_t res_thread=xbt_new(s_xbt_thread_t,1);
65    res_thread->start_routine = start_routine;
66    res_thread->param = param;
67
68    
69    if ((errcode = pthread_create(&(res_thread->t), NULL, wrapper_start_routine, res_thread)))
70      THROW0(system_error,errcode, "pthread_create failed");
71
72    return res_thread;
73 }
74
75 void 
76 xbt_thread_join(xbt_thread_t thread,void ** thread_return) {
77         
78         int errcode;   
79         
80         if ((errcode = pthread_join(thread->t,thread_return)))
81                 THROW0(system_error,errcode, "pthread_join failed");
82 }                      
83
84 void xbt_thread_exit(int *retval) {
85    pthread_exit(retval);
86 }
87
88 xbt_thread_t xbt_thread_self(void) {
89    return pthread_getspecific(xbt_self_thread_key);
90 }
91
92 #include <sched.h>
93 void xbt_thread_yield(void) {
94    sched_yield();
95 }
96 /****** mutex related functions ******/
97 typedef struct xbt_mutex_ {
98    pthread_mutex_t m;
99 } s_xbt_mutex_t;
100
101 xbt_mutex_t xbt_mutex_init(void) {
102    xbt_mutex_t res = xbt_new(s_xbt_mutex_t,1);
103    int errcode;
104    
105    if ((errcode = pthread_mutex_init(&(res->m),NULL)))
106      THROW0(system_error,errcode,"pthread_mutex_init() failed");
107    
108    return res;
109 }
110
111 void xbt_mutex_lock(xbt_mutex_t mutex) {
112    int errcode;
113    
114    if ((errcode=pthread_mutex_lock(&(mutex->m))))
115      THROW1(system_error,errcode,"pthread_mutex_lock(%p) failed",mutex);
116 }
117
118 void xbt_mutex_unlock(xbt_mutex_t mutex) {
119    int errcode;
120    
121    if ((errcode=pthread_mutex_unlock(&(mutex->m))))
122      THROW1(system_error,errcode,"pthread_mutex_unlock(%p) failed",mutex);
123 }
124
125 void xbt_mutex_destroy(xbt_mutex_t mutex) {
126    int errcode;
127    
128    if (!mutex) return;
129    
130    if ((errcode=pthread_mutex_destroy(&(mutex->m))))
131      THROW1(system_error,errcode,"pthread_mutex_destroy(%p) failed",mutex);
132    free(mutex);
133 }
134
135 /***** condition related functions *****/
136 typedef struct xbt_thcond_ {
137    pthread_cond_t c;
138 } s_xbt_thcond_t;
139
140 xbt_thcond_t xbt_thcond_init(void) {
141    xbt_thcond_t res = xbt_new(s_xbt_thcond_t,1);
142    int errcode;
143    if ((errcode=pthread_cond_init(&(res->c),NULL)))
144      THROW0(system_error,errcode,"pthread_cond_init() failed");
145
146    return res;
147 }
148
149 void xbt_thcond_wait(xbt_thcond_t cond, xbt_mutex_t mutex) {
150    int errcode;
151    if ((errcode=pthread_cond_wait(&(cond->c),&(mutex->m))))
152      THROW2(system_error,errcode,"pthread_cond_wait(%p,%p) failed",cond,mutex);
153 }
154
155 void xbt_thcond_signal(xbt_thcond_t cond) {
156    int errcode;
157    if ((errcode=pthread_cond_signal(&(cond->c))))
158      THROW1(system_error,errcode,"pthread_cond_signal(%p) failed",cond);
159 }
160          
161 void xbt_thcond_broadcast(xbt_thcond_t cond){
162    int errcode;
163    if ((errcode=pthread_cond_broadcast(&(cond->c))))
164      THROW1(system_error,errcode,"pthread_cond_broadcast(%p) failed",cond);
165 }
166 void xbt_thcond_destroy(xbt_thcond_t cond){
167    int errcode;
168
169    if (!cond) return;
170
171    if ((errcode=pthread_cond_destroy(&(cond->c))))
172      THROW1(system_error,errcode,"pthread_cond_destroy(%p) failed",cond);
173    free(cond);
174 }
175
176 /* ********************************* WINDOWS IMPLEMENTATION ************************************ */
177
178 #elif defined(WIN32)
179
180 typedef struct xbt_thread_ {
181   HANDLE handle;                  /* the win thread handle        */
182   unsigned long id;               /* the win thread id            */
183   pvoid_f_pvoid_t *start_routine;
184   void* param;
185 } s_xbt_thread_t ;
186
187 /* key to the TLS containing the xbt_thread_t structure */
188 static unsigned long xbt_self_thread_key;
189
190 void xbt_thread_mod_init(void) {
191    xbt_self_thread_key = TlsAlloc();
192 }
193 void xbt_thread_mod_exit(void) {
194    
195    if (!TlsFree(xbt_self_thread_key)) 
196      THROW0(system_error,(int)GetLastError(),"TlsFree() failed to cleanup the thread submodule");
197 }
198
199 static DWORD WINAPI  wrapper_start_routine(void *s) {
200   xbt_thread_t t = (xbt_thread_t)s;
201  
202     if(!TlsSetValue(xbt_self_thread_key,t))
203      THROW0(system_error,(int)GetLastError(),"TlsSetValue of data describing the created thread failed");
204    
205    return (DWORD)t->start_routine(t->param);
206 }
207
208
209 xbt_thread_t xbt_thread_create(pvoid_f_pvoid_t start_routine,
210                                void* param)  {
211    
212    xbt_thread_t t = xbt_new(s_xbt_thread_t,1);
213
214    t->start_routine = start_routine ;
215    t->param = param;
216    
217    t->handle = CreateThread(NULL,0,
218                             (LPTHREAD_START_ROUTINE)wrapper_start_routine,
219                             t,0,&(t->id));
220         
221    if(!t->handle) {
222      xbt_free(t);
223      THROW0(system_error,(int)GetLastError(),"CreateThread failed");
224    }
225    
226    return t;
227 }
228
229 void 
230 xbt_thread_join(xbt_thread_t thread,void ** thread_return) {
231
232         if(WAIT_OBJECT_0 != WaitForSingleObject(thread->handle,INFINITE))  
233                 THROW0(system_error,(int)GetLastError(), "WaitForSingleObject failed");
234                 
235         if(thread_return){
236                 
237                 if(!GetExitCodeThread(thread->handle,(DWORD*)(*thread_return)))
238                         THROW0(system_error,(int)GetLastError(), "GetExitCodeThread failed");
239         }
240         
241         CloseHandle(thread->handle);
242 }
243
244 void xbt_thread_exit(int *retval) {
245    if(retval)
246         ExitThread(*retval);
247    else
248         ExitThread(0);
249 }
250
251 xbt_thread_t xbt_thread_self(void) {
252    return TlsGetValue(xbt_self_thread_key);
253 }
254
255 void xbt_thread_yield(void) {
256     Sleep(0);
257 }
258
259 /****** mutex related functions ******/
260 typedef struct xbt_mutex_ {
261    CRITICAL_SECTION lock;   
262 } s_xbt_mutex_t;
263
264 xbt_mutex_t xbt_mutex_init(void) {
265    xbt_mutex_t res = xbt_new(s_xbt_mutex_t,1);
266
267    /* initialize the critical section object */
268    InitializeCriticalSection(&(res->lock));
269    
270    return res;
271 }
272
273 void xbt_mutex_lock(xbt_mutex_t mutex) {
274
275    EnterCriticalSection(& mutex->lock);
276 }
277
278 void xbt_mutex_unlock(xbt_mutex_t mutex) {
279
280    LeaveCriticalSection (& mutex->lock);
281
282 }
283
284 void xbt_mutex_destroy(xbt_mutex_t mutex) {
285
286    if (!mutex) return;
287    
288    DeleteCriticalSection(& mutex->lock);                
289    free(mutex);
290 }
291
292 /***** condition related functions *****/
293  enum {
294     SIGNAL = 0,
295     BROADCAST = 1,
296     MAX_EVENTS = 2
297  };
298
299 typedef struct xbt_thcond_ {
300    HANDLE events[MAX_EVENTS];
301    
302    unsigned int waiters_count;           /* the number of waiters                        */
303    CRITICAL_SECTION waiters_count_lock;  /* protect access to waiters_count  */
304 } s_xbt_thcond_t;
305
306 xbt_thcond_t xbt_thcond_init(void) {
307
308    xbt_thcond_t res = xbt_new0(s_xbt_thcond_t,1);
309         
310    memset(& res->waiters_count_lock,0,sizeof(CRITICAL_SECTION));
311         
312    /* initialize the critical section object */
313    InitializeCriticalSection(& res->waiters_count_lock);
314         
315    res->waiters_count = 0;
316         
317    /* Create an auto-reset event */
318    res->events[SIGNAL] = CreateEvent (NULL, FALSE, FALSE, NULL); 
319         
320    if(!res->events[SIGNAL]){
321       DeleteCriticalSection(& res->waiters_count_lock);
322       free(res);
323       THROW0(system_error,0,"CreateEvent failed for the signals");
324    }
325         
326    /* Create a manual-reset event. */
327    res->events[BROADCAST] = CreateEvent (NULL, TRUE, FALSE,NULL);
328         
329    if(!res->events[BROADCAST]){
330                 
331       DeleteCriticalSection(& res->waiters_count_lock);         
332       CloseHandle(res->events[SIGNAL]);
333       free(res); 
334       THROW0(system_error,0,"CreateEvent failed for the broadcasts");
335    }
336
337    return res;
338 }
339
340 void xbt_thcond_wait(xbt_thcond_t cond, xbt_mutex_t mutex) {
341         
342    unsigned long wait_result;
343    int is_last_waiter;
344
345    /* lock the threads counter and increment it */
346    EnterCriticalSection (& cond->waiters_count_lock);
347    cond->waiters_count++;
348    LeaveCriticalSection (& cond->waiters_count_lock);
349                 
350    /* unlock the mutex associate with the condition */
351    LeaveCriticalSection (& mutex->lock);
352         
353    /* wait for a signal (broadcast or no) */
354    wait_result = WaitForMultipleObjects (2, cond->events, FALSE, INFINITE);
355         
356    if(wait_result == WAIT_FAILED)
357      THROW0(system_error,0,"WaitForMultipleObjects failed, so we cannot wait on the condition");
358         
359    /* we have a signal lock the condition */
360    EnterCriticalSection (& cond->waiters_count_lock);
361    cond->waiters_count--;
362         
363    /* it's the last waiter or it's a broadcast ? */
364    is_last_waiter = ((wait_result == WAIT_OBJECT_0 + BROADCAST - 1) && (cond->waiters_count == 0));
365         
366    LeaveCriticalSection (& cond->waiters_count_lock);
367         
368    /* yes it's the last waiter or it's a broadcast
369     * only reset the manual event (the automatic event is reset in the WaitForMultipleObjects() function
370     * by the system. 
371     */
372    if (is_last_waiter)
373       if(!ResetEvent (cond->events[BROADCAST]))
374         THROW0(system_error,0,"ResetEvent failed");
375         
376    /* relock the mutex associated with the condition in accordance with the posix thread specification */
377    EnterCriticalSection (& mutex->lock);
378 }
379
380 void xbt_thcond_signal(xbt_thcond_t cond) {
381    int have_waiters;
382
383    EnterCriticalSection (& cond->waiters_count_lock);
384    have_waiters = cond->waiters_count > 0;
385    LeaveCriticalSection (& cond->waiters_count_lock);
386         
387    if (have_waiters)
388      if(!SetEvent(cond->events[SIGNAL]))
389        THROW0(system_error,0,"SetEvent failed");
390        
391    xbt_thread_yield();
392 }
393
394 void xbt_thcond_broadcast(xbt_thcond_t cond){
395    int have_waiters;
396
397    EnterCriticalSection (& cond->waiters_count_lock);
398    have_waiters = cond->waiters_count > 0;
399    LeaveCriticalSection (& cond->waiters_count_lock);
400         
401    if (have_waiters)
402      SetEvent(cond->events[BROADCAST]);
403 }
404
405 void xbt_thcond_destroy(xbt_thcond_t cond){
406    int error = 0;
407    
408    if (!cond) return;
409    
410    if(!CloseHandle(cond->events[SIGNAL]))
411      error = 1;
412         
413    if(!CloseHandle(cond->events[BROADCAST]))
414      error = 1;
415         
416    DeleteCriticalSection(& cond->waiters_count_lock);
417         
418    xbt_free(cond);
419    
420    if (error)
421      THROW0(system_error,0,"Error while destroying the condition");
422 }
423
424 #endif