X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9fc3ad34c5326856aeebf02335244ae315cef688..16e8bf31bb4ba1f6374ea86f1ef1dcb1872fda69:/src/unix/threadpsx.cpp diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 1ab453633f..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 ///////////////////////////////////////////////////////////////////////////// @@ -24,9 +24,7 @@ #pragma implementation "thread.h" #endif -// With simple makefiles, we must ignore the file body if not using -// threads. -#include "wx/setup.h" +#include "wx/defs.h" #if wxUSE_THREADS @@ -42,11 +40,19 @@ #include #include #include - #if HAVE_SCHED_H #include #endif +#ifdef HAVE_THR_SETCONCURRENCY + #include +#endif + +// we use wxFFile under Linux in GetCPUCount() +#ifdef __LINUX__ + #include "wx/ffile.h" +#endif + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -66,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 // ---------------------------------------------------------------------------- @@ -128,7 +143,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 = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t gs_mutexDeleteThread; // and a condition variable which will be signaled when all // gs_nThreadsBeingDeleted will have been deleted @@ -140,73 +155,180 @@ 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; }; +wxMutexInternal::wxMutexInternal() +{ + // 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 +#ifdef HAVE_PTHREAD_MUTEXATTR_T + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + + 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 + 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; - pthread_mutex_init(&(m_internal->m_mutex), - (pthread_mutexattr_t*) NULL ); 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--; } @@ -217,55 +339,64 @@ 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 +// ============================================================================ -// notice that we must use a mutex with POSIX condition variables to ensure -// that the worker thread doesn't signal condition before the waiting thread -// starts to wait for it +// ---------------------------------------------------------------------------- +// 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 Signal(bool all = FALSE); private: - pthread_mutex_t m_mutex; + // 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; + + // the condition itself pthread_cond_t m_condition; + + // the mutex used with the conditon: it also protects the counters above + pthread_mutex_t m_mutex; }; wxConditionInternal::wxConditionInternal() { + m_nQueuedSignals = + m_nWaiters = 0; + if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 ) { // this is supposed to never happen wxFAIL_MSG( _T("pthread_cond_init() failed") ); } - if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t*)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() @@ -276,68 +407,106 @@ 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 ) + if ( pthread_mutex_destroy( &m_mutex ) != 0 ) { wxLogDebug(_T("Failed to destroy mutex (it is probably locked)")); } } -void wxConditionInternal::Wait() +bool wxConditionInternal::Wait(const timespec* ts) { - if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 ) + MutexLock lock(m_mutex); + + if ( m_nQueuedSignals ) { - // not supposed to ever happen - wxFAIL_MSG( _T("pthread_cond_wait() failed") ); + m_nQueuedSignals--; + + wxLogTrace(TRACE_THREADS, + _T("wxCondition(%08x)::Wait(): Has been signaled before"), + this); + + return TRUE; } -} -bool wxConditionInternal::WaitWithTimeout(const timespec* ts) -{ - switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) ) + // there are no queued signals, so start really waiting + m_nWaiters++; + + // 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, &m_mutex, ts) + : pthread_cond_wait(&m_condition, &m_mutex); + switch ( err ) { case 0: - // condition signaled - return TRUE; + // condition was signaled + wxLogTrace(TRACE_THREADS, + _T("wxCondition(%08x)::Wait(): ok"), this); + break; default: - wxLogDebug(_T("pthread_cond_timedwait() failed")); - + wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return")); // fall through case ETIMEDOUT: case EINTR: + // The condition has not been signaled, so we have to + // decrement the counter manually + --m_nWaiters; + // wait interrupted or timeout elapsed - return FALSE; + wxLogTrace(TRACE_THREADS, + _T("wxCondition(%08x)::Wait(): timeout/intr"), this); } + + return err == 0; } -void wxConditionInternal::Signal() +void wxConditionInternal::Signal(bool all) { + // make sure that only one Signal() or Broadcast() is in progress MutexLock lock(m_mutex); - if ( pthread_cond_signal( &m_condition ) != 0 ) + // Are there any waiters? + if ( m_nWaiters == 0 ) { - // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_signal() failed")); + // No, there are not, so don't signal but keep in mind for the next + // Wait() + m_nQueuedSignals++; + + return; } -} -void wxConditionInternal::Broadcast() -{ - MutexLock lock(m_mutex); + // now we can finally signal it + wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"), + this, all ? _T("broadcast") : _T("signal")); + + int err = all ? pthread_cond_broadcast(&m_condition) + : pthread_cond_signal(&m_condition); + + if ( all ) + { + m_nWaiters = 0; + } + else + { + --m_nWaiters; + } - if ( pthread_cond_broadcast( &m_condition ) != 0 ) + if ( err ) { // shouldn't ever happen - wxFAIL_MSG(_T("pthread_cond_broadcast() failed")); + wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed")); } } +// ---------------------------------------------------------------------------- +// wxCondition +// ---------------------------------------------------------------------------- + wxCondition::wxCondition() { m_internal = new wxConditionInternal; @@ -350,7 +519,7 @@ wxCondition::~wxCondition() void wxCondition::Wait() { - m_internal->Wait(); + (void)m_internal->Wait(); } bool wxCondition::Wait(unsigned long sec, unsigned long nsec) @@ -360,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() @@ -370,12 +539,29 @@ 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" +{ + +#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 { @@ -384,12 +570,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 @@ -398,6 +579,8 @@ public: 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 @@ -420,12 +603,25 @@ public: 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() { m_shouldBeJoined = m_shouldBroadcast = FALSE; } + void Detach() + { + m_shouldBeJoined = m_shouldBroadcast = 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 + 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 @@ -434,6 +630,9 @@ 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 + bool m_isPaused; + // the thread exit code - only used for joinable (!detached) threads and // is only valid after the thread termination wxThread::ExitCode m_exitcode; @@ -443,6 +642,7 @@ private: 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 @@ -466,11 +666,17 @@ private: // 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); @@ -481,31 +687,47 @@ void *wxThreadInternal::PthreadStart(void *ptr) return (void *)-1; } + // have to declare this before pthread_cleanup_push() which defines a + // block! + bool dontRunAtAll; + #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(); - // call the main entry - pthread->m_exitcode = thread->Entry(); + // test whether we should run the run at all - may be it was deleted + // before it started to Run()? + { + wxCriticalSectionLocker lock(thread->m_critsect); - wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."), - pthread->GetId()); + dontRunAtAll = pthread->GetState() == STATE_NEW && + pthread->WasCancelled(); + } + if ( !dontRunAtAll ) { - wxCriticalSectionLocker lock(thread->m_critsect); + // call the main entry + pthread->m_exitcode = thread->Entry(); - wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."), + wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."), pthread->GetId()); - // change the state of the thread to "exited" so that PthreadCleanup - // handler won't do anything from now (if it's called before we do - // pthread_cleanup_pop below) - pthread->SetState(STATE_EXITED); + { + 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) + pthread->SetState(STATE_EXITED); + } } // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop @@ -516,21 +738,33 @@ void *wxThreadInternal::PthreadStart(void *ptr) pthread_cleanup_pop(FALSE); #endif // HAVE_THREAD_CLEANUP_FUNCTIONS - // terminate the thread - thread->Exit(pthread->m_exitcode); + if ( dontRunAtAll ) + { + delete thread; - wxFAIL_MSG(wxT("wxThread::Exit() can't return.")); + return EXITCODE_CANCELLED; + } + else + { + // terminate the thread + thread->Exit(pthread->m_exitcode); + + wxFAIL_MSG(wxT("wxThread::Exit() can't return.")); - return NULL; + return NULL; + } } #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 ) @@ -558,9 +792,13 @@ wxThreadInternal::wxThreadInternal() m_threadId = 0; m_exitcode = 0; + // set to TRUE only when the thread starts waiting on m_condSuspend + m_isPaused = FALSE; + // defaults for joinable threads m_shouldBeJoined = TRUE; m_shouldBroadcast = TRUE; + m_isDetached = FALSE; } wxThreadInternal::~wxThreadInternal() @@ -572,7 +810,7 @@ wxThreadError wxThreadInternal::Run() wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING, wxT("thread may only be started once after Create()") ); - m_condRun.Signal(); + SignalRun(); SetState(STATE_RUNNING); @@ -586,26 +824,40 @@ void wxThreadInternal::Wait() if ( wxThread::IsMain() ) wxMutexGuiLeave(); + bool isDetached = m_isDetached; + wxThreadIdType id = (wxThreadIdType) GetId(); + + wxLogTrace(TRACE_THREADS, + _T("Starting to wait for thread %ld to exit."), id); + // wait until the thread terminates (we're blocking in _another_ thread, // of course) m_condEnd.Wait(); - // to avoid memory leaks we should call pthread_join(), but it must only - // be done once - wxCriticalSectionLocker lock(m_csJoinFlag); + wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id); - if ( m_shouldBeJoined ) + // we can't use any member variables any more if the thread is detached + // because it could be already deleted + if ( !isDetached ) { - // 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 ) + // to avoid memory leaks we should call pthread_join(), but it must + // only be done once + wxCriticalSectionLocker lock(m_csJoinFlag); + + if ( m_shouldBeJoined ) { - wxLogError(_T("Failed to join a thread, potential memory leak " - "detected - please restart the program")); - } + // 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((pthread_t)id, &m_exitcode) != 0 ) + { + wxLogError(_("Failed to join a thread, potential memory leak " + "detected - please restart the program")); + } - m_shouldBeJoined = FALSE; + m_shouldBeJoined = FALSE; + } } // reacquire GUI mutex @@ -622,6 +874,9 @@ void wxThreadInternal::SignalExit() // 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(); } } @@ -644,10 +899,23 @@ void wxThreadInternal::Resume() wxCHECK_RET( m_state == STATE_PAUSED, wxT("can't resume thread which is not suspended.") ); - wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId()); + // 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, _T("Waking up thread %ld"), GetId()); - // wake up Pause() - m_condSuspend.Signal(); + // wake up Pause() + m_condSuspend.Signal(); + + // reset the flag + SetReallyPaused(FALSE); + } + else + { + wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"), + GetId()); + } SetState(STATE_RUNNING); } @@ -668,7 +936,9 @@ bool wxThread::IsMain() void wxThread::Yield() { +#ifdef HAVE_SCHED_YIELD sched_yield(); +#endif } void wxThread::Sleep(unsigned long milliseconds) @@ -676,6 +946,76 @@ void wxThread::Sleep(unsigned long milliseconds) wxUsleep(milliseconds); } +int wxThread::GetCPUCount() +{ +#if 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; + + wxFFile file(_T("/proc/cpuinfo")); + if ( file.IsOpened() ) + { + // slurp the whole file + wxString s; + if ( file.ReadAll(&s) ) + { + // (ab)use Replace() to find the number of "processor" strings + size_t count = s.Replace(_T("processor"), _T("")); + if ( count > 0 ) + { + return count; + } + + wxLogDebug(_T("failed to parse /proc/cpuinfo")); + } + else + { + wxLogDebug(_T("failed to read /proc/cpuinfo")); + } + } +#elif defined(_SC_NPROCESSORS_ONLN) + // this works for Solaris + int rc = sysconf(_SC_NPROCESSORS_ONLN); + if ( rc != -1 ) + { + return rc; + } +#endif // different ways to get number of CPUs + + // unknown + return -1; +} + +#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 + int rc = thr_setconcurrency(level); + if ( rc != 0 ) + { + wxLogSysError(rc, _T("thr_setconcurrency() failed")); + } + + return rc == 0; +#else // !HAVE_THR_SETCONCURRENCY + // ok only for the default value + return level == 0; +#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY +} + // ----------------------------------------------------------------------------- // creating thread // ----------------------------------------------------------------------------- @@ -690,7 +1030,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 ) { @@ -709,8 +1049,18 @@ wxThreadError wxThread::Create() wxLogError(_("Cannot retrieve thread scheduling policy.")); } - int min_prio = sched_get_priority_min(policy), - max_prio = sched_get_priority_max(policy), +#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 + + int max_prio = sched_get_priority_max(policy), + min_prio = sched_get_priority_min(policy), prio = m_internal->GetPriority(); if ( min_prio == -1 || max_prio == -1 ) @@ -774,7 +1124,7 @@ wxThreadError wxThread::Create() ( m_internal->GetIdPtr(), &attr, - wxThreadInternal::PthreadStart, + wxPthreadStart, (void *)this ); @@ -851,9 +1201,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(); } // ----------------------------------------------------------------------------- @@ -862,6 +1212,9 @@ unsigned long wxThread::GetId() const wxThreadError wxThread::Pause() { + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + _T("a thread can't pause itself") ); + wxCriticalSectionLocker lock(m_critsect); if ( m_internal->GetState() != STATE_RUNNING ) @@ -871,6 +1224,9 @@ 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); @@ -880,20 +1236,17 @@ wxThreadError wxThread::Pause() wxThreadError wxThread::Resume() { - m_critsect.Enter(); + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + _T("a thread can't resume itself") ); - wxThreadState state = m_internal->GetState(); + wxCriticalSectionLocker lock(m_critsect); - // the thread might be not actually paused yet - if there were no call to - // TestDestroy() since the last call to Pause(), so avoid that - // TestDestroy() deadlocks trying to enter m_critsect by leaving it before - // calling Resume() - m_critsect.Leave(); + wxThreadState state = m_internal->GetState(); switch ( state ) { case STATE_PAUSED: - wxLogTrace(TRACE_THREADS, _T("Thread %ld is suspended, resuming."), + wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."), GetId()); m_internal->Resume(); @@ -931,6 +1284,9 @@ wxThread::ExitCode wxThread::Wait() wxThreadError wxThread::Delete(ExitCode *rc) { + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + _T("a thread can't delete itself") ); + m_critsect.Enter(); wxThreadState state = m_internal->GetState(); @@ -950,6 +1306,12 @@ wxThreadError wxThread::Delete(ExitCode *rc) 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 + m_internal->SignalRun(); + + // fall through + case STATE_EXITED: // nothing to do break; @@ -1008,11 +1370,12 @@ wxThreadError wxThread::Kill() if ( m_isDetached ) { // if we use cleanup function, this will be done from - // PthreadCleanup() + // wxPthreadCleanup() #if !HAVE_THREAD_CLEANUP_FUNCTIONS ScheduleThreadForDeletion(); - OnExit(); + // don't call OnExit() here, it can only be called in the + // threads context and we're in the context of another thread DeleteThread(this); #endif // HAVE_THREAD_CLEANUP_FUNCTIONS @@ -1028,6 +1391,10 @@ wxThreadError wxThread::Kill() void wxThread::Exit(ExitCode status) { + wxASSERT_MSG( This() == this, + _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 @@ -1072,10 +1439,16 @@ void wxThread::Exit(ExitCode status) // also test whether we were paused bool wxThread::TestDestroy() { + wxASSERT_MSG( This() == this, + _T("wxThread::TestDestroy() can only be called in the " + "context of the same thread") ); + m_critsect.Enter(); if ( m_internal->GetState() == STATE_PAUSED ) { + m_internal->SetReallyPaused(TRUE); + // 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 @@ -1101,8 +1474,8 @@ wxThread::~wxThread() if ( m_internal->GetState() != STATE_EXITED && m_internal->GetState() != STATE_NEW ) { - wxLogDebug(_T("The thread is being destroyed although it is still " - "running! The application may crash.")); + wxLogDebug(_T("The thread %ld is being destroyed although it is still " + "running! The application may crash."), GetId()); } m_critsect.Leave(); @@ -1112,6 +1485,17 @@ 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); + } } // ----------------------------------------------------------------------------- @@ -1182,6 +1566,10 @@ 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); + return TRUE; } @@ -1208,7 +1596,10 @@ void wxThreadModule::OnExit() // terminate any threads left size_t count = gs_allThreads.GetCount(); if ( count != 0u ) - wxLogDebug(wxT("Some threads were not terminated by the application.")); + { + wxLogDebug(wxT("%u threads were not terminated by the application."), + count); + } for ( size_t n = 0u; n < count; n++ ) { @@ -1243,8 +1634,9 @@ static void ScheduleThreadForDeletion() gs_nThreadsBeingDeleted++; - wxLogTrace(TRACE_THREADS, _T("%u threads waiting to be deleted"), - gs_nThreadsBeingDeleted); + wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"), + gs_nThreadsBeingDeleted, + gs_nThreadsBeingDeleted == 1 ? "" : "s"); } static void DeleteThread(wxThread *This) @@ -1263,6 +1655,9 @@ static void DeleteThread(wxThread *This) "one?") ); } + wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."), + gs_nThreadsBeingDeleted - 1); + if ( !--gs_nThreadsBeingDeleted ) { // no more threads left, signal it