/*
* pthread_once.c
*
* Description:
* This translation unit implements miscellaneous thread functions.
*
* --------------------------------------------------------------------------
*
* Pthreads-win32 - POSIX Threads Library for Win32
* Copyright(C) 1998 John E. Bossom
* Copyright(C) 1999,2005 Pthreads-win32 contributors
*
* Contact Email: rpj@callisto.canberra.edu.au
*
* The current list of contributors is contained
* in the file CONTRIBUTORS included with the source
* code distribution. The list can also be seen at the
* following World Wide Web location:
* http://sources.redhat.com/pthreads-win32/contributors.html
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library in the file COPYING.LIB;
* if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
#include "pthread.h"
#include "implement.h"
static void
ptw32_once_init_routine_cleanup(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);
}
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;
}
/*
* 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))
{
/*
* 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);
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);
}
if (PTW32_INTERLOCKED_EXCHANGE((LPLONG) &once_control->started, 0L) == -1)
{
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_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);
}
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);
}
}
/*
* Fall through Intentionally
*/
/*
* ------------
* Failure Code
* ------------
*/
FAIL0:
return (result);
} /* pthread_once */