X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1e6feb95a79834836e88143b15d9f424ebe79621..2d956b58023a4955313a1c1531bc70a0deb0b831:/src/unix/threadpsx.cpp diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 8cebd7d212..72be919335 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) +// Vadim Zeitlin (1999-2002) // Robert Roebling (1999) +// K. S. Sreeram (2002) // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -34,13 +35,13 @@ #include "wx/log.h" #include "wx/intl.h" #include "wx/dynarray.h" +#include "wx/timer.h" #include #include #include #include #include - #if HAVE_SCHED_H #include #endif @@ -80,35 +81,6 @@ static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1; static void ScheduleThreadForDeletion(); 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 // ---------------------------------------------------------------------------- @@ -135,7 +107,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 @@ -147,23 +119,31 @@ 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; + + friend class wxConditionInternal; }; -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 +154,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,253 +305,388 @@ 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 +// =========================================================================== -// 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) +// --------------------------------------------------------------------------- +// wxConditionInternal +// --------------------------------------------------------------------------- class wxConditionInternal { public: - wxConditionInternal(); + wxConditionInternal(wxMutex& mutex); ~wxConditionInternal(); void Wait(); - bool WaitWithTimeout(const timespec* ts); + + bool Wait( const timespec *ts ); void Signal(); - void Broadcast(); - void WaitDone(); - bool ShouldWait(); - bool HasWaiters(); + void Broadcast(); 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 - - pthread_mutex_t m_mutexProtect; // protects access to vars above + // get the POSIX mutex associated with us + pthread_mutex_t *GetMutex() const { return &m_mutex.m_internal->m_mutex; } - pthread_mutex_t m_mutex; // the mutex used with the condition - pthread_cond_t m_condition; // the condition itself + wxMutex& m_mutex; + pthread_cond_t m_cond; }; -wxConditionInternal::wxConditionInternal() +wxConditionInternal::wxConditionInternal(wxMutex& mutex) + : m_mutex(mutex) { - m_wasSignaled = FALSE; - m_nWaiters = 0; - - if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 ) + if ( pthread_cond_init( &m_cond, NULL ) != 0 ) { - // this is supposed to never happen - wxFAIL_MSG( _T("pthread_cond_init() failed") ); + wxLogDebug(_T("pthread_cond_init() failed")); } +} - if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t *)NULL) != 0 || - pthread_mutex_init(&m_mutexProtect, NULL) != 0 ) +wxConditionInternal::~wxConditionInternal() +{ + if ( pthread_cond_destroy( &m_cond ) != 0 ) { - // neither this - wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") ); + wxLogDebug(_T("pthread_cond_destroy() 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 ) +void wxConditionInternal::Wait() +{ + if ( pthread_cond_wait( &m_cond, GetMutex() ) != 0 ) { - wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") ); + wxLogDebug(_T("pthread_cond_wait() failed")); } } -wxConditionInternal::~wxConditionInternal() +bool wxConditionInternal::Wait( const timespec *ts ) { - if ( pthread_cond_destroy( &m_condition ) != 0 ) + int result = pthread_cond_timedwait( &m_cond, GetMutex(), ts ); + if ( result == ETIMEDOUT ) + return FALSE; + + if ( result != 0 ) { - wxLogDebug(_T("Failed to destroy condition variable (some " - "threads are probably still waiting on it?)")); + wxLogDebug(_T("pthread_cond_timedwait() failed")); } - if ( pthread_mutex_unlock( &m_mutex ) != 0 ) - { - wxLogDebug(_T("wxCondition: failed to unlock the mutex")); + return TRUE; +} + +void wxConditionInternal::Signal() +{ + int result = pthread_cond_signal( &m_cond ); + if ( result != 0 ) +{ + wxFAIL_MSG( _T("pthread_cond_signal() failed") ); } +} - if ( pthread_mutex_destroy( &m_mutex ) != 0 || - pthread_mutex_destroy( &m_mutexProtect ) != 0 ) - { - wxLogDebug(_T("Failed to destroy mutex (it is probably locked)")); +void wxConditionInternal::Broadcast() +{ + int result = pthread_cond_broadcast( &m_cond ); + if ( result != 0 ) +{ + wxFAIL_MSG( _T("pthread_cond_broadcast() failed") ); } } -void wxConditionInternal::WaitDone() + +// --------------------------------------------------------------------------- +// wxCondition +// --------------------------------------------------------------------------- + +wxCondition::wxCondition(wxMutex& mutex) { - MutexLock lock(m_mutexProtect); + m_internal = new wxConditionInternal( mutex ); +} - m_wasSignaled = FALSE; - m_nWaiters--; +wxCondition::~wxCondition() +{ + delete m_internal; } -bool wxConditionInternal::ShouldWait() +void wxCondition::Wait() { - MutexLock lock(m_mutexProtect); + m_internal->Wait(); +} - if ( m_wasSignaled ) - { - // the condition was signaled before we started to wait, reset the - // flag and return - m_wasSignaled = FALSE; +bool wxCondition::Wait( unsigned long timeout_millis ) +{ + wxLongLong curtime = wxGetLocalTimeMillis(); + curtime += timeout_millis; + wxLongLong temp = curtime / 1000; + int sec = temp.GetLo(); + temp = temp * 1000; + temp = curtime - temp; + int millis = temp.GetLo(); - return FALSE; - } + timespec tspec; - // we start to wait for it - m_nWaiters++; + tspec.tv_sec = sec; + tspec.tv_nsec = millis * 1000L * 1000L; - return TRUE; + return m_internal->Wait(&tspec); } -bool wxConditionInternal::HasWaiters() +void wxCondition::Signal() { - MutexLock lock(m_mutexProtect); + m_internal->Signal(); +} - if ( m_nWaiters ) - { - // someone waits for us, signal the condition normally - return TRUE; - } +void wxCondition::Broadcast() +{ + m_internal->Broadcast(); +} - // 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; +// =========================================================================== +// wxSemaphore implementation +// =========================================================================== - return FALSE; -} +// --------------------------------------------------------------------------- +// wxSemaphoreInternal +// --------------------------------------------------------------------------- -void wxConditionInternal::Wait() +class wxSemaphoreInternal +{ +public: + wxSemaphoreInternal( int initialcount, int maxcount ); + + void Wait(); + bool TryWait(); + + bool Wait( unsigned long timeout_millis ); + + void Post(); + +private: + wxMutex m_mutex; + wxCondition m_cond; + + int count, + maxcount; +}; + +wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount ) + : m_cond(m_mutex) { - if ( ShouldWait() ) + + if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) ) { - if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 ) - { - // not supposed to ever happen - wxFAIL_MSG( _T("pthread_cond_wait() failed") ); - } + wxFAIL_MSG( _T("wxSemaphore: invalid initial count") ); } - WaitDone(); + maxcount = maxcount; + count = initialcount; } -bool wxConditionInternal::WaitWithTimeout(const timespec* ts) +void wxSemaphoreInternal::Wait() { - bool ok; + wxMutexLocker locker(m_mutex); - if ( ShouldWait() ) + while ( count <= 0 ) { - switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) ) - { - case 0: - // condition signaled - ok = TRUE; - break; + m_cond.Wait(); + } - default: - wxLogDebug(_T("pthread_cond_timedwait() failed")); + count--; +} - // fall through +bool wxSemaphoreInternal::TryWait() +{ + wxMutexLocker locker(m_mutex); - case ETIMEDOUT: - case EINTR: - // wait interrupted or timeout elapsed - ok = FALSE; - } - } - else - { - // the condition had already been signaled before - ok = TRUE; - } + if ( count <= 0 ) + return FALSE; - WaitDone(); + count--; - return ok; + return TRUE; } -void wxConditionInternal::Signal() +bool wxSemaphoreInternal::Wait( unsigned long timeout_millis ) { - if ( HasWaiters() ) + wxMutexLocker locker(m_mutex); + + wxLongLong startTime = wxGetLocalTimeMillis(); + + while ( count <= 0 ) { - MutexLock lock(m_mutex); + wxLongLong elapsed = wxGetLocalTimeMillis() - startTime; + long remainingTime = (long)timeout_millis - (long)elapsed.GetLo(); + if ( remainingTime <= 0 ) + return FALSE; - if ( pthread_cond_signal( &m_condition ) != 0 ) - { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_signal() failed")); - } + bool result = m_cond.Wait( remainingTime ); + if ( !result ) + return FALSE; } + + count--; + + return TRUE; } -void wxConditionInternal::Broadcast() +void wxSemaphoreInternal::Post() { - if ( HasWaiters() ) - { - MutexLock lock(m_mutex); + wxMutexLocker locker(m_mutex); - if ( pthread_cond_broadcast( &m_condition ) != 0 ) - { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_broadcast() failed")); - } + if ( maxcount > 0 && count == maxcount ) + { + wxFAIL_MSG( _T("wxSemaphore::Post() overflow") ); } + + count++; + + m_cond.Signal(); } -wxCondition::wxCondition() +// -------------------------------------------------------------------------- +// wxSemaphore +// -------------------------------------------------------------------------- + +wxSemaphore::wxSemaphore( int initialcount, int maxcount ) { - m_internal = new wxConditionInternal; + m_internal = new wxSemaphoreInternal( initialcount, maxcount ); } -wxCondition::~wxCondition() +wxSemaphore::~wxSemaphore() { delete m_internal; } -void wxCondition::Wait() +void wxSemaphore::Wait() { m_internal->Wait(); } -bool wxCondition::Wait(unsigned long sec, unsigned long nsec) +bool wxSemaphore::TryWait() { - timespec tspec; - - tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here? - tspec.tv_nsec = nsec; - - return m_internal->WaitWithTimeout(&tspec); + return m_internal->TryWait(); } -void wxCondition::Signal() +bool wxSemaphore::Wait( unsigned long timeout_millis ) { - m_internal->Signal(); + return m_internal->Wait( timeout_millis ); } -void wxCondition::Broadcast() +void wxSemaphore::Post() { - m_internal->Broadcast(); + m_internal->Post(); } -//-------------------------------------------------------------------- -// wxThread (Posix implementation) -//-------------------------------------------------------------------- +// This class is used by wxThreadInternal to support Delete() on +// a detached thread +class wxRefCountedCondition +{ +public: + // start with a initial reference count of 1 + wxRefCountedCondition() + { + m_refCount = 1; + m_signaled = FALSE; + + m_mutex = new wxMutex(); + m_cond = new wxCondition( *m_mutex ); + } + + // increment the reference count + void AddRef() + { + wxMutexLocker locker( *m_mutex ); + + m_refCount++; + } + + // decrement the reference count if reference count is zero then delete the + // object + void DeleteRef() + { + bool shouldDelete = FALSE; + + m_mutex->Lock(); + + if ( --m_refCount == 0 ) + { + shouldDelete = TRUE; + } + + m_mutex->Unlock(); + + if ( shouldDelete ) + { + delete this; + } + } + + + // sets the object to signaled this signal will be a persistent signal all + // further Wait()s on the object will return without blocking + void SetSignaled() + { + wxMutexLocker locker( *m_mutex ); + + m_signaled = TRUE; + + m_cond->Broadcast(); + } + + // wait till the object is signaled if the object was already signaled then + // return immediately + void Wait() + { + wxMutexLocker locker( *m_mutex ); + + if ( !m_signaled ) + { + m_cond->Wait(); + } + } + +private: + int m_refCount; + + wxMutex *m_mutex; + wxCondition *m_cond; + + bool m_signaled; + + // Cannot delete this object directly, call DeleteRef() instead + ~wxRefCountedCondition() + { + delete m_cond; + delete m_mutex; + } + + // suppress gcc warning about the class having private dtor and not having + // friend (so what??) + friend class wxDummyFriend; +}; + +// =========================================================================== +// wxThread implementation +// =========================================================================== + +// the thread callback functions must have the C linkage +extern "C" +{ + +#if HAVE_THREAD_CLEANUP_FUNCTIONS + // thread exit function + void wxPthreadCleanup(void *ptr); +#endif // HAVE_THREAD_CLEANUP_FUNCTIONS + +void *wxPthreadStart(void *ptr); + +} // extern "C" + +// ---------------------------------------------------------------------------- +// wxThreadInternal +// ---------------------------------------------------------------------------- class wxThreadInternal { @@ -497,12 +695,7 @@ public: ~wxThreadInternal(); // thread entry function - static void *PthreadStart(void *ptr); - -#if HAVE_THREAD_CLEANUP_FUNCTIONS - // thread exit function - static void PthreadCleanup(void *ptr); -#endif + static void *PthreadStart(wxThread *thread); // thread actions // start the thread @@ -512,7 +705,7 @@ public: // wake up threads waiting for our termination void SignalExit(); // wake up threads waiting for our start - void SignalRun() { m_condRun.Signal(); } + void SignalRun() { m_semRun.Post(); } // go to sleep until Resume() is called void Pause(); // resume the thread @@ -549,6 +742,11 @@ public: // sometimes - tell the thread that it should do it void Notify() { m_shouldBroadcast = TRUE; } +#if HAVE_THREAD_CLEANUP_FUNCTIONS + // this is used by wxPthreadCleanup() only + static void Cleanup(wxThread *thread); +#endif // HAVE_THREAD_CLEANUP_FUNCTIONS + private: pthread_t m_threadId; // id of the thread wxThreadState m_state; // see wxThreadState enum @@ -557,7 +755,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 @@ -571,33 +769,35 @@ private: 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; + wxSemaphore m_semSuspend; // finally this one is signalled when the thread exits - wxCondition m_condEnd; + // we are using a reference counted condition to support + // Delete() for a detached thread + wxRefCountedCondition *m_condEnd; }; // ---------------------------------------------------------------------------- // thread startup and exit functions // ---------------------------------------------------------------------------- -void *wxThreadInternal::PthreadStart(void *ptr) +void *wxPthreadStart(void *ptr) +{ + return wxThreadInternal::PthreadStart((wxThread *)ptr); +} + +void *wxThreadInternal::PthreadStart(wxThread *thread) { - wxThread *thread = (wxThread *)ptr; wxThreadInternal *pthread = thread->m_internal; + 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); @@ -615,11 +815,11 @@ void *wxThreadInternal::PthreadStart(void *ptr) #if HAVE_THREAD_CLEANUP_FUNCTIONS // install the cleanup handler which will be called if the thread is // cancelled - pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr); + pthread_cleanup_push(wxPthreadCleanup, thread); #endif // HAVE_THREAD_CLEANUP_FUNCTIONS - // wait for the condition to be signaled from Run() - pthread->m_condRun.Wait(); + // 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()? @@ -645,7 +845,7 @@ void *wxThreadInternal::PthreadStart(void *ptr) pthread->GetId()); // change the state of the thread to "exited" so that - // PthreadCleanup handler won't do anything from now (if it's + // wxPthreadCleanup handler won't do anything from now (if it's // called before we do pthread_cleanup_pop below) pthread->SetState(STATE_EXITED); } @@ -679,10 +879,13 @@ void *wxThreadInternal::PthreadStart(void *ptr) #if HAVE_THREAD_CLEANUP_FUNCTIONS // this handler is called when the thread is cancelled -void wxThreadInternal::PthreadCleanup(void *ptr) +extern "C" void wxPthreadCleanup(void *ptr) { - wxThread *thread = (wxThread *) ptr; + wxThreadInternal::Cleanup((wxThread *)ptr); +} +void wxThreadInternal::Cleanup(wxThread *thread) +{ { wxCriticalSectionLocker lock(thread->m_critsect); if ( thread->m_internal->GetState() == STATE_EXITED ) @@ -710,17 +913,20 @@ 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; + + m_condEnd = new wxRefCountedCondition(); } wxThreadInternal::~wxThreadInternal() { + m_condEnd->DeleteRef(); } wxThreadError wxThreadInternal::Run() @@ -743,13 +949,22 @@ void wxThreadInternal::Wait() wxMutexGuiLeave(); bool isDetached = m_isDetached; - long id = (long)GetId(); - 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) - m_condEnd.Wait(); + + // a reference counting condition is used to handle the + // case where a detached thread deletes itself + // before m_condEnd->Wait() returns + // in this case the deletion of the condition object is deferred until + // all Wait()ing threads have finished calling DeleteRef() + m_condEnd->AddRef(); + m_condEnd->Wait(); + m_condEnd->DeleteRef(); wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id); @@ -794,7 +1009,7 @@ void wxThreadInternal::SignalExit() wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."), GetId()); - m_condEnd.Broadcast(); + m_condEnd->SetSignaled(); } } @@ -807,8 +1022,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() @@ -823,7 +1038,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); @@ -904,6 +1119,19 @@ int wxThread::GetCPUCount() return -1; } +#ifdef __VMS + // VMS is a 64 bit system and threads have 64 bit pointers. + // ??? also needed for other systems???? +unsigned long long wxThread::GetCurrentId() +{ + return (unsigned long long)pthread_self(); +#else +unsigned long wxThread::GetCurrentId() +{ + return (unsigned long)pthread_self(); +#endif +} + bool wxThread::SetConcurrency(size_t level) { #ifdef HAVE_THR_SETCONCURRENCY @@ -934,7 +1162,7 @@ wxThread::wxThread(wxThreadKind kind) m_isDetached = kind == wxTHREAD_DETACHED; } -wxThreadError wxThread::Create() +wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) { if ( m_internal->GetState() != STATE_NEW ) { @@ -962,7 +1190,7 @@ wxThreadError wxThread::Create() #define sched_get_priority_min(_pol_) \ (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN) #endif - + int max_prio = sched_get_priority_max(policy), min_prio = sched_get_priority_min(policy), prio = m_internal->GetPriority(); @@ -1028,7 +1256,7 @@ wxThreadError wxThread::Create() ( m_internal->GetIdPtr(), &attr, - wxThreadInternal::PthreadStart, + wxPthreadStart, (void *)this ); @@ -1105,9 +1333,9 @@ unsigned int wxThread::GetPriority() const return m_internal->GetPriority(); } -unsigned long wxThread::GetId() const +wxThreadIdType wxThread::GetId() const { - return (unsigned long)m_internal->GetId(); + return (wxThreadIdType) m_internal->GetId(); } // ----------------------------------------------------------------------------- @@ -1211,7 +1439,7 @@ wxThreadError wxThread::Delete(ExitCode *rc) { 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 m_semRun m_internal->SignalRun(); // fall through @@ -1274,7 +1502,7 @@ wxThreadError wxThread::Kill() if ( m_isDetached ) { // if we use cleanup function, this will be done from - // PthreadCleanup() + // wxPthreadCleanup() #if !HAVE_THREAD_CLEANUP_FUNCTIONS ScheduleThreadForDeletion(); @@ -1394,7 +1622,8 @@ wxThread::~wxThread() // is not called for the joinable threads, so do it here if ( !m_isDetached ) { - MutexLock lock(gs_mutexDeleteThread); + wxMutexLocker lock( *gs_mutexDeleteThread ); + gs_nThreadsBeingDeleted--; wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), @@ -1470,9 +1699,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; } @@ -1483,18 +1711,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 @@ -1521,6 +1750,9 @@ void wxThreadModule::OnExit() // and free TLD slot (void)pthread_key_delete(gs_keySelf); + + delete gs_condAllDeleted; + delete gs_mutexDeleteThread; } // ---------------------------------------------------------------------------- @@ -1529,12 +1761,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++; @@ -1547,17 +1774,15 @@ 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, + 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); @@ -1566,9 +1791,6 @@ static void DeleteThread(wxThread *This) { // no more threads left, signal it gs_condAllDeleted->Signal(); - - delete gs_condAllDeleted; - gs_condAllDeleted = (wxCondition *)NULL; } }