X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a7aef4a92a72f7c8bd251893190ee60702dbddc1..df0dc216ad7c5ace4d80c9afc866f3c002b7b09d:/src/unix/threadpsx.cpp?ds=inline diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index e10fe97e82..5e8ba13423 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -7,7 +7,7 @@ // RCS-ID: $Id$ // Copyright: (c) Wolfram Gloger (1996, 1997) // Guilhem Lavaux (1998) -// Vadim Zeitlin (1999) +// Vadim Zeitlin (1999-2002) // Robert Roebling (1999) // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -40,7 +40,6 @@ #include #include #include - #if HAVE_SCHED_H #include #endif @@ -73,6 +72,15 @@ static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1; // our trace mask #define TRACE_THREADS _T("thread") +// ---------------------------------------------------------------------------- +// pseudo template types +// ---------------------------------------------------------------------------- + +WX_DECLARE_LIST(pthread_mutex_t, wxMutexList); + +#include "wx/listimpl.cpp" +WX_DEFINE_LIST(wxMutexList); + // ---------------------------------------------------------------------------- // private functions // ---------------------------------------------------------------------------- @@ -147,23 +155,29 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL; #endif // wxUSE_GUI // ============================================================================ -// implementation +// wxMutex implementation // ============================================================================ -//-------------------------------------------------------------------- -// wxMutex (Posix implementation) -//-------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// wxMutexInternal +// ---------------------------------------------------------------------------- class wxMutexInternal { public: + wxMutexInternal(); + ~wxMutexInternal(); + + wxMutexError Lock(); + wxMutexError TryLock(); + wxMutexError Unlock(); + +private: pthread_mutex_t m_mutex; }; -wxMutex::wxMutex() +wxMutexInternal::wxMutexInternal() { - m_internal = new wxMutexInternal; - // support recursive locks like Win32, i.e. a thread can lock a mutex which // it had itself already locked // @@ -174,64 +188,147 @@ wxMutex::wxMutex() pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(&(m_internal->m_mutex), &attr); + 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_internal->m_mutex = mutex; + m_mutex = mutex; #else // no recursive mutexes - pthread_mutex_init(&(m_internal->m_mutex), NULL); + pthread_mutex_init(&m_mutex, NULL); + + // used by TryLock() below + #define NO_RECURSIVE_MUTEXES #endif // HAVE_PTHREAD_MUTEXATTR_T/... +} + +wxMutexInternal::~wxMutexInternal() +{ + pthread_mutex_destroy(&m_mutex); +} + +wxMutexError wxMutexInternal::Lock() +{ + int err = pthread_mutex_lock(&m_mutex); + switch ( err ) + { + case EDEADLK: + wxLogDebug(wxT("Locking this mutex would lead to deadlock!")); + return wxMUTEX_DEAD_LOCK; + + default: + wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") ); + // fall through + + case EINVAL: + wxLogDebug(_T("Failed to lock the mutex.")); + return wxMUTEX_MISC_ERROR; + + case 0: + return wxMUTEX_NO_ERROR; + } +} + +wxMutexError wxMutexInternal::TryLock() +{ + int err = pthread_mutex_trylock(&m_mutex); + switch ( err ) + { + case EBUSY: + return wxMUTEX_BUSY; + + default: + wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") ); + // fall through + + case EINVAL: + wxLogDebug(_T("Failed to try to lock the mutex.")); + return wxMUTEX_MISC_ERROR; + + case 0: + return wxMUTEX_NO_ERROR; + } +} + +wxMutexError wxMutexInternal::Unlock() +{ + int err = pthread_mutex_unlock(&m_mutex); + switch ( err ) + { + case EPERM: + // we don't own the mutex + return wxMUTEX_UNLOCKED; + + default: + wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") ); + // fall through + + case EINVAL: + wxLogDebug(_T("Failed to unlock the mutex.")); + return wxMUTEX_MISC_ERROR; + + case 0: + return wxMUTEX_NO_ERROR; + } +} + +// ---------------------------------------------------------------------------- +// wxMutex +// ---------------------------------------------------------------------------- + +// TODO: this is completely generic, move it to common code? + +wxMutex::wxMutex() +{ + m_internal = new wxMutexInternal; m_locked = 0; } wxMutex::~wxMutex() { - if (m_locked > 0) + if ( m_locked > 0 ) wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked); - pthread_mutex_destroy( &(m_internal->m_mutex) ); delete m_internal; } wxMutexError wxMutex::Lock() { - int err = pthread_mutex_lock( &(m_internal->m_mutex) ); - if (err == EDEADLK) - { - wxLogDebug(wxT("Locking this mutex would lead to deadlock!")); + wxMutexError err = m_internal->Lock(); - return wxMUTEX_DEAD_LOCK; + if ( !err ) + { + m_locked++; } - m_locked++; - - return wxMUTEX_NO_ERROR; + return err; } wxMutexError wxMutex::TryLock() { - if (m_locked) + if ( m_locked ) { - return wxMUTEX_BUSY; +#ifdef NO_RECURSIVE_MUTEXES + return wxMUTEX_DEAD_LOCK; +#else // have recursive mutexes on this platform + // we will succeed in locking it when we have it already locked + return wxMUTEX_NO_ERROR; +#endif // recursive/non-recursive mutexes } - int err = pthread_mutex_trylock( &(m_internal->m_mutex) ); - switch (err) + wxMutexError err = m_internal->TryLock(); + if ( !err ) { - case EBUSY: return wxMUTEX_BUSY; + m_locked++; } - m_locked++; - - return wxMUTEX_NO_ERROR; + return err; } wxMutexError wxMutex::Unlock() { - if (m_locked > 0) + if ( m_locked > 0 ) { m_locked--; } @@ -242,51 +339,51 @@ wxMutexError wxMutex::Unlock() return wxMUTEX_UNLOCKED; } - pthread_mutex_unlock( &(m_internal->m_mutex) ); - - return wxMUTEX_NO_ERROR; + return m_internal->Unlock(); } -//-------------------------------------------------------------------- -// wxCondition (Posix implementation) -//-------------------------------------------------------------------- +// ============================================================================ +// 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 { public: wxConditionInternal(); ~wxConditionInternal(); - void Wait(); - bool WaitWithTimeout(const timespec* ts); + // wait with the given timeout or indefinitely if NULL + bool Wait(const timespec* ts = NULL); - void Signal(); - void Broadcast(); - - void WaitDone(); - bool ShouldWait(); - bool HasWaiters(); + void Signal(bool all = FALSE); private: - bool m_wasSignaled; // TRUE if condition was signaled while - // nobody waited for it - size_t m_nWaiters; // TRUE if someone already waits for us + // the number of Signal() calls we "missed", i.e. which were done while + // there were no threads to wait for them + size_t m_nQueuedSignals; + + // counts all pending waiters + size_t m_nWaiters; - pthread_mutex_t m_mutexProtect; // protects access to vars above + // the condition itself + pthread_cond_t m_condition; - pthread_mutex_t m_mutex; // the mutex used with the condition - pthread_cond_t m_condition; // the condition itself + // the mutex used with the conditon: it also protects the counters above + pthread_mutex_t m_mutex; }; wxConditionInternal::wxConditionInternal() { - m_wasSignaled = FALSE; + m_nQueuedSignals = m_nWaiters = 0; if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 ) @@ -295,19 +392,11 @@ wxConditionInternal::wxConditionInternal() wxFAIL_MSG( _T("pthread_cond_init() failed") ); } - if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t *)NULL) != 0 || - pthread_mutex_init(&m_mutexProtect, NULL) != 0 ) + if ( pthread_mutex_init(&m_mutex, NULL) != 0 ) { // neither this wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") ); } - - // initially the mutex is locked, so no thread can Signal() or Broadcast() - // until another thread starts to Wait() - if ( pthread_mutex_lock(&m_mutex) != 0 ) - { - wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") ); - } } wxConditionInternal::~wxConditionInternal() @@ -318,138 +407,105 @@ wxConditionInternal::~wxConditionInternal() "threads are probably still waiting on it?)")); } - if ( pthread_mutex_unlock( &m_mutex ) != 0 ) - { - wxLogDebug(_T("wxCondition: failed to unlock the mutex")); - } - - if ( pthread_mutex_destroy( &m_mutex ) != 0 || - pthread_mutex_destroy( &m_mutexProtect ) != 0 ) + if ( pthread_mutex_destroy( &m_mutex ) != 0 ) { wxLogDebug(_T("Failed to destroy mutex (it is probably locked)")); } } -void wxConditionInternal::WaitDone() +bool wxConditionInternal::Wait(const timespec* ts) { - MutexLock lock(m_mutexProtect); - - m_wasSignaled = FALSE; - m_nWaiters--; -} + MutexLock lock(m_mutex); -bool wxConditionInternal::ShouldWait() -{ - MutexLock lock(m_mutexProtect); - - if ( m_wasSignaled ) + if ( m_nQueuedSignals ) { - // the condition was signaled before we started to wait, reset the - // flag and return - m_wasSignaled = FALSE; + m_nQueuedSignals--; - return FALSE; + wxLogTrace(TRACE_THREADS, + _T("wxCondition(%08x)::Wait(): Has been signaled before"), + this); + + return TRUE; } - // we start to wait for it + // there are no queued signals, so start really waiting m_nWaiters++; - return TRUE; -} - -bool wxConditionInternal::HasWaiters() -{ - MutexLock lock(m_mutexProtect); + // 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); - if ( m_nWaiters ) + int err = ts ? pthread_cond_timedwait(&m_condition, &m_mutex, ts) + : pthread_cond_wait(&m_condition, &m_mutex); + switch ( err ) { - // someone waits for us, signal the condition normally - return TRUE; - } + case 0: + // condition was signaled + wxLogTrace(TRACE_THREADS, + _T("wxCondition(%08x)::Wait(): ok"), this); + break; - // nobody waits for us and may be never will - so just remember that the - // condition was signaled and don't do anything else - m_wasSignaled = TRUE; + default: + wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return")); + // fall through - return FALSE; -} + case ETIMEDOUT: + case EINTR: + // The condition has not been signaled, so we have to + // decrement the counter manually + --m_nWaiters; -void wxConditionInternal::Wait() -{ - if ( ShouldWait() ) - { - if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 ) - { - // not supposed to ever happen - wxFAIL_MSG( _T("pthread_cond_wait() failed") ); - } + // wait interrupted or timeout elapsed + wxLogTrace(TRACE_THREADS, + _T("wxCondition(%08x)::Wait(): timeout/intr"), this); } - WaitDone(); + return err == 0; } -bool wxConditionInternal::WaitWithTimeout(const timespec* ts) +void wxConditionInternal::Signal(bool all) { - bool ok; + // make sure that only one Signal() or Broadcast() is in progress + MutexLock lock(m_mutex); - if ( ShouldWait() ) + // Are there any waiters? + if ( m_nWaiters == 0 ) { - switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) ) - { - case 0: - // condition signaled - ok = TRUE; - break; + // No, there are not, so don't signal but keep in mind for the next + // Wait() + m_nQueuedSignals++; - default: - wxLogDebug(_T("pthread_cond_timedwait() failed")); + return; + } - // fall through + // now we can finally signal it + wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"), + this, all ? _T("broadcast") : _T("signal")); - case ETIMEDOUT: - case EINTR: - // wait interrupted or timeout elapsed - ok = FALSE; - } + int err = all ? pthread_cond_broadcast(&m_condition) + : pthread_cond_signal(&m_condition); + + if ( all ) + { + m_nWaiters = 0; } else { - // the condition had already been signaled before - ok = TRUE; + --m_nWaiters; } - WaitDone(); - - return ok; -} - -void wxConditionInternal::Signal() -{ - if ( HasWaiters() ) + if ( err ) { - MutexLock lock(m_mutex); - - if ( pthread_cond_signal( &m_condition ) != 0 ) - { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_signal() failed")); - } + // shouldn't ever happen + wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed")); } } -void wxConditionInternal::Broadcast() -{ - if ( HasWaiters() ) - { - MutexLock lock(m_mutex); - - if ( pthread_cond_broadcast( &m_condition ) != 0 ) - { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_broadcast() failed")); - } - } -} +// ---------------------------------------------------------------------------- +// wxCondition +// ---------------------------------------------------------------------------- wxCondition::wxCondition() { @@ -463,7 +519,7 @@ wxCondition::~wxCondition() void wxCondition::Wait() { - m_internal->Wait(); + (void)m_internal->Wait(); } bool wxCondition::Wait(unsigned long sec, unsigned long nsec) @@ -473,7 +529,7 @@ bool wxCondition::Wait(unsigned long sec, unsigned long nsec) tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here? tspec.tv_nsec = nsec; - return m_internal->WaitWithTimeout(&tspec); + return m_internal->Wait(&tspec); } void wxCondition::Signal() @@ -483,12 +539,12 @@ void wxCondition::Signal() void wxCondition::Broadcast() { - m_internal->Broadcast(); + m_internal->Signal(TRUE /* all */); } -//-------------------------------------------------------------------- -// wxThread (Posix implementation) -//-------------------------------------------------------------------- +// ============================================================================ +// wxThread implementation +// ============================================================================ // the thread callback functions must have the C linkage extern "C" @@ -503,6 +559,10 @@ void *wxPthreadStart(void *ptr); } // extern "C" +// ---------------------------------------------------------------------------- +// wxThreadInternal +// ---------------------------------------------------------------------------- + class wxThreadInternal { public: @@ -615,6 +675,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; + wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId()); + // associate the thread pointer with the newly created thread so that // wxThread::This() will work int rc = pthread_setspecific(gs_keySelf, thread); @@ -763,13 +825,10 @@ void wxThreadInternal::Wait() wxMutexGuiLeave(); bool isDetached = m_isDetached; -#ifdef __VMS - long long id = (long long)GetId(); -#else - long id = (long)GetId(); -#endif - wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."), - id); + wxThreadIdType id = (wxThreadIdType) GetId(); + + wxLogTrace(TRACE_THREADS, + _T("Starting to wait for thread %ld to exit."), id); // wait until the thread terminates (we're blocking in _another_ thread, // of course) @@ -1142,15 +1201,9 @@ unsigned int wxThread::GetPriority() const return m_internal->GetPriority(); } -#ifdef __VMS -unsigned long long wxThread::GetId() const -{ - return (unsigned long long)m_internal->GetId(); -#else -unsigned long wxThread::GetId() const +wxThreadIdType wxThread::GetId() const { - return (unsigned long)m_internal->GetId(); -#endif + return (wxThreadIdType) m_internal->GetId(); } // -----------------------------------------------------------------------------