Fix two bugs: 1) If abs_time is NULL, should use infinite time. 2) Check
[platform/upstream/glib.git] / gthread / gthread-win32.c
1 /* GLIB - Library of useful routines for C programming
2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
3  *
4  * gthread.c: solaris thread system implementation
5  * Copyright 1998-2001 Sebastian Wilhelmi; University of Karlsruhe
6  * Copyright 2001 Hans Breuer
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library 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 GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23
24 /*
25  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
26  * file for a list of people on the GLib Team.  See the ChangeLog
27  * files for a list of changes.  These files are distributed with
28  * GLib at ftp://ftp.gtk.org/pub/gtk/. 
29  */
30
31 /* 
32  * MT safe
33  */
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 #include <glib.h>
40
41 #define STRICT
42 #include <windows.h>
43 #undef STRICT
44
45 #include <process.h>
46 #include <stdlib.h>
47
48 #define win32_check_for_error(what) G_STMT_START{                       \
49   if (!(what))                                                          \
50     g_error ("file %s: line %d (%s): error %s during %s",               \
51              __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION,                \
52              g_win32_error_message (GetLastError ()), #what);           \
53   }G_STMT_END
54
55 #define G_MUTEX_SIZE (sizeof (gpointer))
56
57 #define PRIORITY_LOW_VALUE    THREAD_PRIORITY_BELOW_NORMAL
58 #define PRIORITY_NORMAL_VALUE THREAD_PRIORITY_NORMAL
59 #define PRIORITY_HIGH_VALUE   THREAD_PRIORITY_ABOVE_NORMAL
60 #define PRIORITY_URGENT_VALUE THREAD_PRIORITY_HIGHEST
61
62 static DWORD g_thread_self_tls;
63 static DWORD g_private_tls;
64 static DWORD g_cond_event_tls;
65 static CRITICAL_SECTION g_thread_global_spinlock;
66
67 typedef BOOL (__stdcall *GTryEnterCriticalSectionFunc) (CRITICAL_SECTION *);
68
69 static GTryEnterCriticalSectionFunc try_enter_critical_section = NULL;
70
71 /* As noted in the docs, GPrivate is a limited resource, here we take
72  * a rather low maximum to save memory, use GStaticPrivate instead. */
73 #define G_PRIVATE_MAX 16
74
75 static GDestroyNotify g_private_destructors[G_PRIVATE_MAX];
76
77 static guint g_private_next = 0;
78
79 typedef struct _GThreadData GThreadData;
80 struct _GThreadData
81 {
82   GThreadFunc func;
83   gpointer data;
84   HANDLE thread;
85   gboolean joinable;
86 };
87
88 struct _GCond 
89 {
90   GPtrArray *array;
91   CRITICAL_SECTION lock;
92 };
93
94 static GMutex *
95 g_mutex_new_win32_cs_impl (void)
96 {
97   CRITICAL_SECTION *cs = g_new (CRITICAL_SECTION, 1);
98   gpointer *retval = g_new (gpointer, 1);
99
100   InitializeCriticalSection (cs);
101   *retval = cs;
102   return (GMutex *) retval;
103 }
104
105 static void
106 g_mutex_free_win32_cs_impl (GMutex *mutex)
107 {
108   gpointer *ptr = (gpointer *) mutex;
109   CRITICAL_SECTION *cs = (CRITICAL_SECTION *) *ptr;
110
111   DeleteCriticalSection (cs);
112   g_free (cs);
113   g_free (mutex);
114 }
115
116 /* NOTE: the functions g_mutex_lock and g_mutex_unlock may not use
117    functions from gmem.c and gmessages.c; */
118
119 static void
120 g_mutex_lock_win32_cs_impl (GMutex *mutex)
121 {
122   EnterCriticalSection (*(CRITICAL_SECTION **)mutex);
123 }
124
125 static gboolean
126 g_mutex_trylock_win32_cs_impl (GMutex * mutex)
127 {
128   return try_enter_critical_section (*(CRITICAL_SECTION **)mutex);
129 }
130
131 static void
132 g_mutex_unlock_win32_cs_impl (GMutex *mutex)
133 {
134   LeaveCriticalSection (*(CRITICAL_SECTION **)mutex);
135 }
136
137 static GMutex *
138 g_mutex_new_win32_impl (void)
139 {
140   HANDLE handle;
141   HANDLE *retval;
142   win32_check_for_error (handle = CreateMutex (NULL, FALSE, NULL));
143   retval = g_new (HANDLE, 1);
144   *retval = handle;
145   return (GMutex *) retval;
146 }
147
148 static void
149 g_mutex_free_win32_impl (GMutex *mutex)
150 {
151   win32_check_for_error (CloseHandle (*(HANDLE *) mutex));
152   g_free (mutex);
153 }
154
155 /* NOTE: the functions g_mutex_lock and g_mutex_unlock may not use
156    functions from gmem.c and gmessages.c; */
157
158 static void
159 g_mutex_lock_win32_impl (GMutex *mutex)
160 {
161   WaitForSingleObject (*(HANDLE *) mutex, INFINITE);
162 }
163
164 static gboolean
165 g_mutex_trylock_win32_impl (GMutex * mutex)
166 {
167   DWORD result;
168   win32_check_for_error (WAIT_FAILED != 
169                          (result = WaitForSingleObject (*(HANDLE *)mutex, 0)));
170   return result != WAIT_TIMEOUT;
171 }
172
173 static void
174 g_mutex_unlock_win32_impl (GMutex *mutex)
175 {
176   ReleaseMutex (*(HANDLE *) mutex);
177 }
178
179 static GCond *
180 g_cond_new_win32_impl (void)
181 {
182   GCond *retval = g_new (GCond, 1);
183
184   retval->array = g_ptr_array_new ();
185   InitializeCriticalSection (&retval->lock);
186
187   return retval;
188 }
189
190 static void
191 g_cond_signal_win32_impl (GCond * cond)
192 {
193   EnterCriticalSection (&cond->lock);
194
195   if (cond->array->len > 0)
196     {
197       SetEvent (g_ptr_array_index (cond->array, 0));
198       g_ptr_array_remove_index (cond->array, 0);
199     }
200
201   LeaveCriticalSection (&cond->lock);
202 }
203
204 static void
205 g_cond_broadcast_win32_impl (GCond * cond)
206 {
207   guint i;
208   EnterCriticalSection (&cond->lock);
209
210   for (i = 0; i < cond->array->len; i++)
211     SetEvent (g_ptr_array_index (cond->array, i));
212
213   g_ptr_array_set_size (cond->array, 0);
214   LeaveCriticalSection (&cond->lock);
215 }
216
217 static gboolean
218 g_cond_wait_internal (GCond *cond,
219                       GMutex *entered_mutex,
220                       gulong milliseconds)
221 {
222   gulong retval;
223   HANDLE event = TlsGetValue (g_cond_event_tls);
224
225   if (!event)
226     {
227       win32_check_for_error (event = CreateEvent (0, FALSE, FALSE, NULL));
228       TlsSetValue (g_cond_event_tls, event);
229     }
230
231   EnterCriticalSection (&cond->lock);
232
233   /* The event must not be signaled. Check this */
234   g_assert (WaitForSingleObject (event, 0) == WAIT_TIMEOUT);
235
236   g_ptr_array_add (cond->array, event);
237   LeaveCriticalSection (&cond->lock);
238
239   g_mutex_unlock (entered_mutex);
240
241   win32_check_for_error (WAIT_FAILED !=
242                          (retval = WaitForSingleObject (event, milliseconds)));
243
244   g_mutex_lock (entered_mutex);
245
246   if (retval == WAIT_TIMEOUT)
247     {
248       EnterCriticalSection (&cond->lock);
249       g_ptr_array_remove (cond->array, event);
250
251       /* In the meantime we could have been signaled, so we must again
252        * wait for the signal, this time with no timeout, to reset
253        * it. retval is set again to honour the late arrival of the
254        * signal */
255       win32_check_for_error (WAIT_FAILED != 
256                              (retval = WaitForSingleObject (event, 0)));
257
258       LeaveCriticalSection (&cond->lock);
259     }
260
261 #ifndef G_DISABLE_ASSERT
262   EnterCriticalSection (&cond->lock);
263
264   /* Now event must not be inside the array, check this */
265   g_assert (g_ptr_array_remove (cond->array, event) == FALSE);
266
267   LeaveCriticalSection (&cond->lock);
268 #endif /* !G_DISABLE_ASSERT */
269
270   return retval != WAIT_TIMEOUT;
271 }
272
273 static void     
274 g_cond_wait_win32_impl (GCond *cond,
275                         GMutex *entered_mutex)
276 {
277   g_return_if_fail (cond != NULL);
278   g_return_if_fail (entered_mutex != NULL);
279
280   g_cond_wait_internal (cond, entered_mutex, INFINITE);
281 }
282
283 static gboolean
284 g_cond_timed_wait_win32_impl (GCond *cond, 
285                               GMutex *entered_mutex,
286                               GTimeVal *abs_time)
287 {
288   GTimeVal current_time;
289   gulong to_wait;
290
291   g_return_val_if_fail (cond != NULL, FALSE);
292   g_return_val_if_fail (entered_mutex != NULL, FALSE);
293
294   if (!abs_time)
295     to_wait = INFINITE;
296   else
297     {
298       g_get_current_time (&current_time);
299       if (abs_time->tv_sec < current_time.tv_sec ||
300           (abs_time->tv_sec == current_time.tv_sec &&
301            abs_time->tv_usec <= current_time.tv_usec))
302         to_wait = 0;
303       else
304         to_wait = (abs_time->tv_sec - current_time.tv_sec) * 1000 +
305           (abs_time->tv_usec - current_time.tv_usec) / 1000;      
306     }
307   
308   return g_cond_wait_internal (cond, entered_mutex, to_wait);
309 }
310
311 static void
312 g_cond_free_win32_impl (GCond * cond)
313 {
314   DeleteCriticalSection (&cond->lock);
315   g_ptr_array_free (cond->array, TRUE);
316   g_free (cond);
317 }
318
319 static GPrivate *
320 g_private_new_win32_impl (GDestroyNotify destructor)
321 {
322   GPrivate *result;
323   EnterCriticalSection (&g_thread_global_spinlock);
324   if (g_private_next >= G_PRIVATE_MAX)
325     g_error ("Too many GPrivate allocated. Their number is limited to %d.\n"
326              "Use GStaticPrivate instead.\n", G_PRIVATE_MAX);
327   g_private_destructors[g_private_next] = destructor;
328   result = GUINT_TO_POINTER (g_private_next);
329   g_private_next++;
330   LeaveCriticalSection (&g_thread_global_spinlock);
331
332   return result;
333 }
334
335 /* NOTE: the functions g_private_get and g_private_set may not use
336    functions from gmem.c and gmessages.c */
337
338 static void
339 g_private_set_win32_impl (GPrivate * private_key, gpointer value)
340 {
341   gpointer* array = TlsGetValue (g_private_tls);
342   guint index = GPOINTER_TO_UINT (private_key);
343
344   if (index >= G_PRIVATE_MAX)
345       return;
346
347   if (!array)
348     {
349       array = (gpointer*) calloc (G_PRIVATE_MAX, sizeof (gpointer));
350       TlsSetValue (g_private_tls, array);
351     }
352
353   array[index] = value;
354 }
355
356 static gpointer
357 g_private_get_win32_impl (GPrivate * private_key)
358 {
359   gpointer* array = TlsGetValue (g_private_tls);
360   guint index = GPOINTER_TO_UINT (private_key);
361
362   if (index >= G_PRIVATE_MAX || !array)
363     return NULL;
364
365   return array[index];
366 }
367
368 static void
369 g_thread_set_priority_win32_impl (gpointer thread, GThreadPriority priority)
370 {
371   GThreadData *target = *(GThreadData **)thread;
372
373   g_return_if_fail (priority >= G_THREAD_PRIORITY_LOW);
374   g_return_if_fail (priority <= G_THREAD_PRIORITY_URGENT);
375
376   win32_check_for_error (SetThreadPriority (target->thread,  
377                                             g_thread_priority_map [priority]));
378 }
379
380 static void
381 g_thread_self_win32_impl (gpointer thread)
382 {  
383   GThreadData *self = TlsGetValue (g_thread_self_tls);
384
385   if (!self)
386     {
387       /* This should only happen for the main thread! */
388       HANDLE handle = GetCurrentThread ();
389       HANDLE process = GetCurrentProcess ();
390       self = g_new (GThreadData, 1);
391       win32_check_for_error (DuplicateHandle (process, handle, process, 
392                                               &self->thread, 0, FALSE, 
393                                               DUPLICATE_SAME_ACCESS));
394       win32_check_for_error (TlsSetValue (g_thread_self_tls, self));
395       self->func = NULL;
396       self->data = NULL;      
397       self->joinable = FALSE;
398     }
399
400   *(GThreadData **)thread = self;
401 }
402
403 static void 
404 g_thread_exit_win32_impl (void)
405 {
406   GThreadData *self = TlsGetValue (g_thread_self_tls);
407   guint i, private_max;
408   gpointer *array = TlsGetValue (g_private_tls);
409   HANDLE event = TlsGetValue (g_cond_event_tls);
410
411   EnterCriticalSection (&g_thread_global_spinlock);
412   private_max = g_private_next;
413   LeaveCriticalSection (&g_thread_global_spinlock);
414
415   if (array)
416     {
417       for (i = 0; i < private_max; i++)
418         {
419           GDestroyNotify destructor = g_private_destructors[i];
420           GDestroyNotify data = array[i];
421           if (destructor && data)
422             destructor (data);
423         }
424
425       g_free (array);
426
427       win32_check_for_error (TlsSetValue (g_private_tls, NULL));
428     }
429   
430   if (self)
431     {
432       if (!self->joinable)
433         {
434           win32_check_for_error (CloseHandle (self->thread));
435           g_free (self);
436         }
437       win32_check_for_error (TlsSetValue (g_thread_self_tls, NULL));
438     }
439
440   if (event)
441     {
442       CloseHandle (event);
443       win32_check_for_error (TlsSetValue (g_cond_event_tls, NULL));
444     }
445
446   _endthreadex (0);
447 }
448
449 static guint __stdcall
450 g_thread_proxy (gpointer data)
451 {
452   GThreadData *self = (GThreadData*) data;
453
454   win32_check_for_error (TlsSetValue (g_thread_self_tls, self));
455   
456   self->func (self->data);
457
458   g_thread_exit_win32_impl ();
459
460   g_assert_not_reached ();
461
462   return 0;
463 }
464
465 static void
466 g_thread_create_win32_impl (GThreadFunc func, 
467                             gpointer data, 
468                             gulong stack_size,
469                             gboolean joinable,
470                             gboolean bound,
471                             GThreadPriority priority,
472                             gpointer thread,
473                             GError **error)
474 {     
475   guint ignore;
476   GThreadData *retval;
477
478   g_return_if_fail (func);
479   g_return_if_fail (priority >= G_THREAD_PRIORITY_LOW);
480   g_return_if_fail (priority <= G_THREAD_PRIORITY_URGENT);
481   
482   retval = g_new(GThreadData, 1);
483   retval->func = func;
484   retval->data = data;
485   
486   retval->joinable = joinable;
487
488   retval->thread = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_proxy, 
489                                             retval, 0, &ignore);
490
491   if (retval->thread == NULL)
492     {
493       gchar *win_error = g_win32_error_message (GetLastError ());
494       g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN, 
495                    "Error creating thread: %s", win_error);
496       g_free (retval);
497       g_free (win_error);
498       return;
499     }
500
501   *(GThreadData **)thread = retval;
502
503   g_thread_set_priority_win32_impl (thread, priority);
504 }
505
506 static void 
507 g_thread_yield_win32_impl (void)
508 {
509   Sleep(0);
510 }
511
512 static void
513 g_thread_join_win32_impl (gpointer thread)
514 {
515   GThreadData *target = *(GThreadData **)thread;
516
517   g_return_if_fail (target->joinable);
518
519   win32_check_for_error (WAIT_FAILED != 
520                          WaitForSingleObject (target->thread, INFINITE));
521
522   win32_check_for_error (CloseHandle (target->thread));
523   g_free (target);
524 }
525
526 static GThreadFunctions g_thread_functions_for_glib_use_default =
527 {
528   g_mutex_new_win32_impl,           /* mutex */
529   g_mutex_lock_win32_impl,
530   g_mutex_trylock_win32_impl,
531   g_mutex_unlock_win32_impl,
532   g_mutex_free_win32_impl,
533   g_cond_new_win32_impl,            /* condition */
534   g_cond_signal_win32_impl,
535   g_cond_broadcast_win32_impl,
536   g_cond_wait_win32_impl,
537   g_cond_timed_wait_win32_impl,
538   g_cond_free_win32_impl,
539   g_private_new_win32_impl,         /* private thread data */
540   g_private_get_win32_impl,
541   g_private_set_win32_impl,
542   g_thread_create_win32_impl,       /* thread */
543   g_thread_yield_win32_impl,
544   g_thread_join_win32_impl,
545   g_thread_exit_win32_impl,
546   g_thread_set_priority_win32_impl,
547   g_thread_self_win32_impl,
548   NULL                              /* no equal function necessary */
549 };
550
551 #define HAVE_G_THREAD_IMPL_INIT
552 static void
553 g_thread_impl_init ()
554 {
555   static gboolean beenhere = FALSE;
556   HMODULE kernel32;
557
558   if (beenhere)
559     return;
560
561   beenhere = TRUE;
562   
563   win32_check_for_error (TLS_OUT_OF_INDEXES != 
564                          (g_thread_self_tls = TlsAlloc ()));
565   win32_check_for_error (TLS_OUT_OF_INDEXES != 
566                          (g_private_tls = TlsAlloc ()));
567   win32_check_for_error (TLS_OUT_OF_INDEXES != 
568                          (g_cond_event_tls = TlsAlloc ()));
569   InitializeCriticalSection (&g_thread_global_spinlock);
570
571   /* Here we are looking for TryEnterCriticalSection in KERNEL32.DLL,
572    * if it is found, we can use the faster critical sections instead
573    * of mutexes. Note however that
574    * http://www2.awl.com/cseng/titles/0-201-63465-1/csmutx.htm indicates,
575    * that critical sections might not be ideal after all on SMP machines */
576   kernel32 = GetModuleHandle ("KERNEL32.DLL");
577   if (kernel32)
578     {
579       try_enter_critical_section = (GTryEnterCriticalSectionFunc)
580         GetProcAddress(kernel32, "TryEnterCriticalSection");
581       
582       /* Even if TryEnterCriticalSection is found, it is not
583        * necessarily working..., we have to check it */
584       if (try_enter_critical_section && 
585           try_enter_critical_section (&g_thread_global_spinlock))
586         {
587           LeaveCriticalSection (&g_thread_global_spinlock);
588
589           g_thread_functions_for_glib_use_default.mutex_new =
590             g_mutex_new_win32_cs_impl;
591           g_thread_functions_for_glib_use_default.mutex_lock =
592             g_mutex_lock_win32_cs_impl;
593           g_thread_functions_for_glib_use_default.mutex_trylock =
594             g_mutex_trylock_win32_cs_impl;
595           g_thread_functions_for_glib_use_default.mutex_unlock =
596             g_mutex_unlock_win32_cs_impl;
597           g_thread_functions_for_glib_use_default.mutex_free =
598             g_mutex_free_win32_cs_impl;
599         }
600     }
601 }