mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-26 15:36:14 +01:00
gthread-win32: Remove WinXP compat code
This commit is contained in:
Christoph Reiter
parent
6054d11001
commit
cce2957938
@ -73,81 +73,36 @@ g_thread_abort (gint status,
|
||||
* of these new types is that they can be statically initialised to
|
||||
* 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:
|
||||
*
|
||||
* - avoid depending on structure declarations at compile-time by
|
||||
* declaring our own GMutex and GCond strutures to be
|
||||
* ABI-compatible with SRWLock and CONDITION_VARIABLE and using
|
||||
* those instead
|
||||
*
|
||||
* - avoid a hard dependency on the symbols used to manipulate these
|
||||
* structures by doing a dynamic lookup of those symbols at
|
||||
* runtime
|
||||
*
|
||||
* - if the symbols are not available, emulate them using other
|
||||
* primatives
|
||||
*
|
||||
* Using this approach also allows us to easily build a GLib that lacks
|
||||
* support for Windows XP or to remove this code entirely when XP is no
|
||||
* longer supported (end of line is currently April 8, 2014).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
void (__stdcall * CallThisOnThreadExit) (void); /* fake */
|
||||
|
||||
void (__stdcall * InitializeSRWLock) (gpointer lock);
|
||||
void (__stdcall * DeleteSRWLock) (gpointer lock); /* fake */
|
||||
void (__stdcall * AcquireSRWLockExclusive) (gpointer lock);
|
||||
BOOLEAN (__stdcall * TryAcquireSRWLockExclusive) (gpointer lock);
|
||||
void (__stdcall * ReleaseSRWLockExclusive) (gpointer lock);
|
||||
void (__stdcall * AcquireSRWLockShared) (gpointer lock);
|
||||
BOOLEAN (__stdcall * TryAcquireSRWLockShared) (gpointer lock);
|
||||
void (__stdcall * ReleaseSRWLockShared) (gpointer lock);
|
||||
|
||||
void (__stdcall * InitializeConditionVariable) (gpointer cond);
|
||||
void (__stdcall * DeleteConditionVariable) (gpointer cond); /* fake */
|
||||
BOOL (__stdcall * SleepConditionVariableSRW) (gpointer cond,
|
||||
gpointer lock,
|
||||
DWORD timeout,
|
||||
ULONG flags);
|
||||
void (__stdcall * WakeAllConditionVariable) (gpointer cond);
|
||||
void (__stdcall * WakeConditionVariable) (gpointer cond);
|
||||
} GThreadImplVtable;
|
||||
|
||||
static GThreadImplVtable g_thread_impl_vtable;
|
||||
|
||||
/* {{{1 GMutex */
|
||||
void
|
||||
g_mutex_init (GMutex *mutex)
|
||||
{
|
||||
g_thread_impl_vtable.InitializeSRWLock (mutex);
|
||||
InitializeSRWLock ((gpointer) mutex);
|
||||
}
|
||||
|
||||
void
|
||||
g_mutex_clear (GMutex *mutex)
|
||||
{
|
||||
if (g_thread_impl_vtable.DeleteSRWLock != NULL)
|
||||
g_thread_impl_vtable.DeleteSRWLock (mutex);
|
||||
}
|
||||
|
||||
void
|
||||
g_mutex_lock (GMutex *mutex)
|
||||
{
|
||||
g_thread_impl_vtable.AcquireSRWLockExclusive (mutex);
|
||||
AcquireSRWLockExclusive ((gpointer) mutex);
|
||||
}
|
||||
|
||||
gboolean
|
||||
g_mutex_trylock (GMutex *mutex)
|
||||
{
|
||||
return g_thread_impl_vtable.TryAcquireSRWLockExclusive (mutex);
|
||||
return TryAcquireSRWLockExclusive ((gpointer) mutex);
|
||||
}
|
||||
|
||||
void
|
||||
g_mutex_unlock (GMutex *mutex)
|
||||
{
|
||||
g_thread_impl_vtable.ReleaseSRWLockExclusive (mutex);
|
||||
ReleaseSRWLockExclusive ((gpointer) mutex);
|
||||
}
|
||||
|
||||
/* {{{1 GRecMutex */
|
||||
@ -221,83 +176,79 @@ g_rec_mutex_trylock (GRecMutex *mutex)
|
||||
void
|
||||
g_rw_lock_init (GRWLock *lock)
|
||||
{
|
||||
g_thread_impl_vtable.InitializeSRWLock (lock);
|
||||
InitializeSRWLock ((gpointer) lock);
|
||||
}
|
||||
|
||||
void
|
||||
g_rw_lock_clear (GRWLock *lock)
|
||||
{
|
||||
if (g_thread_impl_vtable.DeleteSRWLock != NULL)
|
||||
g_thread_impl_vtable.DeleteSRWLock (lock);
|
||||
}
|
||||
|
||||
void
|
||||
g_rw_lock_writer_lock (GRWLock *lock)
|
||||
{
|
||||
g_thread_impl_vtable.AcquireSRWLockExclusive (lock);
|
||||
AcquireSRWLockExclusive ((gpointer) lock);
|
||||
}
|
||||
|
||||
gboolean
|
||||
g_rw_lock_writer_trylock (GRWLock *lock)
|
||||
{
|
||||
return g_thread_impl_vtable.TryAcquireSRWLockExclusive (lock);
|
||||
return TryAcquireSRWLockExclusive ((gpointer) lock);
|
||||
}
|
||||
|
||||
void
|
||||
g_rw_lock_writer_unlock (GRWLock *lock)
|
||||
{
|
||||
g_thread_impl_vtable.ReleaseSRWLockExclusive (lock);
|
||||
ReleaseSRWLockExclusive ((gpointer) lock);
|
||||
}
|
||||
|
||||
void
|
||||
g_rw_lock_reader_lock (GRWLock *lock)
|
||||
{
|
||||
g_thread_impl_vtable.AcquireSRWLockShared (lock);
|
||||
AcquireSRWLockShared ((gpointer) lock);
|
||||
}
|
||||
|
||||
gboolean
|
||||
g_rw_lock_reader_trylock (GRWLock *lock)
|
||||
{
|
||||
return g_thread_impl_vtable.TryAcquireSRWLockShared (lock);
|
||||
return TryAcquireSRWLockShared ((gpointer) lock);
|
||||
}
|
||||
|
||||
void
|
||||
g_rw_lock_reader_unlock (GRWLock *lock)
|
||||
{
|
||||
g_thread_impl_vtable.ReleaseSRWLockShared (lock);
|
||||
ReleaseSRWLockShared ((gpointer) lock);
|
||||
}
|
||||
|
||||
/* {{{1 GCond */
|
||||
void
|
||||
g_cond_init (GCond *cond)
|
||||
{
|
||||
g_thread_impl_vtable.InitializeConditionVariable (cond);
|
||||
InitializeConditionVariable ((gpointer) cond);
|
||||
}
|
||||
|
||||
void
|
||||
g_cond_clear (GCond *cond)
|
||||
{
|
||||
if (g_thread_impl_vtable.DeleteConditionVariable)
|
||||
g_thread_impl_vtable.DeleteConditionVariable (cond);
|
||||
}
|
||||
|
||||
void
|
||||
g_cond_signal (GCond *cond)
|
||||
{
|
||||
g_thread_impl_vtable.WakeConditionVariable (cond);
|
||||
WakeConditionVariable ((gpointer) cond);
|
||||
}
|
||||
|
||||
void
|
||||
g_cond_broadcast (GCond *cond)
|
||||
{
|
||||
g_thread_impl_vtable.WakeAllConditionVariable (cond);
|
||||
WakeAllConditionVariable ((gpointer) cond);
|
||||
}
|
||||
|
||||
void
|
||||
g_cond_wait (GCond *cond,
|
||||
GMutex *entered_mutex)
|
||||
{
|
||||
g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, INFINITE, 0);
|
||||
SleepConditionVariableSRW ((gpointer) cond, (gpointer) entered_mutex, INFINITE, 0);
|
||||
}
|
||||
|
||||
gboolean
|
||||
@ -326,7 +277,7 @@ g_cond_wait_until (GCond *cond,
|
||||
if (span_millis >= INFINITE)
|
||||
span_millis = INFINITE - 1;
|
||||
|
||||
signalled = g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, span_millis, 0);
|
||||
signalled = SleepConditionVariableSRW ((gpointer) cond, (gpointer) entered_mutex, span_millis, 0);
|
||||
if (signalled)
|
||||
break;
|
||||
|
||||
@ -580,491 +531,11 @@ g_system_thread_set_name (const gchar *name)
|
||||
SetThreadName ((DWORD) -1, name);
|
||||
}
|
||||
|
||||
/* {{{1 SRWLock and CONDITION_VARIABLE emulation (for Windows XP) */
|
||||
|
||||
static CRITICAL_SECTION g_thread_xp_lock;
|
||||
static DWORD g_thread_xp_waiter_tls;
|
||||
|
||||
/* {{{2 GThreadWaiter utility class for CONDITION_VARIABLE emulation */
|
||||
typedef struct _GThreadXpWaiter GThreadXpWaiter;
|
||||
struct _GThreadXpWaiter
|
||||
{
|
||||
HANDLE event;
|
||||
volatile GThreadXpWaiter *next;
|
||||
volatile GThreadXpWaiter **my_owner;
|
||||
};
|
||||
|
||||
static GThreadXpWaiter *
|
||||
g_thread_xp_waiter_get (void)
|
||||
{
|
||||
GThreadXpWaiter *waiter;
|
||||
|
||||
waiter = TlsGetValue (g_thread_xp_waiter_tls);
|
||||
|
||||
if G_UNLIKELY (waiter == NULL)
|
||||
{
|
||||
waiter = malloc (sizeof (GThreadXpWaiter));
|
||||
if (waiter == NULL)
|
||||
g_thread_abort (GetLastError (), "malloc");
|
||||
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);
|
||||
}
|
||||
|
||||
return waiter;
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_CallThisOnThreadExit (void)
|
||||
{
|
||||
GThreadXpWaiter *waiter;
|
||||
|
||||
waiter = TlsGetValue (g_thread_xp_waiter_tls);
|
||||
|
||||
if (waiter != NULL)
|
||||
{
|
||||
TlsSetValue (g_thread_xp_waiter_tls, NULL);
|
||||
CloseHandle (waiter->event);
|
||||
free (waiter);
|
||||
}
|
||||
}
|
||||
|
||||
/* {{{2 SRWLock emulation */
|
||||
typedef struct
|
||||
{
|
||||
CRITICAL_SECTION writer_lock;
|
||||
gboolean ever_shared; /* protected by writer_lock */
|
||||
gboolean writer_locked; /* protected by writer_lock */
|
||||
|
||||
/* below is only ever touched if ever_shared becomes true */
|
||||
CRITICAL_SECTION atomicity;
|
||||
GThreadXpWaiter *queued_writer; /* protected by atomicity lock */
|
||||
gint num_readers; /* protected by atomicity lock */
|
||||
} GThreadSRWLock;
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_InitializeSRWLock (gpointer mutex)
|
||||
{
|
||||
*(GThreadSRWLock * volatile *) mutex = NULL;
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_DeleteSRWLock (gpointer mutex)
|
||||
{
|
||||
GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
|
||||
|
||||
if (lock)
|
||||
{
|
||||
if (lock->ever_shared)
|
||||
DeleteCriticalSection (&lock->atomicity);
|
||||
|
||||
DeleteCriticalSection (&lock->writer_lock);
|
||||
free (lock);
|
||||
}
|
||||
}
|
||||
|
||||
static GThreadSRWLock * __stdcall
|
||||
g_thread_xp_get_srwlock (GThreadSRWLock * volatile *lock)
|
||||
{
|
||||
GThreadSRWLock *result;
|
||||
|
||||
/* It looks like we're missing some barriers here, but this code only
|
||||
* ever runs on Windows XP, which in turn only ever runs on hardware
|
||||
* with a relatively rigid memory model. The 'volatile' will take
|
||||
* care of the compiler.
|
||||
*/
|
||||
result = *lock;
|
||||
|
||||
if G_UNLIKELY (result == NULL)
|
||||
{
|
||||
EnterCriticalSection (&g_thread_xp_lock);
|
||||
|
||||
/* Check again */
|
||||
result = *lock;
|
||||
if (result == NULL)
|
||||
{
|
||||
result = malloc (sizeof (GThreadSRWLock));
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_AcquireSRWLockExclusive (gpointer mutex)
|
||||
{
|
||||
GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
|
||||
|
||||
EnterCriticalSection (&lock->writer_lock);
|
||||
|
||||
/* CRITICAL_SECTION is reentrant, but SRWLock is not.
|
||||
* Detect the deadlock that would occur on later Windows version.
|
||||
*/
|
||||
g_assert (!lock->writer_locked);
|
||||
lock->writer_locked = TRUE;
|
||||
|
||||
if (lock->ever_shared)
|
||||
{
|
||||
GThreadXpWaiter *waiter = NULL;
|
||||
|
||||
EnterCriticalSection (&lock->atomicity);
|
||||
if (lock->num_readers > 0)
|
||||
lock->queued_writer = waiter = g_thread_xp_waiter_get ();
|
||||
LeaveCriticalSection (&lock->atomicity);
|
||||
|
||||
if (waiter != NULL)
|
||||
WaitForSingleObject (waiter->event, INFINITE);
|
||||
|
||||
lock->queued_writer = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static BOOLEAN __stdcall
|
||||
g_thread_xp_TryAcquireSRWLockExclusive (gpointer mutex)
|
||||
{
|
||||
GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
|
||||
|
||||
if (!TryEnterCriticalSection (&lock->writer_lock))
|
||||
return FALSE;
|
||||
|
||||
/* CRITICAL_SECTION is reentrant, but SRWLock is not.
|
||||
* Ensure that this properly returns FALSE (as SRWLock would).
|
||||
*/
|
||||
if G_UNLIKELY (lock->writer_locked)
|
||||
{
|
||||
LeaveCriticalSection (&lock->writer_lock);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
lock->writer_locked = TRUE;
|
||||
|
||||
if (lock->ever_shared)
|
||||
{
|
||||
gboolean available;
|
||||
|
||||
EnterCriticalSection (&lock->atomicity);
|
||||
available = lock->num_readers == 0;
|
||||
LeaveCriticalSection (&lock->atomicity);
|
||||
|
||||
if (!available)
|
||||
{
|
||||
LeaveCriticalSection (&lock->writer_lock);
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_ReleaseSRWLockExclusive (gpointer mutex)
|
||||
{
|
||||
GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
|
||||
|
||||
lock->writer_locked = FALSE;
|
||||
|
||||
/* We need this until we fix some weird parts of GLib that try to
|
||||
* unlock freshly-allocated mutexes.
|
||||
*/
|
||||
if (lock != NULL)
|
||||
LeaveCriticalSection (&lock->writer_lock);
|
||||
}
|
||||
|
||||
static void
|
||||
g_thread_xp_srwlock_become_reader (GThreadSRWLock *lock)
|
||||
{
|
||||
if G_UNLIKELY (!lock->ever_shared)
|
||||
{
|
||||
InitializeCriticalSection (&lock->atomicity);
|
||||
lock->queued_writer = NULL;
|
||||
lock->num_readers = 0;
|
||||
|
||||
lock->ever_shared = TRUE;
|
||||
}
|
||||
|
||||
EnterCriticalSection (&lock->atomicity);
|
||||
lock->num_readers++;
|
||||
LeaveCriticalSection (&lock->atomicity);
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_AcquireSRWLockShared (gpointer mutex)
|
||||
{
|
||||
GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
|
||||
|
||||
EnterCriticalSection (&lock->writer_lock);
|
||||
|
||||
/* See g_thread_xp_AcquireSRWLockExclusive */
|
||||
g_assert (!lock->writer_locked);
|
||||
|
||||
g_thread_xp_srwlock_become_reader (lock);
|
||||
|
||||
LeaveCriticalSection (&lock->writer_lock);
|
||||
}
|
||||
|
||||
static BOOLEAN __stdcall
|
||||
g_thread_xp_TryAcquireSRWLockShared (gpointer mutex)
|
||||
{
|
||||
GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
|
||||
|
||||
if (!TryEnterCriticalSection (&lock->writer_lock))
|
||||
return FALSE;
|
||||
|
||||
/* See g_thread_xp_AcquireSRWLockExclusive */
|
||||
if G_UNLIKELY (lock->writer_locked)
|
||||
{
|
||||
LeaveCriticalSection (&lock->writer_lock);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
g_thread_xp_srwlock_become_reader (lock);
|
||||
|
||||
LeaveCriticalSection (&lock->writer_lock);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_ReleaseSRWLockShared (gpointer mutex)
|
||||
{
|
||||
GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
|
||||
|
||||
EnterCriticalSection (&lock->atomicity);
|
||||
|
||||
lock->num_readers--;
|
||||
|
||||
if (lock->num_readers == 0 && lock->queued_writer)
|
||||
SetEvent (lock->queued_writer->event);
|
||||
|
||||
LeaveCriticalSection (&lock->atomicity);
|
||||
}
|
||||
|
||||
/* {{{2 CONDITION_VARIABLE emulation */
|
||||
typedef struct
|
||||
{
|
||||
volatile GThreadXpWaiter *first;
|
||||
volatile GThreadXpWaiter **last_ptr;
|
||||
} GThreadXpCONDITION_VARIABLE;
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_InitializeConditionVariable (gpointer cond)
|
||||
{
|
||||
*(GThreadXpCONDITION_VARIABLE * volatile *) cond = NULL;
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_DeleteConditionVariable (gpointer cond)
|
||||
{
|
||||
GThreadXpCONDITION_VARIABLE *cv = *(GThreadXpCONDITION_VARIABLE * volatile *) cond;
|
||||
|
||||
if (cv)
|
||||
free (cv);
|
||||
}
|
||||
|
||||
static GThreadXpCONDITION_VARIABLE * __stdcall
|
||||
g_thread_xp_get_condition_variable (GThreadXpCONDITION_VARIABLE * volatile *cond)
|
||||
{
|
||||
GThreadXpCONDITION_VARIABLE *result;
|
||||
|
||||
/* It looks like we're missing some barriers here, but this code only
|
||||
* ever runs on Windows XP, which in turn only ever runs on hardware
|
||||
* with a relatively rigid memory model. The 'volatile' will take
|
||||
* care of the compiler.
|
||||
*/
|
||||
result = *cond;
|
||||
|
||||
if G_UNLIKELY (result == NULL)
|
||||
{
|
||||
result = malloc (sizeof (GThreadXpCONDITION_VARIABLE));
|
||||
|
||||
if (result == NULL)
|
||||
g_thread_abort (errno, "malloc");
|
||||
|
||||
result->first = NULL;
|
||||
result->last_ptr = &result->first;
|
||||
|
||||
if (InterlockedCompareExchangePointer (cond, result, NULL) != NULL)
|
||||
{
|
||||
free (result);
|
||||
result = *cond;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static BOOL __stdcall
|
||||
g_thread_xp_SleepConditionVariableSRW (gpointer cond,
|
||||
gpointer mutex,
|
||||
DWORD timeout,
|
||||
ULONG flags)
|
||||
{
|
||||
GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
|
||||
GThreadXpWaiter *waiter = g_thread_xp_waiter_get ();
|
||||
DWORD status;
|
||||
|
||||
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);
|
||||
|
||||
g_mutex_unlock (mutex);
|
||||
status = WaitForSingleObject (waiter->event, timeout);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_WakeConditionVariable (gpointer cond)
|
||||
{
|
||||
GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (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)
|
||||
cv->first->my_owner = &cv->first;
|
||||
else
|
||||
cv->last_ptr = &cv->first;
|
||||
}
|
||||
|
||||
if (waiter != NULL)
|
||||
SetEvent (waiter->event);
|
||||
|
||||
LeaveCriticalSection (&g_thread_xp_lock);
|
||||
}
|
||||
|
||||
static void __stdcall
|
||||
g_thread_xp_WakeAllConditionVariable (gpointer cond)
|
||||
{
|
||||
GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
|
||||
volatile GThreadXpWaiter *waiter;
|
||||
|
||||
EnterCriticalSection (&g_thread_xp_lock);
|
||||
|
||||
waiter = cv->first;
|
||||
cv->first = NULL;
|
||||
cv->last_ptr = &cv->first;
|
||||
|
||||
while (waiter != NULL)
|
||||
{
|
||||
volatile GThreadXpWaiter *next;
|
||||
|
||||
next = waiter->next;
|
||||
SetEvent (waiter->event);
|
||||
waiter->my_owner = NULL;
|
||||
waiter = next;
|
||||
}
|
||||
|
||||
LeaveCriticalSection (&g_thread_xp_lock);
|
||||
}
|
||||
|
||||
/* {{{2 XP Setup */
|
||||
static void
|
||||
g_thread_xp_init (void)
|
||||
{
|
||||
static const GThreadImplVtable g_thread_xp_impl_vtable = {
|
||||
g_thread_xp_CallThisOnThreadExit,
|
||||
g_thread_xp_InitializeSRWLock,
|
||||
g_thread_xp_DeleteSRWLock,
|
||||
g_thread_xp_AcquireSRWLockExclusive,
|
||||
g_thread_xp_TryAcquireSRWLockExclusive,
|
||||
g_thread_xp_ReleaseSRWLockExclusive,
|
||||
g_thread_xp_AcquireSRWLockShared,
|
||||
g_thread_xp_TryAcquireSRWLockShared,
|
||||
g_thread_xp_ReleaseSRWLockShared,
|
||||
g_thread_xp_InitializeConditionVariable,
|
||||
g_thread_xp_DeleteConditionVariable,
|
||||
g_thread_xp_SleepConditionVariableSRW,
|
||||
g_thread_xp_WakeAllConditionVariable,
|
||||
g_thread_xp_WakeConditionVariable
|
||||
};
|
||||
|
||||
InitializeCriticalSection (&g_thread_xp_lock);
|
||||
g_thread_xp_waiter_tls = TlsAlloc ();
|
||||
|
||||
g_thread_impl_vtable = g_thread_xp_impl_vtable;
|
||||
}
|
||||
|
||||
/* {{{1 Epilogue */
|
||||
|
||||
static gboolean
|
||||
g_thread_lookup_native_funcs (void)
|
||||
{
|
||||
GThreadImplVtable native_vtable = { 0, };
|
||||
HMODULE kernel32;
|
||||
|
||||
kernel32 = GetModuleHandle ("KERNEL32.DLL");
|
||||
|
||||
if (kernel32 == NULL)
|
||||
return FALSE;
|
||||
|
||||
#define GET_FUNC(name) if ((native_vtable.name = (void *) GetProcAddress (kernel32, #name)) == NULL) return FALSE
|
||||
GET_FUNC(InitializeSRWLock);
|
||||
GET_FUNC(AcquireSRWLockExclusive);
|
||||
GET_FUNC(TryAcquireSRWLockExclusive);
|
||||
GET_FUNC(ReleaseSRWLockExclusive);
|
||||
GET_FUNC(AcquireSRWLockShared);
|
||||
GET_FUNC(TryAcquireSRWLockShared);
|
||||
GET_FUNC(ReleaseSRWLockShared);
|
||||
|
||||
GET_FUNC(InitializeConditionVariable);
|
||||
GET_FUNC(SleepConditionVariableSRW);
|
||||
GET_FUNC(WakeAllConditionVariable);
|
||||
GET_FUNC(WakeConditionVariable);
|
||||
#undef GET_FUNC
|
||||
|
||||
g_thread_impl_vtable = native_vtable;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void
|
||||
g_thread_win32_init (void)
|
||||
{
|
||||
if (!g_thread_lookup_native_funcs ())
|
||||
g_thread_xp_init ();
|
||||
|
||||
InitializeCriticalSection (&g_private_lock);
|
||||
|
||||
#ifndef _MSC_VER
|
||||
@ -1109,9 +580,6 @@ g_thread_win32_thread_detach (void)
|
||||
}
|
||||
}
|
||||
while (dtors_called);
|
||||
|
||||
if (g_thread_impl_vtable.CallThisOnThreadExit)
|
||||
g_thread_impl_vtable.CallThisOnThreadExit ();
|
||||
}
|
||||
|
||||
void
|
||||
|
||||
Loading…
Reference in New Issue
Block a user