]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/threadpsx.cpp
fixed typo (missing comma) in MIME test
[wxWidgets.git] / src / unix / threadpsx.cpp
index 197d935d3d25106e511a660aa5277cc26f8634df..5e8ba134236f1b5b4b89bf2642aff45488963a77 100644 (file)
@@ -7,7 +7,7 @@
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
-//                  Vadim Zeitlin (1999)
+//                  Vadim Zeitlin (1999-2002)
 //                  Robert Roebling (1999)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 //                  Robert Roebling (1999)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 #include <pthread.h>
 #include <errno.h>
 #include <time.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"
+#endif
+
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
@@ -64,6 +72,15 @@ static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 // our trace mask
 #define TRACE_THREADS   _T("thread")
 
 // our trace mask
 #define TRACE_THREADS   _T("thread")
 
+// ----------------------------------------------------------------------------
+// pseudo template types
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST(pthread_mutex_t, wxMutexList);
+
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxMutexList);
+
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
@@ -126,7 +143,7 @@ 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 pthread_mutex_t gs_mutexDeleteThread;
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
@@ -138,73 +155,180 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 #endif // wxUSE_GUI
 
 // ============================================================================
 #endif // wxUSE_GUI
 
 // ============================================================================
-// implementation
+// wxMutex implementation
 // ============================================================================
 
 // ============================================================================
 
-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------
 
 class wxMutexInternal
 {
 public:
 
 class wxMutexInternal
 {
 public:
+    wxMutexInternal();
+    ~wxMutexInternal();
+
+    wxMutexError Lock();
+    wxMutexError TryLock();
+    wxMutexError Unlock();
+
+private:
     pthread_mutex_t m_mutex;
 };
 
     pthread_mutex_t m_mutex;
 };
 
+wxMutexInternal::wxMutexInternal()
+{
+    // support recursive locks like Win32, i.e. a thread can lock a mutex which
+    // it had itself already locked
+    //
+    // but initialization of recursive mutexes is non portable <sigh>, so try
+    // several methods
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+
+    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
+    pthread_mutex_init(&m_mutex, NULL);
+
+    // used by TryLock() below
+    #define NO_RECURSIVE_MUTEXES
+#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+}
+
+wxMutexInternal::~wxMutexInternal()
+{
+    pthread_mutex_destroy(&m_mutex);
+}
+
+wxMutexError wxMutexInternal::Lock()
+{
+    int err = pthread_mutex_lock(&m_mutex);
+    switch ( err )
+    {
+        case EDEADLK:
+            wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+            return wxMUTEX_DEAD_LOCK;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::TryLock()
+{
+    int err = pthread_mutex_trylock(&m_mutex);
+    switch ( err )
+    {
+        case EBUSY:
+            return wxMUTEX_BUSY;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to try to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::Unlock()
+{
+    int err = pthread_mutex_unlock(&m_mutex);
+    switch ( err )
+    {
+        case EPERM:
+            // we don't own the mutex
+            return wxMUTEX_UNLOCKED;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to unlock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxMutex
+// ----------------------------------------------------------------------------
+
+// TODO: this is completely generic, move it to common code?
+
 wxMutex::wxMutex()
 {
     m_internal = new wxMutexInternal;
 
 wxMutex::wxMutex()
 {
     m_internal = new wxMutexInternal;
 
-    pthread_mutex_init(&(m_internal->m_mutex),
-                       (pthread_mutexattr_t*) NULL );
     m_locked = 0;
 }
 
 wxMutex::~wxMutex()
 {
     m_locked = 0;
 }
 
 wxMutex::~wxMutex()
 {
-    if (m_locked > 0)
+    if ( m_locked > 0 )
         wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
 
         wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
 
-    pthread_mutex_destroy( &(m_internal->m_mutex) );
     delete m_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {
     delete m_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {
-    int err = pthread_mutex_lock( &(m_internal->m_mutex) );
-    if (err == EDEADLK)
-    {
-        wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+    wxMutexError err = m_internal->Lock();
 
 
-        return wxMUTEX_DEAD_LOCK;
+    if ( !err )
+    {
+        m_locked++;
     }
 
     }
 
-    m_locked++;
-
-    return wxMUTEX_NO_ERROR;
+    return err;
 }
 
 wxMutexError wxMutex::TryLock()
 {
 }
 
 wxMutexError wxMutex::TryLock()
 {
-    if (m_locked)
+    if ( m_locked )
     {
     {
-        return wxMUTEX_BUSY;
+#ifdef NO_RECURSIVE_MUTEXES
+        return wxMUTEX_DEAD_LOCK;
+#else // have recursive mutexes on this platform
+        // we will succeed in locking it when we have it already locked
+        return wxMUTEX_NO_ERROR;
+#endif // recursive/non-recursive mutexes
     }
 
     }
 
-    int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
-    switch (err)
+    wxMutexError err = m_internal->TryLock();
+    if ( !err )
     {
     {
-        case EBUSY: return wxMUTEX_BUSY;
+        m_locked++;
     }
 
     }
 
-    m_locked++;
-
-    return wxMUTEX_NO_ERROR;
+    return err;
 }
 
 wxMutexError wxMutex::Unlock()
 {
 }
 
 wxMutexError wxMutex::Unlock()
 {
-    if (m_locked > 0)
+    if ( m_locked > 0 )
     {
         m_locked--;
     }
     {
         m_locked--;
     }
@@ -215,55 +339,64 @@ wxMutexError wxMutex::Unlock()
         return wxMUTEX_UNLOCKED;
     }
 
         return wxMUTEX_UNLOCKED;
     }
 
-    pthread_mutex_unlock( &(m_internal->m_mutex) );
-
-    return wxMUTEX_NO_ERROR;
+    return m_internal->Unlock();
 }
 
 }
 
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ============================================================================
+// wxCondition implementation
+// ============================================================================
 
 
-// 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
+// ----------------------------------------------------------------------------
+// wxConditionInternal
+// ----------------------------------------------------------------------------
+
+// The native POSIX condition variables are dumb: if the condition is signaled
+// before another thread starts to wait on it, the signal is lost and so this
+// other thread will be never woken up. It's much more convenient to us to
+// remember that the condition was signaled and to return from Wait()
+// immediately in this case (this is more like Win32 automatic event objects)
 class wxConditionInternal
 {
 public:
     wxConditionInternal();
     ~wxConditionInternal();
 
 class wxConditionInternal
 {
 public:
     wxConditionInternal();
     ~wxConditionInternal();
 
-    void Wait();
-    bool WaitWithTimeout(const timespec* ts);
+    // wait with the given timeout or indefinitely if NULL
+    bool Wait(const timespec* ts = NULL);
 
 
-    void Signal();
-    void Broadcast();
+    void Signal(bool all = FALSE);
 
 private:
 
 private:
-    pthread_mutex_t m_mutex;
+    // the number of Signal() calls we "missed", i.e. which were done while
+    // there were no threads to wait for them
+    size_t m_nQueuedSignals;
+
+    // counts all pending waiters
+    size_t m_nWaiters;
+
+    // the condition itself
     pthread_cond_t m_condition;
     pthread_cond_t m_condition;
+
+    // the mutex used with the conditon: it also protects the counters above
+    pthread_mutex_t m_mutex;
 };
 
 wxConditionInternal::wxConditionInternal()
 {
 };
 
 wxConditionInternal::wxConditionInternal()
 {
+    m_nQueuedSignals =
+    m_nWaiters = 0;
+
     if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
     {
         // this is supposed to never happen
         wxFAIL_MSG( _T("pthread_cond_init() failed") );
     }
 
     if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
     {
         // this is supposed to never happen
         wxFAIL_MSG( _T("pthread_cond_init() failed") );
     }
 
-    if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t*)NULL) != 0 )
+    if ( pthread_mutex_init(&m_mutex, NULL) != 0 )
     {
         // neither this
         wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
     }
     {
         // neither this
         wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
     }
-
-    // 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 )
-    {
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
-    }
 }
 
 wxConditionInternal::~wxConditionInternal()
 }
 
 wxConditionInternal::~wxConditionInternal()
@@ -274,68 +407,106 @@ wxConditionInternal::~wxConditionInternal()
                       "threads are probably still waiting on it?)"));
     }
 
                       "threads are probably still waiting on it?)"));
     }
 
-    if ( pthread_mutex_unlock( &m_mutex ) != 0 )
-    {
-        wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
-    }
-
-    if ( pthread_mutex_destroy( &m_mutex ) != 0 )
+    if ( pthread_mutex_destroy( &m_mutex ) != 0 ) 
     {
         wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
     }
 }
 
     {
         wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
     }
 }
 
-void wxConditionInternal::Wait()
+bool wxConditionInternal::Wait(const timespec* ts)
 {
 {
-    if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
+    MutexLock lock(m_mutex);
+
+    if ( m_nQueuedSignals )
     {
     {
-        // not supposed to ever happen
-        wxFAIL_MSG( _T("pthread_cond_wait() failed") );
+        m_nQueuedSignals--;
+
+        wxLogTrace(TRACE_THREADS,
+                   _T("wxCondition(%08x)::Wait(): Has been signaled before"),
+                   this);
+
+        return TRUE;
     }
     }
-}
 
 
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
-{
-    switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
+    // there are no queued signals, so start really waiting
+    m_nWaiters++;
+
+    // calling wait function below unlocks the mutex and Signal() or
+    // Broadcast() will be able to continue to run now if they were
+    // blocking for it in the loop locking all mutexes)
+    wxLogTrace(TRACE_THREADS,
+               _T("wxCondition(%08x)::Wait(): starting to wait"), this);
+
+    int err = ts ? pthread_cond_timedwait(&m_condition, &m_mutex, ts)
+                 : pthread_cond_wait(&m_condition, &m_mutex);
+    switch ( err )
     {
         case 0:
     {
         case 0:
-            // condition signaled
-            return TRUE;
+            // condition was signaled
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Wait(): ok"), this);
+            break;
 
         default:
 
         default:
-            wxLogDebug(_T("pthread_cond_timedwait() failed"));
-
+            wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return"));
             // fall through
 
         case ETIMEDOUT:
         case EINTR:
             // fall through
 
         case ETIMEDOUT:
         case EINTR:
+            // The condition has not been signaled, so we have to
+            // decrement the counter manually
+            --m_nWaiters;
+
             // wait interrupted or timeout elapsed
             // wait interrupted or timeout elapsed
-            return FALSE;
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Wait(): timeout/intr"), this);
     }
     }
+
+    return err == 0;
 }
 
 }
 
-void wxConditionInternal::Signal()
+void wxConditionInternal::Signal(bool all)
 {
 {
+    // make sure that only one Signal() or Broadcast() is in progress
     MutexLock lock(m_mutex);
 
     MutexLock lock(m_mutex);
 
-    if ( pthread_cond_signal( &m_condition ) != 0 )
+    // Are there any waiters?
+    if ( m_nWaiters == 0 )
     {
     {
-        // shouldn't ever happen
-        wxFAIL_MSG(_T("pthread_cond_signal() failed"));
+        // No, there are not, so don't signal but keep in mind for the next
+        // Wait()
+        m_nQueuedSignals++;
+
+        return;
     }
     }
-}
 
 
-void wxConditionInternal::Broadcast()
-{
-    MutexLock lock(m_mutex);
+    // now we can finally signal it
+    wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"),
+               this, all ? _T("broadcast") : _T("signal"));
+
+    int err = all ? pthread_cond_broadcast(&m_condition)
+                  : pthread_cond_signal(&m_condition);
+
+    if ( all )
+    {
+        m_nWaiters = 0;
+    }
+    else
+    {
+        --m_nWaiters;
+    }
 
 
-    if ( pthread_cond_broadcast( &m_condition ) != 0 )
+    if ( err )
     {
         // shouldn't ever happen
     {
         // shouldn't ever happen
-        wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
+        wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed"));
     }
 }
 
     }
 }
 
+// ----------------------------------------------------------------------------
+// wxCondition
+// ----------------------------------------------------------------------------
+
 wxCondition::wxCondition()
 {
     m_internal = new wxConditionInternal;
 wxCondition::wxCondition()
 {
     m_internal = new wxConditionInternal;
@@ -348,7 +519,7 @@ wxCondition::~wxCondition()
 
 void wxCondition::Wait()
 {
 
 void wxCondition::Wait()
 {
-    m_internal->Wait();
+    (void)m_internal->Wait();
 }
 
 bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
 }
 
 bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
@@ -358,7 +529,7 @@ bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
     tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
     tspec.tv_nsec = nsec;
 
     tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
     tspec.tv_nsec = nsec;
 
-    return m_internal->WaitWithTimeout(&tspec);
+    return m_internal->Wait(&tspec);
 }
 
 void wxCondition::Signal()
 }
 
 void wxCondition::Signal()
@@ -368,12 +539,29 @@ void wxCondition::Signal()
 
 void wxCondition::Broadcast()
 {
 
 void wxCondition::Broadcast()
 {
-    m_internal->Broadcast();
+    m_internal->Signal(TRUE /* all */);
 }
 
 }
 
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+// ============================================================================
+// wxThread implementation
+// ============================================================================
+
+// the thread callback functions must have the C linkage
+extern "C"
+{
+
+#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,12 +570,7 @@ 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
 
     // thread actions
         // start the thread
@@ -396,6 +579,8 @@ public:
     void Wait();
         // wake up threads waiting for our termination
     void SignalExit();
     void Wait();
         // wake up threads waiting for our termination
     void SignalExit();
+        // wake up threads waiting for our start
+    void SignalRun() { m_condRun.Signal(); }
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
@@ -418,12 +603,25 @@ 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; }
+    void Detach()
+    {
+        m_shouldBeJoined = m_shouldBroadcast = FALSE;
+        m_isDetached = TRUE;
+    }
         // but even detached threads need to notifyus about their termination
         // sometimes - tell the thread that it should do it
     void Notify() { m_shouldBroadcast = TRUE; }
 
         // but even detached threads need to notifyus about their termination
         // sometimes - tell the thread that it should do it
     void Notify() { m_shouldBroadcast = 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
@@ -432,6 +630,9 @@ private:
     // 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_condSuspend
+    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;
@@ -441,6 +642,7 @@ private:
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;
     bool m_shouldBroadcast;
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;
     bool m_shouldBroadcast;
+    bool m_isDetached;
 
     // VZ: it's possible that we might do with less than three different
     //     condition objects - for example, m_condRun and m_condEnd a priori
 
     // VZ: it's possible that we might do with less than three different
     //     condition objects - for example, m_condRun and m_condEnd a priori
@@ -464,11 +666,17 @@ private:
 // 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."), pthread->GetId());
+
     // 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 +687,47 @@ 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
 
     // wait for the condition to be signaled from Run()
     pthread->m_condRun.Wait();
 
 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
 
     // wait for the condition to be signaled from Run()
     pthread->m_condRun.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
+        pthread->m_exitcode = thread->Entry();
 
 
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
+        wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
                    pthread->GetId());
 
                    pthread->GetId());
 
-        // 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);
+
+            wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
+                       pthread->GetId());
+
+            // 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 +738,33 @@ 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 )
+    {
+        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 +792,13 @@ 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_condSuspend
+    m_isPaused = FALSE;
+
     // defaults for joinable threads
     m_shouldBeJoined = TRUE;
     m_shouldBroadcast = TRUE;
     // defaults for joinable threads
     m_shouldBeJoined = TRUE;
     m_shouldBroadcast = TRUE;
+    m_isDetached = FALSE;
 }
 
 wxThreadInternal::~wxThreadInternal()
 }
 
 wxThreadInternal::~wxThreadInternal()
@@ -570,7 +810,7 @@ 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();
+    SignalRun();
 
     SetState(STATE_RUNNING);
 
 
     SetState(STATE_RUNNING);
 
@@ -584,29 +824,40 @@ void wxThreadInternal::Wait()
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 
-    wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
-               GetId());
+    bool isDetached = m_isDetached;
+    wxThreadIdType id = (wxThreadIdType) GetId();
+
+    wxLogTrace(TRACE_THREADS,
+               _T("Starting to wait for thread %ld to exit."), id);
 
     // wait until the thread terminates (we're blocking in _another_ thread,
     // of course)
     m_condEnd.Wait();
 
 
     // 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("Finished waiting for thread %ld."), id);
 
 
-    if ( m_shouldBeJoined )
+    // we can't use any member variables any more if the thread is detached
+    // because it could be already deleted
+    if ( !isDetached )
     {
     {
-        // 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 )
+        // to avoid memory leaks we should call pthread_join(), but it must
+        // only be done once
+        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((pthread_t)id, &m_exitcode) != 0 )
+            {
+                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
@@ -648,10 +899,23 @@ 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"), GetId());
 
 
-    // wake up Pause()
-    m_condSuspend.Signal();
+        // wake up Pause()
+        m_condSuspend.Signal();
+
+        // reset the flag
+        SetReallyPaused(FALSE);
+    }
+    else
+    {
+        wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
+                   GetId());
+    }
 
     SetState(STATE_RUNNING);
 }
 
     SetState(STATE_RUNNING);
 }
@@ -672,7 +936,9 @@ bool wxThread::IsMain()
 
 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)
@@ -680,6 +946,76 @@ void wxThread::Sleep(unsigned long milliseconds)
     wxUsleep(milliseconds);
 }
 
     wxUsleep(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" strings
+            size_t count = s.Replace(_T("processor"), _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;
+}
+
+#ifdef __VMS
+  // VMS is a 64 bit system and threads have 64 bit pointers.
+  // ??? also needed for other systems????
+unsigned long long wxThread::GetCurrentId()
+{
+    return (unsigned long long)pthread_self();
+#else
+unsigned long wxThread::GetCurrentId()
+{
+    return (unsigned long)pthread_self();
+#endif
+}
+
+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
+}
+
 // -----------------------------------------------------------------------------
 // creating thread
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // creating thread
 // -----------------------------------------------------------------------------
@@ -694,7 +1030,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 +1049,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 +1124,7 @@ wxThreadError wxThread::Create()
              (
                 m_internal->GetIdPtr(),
                 &attr,
              (
                 m_internal->GetIdPtr(),
                 &attr,
-                wxThreadInternal::PthreadStart,
+                wxPthreadStart,
                 (void *)this
              );
 
                 (void *)this
              );
 
@@ -855,9 +1201,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 +1212,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 )
@@ -875,6 +1224,9 @@ wxThreadError wxThread::Pause()
         return wxTHREAD_NOT_RUNNING;
     }
 
         return wxTHREAD_NOT_RUNNING;
     }
 
+    wxLogTrace(TRACE_THREADS, _T("Asking thread %ld to pause."),
+               GetId());
+
     // just set a flag, the thread will be really paused only during the next
     // call to TestDestroy()
     m_internal->SetState(STATE_PAUSED);
     // just set a flag, the thread will be really paused only during the next
     // call to TestDestroy()
     m_internal->SetState(STATE_PAUSED);
@@ -884,20 +1236,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,6 +1284,9 @@ 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") );
+
     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();
 
     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();
 
@@ -954,6 +1306,12 @@ wxThreadError wxThread::Delete(ExitCode *rc)
     switch ( state )
     {
         case STATE_NEW:
     switch ( state )
     {
         case STATE_NEW:
+            // we need to wake up the thread so that PthreadStart() will
+            // terminate - right now it's blocking on m_condRun
+            m_internal->SignalRun();
+
+            // fall through
+
         case STATE_EXITED:
             // nothing to do
             break;
         case STATE_EXITED:
             // nothing to do
             break;
@@ -1012,11 +1370,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,6 +1391,10 @@ wxThreadError wxThread::Kill()
 
 void wxThread::Exit(ExitCode status)
 {
 
 void wxThread::Exit(ExitCode status)
 {
+    wxASSERT_MSG( This() == this,
+                  _T("wxThread::Exit() can only be called in the "
+                     "context of the same thread") );
+
     // 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
     // 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
@@ -1076,10 +1439,16 @@ 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 +1474,8 @@ 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();
@@ -1116,6 +1485,17 @@ wxThread::~wxThread()
 
     // remove this thread from the global array
     gs_allThreads.Remove(this);
 
     // remove this thread from the global array
     gs_allThreads.Remove(this);
+
+    // detached thread will decrement this counter in DeleteThread(), but it
+    // is not called for the joinable threads, so do it here
+    if ( !m_isDetached )
+    {
+        MutexLock lock(gs_mutexDeleteThread);
+        gs_nThreadsBeingDeleted--;
+
+        wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
+                   gs_nThreadsBeingDeleted - 1);
+    }
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -1186,6 +1566,10 @@ bool wxThreadModule::OnInit()
     gs_mutexGui->Lock();
 #endif // wxUSE_GUI
 
     gs_mutexGui->Lock();
 #endif // wxUSE_GUI
 
+    // under Solaris we get a warning from CC when using
+    // PTHREAD_MUTEX_INITIALIZER, so do it dynamically
+    pthread_mutex_init(&gs_mutexDeleteThread, NULL);
+
     return TRUE;
 }
 
     return TRUE;
 }
 
@@ -1212,7 +1596,10 @@ void wxThreadModule::OnExit()
     // 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("%u threads were not terminated by the application."),
+                   count);
+    }
 
     for ( size_t n = 0u; n < count; n++ )
     {
 
     for ( size_t n = 0u; n < count; n++ )
     {
@@ -1268,6 +1655,9 @@ static void DeleteThread(wxThread *This)
                         "one?") );
     }
 
                         "one?") );
     }
 
+    wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
+               gs_nThreadsBeingDeleted - 1);
+
     if ( !--gs_nThreadsBeingDeleted )
     {
         // no more threads left, signal it
     if ( !--gs_nThreadsBeingDeleted )
     {
         // no more threads left, signal it