summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--ChangeLog10
-rw-r--r--GNUmakefile16
-rw-r--r--README14
-rw-r--r--pthread.h39
-rw-r--r--pthread_once.c285
5 files changed, 107 insertions, 257 deletions
diff --git a/ChangeLog b/ChangeLog
index 2c4ef6d..537b365 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,12 @@
-2005-05-24 Mikael Magnusson <mikaelmagnusson at glocalnet.net>
+2005-05-25 Vladimir Kliatchko <vladimir at kliatchko.com>
+
+ * pthread_once.c: Eliminate all priority operations and other
+ complexity by replacing the event with a semaphore. The advantage
+ of the change is the ability to release just one waiter if the
+ init_routine thread is cancelled yet still release all waiters when
+ done.
+
+2005-05-24 Mikael Magnusson <mikaelmagnusson at glocalnet.net>
* GNUmakefile: Patched to allow cross-compile with mingw32 on Linux.
It uses macros instead of referencing dlltool, gcc and g++ directly;
diff --git a/GNUmakefile b/GNUmakefile
index 716d47e..992251d 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -41,18 +41,22 @@ LIBDEST = $(DEVROOT)\DLL
RM = rm -f
MV = mv -f
CP = cp -f
-RC = windres
# If not.
#RM = erase
#MV = rename
#CP = copy
-AR = ar
-DLLTOOL = dlltool
-CC = gcc
-CXX = g++
-RANLIB = ranlib
+# For cross compiling use e.g.
+# make CROSS=i386-mingw32msvc- clean GC-inlined
+CROSS =
+
+AR = $(CROSS)ar
+DLLTOOL = $(CROSS)dlltool
+CC = $(CROSS)gcc
+CXX = $(CROSS)g++
+RANLIB = $(CROSS)ranlib
+RC = $(CROSS)windres
OPT = $(CLEANUP) -O3 -finline-functions
DOPT = $(CLEANUP) -g -O0
diff --git a/README b/README
index 091fa89..5649333 100644
--- a/README
+++ b/README
@@ -411,6 +411,20 @@ make clean GCE-bench (to benchtest using GNU C dll with C++ exception handling
make clean GC-static (to test using GC static lib with C (no EH) applications)
+Building under Linux using the Mingw32 cross development tools
+--------------------------------------------------------------
+
+You can build the library without leaving Linux by using the Mingw32 cross
+development toolchain. See http://www.libsdl.org/extras/win32/cross/ for
+tools and info. The GNUmakefile contains some support for this, for example:
+
+make CROSS=i386-mingw32msvc- clean GC-inlined
+
+will build pthreadGCn.dll and libpthreadGCn.a (n=version#), provided your
+cross-tools/bin directory is in your PATH (or use the cross-make.sh script
+at the URL above).
+
+
Building the library as a statically linkable library
-----------------------------------------------------
diff --git a/pthread.h b/pthread.h
index 64f21b9..93060eb 100644
--- a/pthread.h
+++ b/pthread.h
@@ -191,15 +191,6 @@
/* Try to avoid including windows.h */
#if defined(__MINGW32__) && defined(__cplusplus)
-/*
- * FIXME: The pthreadGCE.dll build gets linker unresolved errors
- * on pthread_key_create() unless windows.h is included here.
- * It appears to have something to do with an argument type mismatch.
- * Looking at tsd.o with 'nm' shows this line:
- * 00000000 T _pthread_key_create__FPP14pthread_key_t_PFPv_v
- * instead of
- * 00000000 T _pthread_key_create
- */
#define PTW32_INCLUDE_WINDOWS_H
#endif
@@ -223,26 +214,6 @@ typedef unsigned long DWORD_PTR;
#include "config.h"
#endif /* HAVE_CONFIG_H */
-#if PTW32_LEVEL >= PTW32_LEVEL_MAX
-
-/* Try to avoid including windows.h */
-#if defined(__MINGW32__) && defined(__cplusplus)
-/*
- * FIXME: The pthreadGCE.dll build gets linker unresolved errors
- * on pthread_key_create() unless windows.h is included here.
- * It appears to have something to do with an argument type mismatch.
- * Looking at tsd.o with 'nm' shows this line:
- * 00000000 T _pthread_key_create__FPP14pthread_key_t_PFPv_v
- * instead of
- * 00000000 T _pthread_key_create
- */
-#define PTW32_INCLUDE_WINDOWS_H
-#endif
-
-#ifdef PTW32_INCLUDE_WINDOWS_H
-#include <windows.h>
-#endif
-
#ifndef NEED_FTIME
#include <time.h>
#else /* NEED_FTIME */
@@ -332,8 +303,6 @@ enum {
#endif
#endif
-#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
-
#ifndef HAVE_STRUCT_TIMESPEC
#define HAVE_STRUCT_TIMESPEC 1
struct timespec {
@@ -684,14 +653,14 @@ enum {
* ====================
* ====================
*/
-#define PTHREAD_ONCE_INIT { 0, PTW32_FALSE, 0, 0}
+#define PTHREAD_ONCE_INIT { PTW32_FALSE, PTW32_FALSE, 0, 0}
struct pthread_once_t_
{
- int state; /* indicates if user function has been executed, or cancelled */
+ int done; /* indicates if user function has been executed */
int started;
- int eventUsers;
- HANDLE event;
+ int numSemaphoreUsers;
+ HANDLE semaphore;
};
diff --git a/pthread_once.c b/pthread_once.c
index 0ee063a..b42036f 100644
--- a/pthread_once.c
+++ b/pthread_once.c
@@ -96,9 +96,13 @@
* be restricted to the post cancellation tracks. That is, it need not slow
* the normal cancel-free behaviour. Threads remain independent of other threads.
*
- * The implementation below adds only a few local (to the thread) integer comparisons
- * to the normal track through the routine and additional bus locking/cache line
- * syncing operations have been avoided altogether in the uncontended track.
+ * 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"
@@ -110,72 +114,55 @@ ptw32_once_init_routine_cleanup(void * arg)
{
pthread_once_t * once_control = (pthread_once_t *) arg;
- (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->state, (LONG)PTW32_ONCE_CANCELLED);
(void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->started, (LONG)PTW32_FALSE);
- if (InterlockedExchangeAdd((LPLONG)&once_control->event, 0L)) /* MBR fence */
+ if (InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
{
- int lasterror = GetLastError ();
- int lastWSAerror = WSAGetLastError ();
-
- /*
- * There are waiters, wake some up.
- */
- if (!SetEvent(once_control->event))
- {
- SetLastError (lasterror);
- WSASetLastError (lastWSAerror);
- }
+ ReleaseSemaphore(once_control->semaphore, 1, NULL);
}
}
-
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
- *
- * ------------------------------------------------------
- */
+ /*
+ * ------------------------------------------------------
+ * 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;
- int lasterror;
- int lastWSAerror;
- int restoreLastError;
- LONG state;
- pthread_t self;
- HANDLE w32Thread = 0;
+ HANDLE sema;
if (once_control == NULL || init_routine == NULL)
{
@@ -187,67 +174,10 @@ pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
result = 0;
}
- /*
- * We want to be invisible to GetLastError() outside of this routine.
- */
- lasterror = GetLastError ();
- lastWSAerror = WSAGetLastError ();
- restoreLastError = PTW32_FALSE;
-
- while (!((state = InterlockedExchangeAdd((LPLONG)&once_control->state, 0L)) /* Atomic Read */
- & (LONG)PTW32_ONCE_DONE))
+ while (!InterlockedExchangeAdd((LPLONG)&once_control->done, 0L)) /* Atomic Read */
{
- 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() from changing our priority while we're boosted.
- */
- pthread_mutex_lock(&((ptw32_thread_t *)self.p)->threadLock);
- SetThreadPriority(w32Thread, THREAD_PRIORITY_HIGHEST);
- }
-
if (!PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->started, (LONG)PTW32_TRUE))
{
- if (cancelled)
- {
- /*
- * The previous initter was cancelled.
- * We now have a new initter (us) and we need to make the rest wait again.
- * Furthermore, we're running at max priority until after we've reset the event
- * so we will not be starved by any other threads that may now be looping
- * around.
- */
- if (InterlockedExchangeAdd((LPLONG)&once_control->event, 0L)) /* MBR fence */
- {
- if (!ResetEvent(once_control->event))
- {
- restoreLastError = PTW32_TRUE;
- }
- }
-
- /*
- * Any threads entering the wait section and getting out again before
- * the event is reset and the CANCELLED state is cleared will, at worst,
- * just go around again or, if they suspend and we (the initter) completes before
- * they resume, they will see state == DONE and leave immediately.
- */
- PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->state, (LONG)PTW32_ONCE_CLEAR);
-
- /*
- * Restore priority. We catch any changes to this thread's priority
- * only if they were done through the POSIX API (i.e. pthread_setschedparam)
- */
- SetThreadPriority(w32Thread, ((ptw32_thread_t *)self.p)->sched_priority);
- pthread_mutex_unlock(&((ptw32_thread_t *)self.p)->threadLock);
- }
#ifdef _MSC_VER
#pragma inline_depth(0)
@@ -261,128 +191,54 @@ pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
#pragma inline_depth()
#endif
- (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->state, (LONG)PTW32_ONCE_DONE);
+ (void) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->done, (LONG)PTW32_TRUE);
/*
- * we didn't create the event.
+ * we didn't create the semaphore.
* it is only there if there is someone waiting.
- * Avoid using the global event_lock but still prevent SetEvent
- * from overwriting any 'lasterror' if the event is closed before we
- * are done with it.
*/
- if (InterlockedExchangeAdd((LPLONG)&once_control->event, 0L)) /* MBR fence */
+ if (InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
{
- if (!SetEvent(once_control->event))
- {
- restoreLastError = PTW32_TRUE;
- }
+ ReleaseSemaphore(once_control->semaphore, once_control->numSemaphoreUsers, NULL);
}
}
else
{
- HANDLE tmpEvent;
+ InterlockedIncrement((LPLONG)&once_control->numSemaphoreUsers);
- if (cancelled)
+ if (!InterlockedExchangeAdd((LPLONG)&once_control->semaphore, 0L)) /* MBR fence */
{
- /*
- * Restore priority. We catch any changes to this thread's priority
- * only if they were done through the POSIX API (i.e. pthread_setschedparam.
- */
- SetThreadPriority(w32Thread, ((ptw32_thread_t *)self.p)->sched_priority);
- pthread_mutex_unlock(&((ptw32_thread_t *)self.p)->threadLock);
- }
+ sema = CreateSemaphore(NULL, 0, INT_MAX, NULL);
- /*
- * wait for init.
- * while waiting, create an event to wait on
- */
-
- if (1 == InterlockedIncrement((LPLONG)&once_control->eventUsers))
- {
- /*
- * RE CANCELLATION:
- * If we are the first thread after the initter thread, and the init_routine is cancelled
- * while we're suspended at this point in the code:-
- * - state will not get set to PTW32_ONCE_DONE;
- * - cleanup will not see an event and cannot set it;
- * - therefore, we will eventually resume, create an event and wait on it;
- * cleanup will set state == CANCELLED before checking for an event, so that
- * we will see it and avoid waiting (as for state == DONE). We will go around again and
- * we may then become the initter.
- * If we are still the only other thread when we get to the end of this block, we will
- * have closed the event (good). If another thread beats us to be initter, then we will
- * re-enter here (good). In case the old event is reused, the event is always reset by
- * the new initter before clearing the CANCELLED state, causing any threads that are
- * cycling around the loop to wait again.
- * The initter thread is guaranteed to be at equal or higher priority than any waiters
- * so no waiters will starve the initter, which might otherwise cause us to loop
- * forever.
- */
- tmpEvent = CreateEvent(NULL, PTW32_TRUE, PTW32_FALSE, NULL);
- if (PTW32_INTERLOCKED_COMPARE_EXCHANGE((PTW32_INTERLOCKED_LPLONG)&once_control->event,
- (PTW32_INTERLOCKED_LONG)tmpEvent,
+ if (PTW32_INTERLOCKED_COMPARE_EXCHANGE((PTW32_INTERLOCKED_LPLONG)&once_control->semaphore,
+ (PTW32_INTERLOCKED_LONG)sema,
(PTW32_INTERLOCKED_LONG)0))
{
- CloseHandle(tmpEvent);
+ CloseHandle(sema);
}
}
/*
- * Check 'state' again in case the initting thread has finished or cancelled
- * and left before seeing that there was an event to trigger.
+ * 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.
*/
-
- switch (InterlockedExchangeAdd((LPLONG)&once_control->state, 0L))
+ 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 */
{
- case PTW32_ONCE_CLEAR:
- {
- /* Neither DONE nor CANCELLED */
- if (WAIT_FAILED == WaitForSingleObject(once_control->event, INFINITE))
- {
- restoreLastError = PTW32_TRUE;
- /*
- * If the wait failed it's probably because the event is invalid.
- * That's possible after a cancellation (but rare) if we got through the
- * event create block above while a woken thread was suspended between
- * the decrement and exchange below and then resumed before we could wait.
- * So we'll yield.
- */
- Sleep(0);
- }
- break;
- }
- case PTW32_ONCE_CANCELLED:
- {
- if (once_control->started)
- {
- /* The new initter hasn't cleared the cancellation yet, so give the
- * processor to a more productive thread. */
- Sleep(0);
- }
- break;
- }
- }
-
- /* last one out shut off the lights */
- if (0 == InterlockedDecrement((LPLONG)&once_control->eventUsers))
- {
- /* we were last */
- if ((tmpEvent = (HANDLE)
- PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->event,
- (LONG)0)))
+ if (0 == InterlockedDecrement((LPLONG)&once_control->numSemaphoreUsers))
{
- CloseHandle(tmpEvent);
+ /* we were last */
+ if ((sema = (HANDLE) PTW32_INTERLOCKED_EXCHANGE((LPLONG)&once_control->semaphore,
+ (LONG)0)))
+ {
+ CloseHandle(sema);
+ }
}
}
}
}
- if (restoreLastError)
- {
- SetLastError (lasterror);
- WSASetLastError (lastWSAerror);
- }
-
/*
* ------------
* Failure Code
@@ -390,5 +246,4 @@ pthread_once (pthread_once_t * once_control, void (*init_routine) (void))
*/
FAIL0:
return (result);
-
-} /* pthread_once */
+} /* pthread_once */