]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/threadpsx.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
renamed Render's argument to not obfuscate its meaning
[wxWidgets.git] / src / unix / threadpsx.cpp
diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 197d935d3d25106e511a660aa5277cc26f8634df..3da088548daaf881646ef59286630d172693e54c 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -2,13 +2,14 @@
 // Name:        threadpsx.cpp
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
 // Name:        threadpsx.cpp
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
-// Modified by:
+// Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
-//                  Vadim Zeitlin (1999)
+//                  Vadim Zeitlin (1999-2002)
 //                  Robert Roebling (1999)
 //                  Robert Roebling (1999)
+//                  K. S. Sreeram (2002)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -20,11 +21,12 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
     #pragma implementation "thread.h"
 #endif
 
     #pragma implementation "thread.h"
 #endif
 
-#include "wx/defs.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
 
 #if wxUSE_THREADS
 
 
 #if wxUSE_THREADS
 
@@ -34,17 +36,35 @@
 #include "wx/log.h"
 #include "wx/intl.h"
 #include "wx/dynarray.h"
 #include "wx/log.h"
 #include "wx/intl.h"
 #include "wx/dynarray.h"
+#include "wx/timer.h"
 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
-
 #if HAVE_SCHED_H
     #include <sched.h>
 #endif
 
 #if HAVE_SCHED_H
     #include <sched.h>
 #endif
 
+#ifdef HAVE_THR_SETCONCURRENCY
+    #include <thread.h>
+#endif
+
+// we use wxFFile under Linux in GetCPUCount()
+#ifdef __LINUX__
+    #include "wx/ffile.h"
+    // For setpriority.
+    #include <sys/time.h>
+    #include <sys/resource.h>
+#endif
+
+#ifdef __VMS
+    #define THR_ID(thr) ((long long)(thr)->GetId())
+#else
+    #define THR_ID(thr) ((long)(thr)->GetId())
+#endif
+
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
@@ -61,9 +81,12 @@ enum wxThreadState
 // the exit value of a thread which has been cancelled
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 
 // the exit value of a thread which has been cancelled
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 
-// our trace mask
+// trace mask for wxThread operations
 #define TRACE_THREADS   _T("thread")
 
 #define TRACE_THREADS   _T("thread")
 
+// you can get additional debugging messages for the semaphore operations
+#define TRACE_SEMA      _T("semaphore")
+
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
@@ -75,37 +98,11 @@ static void DeleteThread(wxThread *This);
 // private classes
 // ----------------------------------------------------------------------------
 
 // private classes
 // ----------------------------------------------------------------------------
 
-// same as wxMutexLocker but for "native" mutex
-class MutexLock
-{
-public:
-    MutexLock(pthread_mutex_t& mutex)
-    {
-        m_mutex = &mutex;
-        if ( pthread_mutex_lock(m_mutex) != 0 )
-        {
-            wxLogDebug(_T("pthread_mutex_lock() failed"));
-        }
-    }
-
-    ~MutexLock()
-    {
-        if ( pthread_mutex_unlock(m_mutex) != 0 )
-        {
-            wxLogDebug(_T("pthread_mutex_unlock() failed"));
-        }
-    }
-
-private:
-    pthread_mutex_t *m_mutex;
-};
-
-// ----------------------------------------------------------------------------
-// types
-// ----------------------------------------------------------------------------
-
+// an (non owning) array of pointers to threads
 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 
 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 
+// an entry for a thread we can wait for
+
 // -----------------------------------------------------------------------------
 // global data
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // global data
 // -----------------------------------------------------------------------------
@@ -116,7 +113,7 @@ WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 static wxArrayThread gs_allThreads;
 
 // the id of the main thread
 static wxArrayThread gs_allThreads;
 
 // the id of the main thread
-static pthread_t gs_tidMain;
+static pthread_t gs_tidMain = (pthread_t)-1;
 
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
 
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
@@ -126,254 +123,485 @@ static pthread_key_t gs_keySelf;
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted
-static pthread_mutex_t gs_mutexDeleteThread = PTHREAD_MUTEX_INITIALIZER;
+static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
 static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
 static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 
-#if wxUSE_GUI
-    // this mutex must be acquired before any call to a GUI function
-    static wxMutex *gs_mutexGui;
-#endif // wxUSE_GUI
+// this mutex must be acquired before any call to a GUI function
+// (it's not inside #if wxUSE_GUI because this file is compiled as part
+// of wxBase)
+static wxMutex *gs_mutexGui = NULL;
+
+// when we wait for a thread to exit, we're blocking on a condition which the
+// thread signals in its SignalExit() method -- but this condition can't be a
+// member of the thread itself as a detached thread may delete itself at any
+// moment and accessing the condition member of the thread after this would
+// result in a disaster
+//
+// so instead we maintain a global list of the structs below for the threads
+// we're interested in waiting on
 
 // ============================================================================
 
 // ============================================================================
-// implementation
+// wxMutex implementation
 // ============================================================================
 
 // ============================================================================
 
-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------
 
 
+// this is a simple wrapper around pthread_mutex_t which provides error
+// checking
 class wxMutexInternal
 {
 public:
 class wxMutexInternal
 {
 public:
+    wxMutexInternal(wxMutexType mutexType);
+    ~wxMutexInternal();
+
+    wxMutexError Lock();
+    wxMutexError TryLock();
+    wxMutexError Unlock();
+
+    bool IsOk() const { return m_isOk; }
+
+private:
     pthread_mutex_t m_mutex;
     pthread_mutex_t m_mutex;
+    bool m_isOk;
+
+    // wxConditionInternal uses our m_mutex
+    friend class wxConditionInternal;
 };
 
 };
 
-wxMutex::wxMutex()
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
+// on some systems pthread_mutexattr_settype() is not in the headers (but it is
+// in the library, otherwise we wouldn't compile this code at all)
+extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
+#endif
+
+wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {
 {
-    m_internal = new wxMutexInternal;
+    int err;
+    switch ( mutexType )
+    {
+        case wxMUTEX_RECURSIVE:
+            // support recursive locks like Win32, i.e. a thread can lock a
+            // mutex which it had itself already locked
+            //
+            // unfortunately initialization of recursive mutexes is non
+            // portable, so try several methods
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
+            {
+                pthread_mutexattr_t attr;
+                pthread_mutexattr_init(&attr);
+                pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+
+                err = pthread_mutex_init(&m_mutex, &attr);
+            }
+#elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
+            // we can use this only as initializer so we have to assign it
+            // first to a temp var - assigning directly to m_mutex wouldn't
+            // even compile
+            {
+                pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+                m_mutex = mutex;
+            }
+#else // no recursive mutexes
+            err = EINVAL;
+#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+            break;
+
+        default:
+            wxFAIL_MSG( _T("unknown mutex type") );
+            // fall through
+
+        case wxMUTEX_DEFAULT:
+            err = pthread_mutex_init(&m_mutex, NULL);
+            break;
+    }
 
 
-    pthread_mutex_init(&(m_internal->m_mutex),
-                       (pthread_mutexattr_t*) NULL );
-    m_locked = 0;
+    m_isOk = err == 0;
+    if ( !m_isOk )
+    {
+        wxLogApiError( wxT("pthread_mutex_init()"), err);
+    }
 }
 
 }
 
-wxMutex::~wxMutex()
+wxMutexInternal::~wxMutexInternal()
 {
 {
-    if (m_locked > 0)
-        wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
-
-    pthread_mutex_destroy( &(m_internal->m_mutex) );
-    delete m_internal;
+    if ( m_isOk )
+    {
+        int err = pthread_mutex_destroy(&m_mutex);
+        if ( err != 0 )
+        {
+            wxLogApiError( wxT("pthread_mutex_destroy()"), err);
+        }
+    }
 }
 
 }
 
-wxMutexError wxMutex::Lock()
+wxMutexError wxMutexInternal::Lock()
 {
 {
-    int err = pthread_mutex_lock( &(m_internal->m_mutex) );
-    if (err == EDEADLK)
+    int err = pthread_mutex_lock(&m_mutex);
+    switch ( err )
     {
     {
-        wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+        case EDEADLK:
+            // only error checking mutexes return this value and so it's an
+            // unexpected situation -- hence use assert, not wxLogDebug
+            wxFAIL_MSG( _T("mutex deadlock prevented") );
+            return wxMUTEX_DEAD_LOCK;
+
+        case EINVAL:
+            wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
+            break;
 
 
-        return wxMUTEX_DEAD_LOCK;
-    }
+        case 0:
+            return wxMUTEX_NO_ERROR;
 
 
-    m_locked++;
+        default:
+            wxLogApiError(_T("pthread_mutex_lock()"), err);
+    }
 
 
-    return wxMUTEX_NO_ERROR;
+    return wxMUTEX_MISC_ERROR;
 }
 
 }
 
-wxMutexError wxMutex::TryLock()
+wxMutexError wxMutexInternal::TryLock()
 {
 {
-    if (m_locked)
+    int err = pthread_mutex_trylock(&m_mutex);
+    switch ( err )
     {
     {
-        return wxMUTEX_BUSY;
-    }
+        case EBUSY:
+            // not an error: mutex is already locked, but we're prepared for
+            // this
+            return wxMUTEX_BUSY;
 
 
-    int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
-    switch (err)
-    {
-        case EBUSY: return wxMUTEX_BUSY;
-    }
+        case EINVAL:
+            wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
+            break;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
 
 
-    m_locked++;
+        default:
+            wxLogApiError(_T("pthread_mutex_trylock()"), err);
+    }
 
 
-    return wxMUTEX_NO_ERROR;
+    return wxMUTEX_MISC_ERROR;
 }
 
 }
 
-wxMutexError wxMutex::Unlock()
+wxMutexError wxMutexInternal::Unlock()
 {
 {
-    if (m_locked > 0)
+    int err = pthread_mutex_unlock(&m_mutex);
+    switch ( err )
     {
     {
-        m_locked--;
-    }
-    else
-    {
-        wxLogDebug(wxT("Unlocking not locked mutex."));
+        case EPERM:
+            // we don't own the mutex
+            return wxMUTEX_UNLOCKED;
 
 
-        return wxMUTEX_UNLOCKED;
-    }
+        case EINVAL:
+            wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
+            break;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
 
 
-    pthread_mutex_unlock( &(m_internal->m_mutex) );
+        default:
+            wxLogApiError(_T("pthread_mutex_unlock()"), err);
+    }
 
 
-    return wxMUTEX_NO_ERROR;
+    return wxMUTEX_MISC_ERROR;
 }
 
 }
 
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ===========================================================================
+// wxCondition implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxConditionInternal
+// ---------------------------------------------------------------------------
 
 
-// notice that we must use a mutex with POSIX condition variables to ensure
-// that the worker thread doesn't signal condition before the waiting thread
-// starts to wait for it
+// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
+// with a pthread_mutex_t)
 class wxConditionInternal
 {
 public:
 class wxConditionInternal
 {
 public:
-    wxConditionInternal();
+    wxConditionInternal(wxMutex& mutex);
     ~wxConditionInternal();
 
     ~wxConditionInternal();
 
-    void Wait();
-    bool WaitWithTimeout(const timespec* ts);
+    bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
+
+    wxCondError Wait();
+    wxCondError WaitTimeout(unsigned long milliseconds);
 
 
-    void Signal();
-    void Broadcast();
+    wxCondError Signal();
+    wxCondError Broadcast();
 
 private:
 
 private:
-    pthread_mutex_t m_mutex;
-    pthread_cond_t m_condition;
+    // get the POSIX mutex associated with us
+    pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }
+
+    wxMutex& m_mutex;
+    pthread_cond_t m_cond;
+
+    bool m_isOk;
 };
 
 };
 
-wxConditionInternal::wxConditionInternal()
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+                   : m_mutex(mutex)
 {
 {
-    if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
-    {
-        // this is supposed to never happen
-        wxFAIL_MSG( _T("pthread_cond_init() failed") );
-    }
+    int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
 
 
-    if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t*)NULL) != 0 )
-    {
-        // neither this
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
-    }
+    m_isOk = err == 0;
 
 
-    // initially the mutex is locked, so no thread can Signal() or Broadcast()
-    // until another thread starts to Wait()
-    if ( pthread_mutex_lock(&m_mutex) != 0 )
+    if ( !m_isOk )
     {
     {
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
+        wxLogApiError(_T("pthread_cond_init()"), err);
     }
 }
 
 wxConditionInternal::~wxConditionInternal()
 {
     }
 }
 
 wxConditionInternal::~wxConditionInternal()
 {
-    if ( pthread_cond_destroy( &m_condition ) != 0 )
+    if ( m_isOk )
     {
     {
-        wxLogDebug(_T("Failed to destroy condition variable (some "
-                      "threads are probably still waiting on it?)"));
+        int err = pthread_cond_destroy(&m_cond);
+        if ( err != 0 )
+        {
+            wxLogApiError(_T("pthread_cond_destroy()"), err);
+        }
     }
     }
+}
 
 
-    if ( pthread_mutex_unlock( &m_mutex ) != 0 )
+wxCondError wxConditionInternal::Wait()
+{
+    int err = pthread_cond_wait(&m_cond, GetPMutex());
+    if ( err != 0 )
     {
     {
-        wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
-    }
+        wxLogApiError(_T("pthread_cond_wait()"), err);
 
 
-    if ( pthread_mutex_destroy( &m_mutex ) != 0 )
-    {
-        wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
+        return wxCOND_MISC_ERROR;
     }
     }
+
+    return wxCOND_NO_ERROR;
 }
 
 }
 
-void wxConditionInternal::Wait()
+wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
 {
 {
-    if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
+    wxLongLong curtime = wxGetLocalTimeMillis();
+    curtime += milliseconds;
+    wxLongLong temp = curtime / 1000;
+    int sec = temp.GetLo();
+    temp *= 1000;
+    temp = curtime - temp;
+    int millis = temp.GetLo();
+
+    timespec tspec;
+
+    tspec.tv_sec = sec;
+    tspec.tv_nsec = millis * 1000L * 1000L;
+
+    int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
+    switch ( err )
     {
     {
-        // not supposed to ever happen
-        wxFAIL_MSG( _T("pthread_cond_wait() failed") );
+        case ETIMEDOUT:
+            return wxCOND_TIMEOUT;
+
+        case 0:
+            return wxCOND_NO_ERROR;
+
+        default:
+            wxLogApiError(_T("pthread_cond_timedwait()"), err);
     }
     }
+
+    return wxCOND_MISC_ERROR;
 }
 
 }
 
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
+wxCondError wxConditionInternal::Signal()
 {
 {
-    switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
+    int err = pthread_cond_signal(&m_cond);
+    if ( err != 0 )
     {
     {
-        case 0:
-            // condition signaled
-            return TRUE;
+        wxLogApiError(_T("pthread_cond_signal()"), err);
 
 
-        default:
-            wxLogDebug(_T("pthread_cond_timedwait() failed"));
+        return wxCOND_MISC_ERROR;
+    }
 
 
-            // fall through
+    return wxCOND_NO_ERROR;
+}
 
 
-        case ETIMEDOUT:
-        case EINTR:
-            // wait interrupted or timeout elapsed
-            return FALSE;
+wxCondError wxConditionInternal::Broadcast()
+{
+    int err = pthread_cond_broadcast(&m_cond);
+    if ( err != 0 )
+    {
+        wxLogApiError(_T("pthread_cond_broadcast()"), err);
+
+        return wxCOND_MISC_ERROR;
     }
     }
+
+    return wxCOND_NO_ERROR;
 }
 
 }
 
-void wxConditionInternal::Signal()
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxSemaphoreInternal
+// ---------------------------------------------------------------------------
+
+// we implement the semaphores using mutexes and conditions instead of using
+// the sem_xxx() POSIX functions because they're not widely available and also
+// because it's impossible to implement WaitTimeout() using them
+class wxSemaphoreInternal
+{
+public:
+    wxSemaphoreInternal(int initialcount, int maxcount);
+
+    bool IsOk() const { return m_isOk; }
+
+    wxSemaError Wait();
+    wxSemaError TryWait();
+    wxSemaError WaitTimeout(unsigned long milliseconds);
+
+    wxSemaError Post();
+
+private:
+    wxMutex m_mutex;
+    wxCondition m_cond;
+
+    size_t m_count,
+           m_maxcount;
+
+    bool m_isOk;
+};
+
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+                   : m_cond(m_mutex)
 {
 {
-    MutexLock lock(m_mutex);
 
 
-    if ( pthread_cond_signal( &m_condition ) != 0 )
+    if ( (initialcount < 0 || maxcount < 0) ||
+            ((maxcount > 0) && (initialcount > maxcount)) )
+    {
+        wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
+
+        m_isOk = FALSE;
+    }
+    else
     {
     {
-        // shouldn't ever happen
-        wxFAIL_MSG(_T("pthread_cond_signal() failed"));
+        m_maxcount = (size_t)maxcount;
+        m_count = (size_t)initialcount;
     }
     }
+
+    m_isOk = m_mutex.IsOk() && m_cond.IsOk();
 }
 
 }
 
-void wxConditionInternal::Broadcast()
+wxSemaError wxSemaphoreInternal::Wait()
 {
 {
-    MutexLock lock(m_mutex);
+    wxMutexLocker locker(m_mutex);
 
 
-    if ( pthread_cond_broadcast( &m_condition ) != 0 )
+    while ( m_count == 0 )
     {
     {
-        // shouldn't ever happen
-        wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
+        wxLogTrace(TRACE_SEMA,
+                   _T("Thread %ld waiting for semaphore to become signalled"),
+                   wxThread::GetCurrentId());
+
+        if ( m_cond.Wait() != wxCOND_NO_ERROR )
+            return wxSEMA_MISC_ERROR;
+
+        wxLogTrace(TRACE_SEMA,
+                   _T("Thread %ld finished waiting for semaphore, count = %lu"),
+                   wxThread::GetCurrentId(), (unsigned long)m_count);
     }
     }
-}
 
 
-wxCondition::wxCondition()
-{
-    m_internal = new wxConditionInternal;
-}
+    m_count--;
 
 
-wxCondition::~wxCondition()
-{
-    delete m_internal;
+    return wxSEMA_NO_ERROR;
 }
 
 }
 
-void wxCondition::Wait()
+wxSemaError wxSemaphoreInternal::TryWait()
 {
 {
-    m_internal->Wait();
+    wxMutexLocker locker(m_mutex);
+
+    if ( m_count == 0 )
+        return wxSEMA_BUSY;
+
+    m_count--;
+
+    return wxSEMA_NO_ERROR;
 }
 
 }
 
-bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
 {
 {
-    timespec tspec;
+    wxMutexLocker locker(m_mutex);
 
 
-    tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
-    tspec.tv_nsec = nsec;
+    wxLongLong startTime = wxGetLocalTimeMillis();
 
 
-    return m_internal->WaitWithTimeout(&tspec);
+    while ( m_count == 0 )
+    {
+        wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+        long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
+        if ( remainingTime <= 0 )
+        {
+            // timeout
+            return wxSEMA_TIMEOUT;
+        }
+
+        switch ( m_cond.WaitTimeout(remainingTime) )
+        {
+            case wxCOND_TIMEOUT:
+                return wxSEMA_TIMEOUT;
+
+            default:
+                return wxSEMA_MISC_ERROR;
+
+            case wxCOND_NO_ERROR:
+                ;
+        }
+    }
+
+    m_count--;
+
+    return wxSEMA_NO_ERROR;
 }
 
 }
 
-void wxCondition::Signal()
+wxSemaError wxSemaphoreInternal::Post()
 {
 {
-    m_internal->Signal();
+    wxMutexLocker locker(m_mutex);
+
+    if ( m_maxcount > 0 && m_count == m_maxcount )
+    {
+        return wxSEMA_OVERFLOW;
+    }
+
+    m_count++;
+
+    wxLogTrace(TRACE_SEMA,
+               _T("Thread %ld about to signal semaphore, count = %lu"),
+               wxThread::GetCurrentId(), (unsigned long)m_count);
+
+    return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
+                                              : wxSEMA_MISC_ERROR;
 }
 
 }
 
-void wxCondition::Broadcast()
+// ===========================================================================
+// wxThread implementation
+// ===========================================================================
+
+// the thread callback functions must have the C linkage
+extern "C"
 {
 {
-    m_internal->Broadcast();
-}
 
 
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // thread exit function
+    void wxPthreadCleanup(void *ptr);
+#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+
+void *wxPthreadStart(void *ptr);
+
+} // extern "C"
+
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
 
 class wxThreadInternal
 {
 
 class wxThreadInternal
 {
@@ -382,20 +610,15 @@ public:
     ~wxThreadInternal();
 
     // thread entry function
     ~wxThreadInternal();
 
     // thread entry function
-    static void *PthreadStart(void *ptr);
-
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
-    // thread exit function
-    static void PthreadCleanup(void *ptr);
-#endif
+    static void *PthreadStart(wxThread *thread);
 
     // thread actions
         // start the thread
     wxThreadError Run();
 
     // thread actions
         // start the thread
     wxThreadError Run();
+        // unblock the thread allowing it to run
+    void SignalRun() { m_semRun.Post(); }
         // ask the thread to terminate
     void Wait();
         // ask the thread to terminate
     void Wait();
-        // wake up threads waiting for our termination
-    void SignalExit();
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
@@ -407,7 +630,23 @@ public:
     void SetPriority(int prio) { m_prio = prio; }
         // state
     wxThreadState GetState() const { return m_state; }
     void SetPriority(int prio) { m_prio = prio; }
         // state
     wxThreadState GetState() const { return m_state; }
-    void SetState(wxThreadState state) { m_state = state; }
+    void SetState(wxThreadState state)
+    {
+#ifdef __WXDEBUG__
+        static const wxChar *stateNames[] =
+        {
+            _T("NEW"),
+            _T("RUNNING"),
+            _T("PAUSED"),
+            _T("EXITED"),
+        };
+
+        wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
+                   (long)GetId(), stateNames[m_state], stateNames[state]);
+#endif // __WXDEBUG__
+
+        m_state = state;
+    }
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
@@ -418,20 +657,35 @@ public:
     void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
     wxThread::ExitCode GetExitCode() const { return m_exitcode; }
 
     void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
     wxThread::ExitCode GetExitCode() const { return m_exitcode; }
 
+        // the pause flag
+    void SetReallyPaused(bool paused) { m_isPaused = paused; }
+    bool IsReallyPaused() const { return m_isPaused; }
+
         // tell the thread that it is a detached one
         // tell the thread that it is a detached one
-    void Detach() { m_shouldBeJoined = m_shouldBroadcast = FALSE; }
-        // but even detached threads need to notifyus about their termination
-        // sometimes - tell the thread that it should do it
-    void Notify() { m_shouldBroadcast = TRUE; }
+    void Detach()
+    {
+        wxCriticalSectionLocker lock(m_csJoinFlag);
+
+        m_shouldBeJoined = FALSE;
+        m_isDetached = TRUE;
+    }
+
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // this is used by wxPthreadCleanup() only
+    static void Cleanup(wxThread *thread);
+#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum
 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum
-    int           m_prio;       // in wxWindows units: from 0 to 100
+    int           m_prio;       // in wxWidgets units: from 0 to 100
 
     // this flag is set when the thread should terminate
     bool m_cancelled;
 
 
     // this flag is set when the thread should terminate
     bool m_cancelled;
 
+    // this flag is set when the thread is blocking on m_semSuspend
+    bool m_isPaused;
+
     // the thread exit code - only used for joinable (!detached) threads and
     // is only valid after the thread termination
     wxThread::ExitCode m_exitcode;
     // the thread exit code - only used for joinable (!detached) threads and
     // is only valid after the thread termination
     wxThread::ExitCode m_exitcode;
@@ -440,35 +694,32 @@ private:
     // pthread_join(), so we have to keep track of this
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;
     // pthread_join(), so we have to keep track of this
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;
-    bool m_shouldBroadcast;
-
-    // VZ: it's possible that we might do with less than three different
-    //     condition objects - for example, m_condRun and m_condEnd a priori
-    //     won't be used in the same time. But for now I prefer this may be a
-    //     bit less efficient but safer solution of having distinct condition
-    //     variables for each purpose.
+    bool m_isDetached;
 
 
-    // this condition is signaled by Run() and the threads Entry() is not
+    // this semaphore is posted by Run() and the threads Entry() is not
     // called before it is done
     // called before it is done
-    wxCondition m_condRun;
+    wxSemaphore m_semRun;
 
     // this one is signaled when the thread should resume after having been
     // Pause()d
 
     // this one is signaled when the thread should resume after having been
     // Pause()d
-    wxCondition m_condSuspend;
-
-    // finally this one is signalled when the thread exits
-    wxCondition m_condEnd;
+    wxSemaphore m_semSuspend;
 };
 
 // ----------------------------------------------------------------------------
 // thread startup and exit functions
 // ----------------------------------------------------------------------------
 
 };
 
 // ----------------------------------------------------------------------------
 // thread startup and exit functions
 // ----------------------------------------------------------------------------
 
-void *wxThreadInternal::PthreadStart(void *ptr)
+void *wxPthreadStart(void *ptr)
+{
+    return wxThreadInternal::PthreadStart((wxThread *)ptr);
+}
+
+void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
 {
-    wxThread *thread = (wxThread *)ptr;
     wxThreadInternal *pthread = thread->m_internal;
 
     wxThreadInternal *pthread = thread->m_internal;
 
+    wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread));
+
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
     int rc = pthread_setspecific(gs_keySelf, thread);
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
     int rc = pthread_setspecific(gs_keySelf, thread);
@@ -479,31 +730,49 @@ void *wxThreadInternal::PthreadStart(void *ptr)
         return (void *)-1;
     }
 
         return (void *)-1;
     }
 
+    // have to declare this before pthread_cleanup_push() which defines a
+    // block!
+    bool dontRunAtAll;
+
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // install the cleanup handler which will be called if the thread is
     // cancelled
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // install the cleanup handler which will be called if the thread is
     // cancelled
-    pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+    pthread_cleanup_push(wxPthreadCleanup, thread);
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
-    // wait for the condition to be signaled from Run()
-    pthread->m_condRun.Wait();
+    // wait for the semaphore to be posted from Run()
+    pthread->m_semRun.Wait();
 
 
-    // call the main entry
-    pthread->m_exitcode = thread->Entry();
+    // test whether we should run the run at all - may be it was deleted
+    // before it started to Run()?
+    {
+        wxCriticalSectionLocker lock(thread->m_critsect);
 
 
-    wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
-               pthread->GetId());
+        dontRunAtAll = pthread->GetState() == STATE_NEW &&
+                       pthread->WasCancelled();
+    }
 
 
+    if ( !dontRunAtAll )
     {
     {
-        wxCriticalSectionLocker lock(thread->m_critsect);
+        // call the main entry
+        wxLogTrace(TRACE_THREADS,
+                   _T("Thread %ld about to enter its Entry()."),
+                   THR_ID(pthread));
+
+        pthread->m_exitcode = thread->Entry();
 
 
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
-                   pthread->GetId());
+        wxLogTrace(TRACE_THREADS,
+                   _T("Thread %ld Entry() returned %lu."),
+                   THR_ID(pthread), (unsigned long)pthread->m_exitcode);
 
 
-        // change the state of the thread to "exited" so that PthreadCleanup
-        // handler won't do anything from now (if it's called before we do
-        // pthread_cleanup_pop below)
-        pthread->SetState(STATE_EXITED);
+        {
+            wxCriticalSectionLocker lock(thread->m_critsect);
+
+            // change the state of the thread to "exited" so that
+            // wxPthreadCleanup handler won't do anything from now (if it's
+            // called before we do pthread_cleanup_pop below)
+            pthread->SetState(STATE_EXITED);
+        }
     }
 
     // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop
     }
 
     // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop
@@ -514,21 +783,34 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     pthread_cleanup_pop(FALSE);
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
     pthread_cleanup_pop(FALSE);
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
-    // terminate the thread
-    thread->Exit(pthread->m_exitcode);
+    if ( dontRunAtAll )
+    {
+        // FIXME: deleting a possibly joinable thread here???
+        delete thread;
 
 
-    wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
+        return EXITCODE_CANCELLED;
+    }
+    else
+    {
+        // terminate the thread
+        thread->Exit(pthread->m_exitcode);
+
+        wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
 
 
-    return NULL;
+        return NULL;
+    }
 }
 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
 
 // this handler is called when the thread is cancelled
 }
 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
 
 // this handler is called when the thread is cancelled
-void wxThreadInternal::PthreadCleanup(void *ptr)
+extern "C" void wxPthreadCleanup(void *ptr)
 {
 {
-    wxThread *thread = (wxThread *) ptr;
+    wxThreadInternal::Cleanup((wxThread *)ptr);
+}
 
 
+void wxThreadInternal::Cleanup(wxThread *thread)
+{
     {
         wxCriticalSectionLocker lock(thread->m_critsect);
         if ( thread->m_internal->GetState() == STATE_EXITED )
     {
         wxCriticalSectionLocker lock(thread->m_critsect);
         if ( thread->m_internal->GetState() == STATE_EXITED )
@@ -556,9 +838,12 @@ wxThreadInternal::wxThreadInternal()
     m_threadId = 0;
     m_exitcode = 0;
 
     m_threadId = 0;
     m_exitcode = 0;
 
+    // set to TRUE only when the thread starts waiting on m_semSuspend
+    m_isPaused = FALSE;
+
     // defaults for joinable threads
     m_shouldBeJoined = TRUE;
     // defaults for joinable threads
     m_shouldBeJoined = TRUE;
-    m_shouldBroadcast = TRUE;
+    m_isDetached = FALSE;
 }
 
 wxThreadInternal::~wxThreadInternal()
 }
 
 wxThreadInternal::~wxThreadInternal()
@@ -570,43 +855,49 @@ wxThreadError wxThreadInternal::Run()
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
                  wxT("thread may only be started once after Create()") );
 
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
                  wxT("thread may only be started once after Create()") );
 
-    m_condRun.Signal();
-
     SetState(STATE_RUNNING);
 
     SetState(STATE_RUNNING);
 
+    // wake up threads waiting for our start
+    SignalRun();
+
     return wxTHREAD_NO_ERROR;
 }
 
 void wxThreadInternal::Wait()
 {
     return wxTHREAD_NO_ERROR;
 }
 
 void wxThreadInternal::Wait()
 {
+    wxCHECK_RET( !m_isDetached, _T("can't wait for a detached thread") );
+
     // if the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 
     // if the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 
-    wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
-               GetId());
-
-    // wait until the thread terminates (we're blocking in _another_ thread,
-    // of course)
-    m_condEnd.Wait();
-
-    // to avoid memory leaks we should call pthread_join(), but it must only
-    // be done once
-    wxCriticalSectionLocker lock(m_csJoinFlag);
+    wxLogTrace(TRACE_THREADS,
+               _T("Starting to wait for thread %ld to exit."),
+               THR_ID(this));
 
 
-    if ( m_shouldBeJoined )
+    // to avoid memory leaks we should call pthread_join(), but it must only be
+    // done once so use a critical section to serialize the code below
     {
     {
-        // FIXME shouldn't we set cancellation type to DISABLED here? If we're
-        //       cancelled inside pthread_join(), things will almost certainly
-        //       break - but if we disable the cancellation, we might deadlock
-        if ( pthread_join(GetId(), &m_exitcode) != 0 )
+        wxCriticalSectionLocker lock(m_csJoinFlag);
+
+        if ( m_shouldBeJoined )
         {
         {
-            wxLogError(_T("Failed to join a thread, potential memory leak "
-                          "detected - please restart the program"));
-        }
+            // FIXME shouldn't we set cancellation type to DISABLED here? If
+            //       we're cancelled inside pthread_join(), things will almost
+            //       certainly break - but if we disable the cancellation, we
+            //       might deadlock
+            if ( pthread_join(GetId(), &m_exitcode) != 0 )
+            {
+                // this is a serious problem, so use wxLogError and not
+                // wxLogDebug: it is possible to bring the system to its knees
+                // by creating too many threads and not joining them quite
+                // easily
+                wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
+            }
 
 
-        m_shouldBeJoined = FALSE;
+            m_shouldBeJoined = FALSE;
+        }
     }
 
     // reacquire GUI mutex
     }
 
     // reacquire GUI mutex
@@ -614,22 +905,6 @@ void wxThreadInternal::Wait()
         wxMutexGuiEnter();
 }
 
         wxMutexGuiEnter();
 }
 
-void wxThreadInternal::SignalExit()
-{
-    wxLogTrace(TRACE_THREADS, _T("Thread %ld about to exit."), GetId());
-
-    SetState(STATE_EXITED);
-
-    // wake up all the threads waiting for our termination - if there are any
-    if ( m_shouldBroadcast )
-    {
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
-                   GetId());
-
-        m_condEnd.Broadcast();
-    }
-}
-
 void wxThreadInternal::Pause()
 {
     // the state is set from the thread which pauses us first, this function
 void wxThreadInternal::Pause()
 {
     // the state is set from the thread which pauses us first, this function
@@ -637,10 +912,11 @@ void wxThreadInternal::Pause()
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("thread must first be paused with wxThread::Pause().") );
 
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("thread must first be paused with wxThread::Pause().") );
 
-    wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
+   wxLogTrace(TRACE_THREADS,
+              _T("Thread %ld goes to sleep."), THR_ID(this));
 
 
-    // wait until the condition is signaled from Resume()
-    m_condSuspend.Wait();
+    // wait until the semaphore is Post()ed from Resume()
+    m_semSuspend.Wait();
 }
 
 void wxThreadInternal::Resume()
 }
 
 void wxThreadInternal::Resume()
@@ -648,10 +924,24 @@ void wxThreadInternal::Resume()
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("can't resume thread which is not suspended.") );
 
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("can't resume thread which is not suspended.") );
 
-    wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
+    // the thread might be not actually paused yet - if there were no call to
+    // TestDestroy() since the last call to Pause() for example
+    if ( IsReallyPaused() )
+    {
+       wxLogTrace(TRACE_THREADS,
+                  _T("Waking up thread %ld"), THR_ID(this));
 
 
-    // wake up Pause()
-    m_condSuspend.Signal();
+        // wake up Pause()
+        m_semSuspend.Post();
+
+        // reset the flag
+        SetReallyPaused(FALSE);
+    }
+    else
+    {
+        wxLogTrace(TRACE_THREADS,
+                   _T("Thread %ld is not yet really paused"), THR_ID(this));
+    }
 
     SetState(STATE_RUNNING);
 }
 
     SetState(STATE_RUNNING);
 }
@@ -667,17 +957,94 @@ wxThread *wxThread::This()
 
 bool wxThread::IsMain()
 {
 
 bool wxThread::IsMain()
 {
-    return (bool)pthread_equal(pthread_self(), gs_tidMain);
+    return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1;
 }
 
 void wxThread::Yield()
 {
 }
 
 void wxThread::Yield()
 {
+#ifdef HAVE_SCHED_YIELD
     sched_yield();
     sched_yield();
+#endif
 }
 
 void wxThread::Sleep(unsigned long milliseconds)
 {
 }
 
 void wxThread::Sleep(unsigned long milliseconds)
 {
-    wxUsleep(milliseconds);
+    wxMilliSleep(milliseconds);
+}
+
+int wxThread::GetCPUCount()
+{
+#if defined(__LINUX__) && wxUSE_FFILE
+    // read from proc (can't use wxTextFile here because it's a special file:
+    // it has 0 size but still can be read from)
+    wxLogNull nolog;
+
+    wxFFile file(_T("/proc/cpuinfo"));
+    if ( file.IsOpened() )
+    {
+        // slurp the whole file
+        wxString s;
+        if ( file.ReadAll(&s) )
+        {
+            // (ab)use Replace() to find the number of "processor: num" strings
+            size_t count = s.Replace(_T("processor\t:"), _T(""));
+            if ( count > 0 )
+            {
+                return count;
+            }
+
+            wxLogDebug(_T("failed to parse /proc/cpuinfo"));
+        }
+        else
+        {
+            wxLogDebug(_T("failed to read /proc/cpuinfo"));
+        }
+    }
+#elif defined(_SC_NPROCESSORS_ONLN)
+    // this works for Solaris
+    int rc = sysconf(_SC_NPROCESSORS_ONLN);
+    if ( rc != -1 )
+    {
+        return rc;
+    }
+#endif // different ways to get number of CPUs
+
+    // unknown
+    return -1;
+}
+
+// VMS is a 64 bit system and threads have 64 bit pointers.
+// FIXME: also needed for other systems????
+#ifdef __VMS
+unsigned long long wxThread::GetCurrentId()
+{
+    return (unsigned long long)pthread_self();
+}
+
+#else // !__VMS
+
+unsigned long wxThread::GetCurrentId()
+{
+    return (unsigned long)pthread_self();
+}
+
+#endif // __VMS/!__VMS
+
+
+bool wxThread::SetConcurrency(size_t level)
+{
+#ifdef HAVE_THR_SETCONCURRENCY
+    int rc = thr_setconcurrency(level);
+    if ( rc != 0 )
+    {
+        wxLogSysError(rc, _T("thr_setconcurrency() failed"));
+    }
+
+    return rc == 0;
+#else // !HAVE_THR_SETCONCURRENCY
+    // ok only for the default value
+    return level == 0;
+#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -694,7 +1061,7 @@ wxThread::wxThread(wxThreadKind kind)
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 
-wxThreadError wxThread::Create()
+wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
 {
     if ( m_internal->GetState() != STATE_NEW )
     {
 {
     if ( m_internal->GetState() != STATE_NEW )
     {
@@ -713,8 +1080,18 @@ wxThreadError wxThread::Create()
         wxLogError(_("Cannot retrieve thread scheduling policy."));
     }
 
         wxLogError(_("Cannot retrieve thread scheduling policy."));
     }
 
-    int min_prio = sched_get_priority_min(policy),
-        max_prio = sched_get_priority_max(policy),
+#ifdef __VMS__
+   /* the pthread.h contains too many spaces. This is a work-around */
+# undef sched_get_priority_max
+#undef sched_get_priority_min
+#define sched_get_priority_max(_pol_) \
+     (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
+#define sched_get_priority_min(_pol_) \
+     (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
+#endif
+
+    int max_prio = sched_get_priority_max(policy),
+        min_prio = sched_get_priority_min(policy),
         prio = m_internal->GetPriority();
 
     if ( min_prio == -1 || max_prio == -1 )
         prio = m_internal->GetPriority();
 
     if ( min_prio == -1 || max_prio == -1 )
@@ -778,7 +1155,7 @@ wxThreadError wxThread::Create()
              (
                 m_internal->GetIdPtr(),
                 &attr,
              (
                 m_internal->GetIdPtr(),
                 &attr,
-                wxThreadInternal::PthreadStart,
+                wxPthreadStart,
                 (void *)this
              );
 
                 (void *)this
              );
 
@@ -829,6 +1206,45 @@ void wxThread::SetPriority(unsigned int prio)
         case STATE_RUNNING:
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
         case STATE_RUNNING:
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
+#if defined(__LINUX__)
+// On Linux, pthread_setschedparam with SCHED_OTHER does not allow
+// a priority other than 0.  Instead, we use the BSD setpriority
+// which alllows us to set a 'nice' value between 20 to -20.  Only
+// super user can set a value less than zero (more negative yields
+// higher priority).  setpriority set the static priority of a process,
+// but this is OK since Linux is configured as a thread per process.
+            {
+                float   fPrio;
+                float  pSpan;
+                int            iPrio;
+
+                // Map Wx priorites (WXTHREAD_MIN_PRIORITY -
+                // WXTHREAD_MAX_PRIORITY) into BSD priorities (20 - -20).
+                // Do calculation of values instead of hard coding them
+                // to make maintenance easier.
+
+                pSpan = ((float)(WXTHREAD_MAX_PRIORITY - WXTHREAD_MIN_PRIORITY)) / 2.0;
+
+                // prio starts as ...................  // value =>  (0) >=  p  <=  (n)
+
+                fPrio = ((float)prio) -  pSpan;        // value =>  (-n) >=  p  <=  (+n)
+
+                fPrio = 0.0 - fPrio;                   // value =>  (+n) <=  p  >=  (-n)
+
+                fPrio = fPrio * (20. / pSpan) + .5;    // value =>  (20) <=  p  >=  (-20)
+
+                iPrio = (int)fPrio;
+
+                // Clamp prio from 20 - -20;
+                iPrio = (iPrio > 20)  ?  20 : iPrio;
+                iPrio = (iPrio < -20) ? -20 : iPrio;
+
+                if (setpriority(PRIO_PROCESS, 0, iPrio) == -1)
+                {
+                    wxLogError(_("Failed to set thread priority %d."), prio);
+                }
+            }
+#else // __LINUX__
             {
                 struct sched_param sparam;
                 sparam.sched_priority = prio;
             {
                 struct sched_param sparam;
                 sparam.sched_priority = prio;
@@ -839,6 +1255,7 @@ void wxThread::SetPriority(unsigned int prio)
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }
+#endif // __LINUX__
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
             break;
 
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
             break;
 
@@ -855,9 +1272,9 @@ unsigned int wxThread::GetPriority() const
     return m_internal->GetPriority();
 }
 
     return m_internal->GetPriority();
 }
 
-unsigned long wxThread::GetId() const
+wxThreadIdType wxThread::GetId() const
 {
 {
-    return (unsigned long)m_internal->GetId();
+    return (wxThreadIdType) m_internal->GetId();
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -866,6 +1283,9 @@ unsigned long wxThread::GetId() const
 
 wxThreadError wxThread::Pause()
 {
 
 wxThreadError wxThread::Pause()
 {
+    wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+                 _T("a thread can't pause itself") );
+
     wxCriticalSectionLocker lock(m_critsect);
 
     if ( m_internal->GetState() != STATE_RUNNING )
     wxCriticalSectionLocker lock(m_critsect);
 
     if ( m_internal->GetState() != STATE_RUNNING )
@@ -884,20 +1304,17 @@ wxThreadError wxThread::Pause()
 
 wxThreadError wxThread::Resume()
 {
 
 wxThreadError wxThread::Resume()
 {
-    m_critsect.Enter();
+    wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+                 _T("a thread can't resume itself") );
 
 
-    wxThreadState state = m_internal->GetState();
+    wxCriticalSectionLocker lock(m_critsect);
 
 
-    // the thread might be not actually paused yet - if there were no call to
-    // TestDestroy() since the last call to Pause(), so avoid that
-    // TestDestroy() deadlocks trying to enter m_critsect by leaving it before
-    // calling Resume()
-    m_critsect.Leave();
+    wxThreadState state = m_internal->GetState();
 
     switch ( state )
     {
         case STATE_PAUSED:
 
     switch ( state )
     {
         case STATE_PAUSED:
-            wxLogTrace(TRACE_THREADS, _T("Thread %ld is suspended, resuming."),
+            wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
                        GetId());
 
             m_internal->Resume();
                        GetId());
 
             m_internal->Resume();
@@ -935,48 +1352,52 @@ wxThread::ExitCode wxThread::Wait()
 
 wxThreadError wxThread::Delete(ExitCode *rc)
 {
 
 wxThreadError wxThread::Delete(ExitCode *rc)
 {
+    wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+                 _T("a thread can't delete itself") );
+
+    bool isDetached = m_isDetached;
+
     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();
 
     // ask the thread to stop
     m_internal->SetCancelFlag();
 
     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();
 
     // ask the thread to stop
     m_internal->SetCancelFlag();
 
-    if ( m_isDetached )
-    {
-        // detached threads won't broadcast about their termination by default
-        // because usually nobody waits for them - but here we do, so ask the
-        // thread to notify us
-        m_internal->Notify();
-    }
-
     m_critsect.Leave();
 
     switch ( state )
     {
         case STATE_NEW:
     m_critsect.Leave();
 
     switch ( state )
     {
         case STATE_NEW:
+            // we need to wake up the thread so that PthreadStart() will
+            // terminate - right now it's blocking on run semaphore in
+            // PthreadStart()
+            m_internal->SignalRun();
+
+            // fall through
+
         case STATE_EXITED:
             // nothing to do
             break;
 
         case STATE_PAUSED:
         case STATE_EXITED:
             // nothing to do
             break;
 
         case STATE_PAUSED:
-            // resume the thread first (don't call our Resume() because this
-            // would dead lock when it tries to enter m_critsect)
+            // resume the thread first
             m_internal->Resume();
 
             // fall through
 
         default:
             m_internal->Resume();
 
             // fall through
 
         default:
-            // wait until the thread stops
-            m_internal->Wait();
-
-            if ( rc )
+            if ( !isDetached )
             {
             {
-                wxASSERT_MSG( !m_isDetached,
-                              _T("no return code for detached threads") );
+                // wait until the thread stops
+                m_internal->Wait();
 
 
-                // if it's a joinable thread, it's not deleted yet
-                *rc = m_internal->GetExitCode();
+                if ( rc )
+                {
+                    // return the exit code of the thread
+                    *rc = m_internal->GetExitCode();
+                }
             }
             }
+            //else: can't wait for detached threads
     }
 
     return wxTHREAD_NO_ERROR;
     }
 
     return wxTHREAD_NO_ERROR;
@@ -1012,11 +1433,12 @@ wxThreadError wxThread::Kill()
             if ( m_isDetached )
             {
                 // if we use cleanup function, this will be done from
             if ( m_isDetached )
             {
                 // if we use cleanup function, this will be done from
-                // PthreadCleanup()
+                // wxPthreadCleanup()
 #if !HAVE_THREAD_CLEANUP_FUNCTIONS
                 ScheduleThreadForDeletion();
 
 #if !HAVE_THREAD_CLEANUP_FUNCTIONS
                 ScheduleThreadForDeletion();
 
-                OnExit();
+                // don't call OnExit() here, it can only be called in the
+                // threads context and we're in the context of another thread
 
                 DeleteThread(this);
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
                 DeleteThread(this);
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
@@ -1032,10 +1454,16 @@ wxThreadError wxThread::Kill()
 
 void wxThread::Exit(ExitCode status)
 {
 
 void wxThread::Exit(ExitCode status)
 {
-    // from the moment we call OnExit(), the main program may terminate at any
-    // moment, so mark this thread as being already in process of being
-    // deleted or wxThreadModule::OnExit() will try to delete it again
-    ScheduleThreadForDeletion();
+    wxASSERT_MSG( This() == this,
+                  _T("wxThread::Exit() can only be called in the context of the same thread") );
+
+    if ( m_isDetached )
+    {
+        // from the moment we call OnExit(), the main program may terminate at
+        // any moment, so mark this thread as being already in process of being
+        // deleted or wxThreadModule::OnExit() will try to delete it again
+        ScheduleThreadForDeletion();
+    }
 
     // don't enter m_critsect before calling OnExit() because the user code
     // might deadlock if, for example, it signals a condition in OnExit() (a
 
     // don't enter m_critsect before calling OnExit() because the user code
     // might deadlock if, for example, it signals a condition in OnExit() (a
@@ -1043,17 +1471,6 @@ void wxThread::Exit(ExitCode status)
     // m_critsect on us (almost all of them do)
     OnExit();
 
     // m_critsect on us (almost all of them do)
     OnExit();
 
-    // now do enter it because SignalExit() will change our state
-    m_critsect.Enter();
-
-    // next wake up the threads waiting for us (OTOH, this function won't return
-    // until someone waited for us!)
-    m_internal->SignalExit();
-
-    // leave the critical section before entering the dtor which tries to
-    // enter it
-    m_critsect.Leave();
-
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
     if ( m_isDetached )
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
     if ( m_isDetached )
@@ -1076,10 +1493,15 @@ void wxThread::Exit(ExitCode status)
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
+    wxASSERT_MSG( This() == this,
+                  _T("wxThread::TestDestroy() can only be called in the context of the same thread") );
+
     m_critsect.Enter();
 
     if ( m_internal->GetState() == STATE_PAUSED )
     {
     m_critsect.Enter();
 
     if ( m_internal->GetState() == STATE_PAUSED )
     {
+        m_internal->SetReallyPaused(TRUE);
+
         // leave the crit section or the other threads will stop too if they
         // try to call any of (seemingly harmless) IsXXX() functions while we
         // sleep
         // leave the crit section or the other threads will stop too if they
         // try to call any of (seemingly harmless) IsXXX() functions while we
         // sleep
@@ -1105,8 +1527,7 @@ wxThread::~wxThread()
     if ( m_internal->GetState() != STATE_EXITED &&
          m_internal->GetState() != STATE_NEW )
     {
     if ( m_internal->GetState() != STATE_EXITED &&
          m_internal->GetState() != STATE_NEW )
     {
-        wxLogDebug(_T("The thread is being destroyed although it is still "
-                      "running! The application may crash."));
+        wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."), GetId());
     }
 
     m_critsect.Leave();
     }
 
     m_critsect.Leave();
@@ -1172,19 +1593,18 @@ bool wxThreadModule::OnInit()
     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
     if ( rc != 0 )
     {
     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
     if ( rc != 0 )
     {
-        wxLogSysError(rc, _("Thread module initialization failed: "
-                            "failed to create thread key"));
+        wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
 
         return FALSE;
     }
 
     gs_tidMain = pthread_self();
 
 
         return FALSE;
     }
 
     gs_tidMain = pthread_self();
 
-#if wxUSE_GUI
     gs_mutexGui = new wxMutex();
     gs_mutexGui = new wxMutex();
-
     gs_mutexGui->Lock();
     gs_mutexGui->Lock();
-#endif // wxUSE_GUI
+
+    gs_mutexDeleteThread = new wxMutex();
+    gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );
 
     return TRUE;
 }
 
     return TRUE;
 }
@@ -1195,24 +1615,29 @@ void wxThreadModule::OnExit()
 
     // are there any threads left which are being deleted right now?
     size_t nThreadsBeingDeleted;
 
     // are there any threads left which are being deleted right now?
     size_t nThreadsBeingDeleted;
+
     {
     {
-        MutexLock lock(gs_mutexDeleteThread);
+        wxMutexLocker lock( *gs_mutexDeleteThread );
         nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
         nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
-    }
 
 
-    if ( nThreadsBeingDeleted > 0 )
-    {
-        wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
-                   nThreadsBeingDeleted);
+        if ( nThreadsBeingDeleted > 0 )
+        {
+            wxLogTrace(TRACE_THREADS,
+                       _T("Waiting for %lu threads to disappear"),
+                       (unsigned long)nThreadsBeingDeleted);
 
 
-        // have to wait until all of them disappear
-        gs_condAllDeleted->Wait();
+            // have to wait until all of them disappear
+            gs_condAllDeleted->Wait();
+        }
     }
 
     // terminate any threads left
     size_t count = gs_allThreads.GetCount();
     if ( count != 0u )
     }
 
     // terminate any threads left
     size_t count = gs_allThreads.GetCount();
     if ( count != 0u )
-        wxLogDebug(wxT("Some threads were not terminated by the application."));
+    {
+        wxLogDebug(wxT("%lu threads were not terminated by the application."),
+                   (unsigned long)count);
+    }
 
     for ( size_t n = 0u; n < count; n++ )
     {
 
     for ( size_t n = 0u; n < count; n++ )
     {
@@ -1221,15 +1646,15 @@ void wxThreadModule::OnExit()
         gs_allThreads[0]->Delete();
     }
 
         gs_allThreads[0]->Delete();
     }
 
-#if wxUSE_GUI
     // destroy GUI mutex
     gs_mutexGui->Unlock();
     // destroy GUI mutex
     gs_mutexGui->Unlock();
-
     delete gs_mutexGui;
     delete gs_mutexGui;
-#endif // wxUSE_GUI
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
+
+    delete gs_condAllDeleted;
+    delete gs_mutexDeleteThread;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -1238,17 +1663,12 @@ void wxThreadModule::OnExit()
 
 static void ScheduleThreadForDeletion()
 {
 
 static void ScheduleThreadForDeletion()
 {
-    MutexLock lock(gs_mutexDeleteThread);
-
-    if ( gs_nThreadsBeingDeleted == 0 )
-    {
-        gs_condAllDeleted = new wxCondition;
-    }
+    wxMutexLocker lock( *gs_mutexDeleteThread );
 
     gs_nThreadsBeingDeleted++;
 
 
     gs_nThreadsBeingDeleted++;
 
-    wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
-               gs_nThreadsBeingDeleted,
+    wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+               (unsigned long)gs_nThreadsBeingDeleted,
                gs_nThreadsBeingDeleted == 1 ? "" : "s");
 }
 
                gs_nThreadsBeingDeleted == 1 ? "" : "s");
 }
 
@@ -1256,41 +1676,40 @@ static void DeleteThread(wxThread *This)
 {
     // gs_mutexDeleteThread should be unlocked before signalling the condition
     // or wxThreadModule::OnExit() would deadlock
 {
     // gs_mutexDeleteThread should be unlocked before signalling the condition
     // or wxThreadModule::OnExit() would deadlock
-    {
-        MutexLock lock(gs_mutexDeleteThread);
+    wxMutexLocker locker( *gs_mutexDeleteThread );
 
 
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
+    wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
 
 
-        delete This;
+    delete This;
 
 
-        wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
-                     _T("no threads scheduled for deletion, yet we delete "
-                        "one?") );
-    }
+    wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
+                 _T("no threads scheduled for deletion, yet we delete one?") );
+
+    wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
+               (unsigned long)gs_nThreadsBeingDeleted - 1);
 
     if ( !--gs_nThreadsBeingDeleted )
     {
         // no more threads left, signal it
         gs_condAllDeleted->Signal();
 
     if ( !--gs_nThreadsBeingDeleted )
     {
         // no more threads left, signal it
         gs_condAllDeleted->Signal();
-
-        delete gs_condAllDeleted;
-        gs_condAllDeleted = (wxCondition *)NULL;
     }
 }
 
 void wxMutexGuiEnter()
 {
     }
 }
 
 void wxMutexGuiEnter()
 {
-#if wxUSE_GUI
     gs_mutexGui->Lock();
     gs_mutexGui->Lock();
-#endif // wxUSE_GUI
 }
 
 void wxMutexGuiLeave()
 {
 }
 
 void wxMutexGuiLeave()
 {
-#if wxUSE_GUI
     gs_mutexGui->Unlock();
     gs_mutexGui->Unlock();
-#endif // wxUSE_GUI
 }
 
 }
 
-#endif
-  // wxUSE_THREADS
+// ----------------------------------------------------------------------------
+// include common implementation code
+// ----------------------------------------------------------------------------
+
+#include "wx/thrimpl.cpp"
+
+#endif // wxUSE_THREADS
+
wxWidgets (Impactor)