Commit 3bff2b3c authored by Alexandre Julliard's avatar Alexandre Julliard

Authors: Juraj Hercek <juraj@syncad.com>, Eric Frias <efrias@syncad.com>

Implemented pthread conditions.
parent 9d481e32
...@@ -304,6 +304,230 @@ static int wine_pthread_rwlock_unlock(pthread_rwlock_t *rwlock) ...@@ -304,6 +304,230 @@ static int wine_pthread_rwlock_unlock(pthread_rwlock_t *rwlock)
return 0; return 0;
} }
/***** CONDITIONS *****/
/* The condition code is basically cut-and-pasted from Douglas
* Schmidt's paper:
* "Strategies for Implementing POSIX Condition Variables on Win32",
* at http://www.cs.wustl.edu/~schmidt/win32-cv-1.html and
* http://www.cs.wustl.edu/~schmidt/win32-cv-2.html.
* This paper formed the basis for the condition variable
* impementation used in the ACE library.
*/
/* Possible problems with ACE:
* - unimplemented pthread_mutexattr_init
*/
typedef struct {
/* Number of waiting threads. */
int waiters_count;
/* Serialize access to <waiters_count>. */
CRITICAL_SECTION waiters_count_lock;
/*
* Semaphore used to queue up threads waiting for the condition to
* become signaled.
*/
HANDLE sema;
/*
* An auto-reset event used by the broadcast/signal thread to wait
* for all the waiting thread(s) to wake up and be released from the
* semaphore.
*/
HANDLE waiters_done;
/*
* Keeps track of whether we were broadcasting or signaling. This
* allows us to optimize the code if we're just signaling.
*/
size_t was_broadcast;
} wine_cond_detail;
/* see wine_mutex above for comments */
typedef struct {
wine_cond_detail *cond;
} *wine_cond;
static void wine_cond_real_init(pthread_cond_t *cond)
{
wine_cond_detail *detail = HeapAlloc(GetProcessHeap(), 0, sizeof(wine_cond_detail));
detail->waiters_count = 0;
detail->was_broadcast = 0;
detail->sema = CreateSemaphoreW( NULL, 0, 0x7fffffff, NULL );
detail->waiters_done = CreateEventW( NULL, FALSE, FALSE, NULL );
RtlInitializeCriticalSection (&detail->waiters_count_lock);
if (InterlockedCompareExchangePointer((void**)&(((wine_cond)cond)->cond), detail, NULL) != NULL)
{
/* too late, some other thread already did it */
P_OUTPUT("FIXME:pthread_cond_init:expect troubles...\n");
CloseHandle(detail->sema);
RtlDeleteCriticalSection(&detail->waiters_count_lock);
CloseHandle(detail->waiters_done);
HeapFree(GetProcessHeap(), 0, detail);
}
}
int wine_pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
{
/* The same as for wine_pthread_mutex_init, we postpone initialization
until condition is really used.*/
((wine_cond)cond)->cond = NULL;
return 0;
}
int wine_pthread_cond_destroy(pthread_cond_t *cond)
{
wine_cond_detail *detail = ((wine_cond)cond)->cond;
if (!detail) return 0;
CloseHandle(detail->sema);
RtlDeleteCriticalSection(&detail->waiters_count_lock);
CloseHandle(detail->waiters_done);
HeapFree(GetProcessHeap(), 0, detail);
((wine_cond)cond)->cond = NULL;
return 0;
}
int wine_pthread_cond_signal(pthread_cond_t *cond)
{
int have_waiters;
wine_cond_detail *detail;
if ( !((wine_cond)cond)->cond ) wine_cond_real_init(cond);
detail = ((wine_cond)cond)->cond;
RtlEnterCriticalSection (&detail->waiters_count_lock);
have_waiters = detail->waiters_count > 0;
RtlLeaveCriticalSection (&detail->waiters_count_lock);
/* If there aren't any waiters, then this is a no-op. */
if (have_waiters)
ReleaseSemaphore(detail->sema, 1, NULL);
return 0;
}
int wine_pthread_cond_broadcast(pthread_cond_t *cond)
{
int have_waiters = 0;
wine_cond_detail *detail;
if ( !((wine_cond)cond)->cond ) wine_cond_real_init(cond);
detail = ((wine_cond)cond)->cond;
/*
* This is needed to ensure that <waiters_count> and <was_broadcast> are
* consistent relative to each other.
*/
RtlEnterCriticalSection (&detail->waiters_count_lock);
if (detail->waiters_count > 0) {
/*
* We are broadcasting, even if there is just one waiter...
* Record that we are broadcasting, which helps optimize
* <pthread_cond_wait> for the non-broadcast case.
*/
detail->was_broadcast = 1;
have_waiters = 1;
}
if (have_waiters) {
/* Wake up all the waiters atomically. */
ReleaseSemaphore(detail->sema, detail->waiters_count, NULL);
RtlLeaveCriticalSection (&detail->waiters_count_lock);
/* Wait for all the awakened threads to acquire the counting semaphore. */
WaitForSingleObject (detail->waiters_done, INFINITE);
/*
* This assignment is okay, even without the <waiters_count_lock> held
* because no other waiter threads can wake up to access it.
*/
detail->was_broadcast = 0;
}
else
RtlLeaveCriticalSection (&detail->waiters_count_lock);
return 0;
}
int wine_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
wine_cond_detail *detail;
int last_waiter;
if ( !((wine_cond)cond)->cond ) wine_cond_real_init(cond);
detail = ((wine_cond)cond)->cond;
/* Avoid race conditions. */
RtlEnterCriticalSection (&detail->waiters_count_lock);
detail->waiters_count++;
RtlLeaveCriticalSection (&detail->waiters_count_lock);
RtlLeaveCriticalSection ( ((wine_mutex)mutex)->critsect );
WaitForSingleObject(detail->sema, INFINITE);
/* Reacquire lock to avoid race conditions. */
RtlEnterCriticalSection (&detail->waiters_count_lock);
/* We're no longer waiting... */
detail->waiters_count--;
/* Check to see if we're the last waiter after <pthread_cond_broadcast>. */
last_waiter = detail->was_broadcast && detail->waiters_count == 0;
RtlLeaveCriticalSection (&detail->waiters_count_lock);
/*
* If we're the last waiter thread during this particular broadcast
* then let all the other threads proceed.
*/
if (last_waiter) SetEvent(detail->waiters_done);
RtlEnterCriticalSection (((wine_mutex)mutex)->critsect);
return 0;
}
int wine_pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
const struct timespec *abstime)
{
DWORD ms = abstime->tv_sec * 1000 + abstime->tv_nsec / 1000000;
int last_waiter;
wine_cond_detail *detail;
if ( !((wine_cond)cond)->cond ) wine_cond_real_init(cond);
detail = ((wine_cond)cond)->cond;
/* Avoid race conditions. */
RtlEnterCriticalSection (&detail->waiters_count_lock);
detail->waiters_count++;
RtlLeaveCriticalSection (&detail->waiters_count_lock);
RtlLeaveCriticalSection (((wine_mutex)mutex)->critsect);
WaitForSingleObject (detail->sema, ms);
/* Reacquire lock to avoid race conditions. */
RtlEnterCriticalSection (&detail->waiters_count_lock);
/* We're no longer waiting... */
detail->waiters_count--;
/* Check to see if we're the last waiter after <pthread_cond_broadcast>. */
last_waiter = detail->was_broadcast && detail->waiters_count == 0;
RtlLeaveCriticalSection (&detail->waiters_count_lock);
/*
* If we're the last waiter thread during this particular broadcast
* then let all the other threads proceed.
*/
if (last_waiter) SetEvent (detail->waiters_done);
RtlEnterCriticalSection (((wine_mutex)mutex)->critsect);
return 0;
}
/***** MISC *****/ /***** MISC *****/
static pthread_t wine_pthread_self(void) static pthread_t wine_pthread_self(void)
...@@ -353,5 +577,11 @@ static const struct wine_pthread_functions functions = ...@@ -353,5 +577,11 @@ static const struct wine_pthread_functions functions =
wine_pthread_rwlock_tryrdlock, /* ptr_pthread_rwlock_tryrdlock */ wine_pthread_rwlock_tryrdlock, /* ptr_pthread_rwlock_tryrdlock */
wine_pthread_rwlock_wrlock, /* ptr_pthread_rwlock_wrlock */ wine_pthread_rwlock_wrlock, /* ptr_pthread_rwlock_wrlock */
wine_pthread_rwlock_trywrlock, /* ptr_pthread_rwlock_trywrlock */ wine_pthread_rwlock_trywrlock, /* ptr_pthread_rwlock_trywrlock */
wine_pthread_rwlock_unlock /* ptr_pthread_rwlock_unlock */ wine_pthread_rwlock_unlock, /* ptr_pthread_rwlock_unlock */
wine_pthread_cond_init, /* ptr_pthread_cond_init */
wine_pthread_cond_destroy, /* ptr_pthread_cond_destroy */
wine_pthread_cond_signal, /* ptr_pthread_cond_signal */
wine_pthread_cond_broadcast, /* ptr_pthread_cond_broadcast */
wine_pthread_cond_wait, /* ptr_pthread_cond_wait */
wine_pthread_cond_timedwait /* ptr_pthread_cond_timedwait */
}; };
...@@ -56,6 +56,13 @@ struct wine_pthread_functions ...@@ -56,6 +56,13 @@ struct wine_pthread_functions
int (*ptr_pthread_rwlock_wrlock)(pthread_rwlock_t *rwlock); int (*ptr_pthread_rwlock_wrlock)(pthread_rwlock_t *rwlock);
int (*ptr_pthread_rwlock_trywrlock)(pthread_rwlock_t *rwlock); int (*ptr_pthread_rwlock_trywrlock)(pthread_rwlock_t *rwlock);
int (*ptr_pthread_rwlock_unlock)(pthread_rwlock_t *rwlock); int (*ptr_pthread_rwlock_unlock)(pthread_rwlock_t *rwlock);
int (*ptr_pthread_cond_init)(pthread_cond_t *cond, const pthread_condattr_t *cond_attr);
int (*ptr_pthread_cond_destroy)(pthread_cond_t *cond);
int (*ptr_pthread_cond_signal)(pthread_cond_t *cond);
int (*ptr_pthread_cond_broadcast)(pthread_cond_t *cond);
int (*ptr_pthread_cond_wait)(pthread_cond_t *cond, pthread_mutex_t *mutex);
int (*ptr_pthread_cond_timedwait)(pthread_cond_t *cond, pthread_mutex_t *mutex,
const struct timespec *abstime);
}; };
extern void wine_pthread_init_process( const struct wine_pthread_functions *functions ); extern void wine_pthread_init_process( const struct wine_pthread_functions *functions );
......
...@@ -563,47 +563,46 @@ void __pthread_cleanup_upto(jmp_buf target, char *frame) ...@@ -563,47 +563,46 @@ void __pthread_cleanup_upto(jmp_buf target, char *frame)
} }
/***** CONDITIONS *****/ /***** CONDITIONS *****/
/* not implemented right now */
int __pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr) int __pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
{ {
P_OUTPUT("FIXME:pthread_cond_init\n"); if (!funcs.ptr_pthread_cond_init) return 0;
return 0; return funcs.ptr_pthread_cond_init(cond, cond_attr);
} }
strong_alias(__pthread_cond_init, pthread_cond_init); strong_alias(__pthread_cond_init, pthread_cond_init);
int __pthread_cond_destroy(pthread_cond_t *cond) int __pthread_cond_destroy(pthread_cond_t *cond)
{ {
P_OUTPUT("FIXME:pthread_cond_destroy\n"); if (!funcs.ptr_pthread_cond_destroy) return 0;
return 0; return funcs.ptr_pthread_cond_destroy(cond);
} }
strong_alias(__pthread_cond_destroy, pthread_cond_destroy); strong_alias(__pthread_cond_destroy, pthread_cond_destroy);
int __pthread_cond_signal(pthread_cond_t *cond) int __pthread_cond_signal(pthread_cond_t *cond)
{ {
P_OUTPUT("FIXME:pthread_cond_signal\n"); if (!funcs.ptr_pthread_cond_signal) return 0;
return 0; return funcs.ptr_pthread_cond_signal(cond);
} }
strong_alias(__pthread_cond_signal, pthread_cond_signal); strong_alias(__pthread_cond_signal, pthread_cond_signal);
int __pthread_cond_broadcast(pthread_cond_t *cond) int __pthread_cond_broadcast(pthread_cond_t *cond)
{ {
P_OUTPUT("FIXME:pthread_cond_broadcast\n"); if (!funcs.ptr_pthread_cond_broadcast) return 0;
return 0; return funcs.ptr_pthread_cond_broadcast(cond);
} }
strong_alias(__pthread_cond_broadcast, pthread_cond_broadcast); strong_alias(__pthread_cond_broadcast, pthread_cond_broadcast);
int __pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) int __pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{ {
P_OUTPUT("FIXME:pthread_cond_wait\n"); if (!funcs.ptr_pthread_cond_wait) return 0;
return 0; return funcs.ptr_pthread_cond_wait(cond, mutex);
} }
strong_alias(__pthread_cond_wait, pthread_cond_wait); strong_alias(__pthread_cond_wait, pthread_cond_wait);
int __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) int __pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
{ {
P_OUTPUT("FIXME:pthread_cond_timedwait\n"); if (!funcs.ptr_pthread_cond_timedwait) return 0;
return 0; return funcs.ptr_pthread_cond_timedwait(cond, mutex, abstime);
} }
strong_alias(__pthread_cond_timedwait, pthread_cond_timedwait); strong_alias(__pthread_cond_timedwait, pthread_cond_timedwait);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment