X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/be8098689121d2352751c51005c133797d77ecea..acd32ffcdb319f162633c20e0202db3f8542998a:/src/unix/threadpsx.cpp diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 4524bae5b8..db3063e48e 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: threadpsx.cpp +// Name: src/unix/threadpsx.cpp // Purpose: wxThread (Posix) Implementation // Author: Original from Wolfram Gloger/Guilhem Lavaux // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore @@ -21,28 +21,31 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "thread.h" -#endif - -#include "wx/defs.h" +// for compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" #if wxUSE_THREADS #include "wx/thread.h" -#include "wx/module.h" -#include "wx/utils.h" -#include "wx/log.h" -#include "wx/intl.h" -#include "wx/dynarray.h" -#include "wx/timer.h" +#include "wx/except.h" + +#ifndef WX_PRECOMP + #include "wx/app.h" + #include "wx/dynarray.h" + #include "wx/intl.h" + #include "wx/log.h" + #include "wx/utils.h" + #include "wx/timer.h" + #include "wx/stopwatch.h" + #include "wx/module.h" +#endif #include #include #include #include #include -#if HAVE_SCHED_H +#ifdef HAVE_SCHED_H #include #endif @@ -53,6 +56,15 @@ // we use wxFFile under Linux in GetCPUCount() #ifdef __LINUX__ #include "wx/ffile.h" + // For setpriority. + #include + #include +#endif + +#ifdef __VMS + #define THR_ID(thr) ((long long)(thr)->GetId()) +#else + #define THR_ID(thr) ((long)(thr)->GetId()) #endif // ---------------------------------------------------------------------------- @@ -71,9 +83,12 @@ enum wxThreadState // 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") +// you can get additional debugging messages for the semaphore operations +#define TRACE_SEMA _T("semaphore") + // ---------------------------------------------------------------------------- // private functions // ---------------------------------------------------------------------------- @@ -82,10 +97,13 @@ static void ScheduleThreadForDeletion(); static void DeleteThread(wxThread *This); // ---------------------------------------------------------------------------- -// types +// private classes // ---------------------------------------------------------------------------- -WX_DEFINE_ARRAY(wxThread *, wxArrayThread); +// an (non owning) array of pointers to threads +WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread); + +// an entry for a thread we can wait for // ----------------------------------------------------------------------------- // global data @@ -96,8 +114,11 @@ WX_DEFINE_ARRAY(wxThread *, wxArrayThread); // be left in memory static wxArrayThread gs_allThreads; +// a mutex to protect gs_allThreads +static wxMutex *gs_mutexAllThreads = NULL; + // 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; @@ -107,16 +128,25 @@ static pthread_key_t gs_keySelf; static size_t gs_nThreadsBeingDeleted = 0; // a mutex to protect gs_nThreadsBeingDeleted -static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL; +static wxMutex *gs_mutexDeleteThread = 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 +static wxCondition *gs_condAllDeleted = NULL; + +// 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 // ============================================================================ // wxMutex implementation @@ -126,98 +156,228 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL; // wxMutexInternal // ---------------------------------------------------------------------------- +// this is a simple wrapper around pthread_mutex_t which provides error +// checking class wxMutexInternal { public: - wxMutexInternal(); + wxMutexInternal(wxMutexType mutexType); ~wxMutexInternal(); wxMutexError Lock(); + wxMutexError Lock(unsigned long ms); wxMutexError TryLock(); wxMutexError Unlock(); + bool IsOk() const { return m_isOk; } + +private: + // convert the result of pthread_mutex_[timed]lock() call to wx return code + wxMutexError HandleLockResult(int err); + private: pthread_mutex_t m_mutex; + bool m_isOk; + wxMutexType m_type; + unsigned long m_owningThread; + // wxConditionInternal uses our m_mutex friend class wxConditionInternal; }; -wxMutexInternal::wxMutexInternal() +#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \ + wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL) +// 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) { - // 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 , so try - // several methods + m_type = mutexType; + m_owningThread = 0; + + 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); + { + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(&m_mutex, &attr); + 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; + // 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 + 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; + } + + m_isOk = err == 0; + if ( !m_isOk ) + { + wxLogApiError( wxT("pthread_mutex_init()"), err); + } } wxMutexInternal::~wxMutexInternal() { - pthread_mutex_destroy(&m_mutex); + if ( m_isOk ) + { + int err = pthread_mutex_destroy(&m_mutex); + if ( err != 0 ) + { + wxLogApiError( wxT("pthread_mutex_destroy()"), err); + } + } } wxMutexError wxMutexInternal::Lock() { - int err = pthread_mutex_lock(&m_mutex); + if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0)) + { + if (m_owningThread == wxThread::GetCurrentId()) + return wxMUTEX_DEAD_LOCK; + } + + return HandleLockResult(pthread_mutex_lock(&m_mutex)); +} + +wxMutexError wxMutexInternal::Lock(unsigned long ms) +{ +#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK + static const long MSEC_IN_SEC = 1000; + static const long NSEC_IN_MSEC = 1000000; + static const long NSEC_IN_USEC = 1000; + static const long NSEC_IN_SEC = MSEC_IN_SEC * NSEC_IN_MSEC; + + time_t seconds = ms/MSEC_IN_SEC; + long nanoseconds = (ms % MSEC_IN_SEC) * NSEC_IN_MSEC; + timespec ts = { 0, 0 }; + + // normally we should use clock_gettime(CLOCK_REALTIME) here but this + // function is in librt and we don't link with it currently, so use + // gettimeofday() instead -- if it turns out that this is really too + // imprecise, we should modify configure to check if clock_gettime() is + // available and whether it requires -lrt and use it instead +#if 0 + if ( clock_gettime(CLOCK_REALTIME, &ts) == 0 ) + { + } +#else + struct timeval tv; + if ( wxGetTimeOfDay(&tv) != -1 ) + { + ts.tv_sec = tv.tv_sec; + ts.tv_nsec = tv.tv_usec*NSEC_IN_USEC; + } +#endif + else // fall back on system timer + { + ts.tv_sec = time(NULL); + } + + ts.tv_sec += seconds; + ts.tv_nsec += nanoseconds; + if ( ts.tv_nsec > NSEC_IN_SEC ) + { + ts.tv_sec += 1; + ts.tv_nsec -= NSEC_IN_SEC; + } + + return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts)); +#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK + wxUnusedVar(ms); + + return wxMUTEX_MISC_ERROR; +#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK +} + +wxMutexError wxMutexInternal::HandleLockResult(int err) +{ + // wxPrintf( "err %d\n", err ); + switch ( err ) { case EDEADLK: - wxLogDebug(wxT("Locking this mutex would lead to deadlock!")); + // 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; - default: - wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") ); - // fall through - case EINVAL: - wxLogDebug(_T("Failed to lock the mutex.")); - return wxMUTEX_MISC_ERROR; + wxLogDebug(_T("pthread_mutex_[timed]lock(): mutex not initialized")); + break; + + case ETIMEDOUT: + return wxMUTEX_TIMEOUT; case 0: + if (m_type == wxMUTEX_DEFAULT) + m_owningThread = wxThread::GetCurrentId(); return wxMUTEX_NO_ERROR; + + default: + wxLogApiError(_T("pthread_mutex_[timed]lock()"), err); } + + return wxMUTEX_MISC_ERROR; } + wxMutexError wxMutexInternal::TryLock() { int err = pthread_mutex_trylock(&m_mutex); switch ( err ) { case EBUSY: + // not an error: mutex is already locked, but we're prepared for + // this 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; + wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized.")); + break; case 0: + if (m_type == wxMUTEX_DEFAULT) + m_owningThread = wxThread::GetCurrentId(); return wxMUTEX_NO_ERROR; + + default: + wxLogApiError(_T("pthread_mutex_trylock()"), err); } + + return wxMUTEX_MISC_ERROR; } wxMutexError wxMutexInternal::Unlock() { + m_owningThread = 0; + int err = pthread_mutex_unlock(&m_mutex); switch ( err ) { @@ -225,87 +385,18 @@ wxMutexError wxMutexInternal::Unlock() // 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; + wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized.")); + break; case 0: return wxMUTEX_NO_ERROR; - } -} - -// ---------------------------------------------------------------------------- -// wxMutex -// ---------------------------------------------------------------------------- - -// TODO: this is completely generic, move it to common code? - -wxMutex::wxMutex() -{ - m_internal = new wxMutexInternal; - m_locked = 0; -} - -wxMutex::~wxMutex() -{ - if ( m_locked > 0 ) - wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked); - - delete m_internal; -} - -wxMutexError wxMutex::Lock() -{ - wxMutexError err = m_internal->Lock(); - - if ( !err ) - { - m_locked++; - } - - return err; -} - -wxMutexError wxMutex::TryLock() -{ - if ( m_locked ) - { -#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 - } - - wxMutexError err = m_internal->TryLock(); - if ( !err ) - { - m_locked++; - } - - return err; -} - -wxMutexError wxMutex::Unlock() -{ - if ( m_locked > 0 ) - { - m_locked--; - } - else - { - wxLogDebug(wxT("Unlocking not locked mutex.")); - - return wxMUTEX_UNLOCKED; + default: + wxLogApiError(_T("pthread_mutex_unlock()"), err); } - return m_internal->Unlock(); + return wxMUTEX_MISC_ERROR; } // =========================================================================== @@ -316,121 +407,77 @@ wxMutexError wxMutex::Unlock() // wxConditionInternal // --------------------------------------------------------------------------- +// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence +// with a pthread_mutex_t) class wxConditionInternal { public: - wxConditionInternal( wxMutex *mutex ); + wxConditionInternal(wxMutex& mutex); ~wxConditionInternal(); - void Wait(); - - bool Wait( const timespec *ts ); + bool IsOk() const { return m_isOk && m_mutex.IsOk(); } - void Signal(); + wxCondError Wait(); + wxCondError WaitTimeout(unsigned long milliseconds); - void Broadcast(); + wxCondError Signal(); + wxCondError Broadcast(); private: + // get the POSIX mutex associated with us + pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; } - wxMutex *m_mutex; + wxMutex& m_mutex; pthread_cond_t m_cond; + + bool m_isOk; }; -wxConditionInternal::wxConditionInternal( wxMutex *mutex ) +wxConditionInternal::wxConditionInternal(wxMutex& mutex) + : m_mutex(mutex) { - m_mutex = mutex; - if ( pthread_cond_init( &m_cond, NULL ) != 0 ) - { - wxLogDebug(_T("pthread_cond_init() failed")); - } -} + int err = pthread_cond_init(&m_cond, NULL /* default attributes */); -wxConditionInternal::~wxConditionInternal() -{ - if ( pthread_cond_destroy( &m_cond ) != 0 ) - { - wxLogDebug(_T("pthread_cond_destroy() failed")); - } -} + m_isOk = err == 0; -void wxConditionInternal::Wait() -{ - if ( pthread_cond_wait( &m_cond, &(m_mutex->m_internal->m_mutex) ) != 0 ) + if ( !m_isOk ) { - wxLogDebug(_T("pthread_cond_wait() failed")); - } -} - -bool wxConditionInternal::Wait( const timespec *ts ) -{ - int result = pthread_cond_timedwait( &m_cond, - &(m_mutex->m_internal->m_mutex), - ts ); - if ( result == ETIMEDOUT ) - return FALSE; - - wxASSERT_MSG( result == 0, _T("pthread_cond_timedwait() failed") ); - - return TRUE; -} - -void wxConditionInternal::Signal() -{ - int result = pthread_cond_signal( &m_cond ); - if ( result != 0 ) -{ - wxFAIL_MSG( _T("pthread_cond_signal() failed") ); + wxLogApiError(_T("pthread_cond_init()"), err); } } -void wxConditionInternal::Broadcast() -{ - int result = pthread_cond_broadcast( &m_cond ); - if ( result != 0 ) +wxConditionInternal::~wxConditionInternal() { - wxFAIL_MSG( _T("pthread_cond_broadcast() failed") ); + if ( m_isOk ) + { + int err = pthread_cond_destroy(&m_cond); + if ( err != 0 ) + { + wxLogApiError(_T("pthread_cond_destroy()"), err); + } } } - -// --------------------------------------------------------------------------- -// wxCondition -// --------------------------------------------------------------------------- - -wxCondition::wxCondition( wxMutex *mutex ) +wxCondError wxConditionInternal::Wait() { - if ( !mutex ) + int err = pthread_cond_wait(&m_cond, GetPMutex()); + if ( err != 0 ) { - wxFAIL_MSG( _T("NULL mutex in wxCondition ctor") ); + wxLogApiError(_T("pthread_cond_wait()"), err); - m_internal = NULL; + return wxCOND_MISC_ERROR; } - else - { - m_internal = new wxConditionInternal( mutex ); - } -} -wxCondition::~wxCondition() -{ - delete m_internal; + return wxCOND_NO_ERROR; } -void wxCondition::Wait() +wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds) { - if ( m_internal ) - m_internal->Wait(); -} - -bool wxCondition::Wait( unsigned long timeout_millis ) -{ - wxCHECK_MSG( m_internal, FALSE, _T("can't wait on uninitalized condition") ); - wxLongLong curtime = wxGetLocalTimeMillis(); - curtime += timeout_millis; + curtime += milliseconds; wxLongLong temp = curtime / 1000; int sec = temp.GetLo(); - temp = temp * 1000; + temp *= 1000; temp = curtime - temp; int millis = temp.GetLo(); @@ -439,19 +486,46 @@ bool wxCondition::Wait( unsigned long timeout_millis ) tspec.tv_sec = sec; tspec.tv_nsec = millis * 1000L * 1000L; - return m_internal->Wait(&tspec); + int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec ); + switch ( err ) + { + case ETIMEDOUT: + return wxCOND_TIMEOUT; + + case 0: + return wxCOND_NO_ERROR; + + default: + wxLogApiError(_T("pthread_cond_timedwait()"), err); + } + + return wxCOND_MISC_ERROR; } -void wxCondition::Signal() +wxCondError wxConditionInternal::Signal() { - if ( m_internal ) - m_internal->Signal(); + int err = pthread_cond_signal(&m_cond); + if ( err != 0 ) + { + wxLogApiError(_T("pthread_cond_signal()"), err); + + return wxCOND_MISC_ERROR; + } + + return wxCOND_NO_ERROR; } -void wxCondition::Broadcast() +wxCondError wxConditionInternal::Broadcast() { - if ( m_internal ) - m_internal->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; } // =========================================================================== @@ -462,221 +536,139 @@ void wxCondition::Broadcast() // 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 ); + wxSemaphoreInternal(int initialcount, int maxcount); - void Wait(); - bool TryWait(); + bool IsOk() const { return m_isOk; } - bool Wait( unsigned long timeout_millis ); + wxSemaError Wait(); + wxSemaError TryWait(); + wxSemaError WaitTimeout(unsigned long milliseconds); - void Post(); + wxSemaError Post(); private: wxMutex m_mutex; wxCondition m_cond; - int count, - maxcount; + size_t m_count, + m_maxcount; + + bool m_isOk; }; -wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount ) +wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) : m_cond(m_mutex) { - if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) ) + if ( (initialcount < 0 || maxcount < 0) || + ((maxcount > 0) && (initialcount > maxcount)) ) { - wxFAIL_MSG( _T("wxSemaphore: invalid initial count") ); - } + wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") ); - maxcount = maxcount; - count = initialcount; -} - -void wxSemaphoreInternal::Wait() -{ - wxMutexLocker locker(*m_mutex); - - while ( count <= 0 ) - { - m_cond->Wait(); + m_isOk = false; } - - count--; -} - -bool wxSemaphoreInternal::TryWait() -{ - wxMutexLocker locker(*m_mutex); - - if ( count <= 0 ) - return FALSE; - - count--; - - return TRUE; -} - -bool wxSemaphoreInternal::Wait( unsigned long timeout_millis ) -{ - wxMutexLocker locker( *m_mutex ); - - wxLongLong startTime = wxGetLocalTimeMillis(); - - while ( count <= 0 ) + else { - wxLongLong elapsed = wxGetLocalTimeMillis() - startTime; - long remainingTime = (long)timeout_millis - (long)elapsed.GetLo(); - if ( remainingTime <= 0 ) - return FALSE; - - bool result = m_cond->Wait( remainingTime ); - if ( !result ) - return FALSE; + m_maxcount = (size_t)maxcount; + m_count = (size_t)initialcount; } - count--; - - return TRUE; + m_isOk = m_mutex.IsOk() && m_cond.IsOk(); } -void wxSemaphoreInternal::Post() +wxSemaError wxSemaphoreInternal::Wait() { - wxMutexLocker locker(*m_mutex); + wxMutexLocker locker(m_mutex); - if ( (maxcount > 0) && (count == maxcount) ) + while ( m_count == 0 ) { - wxFAIL_MSG( _T("wxSemaphore::Post() overflow") ); - } + wxLogTrace(TRACE_SEMA, + _T("Thread %p waiting for semaphore to become signalled"), + wxThread::GetCurrentId()); - count++; + if ( m_cond.Wait() != wxCOND_NO_ERROR ) + return wxSEMA_MISC_ERROR; - m_cond->Signal(); -} + wxLogTrace(TRACE_SEMA, + _T("Thread %p finished waiting for semaphore, count = %lu"), + wxThread::GetCurrentId(), (unsigned long)m_count); + } -// -------------------------------------------------------------------------- -// wxSemaphore -// -------------------------------------------------------------------------- + m_count--; -wxSemaphore::wxSemaphore( int initialcount, int maxcount ) -{ - m_internal = new wxSemaphoreInternal( initialcount, maxcount ); + return wxSEMA_NO_ERROR; } -wxSemaphore::~wxSemaphore() +wxSemaError wxSemaphoreInternal::TryWait() { - delete m_internal; -} + wxMutexLocker locker(m_mutex); -void wxSemaphore::Wait() -{ - m_internal->Wait(); -} + if ( m_count == 0 ) + return wxSEMA_BUSY; -bool wxSemaphore::TryWait() -{ - return m_internal->TryWait(); -} + m_count--; -bool wxSemaphore::Wait( unsigned long timeout_millis ) -{ - return m_internal->Wait( timeout_millis ); + return wxSEMA_NO_ERROR; } -void wxSemaphore::Post() +wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds) { - m_internal->Post(); -} - -// This class is used by wxThreadInternal to support Delete() on -// a detached thread -class wxRefCountedCondition -{ -public: - // start with a initial reference count of 1 - wxRefCountedCondition() - { - m_refCount = 1; - m_signaled = FALSE; + wxMutexLocker locker(m_mutex); - m_mutex = new wxMutex(); - m_cond = new wxCondition( m_mutex ); - } - - // increment the reference count - void AddRef() - { - wxMutexLocker locker( *m_mutex ); - - m_refCount++; - } + wxLongLong startTime = wxGetLocalTimeMillis(); - // decrement the reference count if reference count is zero then delete the - // object - void DeleteRef() + while ( m_count == 0 ) { - bool shouldDelete = FALSE; - - m_mutex->Lock(); - - if ( --m_refCount == 0 ) + wxLongLong elapsed = wxGetLocalTimeMillis() - startTime; + long remainingTime = (long)milliseconds - (long)elapsed.GetLo(); + if ( remainingTime <= 0 ) { - shouldDelete = TRUE; + // timeout + return wxSEMA_TIMEOUT; } - m_mutex->Unlock(); - - if ( shouldDelete ) + switch ( m_cond.WaitTimeout(remainingTime) ) { - delete this; - } - } - - - // sets the object to signaled this signal will be a persistent signal all - // further Wait()s on the object will return without blocking - void SetSignaled() - { - wxMutexLocker locker( *m_mutex ); - - m_signaled = TRUE; + case wxCOND_TIMEOUT: + return wxSEMA_TIMEOUT; - m_cond->Broadcast(); - } + default: + return wxSEMA_MISC_ERROR; - // wait till the object is signaled if the object was already signaled then - // return immediately - void Wait() - { - wxMutexLocker locker( *m_mutex ); - - if ( !m_signaled ) - { - m_cond->Wait(); + case wxCOND_NO_ERROR: + ; } } -private: - int m_refCount; + m_count--; - wxMutex *m_mutex; - wxCondition *m_cond; + return wxSEMA_NO_ERROR; +} - bool m_signaled; +wxSemaError wxSemaphoreInternal::Post() +{ + wxMutexLocker locker(m_mutex); - // Cannot delete this object directly, call DeleteRef() instead - ~wxRefCountedCondition() + if ( m_maxcount > 0 && m_count == m_maxcount ) { - delete m_cond; - delete m_mutex; + return wxSEMA_OVERFLOW; } - // suppress gcc warning about the class having private dtor and not having - // friend (so what??) - friend class wxDummyFriend; -}; + m_count++; + + wxLogTrace(TRACE_SEMA, + _T("Thread %p 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; +} // =========================================================================== // wxThread implementation @@ -686,10 +678,10 @@ private: extern "C" { -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // thread exit function void wxPthreadCleanup(void *ptr); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP void *wxPthreadStart(void *ptr); @@ -711,12 +703,10 @@ public: // 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(); - // wake up threads waiting for our termination - void SignalExit(); - // wake up threads waiting for our start - void SignalRun() { m_semRun.Post(); } // go to sleep until Resume() is called void Pause(); // resume the thread @@ -728,12 +718,28 @@ public: 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 %p: %s => %s."), + 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; } // "cancelled" flag - void SetCancelFlag() { m_cancelled = TRUE; } + void SetCancelFlag() { m_cancelled = true; } bool WasCancelled() const { return m_cancelled; } // exit code void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; } @@ -746,22 +752,21 @@ public: // tell the thread that it is a detached one void Detach() { - m_shouldBeJoined = m_shouldBroadcast = FALSE; - m_isDetached = TRUE; + wxCriticalSectionLocker lock(m_csJoinFlag); + + m_shouldBeJoined = 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; } -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // this is used by wxPthreadCleanup() only static void Cleanup(wxThread *thread); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP 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; @@ -777,7 +782,6 @@ private: // pthread_join(), so we have to keep track of this wxCriticalSection m_csJoinFlag; bool m_shouldBeJoined; - bool m_shouldBroadcast; bool m_isDetached; // this semaphore is posted by Run() and the threads Entry() is not @@ -787,11 +791,6 @@ private: // this one is signaled when the thread should resume after having been // Pause()d wxSemaphore m_semSuspend; - - // finally this one is signalled when the thread exits - // we are using a reference counted condition to support - // Delete() for a detached thread - wxRefCountedCondition *m_condEnd; }; // ---------------------------------------------------------------------------- @@ -807,7 +806,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; - wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId()); + wxLogTrace(TRACE_THREADS, _T("Thread %p started."), THR_ID(pthread)); // associate the thread pointer with the newly created thread so that // wxThread::This() will work @@ -823,11 +822,11 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) // block! bool dontRunAtAll; -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // install the cleanup handler which will be called if the thread is // cancelled pthread_cleanup_push(wxPthreadCleanup, thread); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP // wait for the semaphore to be posted from Run() pthread->m_semRun.Wait(); @@ -844,17 +843,23 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) if ( !dontRunAtAll ) { // call the main entry - pthread->m_exitcode = thread->Entry(); + wxLogTrace(TRACE_THREADS, + _T("Thread %p about to enter its Entry()."), + THR_ID(pthread)); + + wxTRY + { + pthread->m_exitcode = thread->Entry(); - wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."), - pthread->GetId()); + wxLogTrace(TRACE_THREADS, + _T("Thread %p Entry() returned %lu."), + THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); + } + wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) { 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) @@ -862,16 +867,26 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) } } - // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop - // contains the matching '}' for the '{' in push, so they must be used - // in the same block! -#if HAVE_THREAD_CLEANUP_FUNCTIONS + // NB: pthread_cleanup_push/pop() are macros and pop contains the matching + // '}' for the '{' in push, so they must be used in the same block! +#ifdef wxHAVE_PTHREAD_CLEANUP + #ifdef __DECCXX + // under Tru64 we get a warning from macro expansion + #pragma message save + #pragma message disable(declbutnotref) + #endif + // remove the cleanup handler without executing it pthread_cleanup_pop(FALSE); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS + + #ifdef __DECCXX + #pragma message restore + #endif +#endif // wxHAVE_PTHREAD_CLEANUP if ( dontRunAtAll ) { + // FIXME: deleting a possibly joinable thread here??? delete thread; return EXITCODE_CANCELLED; @@ -887,7 +902,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) } } -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // this handler is called when the thread is cancelled extern "C" void wxPthreadCleanup(void *ptr) @@ -897,6 +912,7 @@ extern "C" void wxPthreadCleanup(void *ptr) void wxThreadInternal::Cleanup(wxThread *thread) { + if (pthread_getspecific(gs_keySelf) == 0) return; { wxCriticalSectionLocker lock(thread->m_critsect); if ( thread->m_internal->GetState() == STATE_EXITED ) @@ -910,7 +926,7 @@ void wxThreadInternal::Cleanup(wxThread *thread) thread->Exit(EXITCODE_CANCELLED); } -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP // ---------------------------------------------------------------------------- // wxThreadInternal @@ -919,25 +935,21 @@ void wxThreadInternal::Cleanup(wxThread *thread) wxThreadInternal::wxThreadInternal() { m_state = STATE_NEW; - m_cancelled = FALSE; + m_cancelled = false; m_prio = WXTHREAD_DEFAULT_PRIORITY; m_threadId = 0; m_exitcode = 0; - // set to TRUE only when the thread starts waiting on m_semSuspend - m_isPaused = FALSE; + // set to true only when the thread starts waiting on m_semSuspend + m_isPaused = false; // defaults for joinable threads - m_shouldBeJoined = TRUE; - m_shouldBroadcast = TRUE; - m_isDetached = FALSE; - - m_condEnd = new wxRefCountedCondition(); + m_shouldBeJoined = true; + m_isDetached = false; } wxThreadInternal::~wxThreadInternal() { - m_condEnd->DeleteRef(); } wxThreadError wxThreadInternal::Run() @@ -945,46 +957,30 @@ wxThreadError wxThreadInternal::Run() wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING, wxT("thread may only be started once after Create()") ); - SignalRun(); - SetState(STATE_RUNNING); + // wake up threads waiting for our start + SignalRun(); + 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(); - 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) + _T("Starting to wait for thread %p to exit."), + THR_ID(this)); - // a reference counting condition is used to handle the - // case where a detached thread deletes itself - // before m_condEnd->Wait() returns - // in this case the deletion of the condition object is deferred until - // all Wait()ing threads have finished calling DeleteRef() - m_condEnd->AddRef(); - m_condEnd->Wait(); - m_condEnd->DeleteRef(); - - wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id); - - // we can't use any member variables any more if the thread is detached - // because it could be already deleted - if ( !isDetached ) + // 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 { - // to avoid memory leaks we should call pthread_join(), but it must - // only be done once wxCriticalSectionLocker lock(m_csJoinFlag); if ( m_shouldBeJoined ) @@ -993,13 +989,16 @@ void wxThreadInternal::Wait() // 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 ) + if ( pthread_join(GetId(), &m_exitcode) != 0 ) { - wxLogError(_("Failed to join a thread, potential memory leak " - "detected - please restart the program")); + // 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; } } @@ -1008,22 +1007,6 @@ void wxThreadInternal::Wait() 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->SetSignaled(); - } -} - void wxThreadInternal::Pause() { // the state is set from the thread which pauses us first, this function @@ -1031,7 +1014,8 @@ void wxThreadInternal::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 %p goes to sleep."), THR_ID(this)); // wait until the semaphore is Post()ed from Resume() m_semSuspend.Wait(); @@ -1046,18 +1030,19 @@ void wxThreadInternal::Resume() // TestDestroy() since the last call to Pause() for example if ( IsReallyPaused() ) { - wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId()); + wxLogTrace(TRACE_THREADS, + _T("Waking up thread %p"), THR_ID(this)); // wake up Pause() m_semSuspend.Post(); // reset the flag - SetReallyPaused(FALSE); + SetReallyPaused(false); } else { - wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"), - GetId()); + wxLogTrace(TRACE_THREADS, + _T("Thread %p is not yet really paused"), THR_ID(this)); } SetState(STATE_RUNNING); @@ -1074,7 +1059,7 @@ wxThread *wxThread::This() 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() @@ -1084,14 +1069,16 @@ void wxThread::Yield() #endif } -void wxThread::Sleep(unsigned long milliseconds) -{ - wxUsleep(milliseconds); -} - int wxThread::GetCPUCount() { -#if defined(__LINUX__) && wxUSE_FFILE +#if defined(_SC_NPROCESSORS_ONLN) + // this works for Solaris and Linux 2.6 + int rc = sysconf(_SC_NPROCESSORS_ONLN); + if ( rc != -1 ) + { + return rc; + } +#elif 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; @@ -1103,8 +1090,8 @@ int wxThread::GetCPUCount() wxString s; if ( file.ReadAll(&s) ) { - // (ab)use Replace() to find the number of "processor" strings - size_t count = s.Replace(_T("processor"), _T("")); + // (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; @@ -1117,32 +1104,30 @@ int wxThread::GetCPUCount() 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 - // 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 +} + +#else // !__VMS + unsigned long wxThread::GetCurrentId() { return (unsigned long)pthread_self(); -#endif } +#endif // __VMS/!__VMS + + bool wxThread::SetConcurrency(size_t level) { #ifdef HAVE_THR_SETCONCURRENCY @@ -1166,14 +1151,24 @@ bool wxThread::SetConcurrency(size_t level) wxThread::wxThread(wxThreadKind kind) { // add this thread to the global list of all threads - gs_allThreads.Add(this); + { + wxMutexLocker lock(*gs_mutexAllThreads); + + gs_allThreads.Add(this); + } m_internal = new wxThreadInternal(); m_isDetached = kind == wxTHREAD_DETACHED; } -wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) +#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE + #define WXUNUSED_STACKSIZE(identifier) identifier +#else + #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier) +#endif + +wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize)) { if ( m_internal->GetState() != STATE_NEW ) { @@ -1185,6 +1180,11 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) pthread_attr_t attr; pthread_attr_init(&attr); +#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE + if (stackSize) + pthread_attr_setstacksize(&attr, stackSize); +#endif + #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS int policy; if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 ) @@ -1318,6 +1318,24 @@ void wxThread::SetPriority(unsigned int prio) 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. + // + // FIXME this is not true for 2.6!! + + // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY + // to Unix priorities 20..-20 + if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 ) + { + wxLogError(_("Failed to set thread priority %d."), prio); + } +#else // __LINUX__ { struct sched_param sparam; sparam.sched_priority = prio; @@ -1328,6 +1346,7 @@ void wxThread::SetPriority(unsigned int prio) wxLogError(_("Failed to set thread priority %d."), prio); } } +#endif // __LINUX__ #endif // HAVE_THREAD_PRIORITY_FUNCTIONS break; @@ -1367,9 +1386,6 @@ wxThreadError wxThread::Pause() 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); @@ -1389,7 +1405,7 @@ wxThreadError wxThread::Resume() switch ( state ) { case STATE_PAUSED: - wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."), + wxLogTrace(TRACE_THREADS, _T("Thread %p suspended, resuming."), GetId()); m_internal->Resume(); @@ -1397,7 +1413,7 @@ wxThreadError wxThread::Resume() return wxTHREAD_NO_ERROR; case STATE_EXITED: - wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."), + wxLogTrace(TRACE_THREADS, _T("Thread %p exited, won't resume."), GetId()); return wxTHREAD_NO_ERROR; @@ -1430,27 +1446,22 @@ 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(); - 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: // we need to wake up the thread so that PthreadStart() will - // terminate - right now it's blocking on m_semRun + // terminate - right now it's blocking on run semaphore in + // PthreadStart() m_internal->SignalRun(); // fall through @@ -1460,24 +1471,24 @@ wxThreadError wxThread::Delete(ExitCode *rc) 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: - // 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; @@ -1503,25 +1514,26 @@ wxThreadError wxThread::Kill() default: #ifdef HAVE_PTHREAD_CANCEL if ( pthread_cancel(m_internal->GetId()) != 0 ) -#endif +#endif // HAVE_PTHREAD_CANCEL { wxLogError(_("Failed to terminate a thread.")); return wxTHREAD_MISC_ERROR; } +#ifdef HAVE_PTHREAD_CANCEL if ( m_isDetached ) { // if we use cleanup function, this will be done from // wxPthreadCleanup() -#if !HAVE_THREAD_CLEANUP_FUNCTIONS +#ifndef wxHAVE_PTHREAD_CLEANUP ScheduleThreadForDeletion(); // 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 +#endif // wxHAVE_PTHREAD_CLEANUP } else { @@ -1529,36 +1541,32 @@ wxThreadError wxThread::Kill() } return wxTHREAD_NO_ERROR; +#endif // HAVE_PTHREAD_CANCEL } } void wxThread::Exit(ExitCode status) { wxASSERT_MSG( This() == this, - _T("wxThread::Exit() can only be called in the " - "context of the same thread") ); + _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 - ScheduleThreadForDeletion(); + 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 // common case) while the main thread calls any of functions entering // 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(); + wxTRY + { + OnExit(); + } + wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) // delete C++ thread object if this is a detached thread - user is // responsible for doing this for joinable ones @@ -1571,6 +1579,13 @@ void wxThread::Exit(ExitCode status) // we make it a global object, but this would mean that we can // only call one thread function at a time :-( DeleteThread(this); + pthread_setspecific(gs_keySelf, 0); + } + else + { + m_critsect.Enter(); + m_internal->SetState(STATE_EXITED); + m_critsect.Leave(); } // terminate the thread (pthread_exit() never returns) @@ -1583,14 +1598,13 @@ void wxThread::Exit(ExitCode status) bool wxThread::TestDestroy() { wxASSERT_MSG( This() == this, - _T("wxThread::TestDestroy() can only be called in the " - "context of the same thread") ); + _T("wxThread::TestDestroy() can only be called in the context of the same thread") ); m_critsect.Enter(); if ( m_internal->GetState() == STATE_PAUSED ) { - m_internal->SetReallyPaused(TRUE); + 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 @@ -1617,8 +1631,8 @@ wxThread::~wxThread() if ( m_internal->GetState() != STATE_EXITED && m_internal->GetState() != STATE_NEW ) { - wxLogDebug(_T("The thread %ld is being destroyed although it is still " - "running! The application may crash."), GetId()); + wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."), + (long)GetId()); } m_critsect.Leave(); @@ -1627,18 +1641,10 @@ wxThread::~wxThread() delete m_internal; // 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 ) { - wxMutexLocker lock( *gs_mutexDeleteThread ); - - gs_nThreadsBeingDeleted--; + wxMutexLocker lock(*gs_mutexAllThreads); - wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), - gs_nThreadsBeingDeleted - 1); + gs_allThreads.Remove(this); } } @@ -1661,10 +1667,10 @@ bool wxThread::IsAlive() const { case STATE_RUNNING: case STATE_PAUSED: - return TRUE; + return true; default: - return FALSE; + return false; } } @@ -1696,24 +1702,22 @@ bool wxThreadModule::OnInit() 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; + return false; } gs_tidMain = pthread_self(); -#if wxUSE_GUI - gs_mutexGui = new wxMutex(); + gs_mutexAllThreads = new wxMutex(); + gs_mutexGui = new wxMutex(); gs_mutexGui->Lock(); -#endif // wxUSE_GUI gs_mutexDeleteThread = new wxMutex(); - gs_condAllDeleted = new wxCondition( gs_mutexDeleteThread ); + gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread); - return TRUE; + return true; } void wxThreadModule::OnExit() @@ -1728,22 +1732,29 @@ void wxThreadModule::OnExit() nThreadsBeingDeleted = gs_nThreadsBeingDeleted; if ( nThreadsBeingDeleted > 0 ) -{ - wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"), - nThreadsBeingDeleted); + { + wxLogTrace(TRACE_THREADS, + _T("Waiting for %lu threads to disappear"), + (unsigned long)nThreadsBeingDeleted); // have to wait until all of them disappear gs_condAllDeleted->Wait(); } } - // terminate any threads left - size_t count = gs_allThreads.GetCount(); - if ( count != 0u ) + size_t count; + { - wxLogDebug(wxT("%u threads were not terminated by the application."), - count); - } + wxMutexLocker lock(*gs_mutexAllThreads); + + // terminate any threads left + count = gs_allThreads.GetCount(); + if ( count != 0u ) + { + wxLogDebug(wxT("%lu threads were not terminated by the application."), + (unsigned long)count); + } + } // unlock mutex before deleting the threads as they lock it in their dtor for ( size_t n = 0u; n < count; n++ ) { @@ -1752,12 +1763,11 @@ void wxThreadModule::OnExit() gs_allThreads[0]->Delete(); } -#if wxUSE_GUI + delete gs_mutexAllThreads; + // destroy GUI mutex gs_mutexGui->Unlock(); - delete gs_mutexGui; -#endif // wxUSE_GUI // and free TLD slot (void)pthread_key_delete(gs_keySelf); @@ -1776,9 +1786,9 @@ static void ScheduleThreadForDeletion() gs_nThreadsBeingDeleted++; - wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"), - gs_nThreadsBeingDeleted, - gs_nThreadsBeingDeleted == 1 ? "" : "s"); + wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"), + (unsigned long)gs_nThreadsBeingDeleted, + gs_nThreadsBeingDeleted == 1 ? _T("") : _T("s")); } static void DeleteThread(wxThread *This) @@ -1787,16 +1797,15 @@ static void DeleteThread(wxThread *This) // or wxThreadModule::OnExit() would deadlock wxMutexLocker locker( *gs_mutexDeleteThread ); - wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); + wxLogTrace(TRACE_THREADS, _T("Thread %p auto deletes."), This->GetId()); delete This; wxCHECK_RET( gs_nThreadsBeingDeleted > 0, - _T("no threads scheduled for deletion, yet we delete " - "one?") ); + _T("no threads scheduled for deletion, yet we delete one?") ); - wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), - gs_nThreadsBeingDeleted - 1); + wxLogTrace(TRACE_THREADS, _T("%lu threads remain scheduled for deletion."), + (unsigned long)gs_nThreadsBeingDeleted - 1); if ( !--gs_nThreadsBeingDeleted ) { @@ -1805,19 +1814,20 @@ static void DeleteThread(wxThread *This) } } -void wxMutexGuiEnter() +void wxMutexGuiEnterImpl() { -#if wxUSE_GUI gs_mutexGui->Lock(); -#endif // wxUSE_GUI } -void wxMutexGuiLeave() +void wxMutexGuiLeaveImpl() { -#if wxUSE_GUI gs_mutexGui->Unlock(); -#endif // wxUSE_GUI } -#endif - // wxUSE_THREADS +// ---------------------------------------------------------------------------- +// include common implementation code +// ---------------------------------------------------------------------------- + +#include "wx/thrimpl.cpp" + +#endif // wxUSE_THREADS