X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fgthread-win32.c;h=275ecc63c552abbf9d8f135e9343651e2a7ba460;hb=1cbdbef77209fe82239bd10f062425491cf256ae;hp=320dda75b1c13471130a55c6082f67845a0ae4df;hpb=1909d2398ad299b86fb708104d82ce5ab7415d36;p=platform%2Fupstream%2Fglib.git diff --git a/glib/gthread-win32.c b/glib/gthread-win32.c index 320dda7..275ecc6 100644 --- a/glib/gthread-win32.c +++ b/glib/gthread-win32.c @@ -16,9 +16,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library; if not, see . */ /* @@ -42,6 +40,8 @@ #include "config.h" +#include "glib.h" +#include "glib-init.h" #include "gthread.h" #include "gthreadprivate.h" #include "gslice.h" @@ -71,13 +71,8 @@ g_thread_abort (gint status, * that only get the kernel involved in cases of contention (similar * to how futex()-based mutexes work on Linux). The biggest advantage * of these new types is that they can be statically initialised to - * zero. This allows us to use them directly and still support: - * - * GMutex mutex = G_MUTEX_INIT; - * - * and - * - * GCond cond = G_COND_INIT; + * zero. That means that they are completely ABI compatible with our + * GMutex and GCond APIs. * * Unfortunately, Windows XP lacks these facilities and GLib still * needs to support Windows XP. Our approach here is as follows: @@ -178,14 +173,14 @@ g_rec_mutex_impl_free (CRITICAL_SECTION *cs) static CRITICAL_SECTION * g_rec_mutex_get_impl (GRecMutex *mutex) { - CRITICAL_SECTION *impl = mutex->impl; + CRITICAL_SECTION *impl = mutex->p; - if G_UNLIKELY (mutex->impl == NULL) + if G_UNLIKELY (mutex->p == NULL) { impl = g_rec_mutex_impl_new (); - if (InterlockedCompareExchangePointer (&mutex->impl, impl, NULL) != NULL) + if (InterlockedCompareExchangePointer (&mutex->p, impl, NULL) != NULL) g_rec_mutex_impl_free (impl); - impl = mutex->impl; + impl = mutex->p; } return impl; @@ -194,14 +189,13 @@ g_rec_mutex_get_impl (GRecMutex *mutex) void g_rec_mutex_init (GRecMutex *mutex) { - mutex->impl = g_rec_mutex_impl_new (); + mutex->p = g_rec_mutex_impl_new (); } void g_rec_mutex_clear (GRecMutex *mutex) { - if (mutex->impl) - g_rec_mutex_impl_free (mutex->impl); + g_rec_mutex_impl_free (mutex->p); } void @@ -213,7 +207,7 @@ g_rec_mutex_lock (GRecMutex *mutex) void g_rec_mutex_unlock (GRecMutex *mutex) { - LeaveCriticalSection (mutex->impl); + LeaveCriticalSection (mutex->p); } gboolean @@ -307,21 +301,13 @@ g_cond_wait (GCond *cond, } gboolean -g_cond_timedwait (GCond *cond, - GMutex *entered_mutex, - gint64 abs_time) +g_cond_wait_until (GCond *cond, + GMutex *entered_mutex, + gint64 end_time) { gint64 span; - FILETIME ft; - gint64 now; - - GetSystemTimeAsFileTime (&ft); - memmove (&now, &ft, sizeof (FILETIME)); - now -= G_GINT64_CONSTANT (116444736000000000); - now /= 10; - - span = abs_time - now; + span = end_time - g_get_monotonic_time (); if G_UNLIKELY (span < 0) span = 0; @@ -332,28 +318,6 @@ g_cond_timedwait (GCond *cond, return g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, span / 1000, 0); } -gboolean -g_cond_timed_wait (GCond *cond, - GMutex *entered_mutex, - GTimeVal *abs_time) -{ - if (abs_time) - { - gint64 micros; - - micros = abs_time->tv_sec; - micros *= 1000000; - micros += abs_time->tv_usec; - - return g_cond_timedwait (cond, entered_mutex, micros); - } - else - { - g_cond_wait (cond, entered_mutex); - return TRUE; - } -} - /* {{{1 GPrivate */ typedef struct _GPrivateDestructor GPrivateDestructor; @@ -444,9 +408,6 @@ g_private_replace (GPrivate *key, /* {{{1 GThread */ -#include "glib.h" -#include "gthreadprivate.h" - #define win32_check_for_error(what) G_STMT_START{ \ if (!(what)) \ g_error ("file %s: line %d (%s): error %s during %s", \ @@ -456,101 +417,37 @@ g_private_replace (GPrivate *key, #define G_MUTEX_SIZE (sizeof (gpointer)) -static DWORD g_thread_self_tls; - typedef BOOL (__stdcall *GTryEnterCriticalSectionFunc) (CRITICAL_SECTION *); -typedef struct _GThreadData GThreadData; -struct _GThreadData +typedef struct { - GThreadFunc func; - gpointer data; - HANDLE thread; - gboolean joinable; -}; + GRealThread thread; + + GThreadFunc proxy; + HANDLE handle; +} GThreadWin32; void -g_system_thread_self (gpointer thread) +g_system_thread_free (GRealThread *thread) { - GThreadData *self = TlsGetValue (g_thread_self_tls); - - if (!self) - { - /* This should only happen for the main thread! */ - HANDLE handle = GetCurrentThread (); - HANDLE process = GetCurrentProcess (); - self = g_new (GThreadData, 1); - win32_check_for_error (DuplicateHandle (process, handle, process, - &self->thread, 0, FALSE, - DUPLICATE_SAME_ACCESS)); - win32_check_for_error (TlsSetValue (g_thread_self_tls, self)); - self->func = NULL; - self->data = NULL; - self->joinable = FALSE; - } + GThreadWin32 *wt = (GThreadWin32 *) thread; - *(GThreadData **)thread = self; + win32_check_for_error (CloseHandle (wt->handle)); + g_slice_free (GThreadWin32, wt); } void g_system_thread_exit (void) { - GThreadData *self = TlsGetValue (g_thread_self_tls); - gboolean dtors_called; - - do - { - GPrivateDestructor *dtor; - - /* We go by the POSIX book on this one. - * - * If we call a destructor then there is a chance that some new - * TLS variables got set by code called in that destructor. - * - * Loop until nothing is left. - */ - dtors_called = FALSE; - - for (dtor = g_private_destructors; dtor; dtor = dtor->next) - { - gpointer value; - - value = TlsGetValue (dtor->index); - if (value != NULL && dtor->notify != NULL) - { - /* POSIX says to clear this before the call */ - TlsSetValue (dtor->index, NULL); - dtor->notify (value); - dtors_called = TRUE; - } - } - } - while (dtors_called); - - if (self) - { - if (!self->joinable) - { - win32_check_for_error (CloseHandle (self->thread)); - g_free (self); - } - win32_check_for_error (TlsSetValue (g_thread_self_tls, NULL)); - } - - if (g_thread_impl_vtable.CallThisOnThreadExit) - g_thread_impl_vtable.CallThisOnThreadExit (); - _endthreadex (0); } static guint __stdcall -g_thread_proxy (gpointer data) +g_thread_win32_proxy (gpointer data) { - GThreadData *self = (GThreadData*) data; + GThreadWin32 *self = data; - win32_check_for_error (TlsSetValue (g_thread_self_tls, self)); - - self->func (self->data); + self->proxy (self); g_system_thread_exit (); @@ -559,39 +456,30 @@ g_thread_proxy (gpointer data) return 0; } -void -g_system_thread_create (GThreadFunc func, - gpointer data, - gulong stack_size, - gboolean joinable, - gpointer thread, - GError **error) +GRealThread * +g_system_thread_new (GThreadFunc func, + gulong stack_size, + GError **error) { + GThreadWin32 *thread; guint ignore; - GThreadData *retval; - - g_return_if_fail (func); - - retval = g_new(GThreadData, 1); - retval->func = func; - retval->data = data; - retval->joinable = joinable; + thread = g_slice_new0 (GThreadWin32); + thread->proxy = func; - retval->thread = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_proxy, - retval, 0, &ignore); + thread->handle = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_win32_proxy, thread, 0, &ignore); - if (retval->thread == NULL) + if (thread->handle == NULL) { gchar *win_error = g_win32_error_message (GetLastError ()); g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN, "Error creating thread: %s", win_error); - g_free (retval); g_free (win_error); - return; + g_slice_free (GThreadWin32, thread); + return NULL; } - *(GThreadData **)thread = retval; + return (GRealThread *) thread; } void @@ -601,24 +489,11 @@ g_thread_yield (void) } void -g_system_thread_join (gpointer thread) +g_system_thread_wait (GRealThread *thread) { - GThreadData *target = *(GThreadData **)thread; + GThreadWin32 *wt = (GThreadWin32 *) thread; - g_return_if_fail (target->joinable); - - win32_check_for_error (WAIT_FAILED != - WaitForSingleObject (target->thread, INFINITE)); - - win32_check_for_error (CloseHandle (target->thread)); - g_free (target); -} - -gboolean -g_system_thread_equal (gpointer thread1, - gpointer thread2) -{ - return ((GSystemThread*)thread1)->dummy_pointer == ((GSystemThread*)thread2)->dummy_pointer; + win32_check_for_error (WAIT_FAILED != WaitForSingleObject (wt->handle, INFINITE)); } void @@ -636,8 +511,9 @@ static DWORD g_thread_xp_waiter_tls; typedef struct _GThreadXpWaiter GThreadXpWaiter; struct _GThreadXpWaiter { - HANDLE event; - volatile GThreadXpWaiter *next; + HANDLE event; + volatile GThreadXpWaiter *next; + volatile GThreadXpWaiter **my_owner; }; static GThreadXpWaiter * @@ -655,6 +531,7 @@ g_thread_xp_waiter_get (void) waiter->event = CreateEvent (0, FALSE, FALSE, NULL); if (waiter->event == NULL) g_thread_abort (GetLastError (), "CreateEvent"); + waiter->my_owner = NULL; TlsSetValue (g_thread_xp_waiter_tls, waiter); } @@ -727,15 +604,20 @@ g_thread_xp_get_srwlock (GThreadSRWLock * volatile *lock) { EnterCriticalSection (&g_thread_xp_lock); - result = malloc (sizeof (GThreadSRWLock)); - + /* Check again */ + result = *lock; if (result == NULL) - g_thread_abort (errno, "malloc"); + { + result = malloc (sizeof (GThreadSRWLock)); - InitializeCriticalSection (&result->writer_lock); - result->writer_locked = FALSE; - result->ever_shared = FALSE; - *lock = result; + if (result == NULL) + g_thread_abort (errno, "malloc"); + + InitializeCriticalSection (&result->writer_lock); + result->writer_locked = FALSE; + result->ever_shared = FALSE; + *lock = result; + } LeaveCriticalSection (&g_thread_xp_lock); } @@ -959,6 +841,7 @@ g_thread_xp_SleepConditionVariableSRW (gpointer cond, waiter->next = NULL; EnterCriticalSection (&g_thread_xp_lock); + waiter->my_owner = cv->last_ptr; *cv->last_ptr = waiter; cv->last_ptr = &waiter->next; LeaveCriticalSection (&g_thread_xp_lock); @@ -968,9 +851,23 @@ g_thread_xp_SleepConditionVariableSRW (gpointer cond, if (status != WAIT_TIMEOUT && status != WAIT_OBJECT_0) g_thread_abort (GetLastError (), "WaitForSingleObject"); - g_mutex_lock (mutex); + if (status == WAIT_TIMEOUT) + { + EnterCriticalSection (&g_thread_xp_lock); + if (waiter->my_owner) + { + if (waiter->next) + waiter->next->my_owner = waiter->my_owner; + else + cv->last_ptr = waiter->my_owner; + *waiter->my_owner = waiter->next; + waiter->my_owner = NULL; + } + LeaveCriticalSection (&g_thread_xp_lock); + } + return status == WAIT_OBJECT_0; } @@ -981,17 +878,22 @@ g_thread_xp_WakeConditionVariable (gpointer cond) volatile GThreadXpWaiter *waiter; EnterCriticalSection (&g_thread_xp_lock); + waiter = cv->first; if (waiter != NULL) { + waiter->my_owner = NULL; cv->first = waiter->next; - if (cv->first == NULL) + if (cv->first != NULL) + cv->first->my_owner = &cv->first; + else cv->last_ptr = &cv->first; } - LeaveCriticalSection (&g_thread_xp_lock); if (waiter != NULL) SetEvent (waiter->event); + + LeaveCriticalSection (&g_thread_xp_lock); } static void __stdcall @@ -1001,10 +903,10 @@ g_thread_xp_WakeAllConditionVariable (gpointer cond) volatile GThreadXpWaiter *waiter; EnterCriticalSection (&g_thread_xp_lock); + waiter = cv->first; cv->first = NULL; cv->last_ptr = &cv->first; - LeaveCriticalSection (&g_thread_xp_lock); while (waiter != NULL) { @@ -1012,8 +914,11 @@ g_thread_xp_WakeAllConditionVariable (gpointer cond) next = waiter->next; SetEvent (waiter->event); + waiter->my_owner = NULL; waiter = next; } + + LeaveCriticalSection (&g_thread_xp_lock); } /* {{{2 XP Setup */ @@ -1076,20 +981,51 @@ g_thread_lookup_native_funcs (void) return TRUE; } -G_GNUC_INTERNAL void -g_thread_DllMain (void) +void +g_thread_win32_init (void) +{ + if (!g_thread_lookup_native_funcs ()) + g_thread_xp_init (); + + InitializeCriticalSection (&g_private_lock); +} + +void +g_thread_win32_thread_detach (void) { - if (g_thread_lookup_native_funcs ()) - fprintf (stderr, "(debug) GThread using native mode\n"); - else + gboolean dtors_called; + + do { - fprintf (stderr, "(debug) GThread using Windows XP mode\n"); - g_thread_xp_init (); + GPrivateDestructor *dtor; + + /* We go by the POSIX book on this one. + * + * If we call a destructor then there is a chance that some new + * TLS variables got set by code called in that destructor. + * + * Loop until nothing is left. + */ + dtors_called = FALSE; + + for (dtor = g_private_destructors; dtor; dtor = dtor->next) + { + gpointer value; + + value = TlsGetValue (dtor->index); + if (value != NULL && dtor->notify != NULL) + { + /* POSIX says to clear this before the call */ + TlsSetValue (dtor->index, NULL); + dtor->notify (value); + dtors_called = TRUE; + } + } } + while (dtors_called); - win32_check_for_error (TLS_OUT_OF_INDEXES != (g_thread_self_tls = TlsAlloc ())); - InitializeCriticalSection (&g_private_lock); + if (g_thread_impl_vtable.CallThisOnThreadExit) + g_thread_impl_vtable.CallThisOnThreadExit (); } /* vim:set foldmethod=marker: */ -