From 15f1b0bc1f4feeca60ca1dda769928822d6c032a Mon Sep 17 00:00:00 2001 From: rpj Date: Fri, 3 Jun 2005 08:32:43 +0000 Subject: '' --- pthread_once.c | 187 +++++---------------------------------------------------- 1 file changed, 16 insertions(+), 171 deletions(-) (limited to 'pthread_once.c') diff --git a/pthread_once.c b/pthread_once.c index 62b412c..efcfd0f 100644 --- a/pthread_once.c +++ b/pthread_once.c @@ -38,204 +38,49 @@ #include "implement.h" -static void -ptw32_once_init_routine_cleanup(void * arg) +static void PTW32_CDECL +ptw32_once_on_init_cancel (void * arg) { - pthread_once_t * once_control = (pthread_once_t *) arg; - - (void) pthread_mutex_lock(&ptw32_once_control.mtx); - once_control->done = PTW32_ONCE_CANCELLED; - (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->started, -1L); - /* - * Wake everyone up. - * - * Holding the mutex during the broadcast prevents threads being left - * behind waiting. - */ - (void) pthread_cond_broadcast(&ptw32_once_control.cond); - (void) pthread_mutex_unlock(&ptw32_once_control.mtx); + /* when the initting thread is cancelled we have to release the lock */ + ptw32_mcs_local_node_t *node = (ptw32_mcs_local_node_t *)arg; + ptw32_mcs_lock_release(node); } - int pthread_once (pthread_once_t * once_control, void (*init_routine) (void)) - /* - * ------------------------------------------------------ - * DOCPUBLIC - * If any thread in a process with a once_control parameter - * makes a call to pthread_once(), the first call will summon - * the init_routine(), but subsequent calls will not. The - * once_control parameter determines whether the associated - * initialization routine has been called. The init_routine() - * is complete upon return of pthread_once(). - * This function guarantees that one and only one thread - * executes the initialization routine, init_routine when - * access is controlled by the pthread_once_t control - * key. - * - * pthread_once() is not a cancelation point, but the init_routine - * can be. If it's cancelled then the effect on the once_control is - * as if pthread_once had never been entered. - * - * PARAMETERS - * once_control - * pointer to an instance of pthread_once_t - * - * init_routine - * pointer to an initialization routine - * - * - * DESCRIPTION - * See above. - * - * RESULTS - * 0 success, - * EINVAL once_control or init_routine is NULL - * - * ------------------------------------------------------ - */ { - int result; - LONG state; - pthread_t self; - HANDLE w32Thread = 0; - if (once_control == NULL || init_routine == NULL) { - - result = EINVAL; - goto FAIL0; - - } - else - { - result = 0; + return EINVAL; } - - /* - * Use a single global cond+mutex to manage access to all once_control objects. - * Unlike a global mutex on it's own, the global cond+mutex allows faster - * once_controls to overtake slower ones. Spurious wakeups may occur, but - * can be tolerated. - * - * Since this is being introduced as a bug fix, the global cond+mtx also avoids - * a change in the ABI, maintaining backwards compatibility. - * - * To maintain a separate mutex for each once_control object requires either - * cleaning up the mutex (difficult to synchronise reliably), or leaving it - * around forever. Since we can't make assumptions about how an application might - * employ pthread_once objects, the later is considered to be unacceptable. - * - * once_control->done is now a multipurpose flag. It indicates either that - * the init_routine has been completed, or the thread running it has been cancelled. - * - * Priority boosting is used to ensure that the init_routine thread is not - * starved, by higher priority threads inside the while loop, before it can - * clear the cancelled flag. The init_routine will be run at the thread's - * normal base priority. Note that priority boosting is momentary, independent - * for each once_control, and occurs only AFTER an init_routine cancellation. - */ - - while (!((state = InterlockedExchangeAdd((LPLONG)&once_control->done, 0L)) /* Full mem barrier read */ - & PTW32_ONCE_DONE)) + + if (InterlockedExchangeAdd((LPLONG)&once_control->done, 0L)) /* MBR fence */ { - /* - * Keep a per thread record of the cancelled state for speed. If the - * once_control state changes before we've finished with our local copy - * then no harm is done - in fact, we need it to complete the full priority - * boost transaction. - */ - LONG cancelled = (state & PTW32_ONCE_CANCELLED); + ptw32_mcs_local_node_t node; - if (cancelled) - { - /* Boost priority momentarily */ - if (!w32Thread) - { - self = pthread_self(); - w32Thread = ((ptw32_thread_t *)self.p)->threadH; - } - /* Prevent pthread_setschedparam() changing our priority while we're boosted. */ - (void) pthread_mutex_lock(&((ptw32_thread_t *)self.p)->threadLock); - SetThreadPriority(w32Thread, THREAD_PRIORITY_HIGHEST); - } + ptw32_mcs_lock_acquire((ptw32_mcs_lock_t *)&once_control->lock, &node); - if (PTW32_INTERLOCKED_EXCHANGE((LPLONG) &once_control->started, 0L) == -1) + if (InterlockedExchangeAdd((LPLONG)&once_control->done, 0L)) { - if (cancelled) - { - /* Reset cancelled state */ - (void) pthread_mutex_lock(&ptw32_once_control.mtx); - once_control->done = PTW32_ONCE_CLEAR; - (void) pthread_mutex_unlock(&ptw32_once_control.mtx); - - /* - * Restore priority - any priority changes since the thread was created - * will be applied only if they were made via POSIX (i.e. pthread_setschedparam). - */ - SetThreadPriority(w32Thread, ((ptw32_thread_t *)self.p)->sched_priority); - (void) pthread_mutex_unlock(&((ptw32_thread_t *)self.p)->threadLock); - } #ifdef _MSC_VER #pragma inline_depth(0) #endif - pthread_cleanup_push(ptw32_once_init_routine_cleanup, (void*) once_control); - (*init_routine) (); + pthread_cleanup_push(ptw32_once_on_init_cancel, (void *)&node); + (*init_routine)(); pthread_cleanup_pop(0); #ifdef _MSC_VER #pragma inline_depth() #endif - /* - * Holding the mutex during the broadcast prevents threads being left - * behind waiting. - */ - (void) pthread_mutex_lock(&ptw32_once_control.mtx); - once_control->done = PTW32_ONCE_DONE; - (void) pthread_cond_broadcast(&ptw32_once_control.cond); - (void) pthread_mutex_unlock(&ptw32_once_control.mtx); + (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->done, 0L); } - else - { - int oldCancelState; - - if (cancelled) - { - /* - * Restore priority - any priority changes since the thread was created - * will be applied only if they were made via POSIX (i.e. pthread_setschedparam). - */ - SetThreadPriority(w32Thread, ((ptw32_thread_t *)self.p)->sched_priority); - (void) pthread_mutex_unlock(&((ptw32_thread_t *)self.p)->threadLock); - } - pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldCancelState); - (void) pthread_mutex_lock(&ptw32_once_control.mtx); - while (!once_control->done /* Neither DONE nor CANCELLED */ - || (!(once_control->done & PTW32_ONCE_DONE) - && cancelled) /* Stop after one init_routine re-contest */) - { - cancelled = 0; - (void) pthread_cond_wait(&ptw32_once_control.cond, &ptw32_once_control.mtx); - } - (void) pthread_mutex_unlock(&ptw32_once_control.mtx); - pthread_setcancelstate(oldCancelState, NULL); - } + ptw32_mcs_lock_release(&node); } - /* - * Fall through Intentionally - */ - - /* - * ------------ - * Failure Code - * ------------ - */ -FAIL0: - return (result); + return 0; } /* pthread_once */ -- cgit v1.2.3