X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8d5eff606ae62a36ea2ccecc017a810081cdc22d..11a2ce5ad289cb21b35cc21131b46f75dd4af060:/src/unix/threadpsx.cpp?ds=inline diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index f097dd3af2..47e9a41e62 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -2,13 +2,14 @@ // Name: threadpsx.cpp // Purpose: wxThread (Posix) Implementation // Author: Original from Wolfram Gloger/Guilhem Lavaux -// 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-2002) // Robert Roebling (1999) +// K. S. Sreeram (2002) // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -34,6 +35,7 @@ #include "wx/log.h" #include "wx/intl.h" #include "wx/dynarray.h" +#include "wx/timer.h" #include #include @@ -51,6 +53,9 @@ // we use wxFFile under Linux in GetCPUCount() #ifdef __LINUX__ #include "wx/ffile.h" + // For setpriority. + #include + #include #endif // ---------------------------------------------------------------------------- @@ -69,17 +74,11 @@ 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") -// ---------------------------------------------------------------------------- -// pseudo template types -// ---------------------------------------------------------------------------- - -WX_DECLARE_LIST(pthread_mutex_t, wxMutexList); - -#include "wx/listimpl.cpp" -WX_DEFINE_LIST(wxMutexList); +// you can get additional debugging messages for the semaphore operations +#define TRACE_SEMA _T("semaphore") // ---------------------------------------------------------------------------- // private functions @@ -92,37 +91,11 @@ static void DeleteThread(wxThread *This); // private classes // ---------------------------------------------------------------------------- -// same as wxMutexLocker but for "native" mutex -class MutexLock -{ -public: - MutexLock(pthread_mutex_t& mutex) - { - m_mutex = &mutex; - if ( pthread_mutex_lock(m_mutex) != 0 ) - { - wxLogDebug(_T("pthread_mutex_lock() failed")); - } - } - - ~MutexLock() - { - if ( pthread_mutex_unlock(m_mutex) != 0 ) - { - wxLogDebug(_T("pthread_mutex_unlock() failed")); - } - } - -private: - pthread_mutex_t *m_mutex; -}; - -// ---------------------------------------------------------------------------- -// types -// ---------------------------------------------------------------------------- - +// an (non owning) array of pointers to threads WX_DEFINE_ARRAY(wxThread *, wxArrayThread); +// an entry for a thread we can wait for + // ----------------------------------------------------------------------------- // global data // ----------------------------------------------------------------------------- @@ -143,7 +116,7 @@ static pthread_key_t gs_keySelf; static size_t gs_nThreadsBeingDeleted = 0; // a mutex to protect gs_nThreadsBeingDeleted -static pthread_mutex_t gs_mutexDeleteThread; +static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL; // and a condition variable which will be signaled when all // gs_nThreadsBeingDeleted will have been deleted @@ -154,6 +127,15 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL; static wxMutex *gs_mutexGui; #endif // wxUSE_GUI +// 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 // ============================================================================ @@ -162,49 +144,86 @@ 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 TryLock(); wxMutexError Unlock(); + bool IsOk() const { return m_isOk; } + private: pthread_mutex_t m_mutex; + bool m_isOk; + + // wxConditionInternal uses our m_mutex + friend class wxConditionInternal; }; -wxMutexInternal::wxMutexInternal() +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 + 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() @@ -213,20 +232,23 @@ wxMutexError wxMutexInternal::Lock() 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_lock(): mutex not initialized.")); + break; case 0: return wxMUTEX_NO_ERROR; + + default: + wxLogApiError(_T("pthread_mutex_lock()"), err); } + + return wxMUTEX_MISC_ERROR; } wxMutexError wxMutexInternal::TryLock() @@ -235,19 +257,22 @@ wxMutexError wxMutexInternal::TryLock() 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: return wxMUTEX_NO_ERROR; + + default: + wxLogApiError(_T("pthread_mutex_trylock()"), err); } + + return wxMUTEX_MISC_ERROR; } wxMutexError wxMutexInternal::Unlock() @@ -259,374 +284,285 @@ 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; + + default: + wxLogApiError(_T("pthread_mutex_unlock()"), err); } + + return wxMUTEX_MISC_ERROR; } -// ---------------------------------------------------------------------------- -// wxMutex -// ---------------------------------------------------------------------------- +// =========================================================================== +// wxCondition implementation +// =========================================================================== -// TODO: this is completely generic, move it to common code? +// --------------------------------------------------------------------------- +// wxConditionInternal +// --------------------------------------------------------------------------- -wxMutex::wxMutex() +// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence +// with a pthread_mutex_t) +class wxConditionInternal { - m_internal = new wxMutexInternal; +public: + wxConditionInternal(wxMutex& mutex); + ~wxConditionInternal(); - m_locked = 0; -} + bool IsOk() const { return m_isOk && m_mutex.IsOk(); } -wxMutex::~wxMutex() -{ - if ( m_locked > 0 ) - wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked); + wxCondError Wait(); + wxCondError WaitTimeout(unsigned long milliseconds); - delete m_internal; -} + wxCondError Signal(); + wxCondError Broadcast(); -wxMutexError wxMutex::Lock() -{ - wxMutexError err = m_internal->Lock(); +private: + // get the POSIX mutex associated with us + pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; } - if ( !err ) - { - m_locked++; - } + wxMutex& m_mutex; + pthread_cond_t m_cond; - return err; -} + bool m_isOk; +}; -wxMutexError wxMutex::TryLock() +wxConditionInternal::wxConditionInternal(wxMutex& mutex) + : m_mutex(mutex) { - 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 - } + int err = pthread_cond_init(&m_cond, NULL /* default attributes */); - wxMutexError err = m_internal->TryLock(); - if ( !err ) + m_isOk = err == 0; + + if ( !m_isOk ) { - m_locked++; + wxLogApiError(_T("pthread_cond_init()"), err); } - - return 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(_T("pthread_cond_destroy()"), err); + } } - else +} + +wxCondError wxConditionInternal::Wait() +{ + int err = pthread_cond_wait(&m_cond, GetPMutex()); + if ( err != 0 ) { - wxLogDebug(wxT("Unlocking not locked mutex.")); + wxLogApiError(_T("pthread_cond_wait()"), err); - return wxMUTEX_UNLOCKED; + return wxCOND_MISC_ERROR; } - return m_internal->Unlock(); + return wxCOND_NO_ERROR; } -// ============================================================================ -// wxCondition implementation -// ============================================================================ - -// ---------------------------------------------------------------------------- -// wxConditionInternal -// ---------------------------------------------------------------------------- - -// The native POSIX condition variables are dumb: if the condition is signaled -// before another thread starts to wait on it, the signal is lost and so this -// other thread will be never woken up. It's much more convenient to us to -// remember that the condition was signaled and to return from Wait() -// immediately in this case (this is more like Win32 automatic event objects) -class wxConditionInternal +wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds) { -public: - wxConditionInternal(); - ~wxConditionInternal(); + wxLongLong curtime = wxGetLocalTimeMillis(); + curtime += milliseconds; + wxLongLong temp = curtime / 1000; + int sec = temp.GetLo(); + temp *= 1000; + temp = curtime - temp; + int millis = temp.GetLo(); - // wait with the given timeout or indefinitely if NULL - bool Wait(const timespec* ts = NULL); + timespec tspec; - void Signal(bool all = FALSE); + tspec.tv_sec = sec; + tspec.tv_nsec = millis * 1000L * 1000L; -private: - // the number of Signal() calls queued - // - // changed by Signal(), accessed by Wait() - // - // protected by m_mutexSignalCount - size_t m_nSignalsMissed; - - // protects access to m_nSignalsMissed - pthread_mutex_t m_mutexSignalCount; - - // serializes Broadcast() and/or Signal() calls - // - // TODO: I'm not sure if this is really needed but it shouldn't harm - // neither (except for efficiency condierations). However MSW doesn't - // do this so maybe we shouldn't do it here neither? (VZ) - pthread_mutex_t m_mutexSignal; - - // a condition variable must be always used with a mutex and so we maintain - // a list of mutexes - one for each thread that calls Wait(). - // - // access to this list must be protected by m_mutexListContents - wxMutexList m_mutexes; - - // the condition itself - pthread_cond_t m_condition; - - // protects all accesses to m_mutexes list - pthread_mutex_t m_mutexListContents; -}; + int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec ); + switch ( err ) + { + case ETIMEDOUT: + return wxCOND_TIMEOUT; -wxConditionInternal::wxConditionInternal() -{ - m_nSignalsMissed = 0; + case 0: + return wxCOND_NO_ERROR; - if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 ) - { - // this is supposed to never happen - wxFAIL_MSG( _T("pthread_cond_init() failed") ); + default: + wxLogApiError(_T("pthread_cond_timedwait()"), err); } - if ( pthread_mutex_init(&m_mutexSignalCount, NULL) != 0 || - pthread_mutex_init(&m_mutexListContents, NULL) != 0 || - pthread_mutex_init(&m_mutexSignal, NULL) != 0 ) - { - // neither this - wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") ); - } + return wxCOND_MISC_ERROR; } -wxConditionInternal::~wxConditionInternal() +wxCondError wxConditionInternal::Signal() { - if ( pthread_cond_destroy( &m_condition ) != 0 ) + int err = pthread_cond_signal(&m_cond); + if ( err != 0 ) { - wxLogDebug(_T("Failed to destroy condition variable (some " - "threads are probably still waiting on it?)")); - } - - // the list of waiters mutexes must be empty by now - wxASSERT_MSG( !m_mutexes.GetFirst(), - _T("deleting condition someone is still waiting on?") ); + wxLogApiError(_T("pthread_cond_signal()"), err); - if ( pthread_mutex_destroy( &m_mutexSignalCount ) != 0 || - pthread_mutex_destroy( &m_mutexListContents ) != 0 || - pthread_mutex_destroy( &m_mutexSignal ) != 0 ) - { - wxLogDebug(_T("Failed to destroy mutex (it is probably locked)")); + return wxCOND_MISC_ERROR; } + + return wxCOND_NO_ERROR; } -bool wxConditionInternal::Wait(const timespec* ts) +wxCondError wxConditionInternal::Broadcast() { + int err = pthread_cond_broadcast(&m_cond); + if ( err != 0 ) { - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Wait: about to lock missed signal counter"), - this); + wxLogApiError(_T("pthread_cond_broadcast()"), err); - MutexLock lock(m_mutexSignalCount); + return wxCOND_MISC_ERROR; + } - if ( m_nSignalsMissed ) - { - // the condition was signaled before we started to wait, just - // decrease the number of queued signals and return - m_nSignalsMissed--; + return wxCOND_NO_ERROR; +} - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Wait: not waiting at all, count = %u"), - this, m_nSignalsMissed); +// =========================================================================== +// wxSemaphore implementation +// =========================================================================== - return TRUE; - } - } +// --------------------------------------------------------------------------- +// wxSemaphoreInternal +// --------------------------------------------------------------------------- - // we need to really wait, create a new mutex for this - pthread_mutex_t *mutex = new pthread_mutex_t; - if ( pthread_mutex_init(mutex, (pthread_mutexattr_t *)NULL) != 0 ) - { - // not supposed to happen - wxFAIL_MSG( _T("pthread_mutex_init() failed when starting waiting") ); - } +// 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); - // lock the mutex before starting to wait on it - pthread_mutex_lock(mutex); + bool IsOk() const { return m_isOk; } - // lock the list before modifying it - wxMutexList::Node *mutexNode; - { - MutexLock lockList(m_mutexListContents); + wxSemaError Wait(); + wxSemaError TryWait(); + wxSemaError WaitTimeout(unsigned long milliseconds); - mutexNode = m_mutexes.Append(mutex); - } + wxSemaError Post(); - // calling wait function below unlocks the mutex and Signal() or - // Broadcast() will be able to continue to run now if they were - // blocking for it in the loop locking all mutexes) - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Wait(): starting to wait"), this); - int err = ts ? pthread_cond_timedwait(&m_condition, mutex, ts) - : pthread_cond_wait(&m_condition, mutex); - switch ( err ) - { - case 0: - // condition was signaled - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Wait(): ok"), this); - break; +private: + wxMutex m_mutex; + wxCondition m_cond; - default: - wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return")); - // fall through + size_t m_count, + m_maxcount; - case ETIMEDOUT: - case EINTR: - // wait interrupted or timeout elapsed - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Wait(): timeout/intr"), this); - } + bool m_isOk; +}; - // delete the mutex we had used for waiting - { - MutexLock lock(m_mutexListContents); +wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) + : m_cond(m_mutex) +{ - pthread_mutex_t *m = mutexNode->GetData(); - pthread_mutex_unlock(m); - pthread_mutex_destroy(m); - delete m; + if ( (initialcount < 0 || maxcount < 0) || + ((maxcount > 0) && (initialcount > maxcount)) ) + { + wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") ); - m_mutexes.DeleteNode(mutexNode); + m_isOk = FALSE; + } + else + { + m_maxcount = (size_t)maxcount; + m_count = (size_t)initialcount; } - return err == 0; + m_isOk = m_mutex.IsOk() && m_cond.IsOk(); } -void wxConditionInternal::Signal(bool all) +wxSemaError wxSemaphoreInternal::Wait() { - // make sure that only one Signal() or Broadcast() is in progress - MutexLock lock(m_mutexSignal); - - // this mutex has to be locked as well, so that during the entire Signal() - // call, no new Wait() is going to wreak havoc (it will block in the very - // beginning on this mutex instead) - MutexLock lockSignalCount(m_mutexSignalCount); - - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Signal(): got signal count mutex"), - this); + wxMutexLocker locker(m_mutex); + while ( m_count == 0 ) { - MutexLock lockList(m_mutexListContents); - - if ( !m_mutexes.GetFirst() ) - { - // nobody is waiting for us, just remember that the condition was - // signaled and don't do anything else for now - m_nSignalsMissed++; + wxLogTrace(TRACE_SEMA, + "Thread %ld waiting for semaphore to become signalled", + wxThread::GetCurrentId()); - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Signal(): no waiters, count = %u"), - this, m_nSignalsMissed); + if ( m_cond.Wait() != wxCOND_NO_ERROR ) + return wxSEMA_MISC_ERROR; - return; - } + wxLogTrace(TRACE_SEMA, + "Thread %ld finished waiting for semaphore, count = %u", + wxThread::GetCurrentId(), m_count); } - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Signal(): acquiring all mutexes"), this); + m_count--; - // All mutexes on the list have to be locked. This means that execution of - // Signal() goes on as soon as all pending Wait() calls have called - // pthread_cond_wait() (where the mutex gets unlocked internally) - wxMutexList::Node *node; - for ( node = m_mutexes.GetFirst(); node; node = node->GetNext() ) - { - pthread_mutex_lock(node->GetData()); - } + return wxSEMA_NO_ERROR; +} - // now we can finally signal it - wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"), - this, all ? _T("broadcast") : _T("signal")); +wxSemaError wxSemaphoreInternal::TryWait() +{ + wxMutexLocker locker(m_mutex); - int err = all ? pthread_cond_broadcast(&m_condition) - : pthread_cond_signal(&m_condition); - if ( err ) - { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed")); - } + if ( m_count == 0 ) + return wxSEMA_BUSY; - // unlock all mutexes so that the threads blocking in their Wait()s could - // continue running - for ( node = m_mutexes.GetFirst(); node; node = node->GetNext() ) - { - pthread_mutex_unlock(node->GetData()); - } + m_count--; - wxLogTrace(TRACE_THREADS, - _T("wxCondition(%08x)::Signal(): exiting"), this); + return wxSEMA_NO_ERROR; } -// ---------------------------------------------------------------------------- -// wxCondition -// ---------------------------------------------------------------------------- - -wxCondition::wxCondition() +wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds) { - m_internal = new wxConditionInternal; -} + wxMutexLocker locker(m_mutex); -wxCondition::~wxCondition() -{ - delete m_internal; -} + wxLongLong startTime = wxGetLocalTimeMillis(); -void wxCondition::Wait() -{ - (void)m_internal->Wait(); -} + while ( m_count == 0 ) + { + wxLongLong elapsed = wxGetLocalTimeMillis() - startTime; + long remainingTime = (long)milliseconds - (long)elapsed.GetLo(); + if ( remainingTime <= 0 ) + { + // timeout + return wxSEMA_TIMEOUT; + } -bool wxCondition::Wait(unsigned long sec, unsigned long nsec) -{ - timespec tspec; + if ( m_cond.Wait(remainingTime) != wxCOND_NO_ERROR ) + return wxSEMA_MISC_ERROR; + } - tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here? - tspec.tv_nsec = nsec; + m_count--; - return m_internal->Wait(&tspec); + return wxSEMA_NO_ERROR; } -void wxCondition::Signal() +wxSemaError wxSemaphoreInternal::Post() { - m_internal->Signal(); -} + wxMutexLocker locker(m_mutex); -void wxCondition::Broadcast() -{ - m_internal->Signal(TRUE /* all */); + if ( m_maxcount > 0 && m_count == m_maxcount ) + { + return wxSEMA_OVERFLOW; + } + + m_count++; + + wxLogTrace(TRACE_SEMA, + "Thread %ld about to signal semaphore, count = %u", + wxThread::GetCurrentId(), m_count); + + return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR + : wxSEMA_MISC_ERROR; } -// ============================================================================ +// =========================================================================== // wxThread implementation -// ============================================================================ +// =========================================================================== // the thread callback functions must have the C linkage extern "C" @@ -657,12 +593,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_condRun.Signal(); } // go to sleep until Resume() is called void Pause(); // resume the thread @@ -674,7 +608,23 @@ 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 %ld: %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; } @@ -692,12 +642,11 @@ public: // tell the thread that it is a detached one void Detach() { - m_shouldBeJoined = m_shouldBroadcast = FALSE; + 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 // this is used by wxPthreadCleanup() only @@ -712,7 +661,7 @@ private: // this flag is set when the thread should terminate bool m_cancelled; - // this flag is set when the thread is blocking on m_condSuspend + // this flag is set when the thread is blocking on m_semSuspend bool m_isPaused; // the thread exit code - only used for joinable (!detached) threads and @@ -723,25 +672,15 @@ private: // pthread_join(), so we have to keep track of this wxCriticalSection m_csJoinFlag; bool m_shouldBeJoined; - bool m_shouldBroadcast; bool m_isDetached; - // VZ: it's possible that we might do with less than three different - // condition objects - for example, m_condRun and m_condEnd a priori - // won't be used in the same time. But for now I prefer this may be a - // bit less efficient but safer solution of having distinct condition - // variables for each purpose. - - // this condition is signaled by Run() and the threads Entry() is not + // this semaphore is posted by Run() and the threads Entry() is not // called before it is done - wxCondition m_condRun; + wxSemaphore m_semRun; // this one is signaled when the thread should resume after having been // Pause()d - wxCondition m_condSuspend; - - // finally this one is signalled when the thread exits - wxCondition m_condEnd; + wxSemaphore m_semSuspend; }; // ---------------------------------------------------------------------------- @@ -779,8 +718,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) pthread_cleanup_push(wxPthreadCleanup, thread); #endif // HAVE_THREAD_CLEANUP_FUNCTIONS - // wait for the condition to be signaled from Run() - pthread->m_condRun.Wait(); + // wait for the semaphore to be posted from Run() + pthread->m_semRun.Wait(); // test whether we should run the run at all - may be it was deleted // before it started to Run()? @@ -794,17 +733,17 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) if ( !dontRunAtAll ) { // call the main entry + wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."), + pthread->GetId()); + pthread->m_exitcode = thread->Entry(); - wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."), - pthread->GetId()); + wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."), + pthread->GetId(), (unsigned long)pthread->m_exitcode); { 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) @@ -822,6 +761,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) if ( dontRunAtAll ) { + // FIXME: deleting a possibly joinable thread here??? delete thread; return EXITCODE_CANCELLED; @@ -874,12 +814,11 @@ wxThreadInternal::wxThreadInternal() m_threadId = 0; m_exitcode = 0; - // set to TRUE only when the thread starts waiting on m_condSuspend + // 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; } @@ -892,38 +831,29 @@ 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 = GetId(); - wxLogTrace(TRACE_THREADS, - _T("Starting to wait for thread %ld to exit."), id); - - // wait until the thread terminates (we're blocking in _another_ thread, - // of course) - m_condEnd.Wait(); - - wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id); + _T("Starting to wait for thread %ld to exit."), GetId()); - // 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 ) @@ -932,8 +862,12 @@ 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((pthread_t)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")); } @@ -947,22 +881,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.Broadcast(); - } -} - void wxThreadInternal::Pause() { // the state is set from the thread which pauses us first, this function @@ -972,8 +890,8 @@ void wxThreadInternal::Pause() wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId()); - // wait until the condition is signaled from Resume() - m_condSuspend.Wait(); + // wait until the semaphore is Post()ed from Resume() + m_semSuspend.Wait(); } void wxThreadInternal::Resume() @@ -988,7 +906,7 @@ void wxThreadInternal::Resume() wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId()); // wake up Pause() - m_condSuspend.Signal(); + m_semSuspend.Post(); // reset the flag SetReallyPaused(FALSE); @@ -1257,6 +1175,45 @@ 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. + { + float fPrio; + float pSpan; + int iPrio; + + // Map Wx priorites (WXTHREAD_MIN_PRIORITY - + // WXTHREAD_MAX_PRIORITY) into BSD priorities (20 - -20). + // Do calculation of values instead of hard coding them + // to make maintenance easier. + + pSpan = ((float)(WXTHREAD_MAX_PRIORITY - WXTHREAD_MIN_PRIORITY)) / 2.0; + + // prio starts as ................... // value => (0) >= p <= (n) + + fPrio = ((float)prio) - pSpan; // value => (-n) >= p <= (+n) + + fPrio = 0.0 - fPrio; // value => (+n) <= p >= (-n) + + fPrio = fPrio * (20. / pSpan) + .5; // value => (20) <= p >= (-20) + + iPrio = (int)fPrio; + + // Clamp prio from 20 - -20; + iPrio = (iPrio > 20) ? 20 : iPrio; + iPrio = (iPrio < -20) ? -20 : iPrio; + + if (setpriority(PRIO_PROCESS, 0, iPrio) == -1) + { + wxLogError(_("Failed to set thread priority %d."), prio); + } + } +#else // __LINUX__ { struct sched_param sparam; sparam.sched_priority = prio; @@ -1267,6 +1224,7 @@ void wxThread::SetPriority(unsigned int prio) wxLogError(_("Failed to set thread priority %d."), prio); } } +#endif // __LINUX__ #endif // HAVE_THREAD_PRIORITY_FUNCTIONS break; @@ -1285,7 +1243,7 @@ unsigned int wxThread::GetPriority() const wxThreadIdType wxThread::GetId() const { - return m_internal->GetId(); + return (wxThreadIdType) m_internal->GetId(); } // ----------------------------------------------------------------------------- @@ -1306,9 +1264,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); @@ -1369,27 +1324,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_condRun + // terminate - right now it's blocking on run semaphore in + // PthreadStart() m_internal->SignalRun(); // fall through @@ -1399,24 +1349,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; @@ -1477,10 +1427,13 @@ void wxThread::Exit(ExitCode status) _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 @@ -1488,17 +1441,6 @@ void wxThread::Exit(ExitCode status) // m_critsect on us (almost all of them do) OnExit(); - // now do enter it because SignalExit() will change our state - m_critsect.Enter(); - - // next wake up the threads waiting for us (OTOH, this function won't return - // until someone waited for us!) - m_internal->SignalExit(); - - // leave the critical section before entering the dtor which tries to - // enter it - m_critsect.Leave(); - // delete C++ thread object if this is a detached thread - user is // responsible for doing this for joinable ones if ( m_isDetached ) @@ -1567,17 +1509,6 @@ wxThread::~wxThread() // remove this thread from the global array gs_allThreads.Remove(this); - - // detached thread will decrement this counter in DeleteThread(), but it - // is not called for the joinable threads, so do it here - if ( !m_isDetached ) - { - MutexLock lock(gs_mutexDeleteThread); - gs_nThreadsBeingDeleted--; - - wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), - gs_nThreadsBeingDeleted - 1); - } } // ----------------------------------------------------------------------------- @@ -1648,9 +1579,8 @@ bool wxThreadModule::OnInit() gs_mutexGui->Lock(); #endif // wxUSE_GUI - // under Solaris we get a warning from CC when using - // PTHREAD_MUTEX_INITIALIZER, so do it dynamically - pthread_mutex_init(&gs_mutexDeleteThread, NULL); + gs_mutexDeleteThread = new wxMutex(); + gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread ); return TRUE; } @@ -1661,18 +1591,19 @@ void wxThreadModule::OnExit() // are there any threads left which are being deleted right now? size_t nThreadsBeingDeleted; + { - MutexLock lock(gs_mutexDeleteThread); + wxMutexLocker lock( *gs_mutexDeleteThread ); nThreadsBeingDeleted = gs_nThreadsBeingDeleted; - } - if ( nThreadsBeingDeleted > 0 ) - { - wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"), - nThreadsBeingDeleted); + if ( nThreadsBeingDeleted > 0 ) + { + wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"), + nThreadsBeingDeleted); - // have to wait until all of them disappear - gs_condAllDeleted->Wait(); + // have to wait until all of them disappear + gs_condAllDeleted->Wait(); + } } // terminate any threads left @@ -1699,6 +1630,9 @@ void wxThreadModule::OnExit() // and free TLD slot (void)pthread_key_delete(gs_keySelf); + + delete gs_condAllDeleted; + delete gs_mutexDeleteThread; } // ---------------------------------------------------------------------------- @@ -1707,12 +1641,7 @@ void wxThreadModule::OnExit() static void ScheduleThreadForDeletion() { - MutexLock lock(gs_mutexDeleteThread); - - if ( gs_nThreadsBeingDeleted == 0 ) - { - gs_condAllDeleted = new wxCondition; - } + wxMutexLocker lock( *gs_mutexDeleteThread ); gs_nThreadsBeingDeleted++; @@ -1725,17 +1654,14 @@ static void DeleteThread(wxThread *This) { // gs_mutexDeleteThread should be unlocked before signalling the condition // or wxThreadModule::OnExit() would deadlock - { - MutexLock lock(gs_mutexDeleteThread); + wxMutexLocker locker( *gs_mutexDeleteThread ); - wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); + wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); - delete This; + delete This; - wxCHECK_RET( gs_nThreadsBeingDeleted > 0, - _T("no threads scheduled for deletion, yet we delete " - "one?") ); - } + wxCHECK_RET( gs_nThreadsBeingDeleted > 0, + _T("no threads scheduled for deletion, yet we delete one?") ); wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), gs_nThreadsBeingDeleted - 1); @@ -1744,9 +1670,6 @@ static void DeleteThread(wxThread *This) { // no more threads left, signal it gs_condAllDeleted->Signal(); - - delete gs_condAllDeleted; - gs_condAllDeleted = (wxCondition *)NULL; } } @@ -1764,5 +1687,11 @@ void wxMutexGuiLeave() #endif // wxUSE_GUI } -#endif - // wxUSE_THREADS +// ---------------------------------------------------------------------------- +// include common implementation code +// ---------------------------------------------------------------------------- + +#include "wx/thrimpl.cpp" + +#endif // wxUSE_THREADS +