summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--implement.h6
-rw-r--r--pthread.h6
-rw-r--r--pthread_once.c176
3 files changed, 62 insertions, 126 deletions
diff --git a/implement.h b/implement.h
index eeb7c88..670d948 100644
--- a/implement.h
+++ b/implement.h
@@ -325,9 +325,9 @@ struct pthread_rwlockattr_t_
};
enum ptw32_once_state {
- PTW32_ONCE_CLEAR = 0x0,
- PTW32_ONCE_DONE = 0x1,
- PTW32_ONCE_CANCELLED = 0x2
+ PTW32_ONCE_INIT = 0x0,
+ PTW32_ONCE_STARTED = 0x1,
+ PTW32_ONCE_DONE = 0x2
};
typedef struct {
diff --git a/pthread.h b/pthread.h
index 93060eb..4d9bdfd 100644
--- a/pthread.h
+++ b/pthread.h
@@ -653,12 +653,12 @@ enum {
* ====================
* ====================
*/
-#define PTHREAD_ONCE_INIT { PTW32_FALSE, PTW32_FALSE, 0, 0}
+#define PTHREAD_ONCE_INIT { 0, 0, 0, 0}
struct pthread_once_t_
{
- int done; /* indicates if user function has been executed */
- int started;
+ int state; /* indicates if user function has been executed */
+ int reserved;
int numSemaphoreUsers;
HANDLE semaphore;
};
diff --git a/pthread_once.c b/pthread_once.c
index b42036f..39ddcce 100644
--- a/pthread_once.c
+++ b/pthread_once.c
@@ -34,77 +34,6 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
-/*
- * NOTES:
- * pthread_once() performs a very simple task. So why is this implementation
- * so complicated?
- *
- * The original implementation WAS very simple, but it relied on Windows random
- * priority boosting to resolve starvation problems. Windows priority boosting
- * does not occur for realtime priority classes (levels 16 to 31).
- *
- * You can check back to previous versions of code in the CVS repository or
- * search the mailing list archives for discussion.
- *
- * Version A
- * ---------
- * Waiting threads would resume and suspend again using Sleep(0) until the
- * init_routine had completed, but a higher priority waiter could hog the CPU and
- * starve the initter thread until Windows randomly boosted it's priority, or forever
- * for realtime applications.
- *
- * Version B
- * ---------
- * This was fixed by introducing a per once_control manual-reset event that is
- * created and destroyed dynamically only if there are waiters. The design did not
- * need global critical sections. Each once_control remained independent. A waiter
- * could be confident that if the event was not null then it did not need to create
- * the event.
- *
- * Version C
- * ---------
- * Since a change in ABI would result from version B, it was decided to take
- * the opportunity and make pthread_once() fully compliant with the Single Unix
- * Specification (version 3 at the time). This required allowing the init_routine
- * to be a cancelation point. A cancelation meant that at least some waiting threads
- * if any had to be woken so that one might become the new initter thread.
- * Waiters could no longer simply assume that, if the event was not null, it did
- * not need to create an event.
- *
- * Also, the cancelled init thread needed to set the event, and the
- * new init thread (the winner of the race between any newly arriving threads and
- * waking waiters) would need to reset it again. In the meantime, threads could be
- * happily looping around until they either suspended on the reset event, or exited
- * because the init thread had completed. It was also once again possible for a higher
- * priority waiter to starve the init thread.
- *
- * Version D
- * ---------
- * There were now two options considered:
- * - use an auto-reset event; OR
- * - add our own priority boosting.
- *
- * An auto-reset event would stop threads from looping ok, but it makes threads
- * dependent on earlier threads to successfully set the event in turn when it's time
- * to wake up, and this serialises threads unecessarily on MP systems. It also adds
- * an extra kernel call for each waking thread. If one waiter wakes and dies (async
- * cancelled or killed) before it can set the event, then all remaining waiters are
- * stranded.
- *
- * Priority boosting is a standard method for solving priority inversion and
- * starvation problems. Furthermore, all of the priority boost logic can
- * be restricted to the post cancellation tracks. That is, it need not slow
- * the normal cancel-free behaviour. Threads remain independent of other threads.
- *
- * Version E
- * ---------
- * Substituting a semaphore in place of the event achieves the same effect as an
- * auto-reset event in the post cancellation phase, and a manual-reset event in the
- * normal exit phase. The new initter thread does not need to do any post-cancellation
- * operations, and waiters only need to check that there is a new initter running
- * before starting to wait. All priority issues and adjustments disappear.
- */
-
#include "pthread.h"
#include "implement.h"
@@ -114,7 +43,7 @@ ptw32_once_init_routine_cleanup(void * arg)
{
pthread_once_t * once_control = (pthread_once_t *) arg;
- (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->started, (LONG)PTW32_FALSE);
+ (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->state, (LONG)PTW32_ONCE_INIT);
if (InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
{
@@ -162,6 +91,7 @@ pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
*/
{
int result;
+ int state;
HANDLE sema;
if (once_control == NULL || init_routine == NULL)
@@ -174,69 +104,75 @@ pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
result = 0;
}
- while (!InterlockedExchangeAdd((LPLONG)&once_control->done, 0L)) /* Atomic Read */
+ while ((state =
+ PTW32_INTERLOCKED_COMPARE_EXCHANGE((PTW32_INTERLOCKED_LPLONG)&once_control->state,
+ (PTW32_INTERLOCKED_LONG)PTW32_ONCE_STARTED,
+ (PTW32_INTERLOCKED_LONG)PTW32_ONCE_INIT))
+ != PTW32_ONCE_DONE)
{
- if (!PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->started, (LONG)PTW32_TRUE))
- {
+ if (PTW32_ONCE_INIT == state)
+ {
#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);
+ pthread_cleanup_push(ptw32_once_init_routine_cleanup, (void *) once_control);
+ (*init_routine)();
+ pthread_cleanup_pop(0);
#ifdef _MSC_VER
#pragma inline_depth()
#endif
- (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->done, (LONG)PTW32_TRUE);
-
- /*
- * we didn't create the semaphore.
- * it is only there if there is someone waiting.
- */
- if (InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
- {
- ReleaseSemaphore(once_control->semaphore, once_control->numSemaphoreUsers, NULL);
- }
- }
+ (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->state,
+ (LONG)PTW32_ONCE_DONE);
+
+ /*
+ * we didn't create the semaphore.
+ * it is only there if there is someone waiting.
+ */
+ if (InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
+ {
+ ReleaseSemaphore(once_control->semaphore,
+ once_control->numSemaphoreUsers, NULL);
+ }
+ }
else
- {
- InterlockedIncrement((LPLONG)&once_control->numSemaphoreUsers);
+ {
+ InterlockedIncrement((LPLONG)&once_control->numSemaphoreUsers);
- if (!InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
- {
- sema = CreateSemaphore(NULL, 0, INT_MAX, NULL);
+ if (!InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
+ {
+ sema = CreateSemaphore(NULL, 0, INT_MAX, NULL);
- if (PTW32_INTERLOCKED_COMPARE_EXCHANGE((PTW32_INTERLOCKED_LPLONG)&once_control->semaphore,
+ if (PTW32_INTERLOCKED_COMPARE_EXCHANGE((PTW32_INTERLOCKED_LPLONG)&once_control->semaphore,
(PTW32_INTERLOCKED_LONG)sema,
(PTW32_INTERLOCKED_LONG)0))
- {
- CloseHandle(sema);
- }
- }
-
- /*
- * Check 'done' and 'started' again in case the initting thread has finished or cancelled
- * and left before seeing that there was a semaphore to release.
- */
- if (InterlockedExchangeAdd((LPLONG)&once_control->done, 0L) /* Done immediately, or */
- || !InterlockedExchangeAdd((LPLONG)&once_control->started, 0L) /* No initter yet, or */
- || WaitForSingleObject(once_control->semaphore, INFINITE)) /* Done or Cancelled */
- {
- if (0 == InterlockedDecrement((LPLONG)&once_control->numSemaphoreUsers))
- {
- /* we were last */
- if ((sema = (HANDLE) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->semaphore,
- (LONG)0)))
- {
- CloseHandle(sema);
- }
- }
- }
- }
+ {
+ CloseHandle(sema);
+ }
+ }
+
+ /*
+ * Check 'state' again in case the initting thread has finished or
+ * cancelled and left before seeing that there was a semaphore.
+ */
+ if (InterlockedExchangeAdd((LPLONG)&once_control->state, 0L) == PTW32_ONCE_STARTED)
+ {
+ WaitForSingleObject(once_control->semaphore, INFINITE);
+ }
+
+ if (0 == InterlockedDecrement((LPLONG)&once_control->numSemaphoreUsers))
+ {
+ /* we were last */
+ if ((sema =
+ (HANDLE) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->semaphore, (LONG)0)))
+ {
+ CloseHandle(sema);
+ }
+ }
+ }
}
/*
@@ -246,4 +182,4 @@ pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
*/
FAIL0:
return (result);
-} /* pthread_once */
+} /* pthread_once */