X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7bcb11d30764df47144189e164f53d8171ed4a63..6ba718d7aee2f519d9146b90424ccec9e2243479:/src/unix/threadpsx.cpp?ds=sidebyside diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 5895f57d77..38897f3b28 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -1,14 +1,14 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: threadpsx.cpp +// Name: src/unix/threadpsx.cpp // Purpose: wxThread (Posix) Implementation // Author: Original from Wolfram Gloger/Guilhem Lavaux -// Modified by: +// Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore // Created: 04/22/98 -// RCS-ID: $Id$ // Copyright: (c) Wolfram Gloger (1996, 1997) // Guilhem Lavaux (1998) -// Vadim Zeitlin (1999) +// Vadim Zeitlin (1999-2002) // Robert Roebling (1999) +// K. S. Sreeram (2002) // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -20,33 +20,55 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "thread.h" -#endif - -// With simple makefiles, we must ignore the file body if not using -// threads. -#include "wx/setup.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/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 +#include // needed for at least __QNX__ +#ifdef HAVE_SCHED_H #include #endif +#ifdef HAVE_THR_SETCONCURRENCY + #include +#endif + +#ifdef HAVE_ABI_FORCEDUNWIND + #include +#endif + +#ifdef HAVE_SETPRIORITY + #include // for setpriority() +#endif + +// we use wxFFile under Linux in GetCPUCount() +#ifdef __LINUX__ + #include "wx/ffile.h" +#endif + +#define THR_ID_CAST(id) (reinterpret_cast(id)) +#define THR_ID(thr) THR_ID_CAST((thr)->GetId()) + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -60,11 +82,30 @@ enum wxThreadState STATE_EXITED // thread doesn't exist any more }; +// the exit value of a thread which has been cancelled +static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1; + +// trace mask for wxThread operations +#define TRACE_THREADS wxT("thread") + +// you can get additional debugging messages for the semaphore operations +#define TRACE_SEMA wxT("semaphore") + // ---------------------------------------------------------------------------- -// types +// private functions // ---------------------------------------------------------------------------- -WX_DEFINE_ARRAY(wxThread *, wxArrayThread); +static void ScheduleThreadForDeletion(); +static void DeleteThread(wxThread *This); + +// ---------------------------------------------------------------------------- +// private classes +// ---------------------------------------------------------------------------- + +// 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 @@ -75,146 +116,588 @@ 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; +// +// we suppose that 0 is not a valid pthread_t value but in principle this might +// be false (e.g. if it's a selector-like value), wxThread::IsMain() would need +// to be updated in such case +wxThreadIdType wxThread::ms_idMainThread = 0; // the key for the pointer to the associated wxThread object static pthread_key_t gs_keySelf; +// the number of threads which are being deleted - the program won't exit +// until there are any left +static size_t gs_nThreadsBeingDeleted = 0; + +// a mutex to protect gs_nThreadsBeingDeleted +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 = NULL; + +#ifndef __WXOSX__ // this mutex must be acquired before any call to a GUI function -static wxMutex *gs_mutexGui; +// (it's not inside #if wxUSE_GUI because this file is compiled as part +// of wxBase) +static wxMutex *gs_mutexGui = NULL; +#endif + +// when we wait for a thread to exit, we're blocking on a condition which the +// thread signals in its SignalExit() method -- but this condition can't be a +// member of the thread itself as a detached thread may delete itself at any +// moment and accessing the condition member of the thread after this would +// result in a disaster +// +// so instead we maintain a global list of the structs below for the threads +// we're interested in waiting on // ============================================================================ -// implementation +// wxMutex implementation // ============================================================================ -//-------------------------------------------------------------------- -// wxMutex (Posix implementation) -//-------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// wxMutexInternal +// ---------------------------------------------------------------------------- +// this is a simple wrapper around pthread_mutex_t which provides error +// checking class wxMutexInternal { public: - pthread_mutex_t p_mutex; + 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; }; -wxMutex::wxMutex() +#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) { - p_internal = new wxMutexInternal; - pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL ); - m_locked = 0; + 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); + + err = pthread_mutex_init(&m_mutex, &attr); + } +#elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER) + // we can use this only as initializer so we have to assign it + // first to a temp var - assigning directly to m_mutex wouldn't + // even compile + { + pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; + m_mutex = mutex; + } +#else // no recursive mutexes + err = EINVAL; +#endif // HAVE_PTHREAD_MUTEXATTR_T/... + break; + + default: + wxFAIL_MSG( wxT("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); + } } -wxMutex::~wxMutex() +wxMutexInternal::~wxMutexInternal() { - if (m_locked > 0) - wxLogDebug("Freeing a locked mutex (%d locks)", m_locked); + if ( m_isOk ) + { + int err = pthread_mutex_destroy(&m_mutex); + if ( err != 0 ) + { + wxLogApiError( wxT("pthread_mutex_destroy()"), err); + } + } +} - pthread_mutex_destroy( &(p_internal->p_mutex) ); - delete p_internal; +wxMutexError wxMutexInternal::Lock() +{ + 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 wxMutex::Lock() +wxMutexError wxMutexInternal::Lock(unsigned long ms) { - int err = pthread_mutex_lock( &(p_internal->p_mutex) ); - if (err == EDEADLK) +#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 ) { - wxLogDebug("Locking this mutex would lead to deadlock!"); + 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); + } - return wxMUTEX_DEAD_LOCK; + 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; } - m_locked++; + return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts)); +#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK + wxUnusedVar(ms); - return wxMUTEX_NO_ERROR; + return wxMUTEX_MISC_ERROR; +#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK } -wxMutexError wxMutex::TryLock() +wxMutexError wxMutexInternal::HandleLockResult(int err) { - if (m_locked) + // wxPrintf( "err %d\n", err ); + + switch ( err ) { - return wxMUTEX_BUSY; + case EDEADLK: + // only error checking mutexes return this value and so it's an + // unexpected situation -- hence use assert, not wxLogDebug + wxFAIL_MSG( wxT("mutex deadlock prevented") ); + return wxMUTEX_DEAD_LOCK; + + case EINVAL: + wxLogDebug(wxT("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(wxT("pthread_mutex_[timed]lock()"), err); } - int err = pthread_mutex_trylock( &(p_internal->p_mutex) ); - switch (err) + return wxMUTEX_MISC_ERROR; +} + + +wxMutexError wxMutexInternal::TryLock() +{ + int err = pthread_mutex_trylock(&m_mutex); + switch ( err ) { - case EBUSY: return wxMUTEX_BUSY; + case EBUSY: + // not an error: mutex is already locked, but we're prepared for + // this + return wxMUTEX_BUSY; + + case EINVAL: + wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized.")); + break; + + case 0: + if (m_type == wxMUTEX_DEFAULT) + m_owningThread = wxThread::GetCurrentId(); + return wxMUTEX_NO_ERROR; + + default: + wxLogApiError(wxT("pthread_mutex_trylock()"), err); } - m_locked++; + return wxMUTEX_MISC_ERROR; +} + +wxMutexError wxMutexInternal::Unlock() +{ + m_owningThread = 0; + + int err = pthread_mutex_unlock(&m_mutex); + switch ( err ) + { + case EPERM: + // we don't own the mutex + return wxMUTEX_UNLOCKED; + + case EINVAL: + wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized.")); + break; + + case 0: + return wxMUTEX_NO_ERROR; + + default: + wxLogApiError(wxT("pthread_mutex_unlock()"), err); + } + + return wxMUTEX_MISC_ERROR; +} + +// =========================================================================== +// wxCondition implementation +// =========================================================================== + +// --------------------------------------------------------------------------- +// 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(); + + bool IsOk() const { return m_isOk && m_mutex.IsOk(); } + + wxCondError Wait(); + wxCondError WaitTimeout(unsigned long milliseconds); + + 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; + pthread_cond_t m_cond; + + bool m_isOk; +}; + +wxConditionInternal::wxConditionInternal(wxMutex& mutex) + : m_mutex(mutex) +{ + int err = pthread_cond_init(&m_cond, NULL /* default attributes */); + + m_isOk = err == 0; - return wxMUTEX_NO_ERROR; + if ( !m_isOk ) + { + wxLogApiError(wxT("pthread_cond_init()"), err); + } } -wxMutexError wxMutex::Unlock() +wxConditionInternal::~wxConditionInternal() { - if (m_locked > 0) + if ( m_isOk ) { - m_locked--; + int err = pthread_cond_destroy(&m_cond); + if ( err != 0 ) + { + wxLogApiError(wxT("pthread_cond_destroy()"), err); + } } - else +} + +wxCondError wxConditionInternal::Wait() +{ + int err = pthread_cond_wait(&m_cond, GetPMutex()); + if ( err != 0 ) { - wxLogDebug("Unlocking not locked mutex."); + wxLogApiError(wxT("pthread_cond_wait()"), err); - return wxMUTEX_UNLOCKED; + return wxCOND_MISC_ERROR; } - pthread_mutex_unlock( &(p_internal->p_mutex) ); + return wxCOND_NO_ERROR; +} - return wxMUTEX_NO_ERROR; +wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds) +{ + wxLongLong curtime = wxGetUTCTimeMillis(); + curtime += milliseconds; + wxLongLong temp = curtime / 1000; + int sec = temp.GetLo(); + temp *= 1000; + temp = curtime - temp; + int millis = temp.GetLo(); + + timespec tspec; + + tspec.tv_sec = sec; + tspec.tv_nsec = millis * 1000L * 1000L; + + int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec ); + switch ( err ) + { + case ETIMEDOUT: + return wxCOND_TIMEOUT; + + case 0: + return wxCOND_NO_ERROR; + + default: + wxLogApiError(wxT("pthread_cond_timedwait()"), err); + } + + return wxCOND_MISC_ERROR; } -//-------------------------------------------------------------------- -// wxCondition (Posix implementation) -//-------------------------------------------------------------------- +wxCondError wxConditionInternal::Signal() +{ + int err = pthread_cond_signal(&m_cond); + if ( err != 0 ) + { + wxLogApiError(wxT("pthread_cond_signal()"), err); -class wxConditionInternal + return wxCOND_MISC_ERROR; + } + + return wxCOND_NO_ERROR; +} + +wxCondError wxConditionInternal::Broadcast() +{ + int err = pthread_cond_broadcast(&m_cond); + if ( err != 0 ) + { + wxLogApiError(wxT("pthread_cond_broadcast()"), err); + + return wxCOND_MISC_ERROR; + } + + return wxCOND_NO_ERROR; +} + +// =========================================================================== +// wxSemaphore implementation +// =========================================================================== + +// --------------------------------------------------------------------------- +// wxSemaphoreInternal +// --------------------------------------------------------------------------- + +// we implement the semaphores using mutexes and conditions instead of using +// the sem_xxx() POSIX functions because they're not widely available and also +// because it's impossible to implement WaitTimeout() using them +class wxSemaphoreInternal { public: - pthread_cond_t p_condition; + wxSemaphoreInternal(int initialcount, int maxcount); + + bool IsOk() const { return m_isOk; } + + wxSemaError Wait(); + wxSemaError TryWait(); + wxSemaError WaitTimeout(unsigned long milliseconds); + + wxSemaError Post(); + +private: + wxMutex m_mutex; + wxCondition m_cond; + + size_t m_count, + m_maxcount; + + bool m_isOk; }; -wxCondition::wxCondition() +wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) + : m_cond(m_mutex) { - p_internal = new wxConditionInternal; - pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL ); + + if ( (initialcount < 0 || maxcount < 0) || + ((maxcount > 0) && (initialcount > maxcount)) ) + { + wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") ); + + m_isOk = false; + } + else + { + m_maxcount = (size_t)maxcount; + m_count = (size_t)initialcount; + } + + m_isOk = m_mutex.IsOk() && m_cond.IsOk(); } -wxCondition::~wxCondition() +wxSemaError wxSemaphoreInternal::Wait() { - pthread_cond_destroy( &(p_internal->p_condition) ); + wxMutexLocker locker(m_mutex); - delete p_internal; + while ( m_count == 0 ) + { + wxLogTrace(TRACE_SEMA, + wxT("Thread %p waiting for semaphore to become signalled"), + THR_ID_CAST(wxThread::GetCurrentId())); + + if ( m_cond.Wait() != wxCOND_NO_ERROR ) + return wxSEMA_MISC_ERROR; + + wxLogTrace(TRACE_SEMA, + wxT("Thread %p finished waiting for semaphore, count = %lu"), + THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count); + } + + m_count--; + + return wxSEMA_NO_ERROR; } -void wxCondition::Wait(wxMutex& mutex) +wxSemaError wxSemaphoreInternal::TryWait() { - pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) ); + wxMutexLocker locker(m_mutex); + + if ( m_count == 0 ) + return wxSEMA_BUSY; + + m_count--; + + return wxSEMA_NO_ERROR; } -bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec) +wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds) { - struct timespec tspec; + wxMutexLocker locker(m_mutex); + + wxLongLong startTime = wxGetLocalTimeMillis(); + + while ( m_count == 0 ) + { + wxLongLong elapsed = wxGetLocalTimeMillis() - startTime; + long remainingTime = (long)milliseconds - (long)elapsed.GetLo(); + if ( remainingTime <= 0 ) + { + // timeout + return wxSEMA_TIMEOUT; + } + + switch ( m_cond.WaitTimeout(remainingTime) ) + { + case wxCOND_TIMEOUT: + return wxSEMA_TIMEOUT; + + default: + return wxSEMA_MISC_ERROR; + + case wxCOND_NO_ERROR: + ; + } + } - tspec.tv_sec = time(0L)+sec; - tspec.tv_nsec = nsec; - return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT); + m_count--; + + return wxSEMA_NO_ERROR; } -void wxCondition::Signal() +wxSemaError wxSemaphoreInternal::Post() { - pthread_cond_signal( &(p_internal->p_condition) ); + wxMutexLocker locker(m_mutex); + + if ( m_maxcount > 0 && m_count == m_maxcount ) + { + return wxSEMA_OVERFLOW; + } + + m_count++; + + wxLogTrace(TRACE_SEMA, + wxT("Thread %p about to signal semaphore, count = %lu"), + THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count); + + return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR + : wxSEMA_MISC_ERROR; } -void wxCondition::Broadcast() +// =========================================================================== +// wxThread implementation +// =========================================================================== + +// the thread callback functions must have the C linkage +extern "C" { - pthread_cond_broadcast( &(p_internal->p_condition) ); -} -//-------------------------------------------------------------------- -// wxThread (Posix implementation) -//-------------------------------------------------------------------- +#ifdef wxHAVE_PTHREAD_CLEANUP + // thread exit function + void wxPthreadCleanup(void *ptr); +#endif // wxHAVE_PTHREAD_CLEANUP + +void *wxPthreadStart(void *ptr); + +} // extern "C" + +// ---------------------------------------------------------------------------- +// wxThreadInternal +// ---------------------------------------------------------------------------- class wxThreadInternal { @@ -223,15 +706,17 @@ public: ~wxThreadInternal(); // thread entry function - static void *PthreadStart(void *ptr); + static void *PthreadStart(wxThread *thread); // thread actions + // create the thread + wxThreadError Create(wxThread *thread, unsigned int stackSize); // 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(); // go to sleep until Resume() is called void Pause(); // resume the thread @@ -243,147 +728,449 @@ 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) + { +#if wxUSE_LOG_TRACE + static const wxChar *const stateNames[] = + { + wxT("NEW"), + wxT("RUNNING"), + wxT("PAUSED"), + wxT("EXITED"), + }; + + wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."), + THR_ID(this), stateNames[m_state], stateNames[state]); +#endif // wxUSE_LOG_TRACE + + m_state = state; + } // id pthread_t GetId() const { return m_threadId; } pthread_t *GetIdPtr() { return &m_threadId; } + // "created" flag + bool WasCreated() const { return m_created; } // "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; } + 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 + void Detach() + { + wxCriticalSectionLocker lock(m_csJoinFlag); + + m_shouldBeJoined = false; + m_isDetached = true; + } + +#ifdef wxHAVE_PTHREAD_CLEANUP + // this is used by wxPthreadCleanup() only + static void Cleanup(wxThread *thread); +#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 - // set when the thread should terminate + // this flag is set when the thread was successfully created + bool m_created; + + // this flag is set when the thread should terminate bool m_cancelled; - // this (mutex, cond) pair is used to synchronize the main thread and this - // thread in several situations: - // 1. The thread function blocks until condition is signaled by Run() when - // it's initially created - this allows thread creation in "suspended" - // state - // 2. The Delete() function blocks until the condition is signaled when the - // thread exits. - wxMutex m_mutex; - wxCondition m_cond; + // this flag is set when the thread is blocking on m_semSuspend + bool m_isPaused; - // another (mutex, cond) pair for Pause()/Resume() usage - // - // VZ: it's possible that we might reuse the mutex and condition from above - // for this too, but as I'm not at all sure that it won't create subtle - // problems with race conditions between, say, Pause() and Delete() I - // prefer this may be a bit less efficient but much safer solution - wxMutex m_mutexSuspend; - wxCondition m_condSuspend; + // the thread exit code - only used for joinable (!detached) threads and + // is only valid after the thread termination + wxThread::ExitCode m_exitcode; + + // many threads may call Wait(), but only one of them should call + // pthread_join(), so we have to keep track of this + wxCriticalSection m_csJoinFlag; + bool m_shouldBeJoined; + bool m_isDetached; + + // this semaphore is posted by Run() and the threads Entry() is not + // called before it is done + wxSemaphore m_semRun; + + // this one is signaled when the thread should resume after having been + // Pause()d + wxSemaphore m_semSuspend; }; -void *wxThreadInternal::PthreadStart(void *ptr) -{ - wxThread *thread = (wxThread *)ptr; - wxThreadInternal *pthread = thread->p_internal; +// ---------------------------------------------------------------------------- +// thread startup and exit functions +// ---------------------------------------------------------------------------- + +void *wxPthreadStart(void *ptr) +{ + return wxThreadInternal::PthreadStart((wxThread *)ptr); +} + +void *wxThreadInternal::PthreadStart(wxThread *thread) +{ + wxThreadInternal *pthread = thread->m_internal; + + wxLogTrace(TRACE_THREADS, wxT("Thread %p started."), THR_ID(pthread)); + + // associate the thread pointer with the newly created thread so that + // wxThread::This() will work + int rc = pthread_setspecific(gs_keySelf, thread); + if ( rc != 0 ) + { + wxLogSysError(rc, _("Cannot start thread: error writing TLS.")); + + return (void *)-1; + } + + // have to declare this before pthread_cleanup_push() which defines a + // block! + bool dontRunAtAll; + +#ifdef wxHAVE_PTHREAD_CLEANUP + // install the cleanup handler which will be called if the thread is + // cancelled + pthread_cleanup_push(wxPthreadCleanup, thread); +#endif // wxHAVE_PTHREAD_CLEANUP + + // wait for the semaphore to be posted from Run() + pthread->m_semRun.Wait(); + + // test whether we should run the run at all - may be it was deleted + // before it started to Run()? + { + wxCriticalSectionLocker lock(thread->m_critsect); + + dontRunAtAll = pthread->GetState() == STATE_NEW && + pthread->WasCancelled(); + } + + if ( !dontRunAtAll ) + { + // call the main entry + wxLogTrace(TRACE_THREADS, + wxT("Thread %p about to enter its Entry()."), + THR_ID(pthread)); + + wxTRY + { + pthread->m_exitcode = thread->Entry(); + + wxLogTrace(TRACE_THREADS, + wxT("Thread %p Entry() returned %lu."), + THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); + } +#ifdef HAVE_ABI_FORCEDUNWIND + // When using common C++ ABI under Linux we must always rethrow this + // special exception used to unwind the stack when the thread was + // cancelled, otherwise the thread library would simply terminate the + // program, see http://udrepper.livejournal.com/21541.html + catch ( abi::__forced_unwind& ) + { + wxCriticalSectionLocker lock(thread->m_critsect); + pthread->SetState(STATE_EXITED); + throw; + } +#endif // HAVE_ABI_FORCEDUNWIND + wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) + + { + wxCriticalSectionLocker lock(thread->m_critsect); + + // change the state of the thread to "exited" so that + // wxPthreadCleanup handler won't do anything from now (if it's + // called before we do pthread_cleanup_pop below) + pthread->SetState(STATE_EXITED); + } + } + + // NB: 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); + + #ifdef __DECCXX + #pragma message restore + #endif +#endif // wxHAVE_PTHREAD_CLEANUP + + if ( dontRunAtAll ) + { + // FIXME: deleting a possibly joinable thread here??? + delete thread; + + return EXITCODE_CANCELLED; + } + else + { + // terminate the thread + thread->Exit(pthread->m_exitcode); + + wxFAIL_MSG(wxT("wxThread::Exit() can't return.")); + + return NULL; + } +} + +#ifdef wxHAVE_PTHREAD_CLEANUP + +// this handler is called when the thread is cancelled +extern "C" void wxPthreadCleanup(void *ptr) +{ + wxThreadInternal::Cleanup((wxThread *)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 ) + { + // thread is already considered as finished. + return; + } + } + + // exit the thread gracefully + thread->Exit(EXITCODE_CANCELLED); +} + +#endif // wxHAVE_PTHREAD_CLEANUP + +// ---------------------------------------------------------------------------- +// wxThreadInternal +// ---------------------------------------------------------------------------- + +wxThreadInternal::wxThreadInternal() +{ + m_state = STATE_NEW; + m_created = false; + m_cancelled = false; + m_prio = wxPRIORITY_DEFAULT; + m_threadId = 0; + m_exitcode = 0; + + // set to true only when the thread starts waiting on m_semSuspend + m_isPaused = false; + + // defaults for joinable threads + m_shouldBeJoined = true; + m_isDetached = false; +} + +wxThreadInternal::~wxThreadInternal() +{ +} + +#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE + #define WXUNUSED_STACKSIZE(identifier) identifier +#else + #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier) +#endif + +wxThreadError wxThreadInternal::Create(wxThread *thread, + unsigned int WXUNUSED_STACKSIZE(stackSize)) +{ + if ( GetState() != STATE_NEW ) + { + // don't recreate thread + return wxTHREAD_RUNNING; + } + + // set up the thread attribute: right now, we only set thread priority + pthread_attr_t attr; + pthread_attr_init(&attr); + +#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE + if (stackSize) + pthread_attr_setstacksize(&attr, stackSize); +#endif - int rc = pthread_setspecific(gs_keySelf, thread); - if ( rc != 0 ) +#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS + int policy; + if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 ) { - wxLogSysError(rc, _("Can not start thread: error writing TLS.")); - - return (void *)-1; + wxLogError(_("Cannot retrieve thread scheduling policy.")); } - // wait for the condition to be signaled from Run() - // mutex state: currently locked by the thread which created us - pthread->m_cond.Wait(pthread->m_mutex); +#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 - // mutex state: locked again on exit of Wait() + int max_prio = sched_get_priority_max(policy), + min_prio = sched_get_priority_min(policy), + prio = GetPriority(); - // call the main entry - void* status = thread->Entry(); + if ( min_prio == -1 || max_prio == -1 ) + { + wxLogError(_("Cannot get priority range for scheduling policy %d."), + policy); + } + else if ( max_prio == min_prio ) + { + if ( prio != wxPRIORITY_DEFAULT ) + { + // notify the programmer that this doesn't work here + wxLogWarning(_("Thread priority setting is ignored.")); + } + //else: we have default priority, so don't complain + + // anyhow, don't do anything because priority is just ignored + } + else + { + struct sched_param sp; + if ( pthread_attr_getschedparam(&attr, &sp) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed")); + } - // terminate the thread - thread->Exit(status); + sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100; - wxFAIL_MSG("wxThread::Exit() can't return."); + if ( pthread_attr_setschedparam(&attr, &sp) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed")); + } + } +#endif // HAVE_THREAD_PRIORITY_FUNCTIONS - return NULL; -} +#ifdef HAVE_PTHREAD_ATTR_SETSCOPE + // this will make the threads created by this process really concurrent + if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed")); + } +#endif // HAVE_PTHREAD_ATTR_SETSCOPE -wxThreadInternal::wxThreadInternal() -{ - m_state = STATE_NEW; - m_cancelled = FALSE; + // VZ: assume that this one is always available (it's rather fundamental), + // if this function is ever missing we should try to use + // pthread_detach() instead (after thread creation) + if ( thread->IsDetached() ) + { + if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed")); + } - // this mutex is locked during almost all thread lifetime - it will only be - // unlocked in the very end - m_mutex.Lock(); + // never try to join detached threads + Detach(); + } + //else: threads are created joinable by default, it's ok - // this mutex is used in Pause()/Resume() and is also locked all the time - // unless the thread is paused - m_mutexSuspend.Lock(); -} + // create the new OS thread object + int rc = pthread_create + ( + GetIdPtr(), + &attr, + wxPthreadStart, + (void *)thread + ); + + if ( pthread_attr_destroy(&attr) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_destroy() failed")); + } -wxThreadInternal::~wxThreadInternal() -{ - m_mutexSuspend.Unlock(); + if ( rc != 0 ) + { + SetState(STATE_EXITED); - // note that m_mutex will be unlocked by the thread which waits for our - // termination + return wxTHREAD_NO_RESOURCE; + } + + m_created = true; + return wxTHREAD_NO_ERROR; } wxThreadError wxThreadInternal::Run() { wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING, - "thread may only be started once after successful Create()" ); + wxT("thread may only be started once after Create()") ); - // the mutex was locked on Create(), so we will be able to lock it again - // only when the thread really starts executing and enters the wait - - // otherwise we might signal the condition before anybody is waiting for it - wxMutexLocker lock(m_mutex); - m_cond.Signal(); + SetState(STATE_RUNNING); - m_state = STATE_RUNNING; + // wake up threads waiting for our start + SignalRun(); return wxTHREAD_NO_ERROR; - - // now the mutex is unlocked back - but just to allow Wait() function to - // terminate by relocking it, so the net result is that the worker thread - // starts executing and the mutex is still locked } void wxThreadInternal::Wait() { - wxCHECK_RET( WasCancelled(), "thread should have been cancelled first" ); + wxCHECK_RET( !m_isDetached, wxT("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() ) + { +#ifdef __WXOSX__ + // give the thread we're waiting for chance to do the GUI call + // it might be in, we don't do this conditionally as the to be waited on + // thread might have to acquire the mutex later but before terminating + if ( wxGuiOwnedByMainThread() ) + wxMutexGuiLeave(); +#else wxMutexGuiLeave(); +#endif + } + + wxLogTrace(TRACE_THREADS, + wxT("Starting to wait for thread %p to exit."), + THR_ID(this)); - // entering Wait() releases the mutex thus allowing SignalExit() to acquire - // it and to signal us its termination - m_cond.Wait(m_mutex); + // 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 + { + wxCriticalSectionLocker lock(m_csJoinFlag); + + if ( m_shouldBeJoined ) + { + // FIXME shouldn't we set cancellation type to DISABLED here? If + // we're cancelled inside pthread_join(), things will almost + // certainly break - but if we disable the cancellation, we + // might deadlock + if ( pthread_join(GetId(), &m_exitcode) != 0 ) + { + // this is a serious problem, so use wxLogError and not + // wxLogDebug: it is possible to bring the system to its knees + // by creating too many threads and not joining them quite + // easily + wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program")); + } - // mutex is still in the locked state - relocked on exit from Wait(), so - // unlock it - we don't need it any more, the thread has already terminated - m_mutex.Unlock(); + m_shouldBeJoined = false; + } + } +#ifndef __WXOSX__ // reacquire GUI mutex if ( wxThread::IsMain() ) wxMutexGuiEnter(); -} - -void wxThreadInternal::SignalExit() -{ - // as mutex is currently locked, this will block until some other thread - // (normally the same which created this one) unlocks it by entering Wait() - m_mutex.Lock(); - - // wake up all the threads waiting for our termination - m_cond.Broadcast(); - - // after this call mutex will be finally unlocked - m_mutex.Unlock(); +#endif } void wxThreadInternal::Pause() @@ -391,32 +1178,44 @@ void wxThreadInternal::Pause() // the state is set from the thread which pauses us first, this function // is called later so the state should have been already set wxCHECK_RET( m_state == STATE_PAUSED, - "thread must first be paused with wxThread::Pause()." ); + wxT("thread must first be paused with wxThread::Pause().") ); - // don't pause the thread which is being terminated - this would lead to - // deadlock if the thread is paused after Delete() had called Resume() but - // before it had time to call Wait() - if ( WasCancelled() ) - return; + wxLogTrace(TRACE_THREADS, + wxT("Thread %p goes to sleep."), THR_ID(this)); - // wait until the condition is signaled from Resume() - m_condSuspend.Wait(m_mutexSuspend); + // wait until the semaphore is Post()ed from Resume() + m_semSuspend.Wait(); } void wxThreadInternal::Resume() { wxCHECK_RET( m_state == STATE_PAUSED, - "can't resume thread which is not suspended." ); + wxT("can't resume thread which is not suspended.") ); - // we will be able to lock this mutex only when Pause() starts waiting - wxMutexLocker lock(m_mutexSuspend); - m_condSuspend.Signal(); + // 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, + wxT("Waking up thread %p"), THR_ID(this)); + + // wake up Pause() + m_semSuspend.Post(); + + // reset the flag + SetReallyPaused(false); + } + else + { + wxLogTrace(TRACE_THREADS, + wxT("Thread %p is not yet really paused"), THR_ID(this)); + } SetState(STATE_RUNNING); } // ----------------------------------------------------------------------------- -// static functions +// wxThread static functions // ----------------------------------------------------------------------------- wxThread *wxThread::This() @@ -424,84 +1223,120 @@ wxThread *wxThread::This() return (wxThread *)pthread_getspecific(gs_keySelf); } -bool wxThread::IsMain() -{ - return (bool)pthread_equal(pthread_self(), gs_tidMain); -} - void wxThread::Yield() { +#ifdef HAVE_SCHED_YIELD sched_yield(); +#endif } -void wxThread::Sleep(unsigned long milliseconds) +int wxThread::GetCPUCount() { - wxUsleep(milliseconds); -} +#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; -// ----------------------------------------------------------------------------- -// creating thread -// ----------------------------------------------------------------------------- + wxFFile file(wxT("/proc/cpuinfo")); + if ( file.IsOpened() ) + { + // slurp the whole file + wxString s; + if ( file.ReadAll(&s) ) + { + // (ab)use Replace() to find the number of "processor: num" strings + size_t count = s.Replace(wxT("processor\t:"), wxT("")); + if ( count > 0 ) + { + return count; + } -wxThread::wxThread() -{ - // add this thread to the global list of all threads - gs_allThreads.Add(this); + wxLogDebug(wxT("failed to parse /proc/cpuinfo")); + } + else + { + wxLogDebug(wxT("failed to read /proc/cpuinfo")); + } + } +#endif // different ways to get number of CPUs - p_internal = new wxThreadInternal(); + // unknown + return -1; } -wxThreadError wxThread::Create() +wxThreadIdType wxThread::GetCurrentId() { - if (p_internal->GetState() != STATE_NEW) - return wxTHREAD_RUNNING; + return (wxThreadIdType)pthread_self(); +} - // set up the thread attribute: right now, we only set thread priority - pthread_attr_t attr; - pthread_attr_init(&attr); -#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS - int prio; - if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 ) +bool wxThread::SetConcurrency(size_t level) +{ +#ifdef HAVE_PTHREAD_SET_CONCURRENCY + int rc = pthread_setconcurrency( level ); +#elif defined(HAVE_THR_SETCONCURRENCY) + int rc = thr_setconcurrency(level); +#else // !HAVE_THR_SETCONCURRENCY + // ok only for the default value + int rc = level == 0 ? 0 : -1; +#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY + + if ( rc != 0 ) { - wxLogError(_("Can not retrieve thread scheduling policy.")); + wxLogSysError(rc, _("Failed to set thread concurrency level to %lu"), + static_cast(level)); + return false; } - int min_prio = sched_get_priority_min(prio), - max_prio = sched_get_priority_max(prio); + return true; +} - if ( min_prio == -1 || max_prio == -1 ) - { - wxLogError(_("Can not get priority range for scheduling policy %d."), - prio); - } - else +// ----------------------------------------------------------------------------- +// creating thread +// ----------------------------------------------------------------------------- + +wxThread::wxThread(wxThreadKind kind) +{ + // add this thread to the global list of all threads { - struct sched_param sp; - pthread_attr_getschedparam(&attr, &sp); - sp.sched_priority = min_prio + - (p_internal->GetPriority()*(max_prio-min_prio))/100; - pthread_attr_setschedparam(&attr, &sp); + wxMutexLocker lock(*gs_mutexAllThreads); + + gs_allThreads.Add(this); } -#endif // HAVE_THREAD_PRIORITY_FUNCTIONS - // create the new OS thread object - int rc = pthread_create(p_internal->GetIdPtr(), &attr, - wxThreadInternal::PthreadStart, (void *)this); - pthread_attr_destroy(&attr); + m_internal = new wxThreadInternal(); - if ( rc != 0 ) - { - p_internal->SetState(STATE_EXITED); - return wxTHREAD_NO_RESOURCE; - } + m_isDetached = kind == wxTHREAD_DETACHED; +} - return wxTHREAD_NO_ERROR; +wxThreadError wxThread::Create(unsigned int stackSize) +{ + wxCriticalSectionLocker lock(m_critsect); + + return m_internal->Create(this, stackSize); } wxThreadError wxThread::Run() { - return p_internal->Run(); + wxCriticalSectionLocker lock(m_critsect); + + // Create the thread if it wasn't created yet with an explicit + // Create() call: + if ( !m_internal->WasCreated() ) + { + wxThreadError rv = m_internal->Create(this, 0); + if ( rv != wxTHREAD_NO_ERROR ) + return rv; + } + + return m_internal->Run(); } // ----------------------------------------------------------------------------- @@ -510,38 +1345,55 @@ wxThreadError wxThread::Run() void wxThread::SetPriority(unsigned int prio) { - wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) && - ((int)prio <= (int)WXTHREAD_MAX_PRIORITY), - "invalid thread priority" ); + wxCHECK_RET( wxPRIORITY_MIN <= prio && prio <= wxPRIORITY_MAX, + wxT("invalid thread priority") ); wxCriticalSectionLocker lock(m_critsect); - switch ( p_internal->GetState() ) + switch ( m_internal->GetState() ) { case STATE_NEW: // thread not yet started, priority will be set when it is - p_internal->SetPriority(prio); + m_internal->SetPriority(prio); break; 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 0..100 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; - if ( pthread_setschedparam(p_internal->GetId(), + if ( pthread_setschedparam(m_internal->GetId(), SCHED_OTHER, &sparam) != 0 ) { wxLogError(_("Failed to set thread priority %d."), prio); } } +#endif // __LINUX__ #endif // HAVE_THREAD_PRIORITY_FUNCTIONS break; case STATE_EXITED: default: - wxFAIL_MSG("impossible to set thread priority in this state"); + wxFAIL_MSG(wxT("impossible to set thread priority in this state")); } } @@ -549,12 +1401,12 @@ unsigned int wxThread::GetPriority() const { wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); - return p_internal->GetPriority(); + return m_internal->GetPriority(); } -unsigned long wxThread::GetID() const +wxThreadIdType wxThread::GetId() const { - return (unsigned long)p_internal->GetId(); + return (wxThreadIdType) m_internal->GetId(); } // ----------------------------------------------------------------------------- @@ -563,35 +1415,53 @@ unsigned long wxThread::GetID() const wxThreadError wxThread::Pause() { + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + wxT("a thread can't pause itself") ); + wxCriticalSectionLocker lock(m_critsect); - if ( p_internal->GetState() != STATE_RUNNING ) + if ( m_internal->GetState() != STATE_RUNNING ) { - wxLogDebug("Can't pause thread which is not running."); + wxLogDebug(wxT("Can't pause thread which is not running.")); return wxTHREAD_NOT_RUNNING; } - p_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); return wxTHREAD_NO_ERROR; } wxThreadError wxThread::Resume() { + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + wxT("a thread can't resume itself") ); + wxCriticalSectionLocker lock(m_critsect); - if ( p_internal->GetState() == STATE_PAUSED ) - { - p_internal->Resume(); + wxThreadState state = m_internal->GetState(); - return wxTHREAD_NO_ERROR; - } - else + switch ( state ) { - wxLogDebug("Attempt to resume a thread which is not paused."); + case STATE_PAUSED: + wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."), + THR_ID(this)); - return wxTHREAD_MISC_ERROR; + m_internal->Resume(); + + return wxTHREAD_NO_ERROR; + + case STATE_EXITED: + wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."), + THR_ID(this)); + return wxTHREAD_NO_ERROR; + + default: + wxLogDebug(wxT("Attempt to resume a thread which is not paused.")); + + return wxTHREAD_MISC_ERROR; } } @@ -599,98 +1469,231 @@ wxThreadError wxThread::Resume() // exiting thread // ----------------------------------------------------------------------------- -wxThread::ExitCode wxThread::Delete() +wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode)) +{ + wxCHECK_MSG( This() != this, (ExitCode)-1, + wxT("a thread can't wait for itself") ); + + wxCHECK_MSG( !m_isDetached, (ExitCode)-1, + wxT("can't wait for detached thread") ); + + m_internal->Wait(); + + return m_internal->GetExitCode(); +} + +wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode)) { + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + wxT("a thread can't delete itself") ); + + bool isDetached = m_isDetached; + m_critsect.Enter(); - wxThreadState state = p_internal->GetState(); - m_critsect.Leave(); + wxThreadState state = m_internal->GetState(); // ask the thread to stop - p_internal->SetCancelFlag(); + m_internal->SetCancelFlag(); + + m_critsect.Leave(); + + OnDelete(); switch ( state ) { case STATE_NEW: + // we need to wake up the thread so that PthreadStart() will + // terminate - right now it's blocking on run semaphore in + // PthreadStart() + m_internal->SignalRun(); + + // fall through + case STATE_EXITED: // nothing to do break; case STATE_PAUSED: // resume the thread first - Resume(); + m_internal->Resume(); // fall through default: - // wait until the thread stops - p_internal->Wait(); + if ( !isDetached ) + { + // wait until the thread stops + m_internal->Wait(); + + if ( rc ) + { + // return the exit code of the thread + *rc = m_internal->GetExitCode(); + } + } + //else: can't wait for detached threads } - return NULL; + if (state == STATE_NEW) + return wxTHREAD_MISC_ERROR; + // for coherency with the MSW implementation, signal the user that + // Delete() was called on a thread which didn't start to run yet. + + return wxTHREAD_NO_ERROR; } wxThreadError wxThread::Kill() { - switch ( p_internal->GetState() ) + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + wxT("a thread can't kill itself") ); + + OnKill(); + + switch ( m_internal->GetState() ) { case STATE_NEW: case STATE_EXITED: return wxTHREAD_NOT_RUNNING; + case STATE_PAUSED: + // resume the thread first + Resume(); + + // fall through + default: -#ifdef HAVE_PTHREAD_CANCEL - if ( pthread_cancel(p_internal->GetId()) != 0 ) -#endif +#ifdef HAVE_PTHREAD_CANCEL + if ( pthread_cancel(m_internal->GetId()) != 0 ) +#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() +#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 // wxHAVE_PTHREAD_CLEANUP + } + else + { + m_internal->SetExitCode(EXITCODE_CANCELLED); + } + return wxTHREAD_NO_ERROR; +#endif // HAVE_PTHREAD_CANCEL } } -void wxThread::Exit(void *status) +void wxThread::Exit(ExitCode status) { - // first call user-level clean up code - OnExit(); + wxASSERT_MSG( This() == this, + wxT("wxThread::Exit() can only be called in the context of the same thread") ); + + if ( m_isDetached ) + { + // from the moment we call OnExit(), the main program may terminate at + // any moment, so mark this thread as being already in process of being + // deleted or wxThreadModule::OnExit() will try to delete it again + ScheduleThreadForDeletion(); + } - // next wake up the threads waiting for us (OTOH, this function won't return - // until someone waited for us!) - p_internal->SignalExit(); + // 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) + wxTRY + { + OnExit(); + } + wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) - p_internal->SetState(STATE_EXITED); + // delete C++ thread object if this is a detached thread - user is + // responsible for doing this for joinable ones + if ( m_isDetached ) + { + // FIXME I'm feeling bad about it - what if another thread function is + // called (in another thread context) now? It will try to access + // half destroyed object which will probably result in something + // very bad - but we can't protect this by a crit section unless + // 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(); + } - // delete both C++ thread object and terminate the OS thread object - delete this; + // terminate the thread (pthread_exit() never returns) pthread_exit(status); + + wxFAIL_MSG(wxT("pthread_exit() failed")); } // also test whether we were paused bool wxThread::TestDestroy() { - wxCriticalSectionLocker lock(m_critsect); + wxASSERT_MSG( This() == this, + wxT("wxThread::TestDestroy() can only be called in the context of the same thread") ); + + m_critsect.Enter(); - if ( p_internal->GetState() == STATE_PAUSED ) + if ( m_internal->GetState() == STATE_PAUSED ) { - // 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 - m_critsect.Leave(); + m_internal->SetReallyPaused(true); - p_internal->Pause(); + // 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 + m_critsect.Leave(); - // enter it back before it's finally left in lock object dtor - m_critsect.Enter(); + m_internal->Pause(); + } + else + { + // thread wasn't requested to pause, nothing to do + m_critsect.Leave(); } - return p_internal->WasCancelled(); + return m_internal->WasCancelled(); } wxThread::~wxThread() { + m_critsect.Enter(); + + // check that the thread either exited or couldn't be created + if ( m_internal->GetState() != STATE_EXITED && + m_internal->GetState() != STATE_NEW ) + { + wxLogDebug(wxT("The thread %p is being destroyed although it is still running! The application may crash."), + THR_ID(this)); + } + + m_critsect.Leave(); + + delete m_internal; + // remove this thread from the global array - gs_allThreads.Remove(this); + { + wxMutexLocker lock(*gs_mutexAllThreads); + + gs_allThreads.Remove(this); + } } // ----------------------------------------------------------------------------- @@ -701,28 +1704,40 @@ bool wxThread::IsRunning() const { wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); - return p_internal->GetState() == STATE_RUNNING; + return m_internal->GetState() == STATE_RUNNING; } bool wxThread::IsAlive() const { wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect); - switch ( p_internal->GetState() ) + switch ( m_internal->GetState() ) { case STATE_RUNNING: case STATE_PAUSED: - return TRUE; + return true; default: - return FALSE; + return false; } } +bool wxThread::IsPaused() const +{ + wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect); + + return (m_internal->GetState() == STATE_PAUSED); +} + //-------------------------------------------------------------------- // wxThreadModule //-------------------------------------------------------------------- +#ifdef __WXOSX__ +void wxOSXThreadModuleOnInit(); +void wxOSXThreadModuleOnExit(); +#endif + class wxThreadModule : public wxModule { public: @@ -737,62 +1752,148 @@ IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule) bool wxThreadModule::OnInit() { - if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 ) + int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */); + if ( rc != 0 ) { - wxLogError(_("Thread module initialization failed: " - "failed to create pthread key.")); + wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key")); - return FALSE; + return false; } - gs_mutexGui = new wxMutex(); + wxThread::ms_idMainThread = wxThread::GetCurrentId(); - //wxThreadGuiInit(); + gs_mutexAllThreads = new wxMutex(); - gs_tidMain = pthread_self(); +#ifdef __WXOSX__ + wxOSXThreadModuleOnInit(); +#else + gs_mutexGui = new wxMutex(); gs_mutexGui->Lock(); +#endif - return TRUE; + gs_mutexDeleteThread = new wxMutex(); + gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread); + + return true; } void wxThreadModule::OnExit() { - wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" ); + wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") ); + + // are there any threads left which are being deleted right now? + size_t nThreadsBeingDeleted; + + { + wxMutexLocker lock( *gs_mutexDeleteThread ); + nThreadsBeingDeleted = gs_nThreadsBeingDeleted; + + if ( nThreadsBeingDeleted > 0 ) + { + wxLogTrace(TRACE_THREADS, + wxT("Waiting for %lu threads to disappear"), + (unsigned long)nThreadsBeingDeleted); + + // have to wait until all of them disappear + gs_condAllDeleted->Wait(); + } + } + + size_t count; + + { + wxMutexLocker lock(*gs_mutexAllThreads); - // terminate any threads left - size_t count = gs_allThreads.GetCount(); - if ( count != 0u ) - wxLogDebug("Some threads were not terminated by the application."); + // 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++ ) { - gs_allThreads[n]->Delete(); + // Delete calls the destructor which removes the current entry. We + // should only delete the first one each time. + gs_allThreads[0]->Delete(); } + delete gs_mutexAllThreads; + +#ifdef __WXOSX__ + wxOSXThreadModuleOnExit(); +#else // destroy GUI mutex gs_mutexGui->Unlock(); - - //wxThreadGuiExit(); - delete gs_mutexGui; +#endif // and free TLD slot (void)pthread_key_delete(gs_keySelf); + + delete gs_condAllDeleted; + delete gs_mutexDeleteThread; } // ---------------------------------------------------------------------------- // global functions // ---------------------------------------------------------------------------- -void wxMutexGuiEnter() +static void ScheduleThreadForDeletion() +{ + wxMutexLocker lock( *gs_mutexDeleteThread ); + + gs_nThreadsBeingDeleted++; + + wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"), + (unsigned long)gs_nThreadsBeingDeleted, + gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s")); +} + +static void DeleteThread(wxThread *This) +{ + wxLogTrace(TRACE_THREADS, wxT("Thread %p auto deletes."), THR_ID(This)); + + delete This; + + // only lock gs_mutexDeleteThread after deleting the thread to avoid + // calling out into user code with it locked as this may result in + // deadlocks if the thread dtor deletes another thread (see #11501) + wxMutexLocker locker( *gs_mutexDeleteThread ); + + wxCHECK_RET( gs_nThreadsBeingDeleted > 0, + wxT("no threads scheduled for deletion, yet we delete one?") ); + + wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."), + (unsigned long)gs_nThreadsBeingDeleted - 1); + + if ( !--gs_nThreadsBeingDeleted ) + { + // no more threads left, signal it + gs_condAllDeleted->Signal(); + } +} + +#ifndef __DARWIN__ + +void wxMutexGuiEnterImpl() { - gs_mutexGui->Lock(); + gs_mutexGui->Lock(); } -void wxMutexGuiLeave() +void wxMutexGuiLeaveImpl() { - gs_mutexGui->Unlock(); + gs_mutexGui->Unlock(); } #endif - // wxUSE_THREADS + +// ---------------------------------------------------------------------------- +// include common implementation code +// ---------------------------------------------------------------------------- + +#include "wx/thrimpl.cpp" + +#endif // wxUSE_THREADS