X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/58230fb1b3d5e32f4199e473bb429216349068db..5100cabffa34c38db26884577113d01f21cda446:/src/unix/threadpsx.cpp diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 50e99df2a7..f0a19482a0 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -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 @@ -47,6 +45,15 @@ #include #endif +#ifdef HAVE_THR_SETCONCURRENCY + #include +#endif + +// we use wxFFile under Linux in GetCPUCount() +#ifdef __LINUX__ + #include "wx/ffile.h" +#endif + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -60,6 +67,48 @@ enum wxThreadState STATE_EXITED // thread doesn't exist any more }; +// the exit value of a thread which has been cancelled +static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1; + +// our trace mask +#define TRACE_THREADS _T("thread") + +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- + +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 // ---------------------------------------------------------------------------- @@ -81,8 +130,21 @@ static pthread_t gs_tidMain; // the key for the pointer to the associated wxThread object static pthread_key_t gs_keySelf; -// this mutex must be acquired before any call to a GUI function -static wxMutex *gs_mutexGui; +// the number of threads which are being deleted - the program won't exit +// until there are any left +static size_t gs_nThreadsBeingDeleted = 0; + +// a mutex to protect gs_nThreadsBeingDeleted +static pthread_mutex_t gs_mutexDeleteThread; + +// and a condition variable which will be signaled when all +// gs_nThreadsBeingDeleted will have been deleted +static wxCondition *gs_condAllDeleted = (wxCondition *)NULL; + +#if wxUSE_GUI + // this mutex must be acquired before any call to a GUI function + static wxMutex *gs_mutexGui; +#endif // wxUSE_GUI // ============================================================================ // implementation @@ -95,31 +157,33 @@ static wxMutex *gs_mutexGui; class wxMutexInternal { public: - pthread_mutex_t p_mutex; + pthread_mutex_t m_mutex; }; wxMutex::wxMutex() { - p_internal = new wxMutexInternal; - pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL ); + m_internal = new wxMutexInternal; + + pthread_mutex_init(&(m_internal->m_mutex), + (pthread_mutexattr_t*) NULL ); m_locked = 0; } wxMutex::~wxMutex() { if (m_locked > 0) - wxLogDebug("Freeing a locked mutex (%d locks)", m_locked); + wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked); - pthread_mutex_destroy( &(p_internal->p_mutex) ); - delete p_internal; + pthread_mutex_destroy( &(m_internal->m_mutex) ); + delete m_internal; } wxMutexError wxMutex::Lock() { - int err = pthread_mutex_lock( &(p_internal->p_mutex) ); + int err = pthread_mutex_lock( &(m_internal->m_mutex) ); if (err == EDEADLK) { - wxLogDebug("Locking this mutex would lead to deadlock!"); + wxLogDebug(wxT("Locking this mutex would lead to deadlock!")); return wxMUTEX_DEAD_LOCK; } @@ -136,7 +200,7 @@ wxMutexError wxMutex::TryLock() return wxMUTEX_BUSY; } - int err = pthread_mutex_trylock( &(p_internal->p_mutex) ); + int err = pthread_mutex_trylock( &(m_internal->m_mutex) ); switch (err) { case EBUSY: return wxMUTEX_BUSY; @@ -155,12 +219,12 @@ wxMutexError wxMutex::Unlock() } else { - wxLogDebug("Unlocking not locked mutex."); + wxLogDebug(wxT("Unlocking not locked mutex.")); return wxMUTEX_UNLOCKED; } - pthread_mutex_unlock( &(p_internal->p_mutex) ); + pthread_mutex_unlock( &(m_internal->m_mutex) ); return wxMUTEX_NO_ERROR; } @@ -169,47 +233,239 @@ wxMutexError wxMutex::Unlock() // wxCondition (Posix 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) + class wxConditionInternal { public: - pthread_cond_t p_condition; + wxConditionInternal(); + ~wxConditionInternal(); + + void Wait(); + bool WaitWithTimeout(const timespec* ts); + + void Signal(); + void Broadcast(); + + void WaitDone(); + bool ShouldWait(); + bool HasWaiters(); + +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 + + pthread_mutex_t m_mutex; // the mutex used with the condition + pthread_cond_t m_condition; // the condition itself }; +wxConditionInternal::wxConditionInternal() +{ + m_wasSignaled = FALSE; + 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 || + pthread_mutex_init(&m_mutexProtect, 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() +{ + if ( pthread_cond_destroy( &m_condition ) != 0 ) + { + wxLogDebug(_T("Failed to destroy condition variable (some " + "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 ) + { + wxLogDebug(_T("Failed to destroy mutex (it is probably locked)")); + } +} + +void wxConditionInternal::WaitDone() +{ + MutexLock lock(m_mutexProtect); + + m_wasSignaled = FALSE; + m_nWaiters--; +} + +bool wxConditionInternal::ShouldWait() +{ + MutexLock lock(m_mutexProtect); + + if ( m_wasSignaled ) + { + // the condition was signaled before we started to wait, reset the + // flag and return + m_wasSignaled = FALSE; + + return FALSE; + } + + // we start to wait for it + m_nWaiters++; + + return TRUE; +} + +bool wxConditionInternal::HasWaiters() +{ + MutexLock lock(m_mutexProtect); + + if ( m_nWaiters ) + { + // someone waits for us, signal the condition normally + return TRUE; + } + + // 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; + + return FALSE; +} + +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") ); + } + } + + WaitDone(); +} + +bool wxConditionInternal::WaitWithTimeout(const timespec* ts) +{ + bool ok; + + if ( ShouldWait() ) + { + switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) ) + { + case 0: + // condition signaled + ok = TRUE; + break; + + default: + wxLogDebug(_T("pthread_cond_timedwait() failed")); + + // fall through + + case ETIMEDOUT: + case EINTR: + // wait interrupted or timeout elapsed + ok = FALSE; + } + } + else + { + // the condition had already been signaled before + ok = TRUE; + } + + WaitDone(); + + return ok; +} + +void wxConditionInternal::Signal() +{ + if ( HasWaiters() ) + { + MutexLock lock(m_mutex); + + if ( pthread_cond_signal( &m_condition ) != 0 ) + { + // shouldn't ever happen + wxFAIL_MSG(_T("pthread_cond_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() { - p_internal = new wxConditionInternal; - pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL ); + m_internal = new wxConditionInternal; } wxCondition::~wxCondition() { - pthread_cond_destroy( &(p_internal->p_condition) ); - - delete p_internal; + delete m_internal; } -void wxCondition::Wait(wxMutex& mutex) +void wxCondition::Wait() { - pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) ); + m_internal->Wait(); } -bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec) +bool wxCondition::Wait(unsigned long sec, unsigned long nsec) { - struct timespec tspec; + timespec tspec; - tspec.tv_sec = time(0L)+sec; + tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here? tspec.tv_nsec = nsec; - return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT); + + return m_internal->WaitWithTimeout(&tspec); } void wxCondition::Signal() { - pthread_cond_signal( &(p_internal->p_condition) ); + m_internal->Signal(); } void wxCondition::Broadcast() { - pthread_cond_broadcast( &(p_internal->p_condition) ); + m_internal->Broadcast(); } //-------------------------------------------------------------------- @@ -225,6 +481,11 @@ public: // thread entry function static void *PthreadStart(void *ptr); +#if HAVE_THREAD_CLEANUP_FUNCTIONS + // thread exit function + static void PthreadCleanup(void *ptr); +#endif + // thread actions // start the thread wxThreadError Run(); @@ -232,6 +493,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 @@ -250,40 +513,75 @@ public: // "cancelled" flag void SetCancelFlag() { m_cancelled = TRUE; } bool WasCancelled() const { return m_cancelled; } + // exit code + void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; } + wxThread::ExitCode GetExitCode() const { return m_exitcode; } + + // the pause flag + void SetReallyPaused(bool paused) { m_isPaused = paused; } + bool IsReallyPaused() const { return m_isPaused; } + + // tell the thread that it is a detached one + void Detach() + { + 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; } private: pthread_t m_threadId; // id of the thread wxThreadState m_state; // see wxThreadState enum int m_prio; // in wxWindows units: from 0 to 100 - // set when the thread should terminate + // this flag is set when the thread should terminate bool m_cancelled; - // this (mutex, cond) pair is used to synchronize the main thread and this - // thread in several situations: - // 1. The thread function blocks until condition is signaled by Run() when - // it's initially created - this allows thread creation in "suspended" - // state - // 2. The Delete() function blocks until the condition is signaled when the - // thread exits. - wxMutex m_mutex; - wxCondition m_cond; - - // another (mutex, cond) pair for Pause()/Resume() usage - // - // VZ: it's possible that we might reuse the mutex and condition from above - // for this too, but as I'm not at all sure that it won't create subtle - // problems with race conditions between, say, Pause() and Delete() I - // prefer this may be a bit less efficient but much safer solution - wxMutex m_mutexSuspend; + // 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; + + // many threads may call Wait(), but only one of them should call + // pthread_join(), so we have to keep track of this + wxCriticalSection m_csJoinFlag; + bool m_shouldBeJoined; + bool m_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 + // called before it is done + wxCondition m_condRun; + + // 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; }; +// ---------------------------------------------------------------------------- +// thread startup and exit functions +// ---------------------------------------------------------------------------- + void *wxThreadInternal::PthreadStart(void *ptr) { wxThread *thread = (wxThread *)ptr; - wxThreadInternal *pthread = thread->p_internal; + wxThreadInternal *pthread = thread->m_internal; + // associate the thread pointer with the newly created thread so that + // wxThread::This() will work int rc = pthread_setspecific(gs_keySelf, thread); if ( rc != 0 ) { @@ -292,81 +590,174 @@ 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); +#endif // HAVE_THREAD_CLEANUP_FUNCTIONS + // wait for the condition to be signaled from Run() - // mutex state: currently locked by the thread which created us - pthread->m_cond.Wait(pthread->m_mutex); + pthread->m_condRun.Wait(); + + // test whether we should run the run at all - may be it was deleted + // before it started to Run()? + { + wxCriticalSectionLocker lock(thread->m_critsect); + + dontRunAtAll = pthread->GetState() == STATE_NEW && + pthread->WasCancelled(); + } + + if ( !dontRunAtAll ) + { + // call the main entry + pthread->m_exitcode = thread->Entry(); + + wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."), + pthread->GetId()); + + { + wxCriticalSectionLocker lock(thread->m_critsect); + + wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."), + pthread->GetId()); - // mutex state: locked again on exit of Wait() + // 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); + } + } + + // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop + // contains the matching '}' for the '{' in push, so they must be used + // in the same block! +#if HAVE_THREAD_CLEANUP_FUNCTIONS + // remove the cleanup handler without executing it + pthread_cleanup_pop(FALSE); +#endif // HAVE_THREAD_CLEANUP_FUNCTIONS - // call the main entry - void* status = thread->Entry(); + if ( dontRunAtAll ) + { + delete thread; - // terminate the thread - thread->Exit(status); + return EXITCODE_CANCELLED; + } + else + { + // terminate the thread + thread->Exit(pthread->m_exitcode); - wxFAIL_MSG("wxThread::Exit() can't return."); + 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) +{ + wxThread *thread = (wxThread *) ptr; + + { + wxCriticalSectionLocker lock(thread->m_critsect); + if ( thread->m_internal->GetState() == STATE_EXITED ) + { + // thread is already considered as finished. + return; + } + } + + // exit the thread gracefully + thread->Exit(EXITCODE_CANCELLED); +} + +#endif // HAVE_THREAD_CLEANUP_FUNCTIONS + +// ---------------------------------------------------------------------------- +// wxThreadInternal +// ---------------------------------------------------------------------------- + wxThreadInternal::wxThreadInternal() { m_state = STATE_NEW; m_cancelled = FALSE; + m_prio = WXTHREAD_DEFAULT_PRIORITY; + m_threadId = 0; + m_exitcode = 0; - // this mutex is locked during almost all thread lifetime - it will only be - // unlocked in the very end - m_mutex.Lock(); + // set to TRUE only when the thread starts waiting on m_condSuspend + m_isPaused = FALSE; - // this mutex is used in Pause()/Resume() and is also locked all the time - // unless the thread is paused - m_mutexSuspend.Lock(); + // defaults for joinable threads + m_shouldBeJoined = TRUE; + m_shouldBroadcast = TRUE; + m_isDetached = FALSE; } wxThreadInternal::~wxThreadInternal() { - m_mutexSuspend.Unlock(); - - // note that m_mutex will be unlocked by the thread which waits for our - // termination } wxThreadError wxThreadInternal::Run() { wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING, - "thread may only be started once after successful Create()" ); + wxT("thread may only be started once after Create()") ); - // the mutex was locked on Create(), so we will be able to lock it again - // only when the thread really starts executing and enters the wait - - // otherwise we might signal the condition before anybody is waiting for it - wxMutexLocker lock(m_mutex); - m_cond.Signal(); + SignalRun(); - m_state = STATE_RUNNING; + SetState(STATE_RUNNING); return wxTHREAD_NO_ERROR; - - // now the mutex is unlocked back - but just to allow Wait() function to - // terminate by relocking it, so the net result is that the worker thread - // starts executing and the mutex is still locked } void wxThreadInternal::Wait() { - wxCHECK_RET( WasCancelled(), "thread should have been cancelled first" ); - // 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(); - // entering Wait() releases the mutex thus allowing SignalExit() to acquire - // it and to signal us its termination - m_cond.Wait(m_mutex); + bool isDetached = m_isDetached; + long id = (long)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); + + // 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 + wxCriticalSectionLocker lock(m_csJoinFlag); + + if ( m_shouldBeJoined ) + { + // FIXME shouldn't we set cancellation type to DISABLED here? If + // we're cancelled inside pthread_join(), things will almost + // certainly break - but if we disable the cancellation, we + // might deadlock + if ( pthread_join((pthread_t)id, &m_exitcode) != 0 ) + { + wxLogError(_("Failed to join a thread, potential memory leak " + "detected - please restart the program")); + } - // mutex is still in the locked state - relocked on exit from Wait(), so - // unlock it - we don't need it any more, the thread has already terminated - m_mutex.Unlock(); + m_shouldBeJoined = FALSE; + } + } // reacquire GUI mutex if ( wxThread::IsMain() ) @@ -375,15 +766,18 @@ void wxThreadInternal::Wait() void wxThreadInternal::SignalExit() { - // as mutex is currently locked, this will block until some other thread - // (normally the same which created this one) unlocks it by entering Wait() - m_mutex.Lock(); + wxLogTrace(TRACE_THREADS, _T("Thread %ld about to exit."), GetId()); - // wake up all the threads waiting for our termination - m_cond.Broadcast(); + 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()); - // after this call mutex will be finally unlocked - m_mutex.Unlock(); + m_condEnd.Broadcast(); + } } void wxThreadInternal::Pause() @@ -391,32 +785,42 @@ void wxThreadInternal::Pause() // the state is set from the thread which pauses us first, this function // is called later so the state should have been already set wxCHECK_RET( m_state == STATE_PAUSED, - "thread must first be paused with wxThread::Pause()." ); + wxT("thread must first be paused with wxThread::Pause().") ); - // don't pause the thread which is being terminated - this would lead to - // deadlock if the thread is paused after Delete() had called Resume() but - // before it had time to call Wait() - if ( WasCancelled() ) - return; + wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId()); // wait until the condition is signaled from Resume() - m_condSuspend.Wait(m_mutexSuspend); + m_condSuspend.Wait(); } void wxThreadInternal::Resume() { wxCHECK_RET( m_state == STATE_PAUSED, - "can't resume thread which is not suspended." ); + wxT("can't resume thread which is not suspended.") ); + + // 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()); - // we will be able to lock this mutex only when Pause() starts waiting - wxMutexLocker lock(m_mutexSuspend); - 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); } // ----------------------------------------------------------------------------- -// static functions +// wxThread static functions // ----------------------------------------------------------------------------- wxThread *wxThread::This() @@ -431,7 +835,9 @@ bool wxThread::IsMain() void wxThread::Yield() { +#ifdef HAVE_SCHED_YIELD sched_yield(); +#endif } void wxThread::Sleep(unsigned long milliseconds) @@ -439,65 +845,184 @@ void wxThread::Sleep(unsigned long milliseconds) wxUsleep(milliseconds); } +int wxThread::GetCPUCount() +{ +#if defined(__LINUX__) + // 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; +} + +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 // ----------------------------------------------------------------------------- -wxThread::wxThread() +wxThread::wxThread(wxThreadKind kind) { // add this thread to the global list of all threads gs_allThreads.Add(this); - p_internal = new wxThreadInternal(); + m_internal = new wxThreadInternal(); + + m_isDetached = kind == wxTHREAD_DETACHED; } wxThreadError wxThread::Create() { - if (p_internal->GetState() != STATE_NEW) + if ( m_internal->GetState() != STATE_NEW ) + { + // don't recreate thread return wxTHREAD_RUNNING; + } // set up the thread attribute: right now, we only set thread priority pthread_attr_t attr; pthread_attr_init(&attr); #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS - int prio; - if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 ) + int policy; + if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 ) { wxLogError(_("Cannot retrieve thread scheduling policy.")); } - int min_prio = sched_get_priority_min(prio), - max_prio = sched_get_priority_max(prio); +#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 ) { wxLogError(_("Cannot get priority range for scheduling policy %d."), - prio); + policy); + } + else if ( max_prio == min_prio ) + { + if ( prio != WXTHREAD_DEFAULT_PRIORITY ) + { + // notify the programmer that this doesn't work here + wxLogWarning(_("Thread priority setting is ignored.")); + } + //else: we have default priority, so don't complain + + // anyhow, don't do anything because priority is just ignored } else { struct sched_param sp; - pthread_attr_getschedparam(&attr, &sp); - sp.sched_priority = min_prio + - (p_internal->GetPriority()*(max_prio-min_prio))/100; - pthread_attr_setschedparam(&attr, &sp); + if ( pthread_attr_getschedparam(&attr, &sp) != 0 ) + { + wxFAIL_MSG(_T("pthread_attr_getschedparam() failed")); + } + + sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100; + + if ( pthread_attr_setschedparam(&attr, &sp) != 0 ) + { + wxFAIL_MSG(_T("pthread_attr_setschedparam(priority) failed")); + } } #endif // HAVE_THREAD_PRIORITY_FUNCTIONS #ifdef HAVE_PTHREAD_ATTR_SETSCOPE // this will make the threads created by this process really concurrent - pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); + if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 ) + { + wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed")); + } #endif // HAVE_PTHREAD_ATTR_SETSCOPE + // VZ: assume that this one is always available (it's rather fundamental), + // if this function is ever missing we should try to use + // pthread_detach() instead (after thread creation) + if ( m_isDetached ) + { + if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 ) + { + wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed")); + } + + // never try to join detached threads + m_internal->Detach(); + } + //else: threads are created joinable by default, it's ok + // create the new OS thread object - int rc = pthread_create(p_internal->GetIdPtr(), &attr, - wxThreadInternal::PthreadStart, (void *)this); - pthread_attr_destroy(&attr); + int rc = pthread_create + ( + m_internal->GetIdPtr(), + &attr, + wxThreadInternal::PthreadStart, + (void *)this + ); + + if ( pthread_attr_destroy(&attr) != 0 ) + { + wxFAIL_MSG(_T("pthread_attr_destroy() failed")); + } if ( rc != 0 ) { - p_internal->SetState(STATE_EXITED); + m_internal->SetState(STATE_EXITED); + return wxTHREAD_NO_RESOURCE; } @@ -506,7 +1031,12 @@ wxThreadError wxThread::Create() wxThreadError wxThread::Run() { - return p_internal->Run(); + wxCriticalSectionLocker lock(m_critsect); + + wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR, + wxT("must call wxThread::Create() first") ); + + return m_internal->Run(); } // ----------------------------------------------------------------------------- @@ -517,15 +1047,15 @@ void wxThread::SetPriority(unsigned int prio) { wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) && ((int)prio <= (int)WXTHREAD_MAX_PRIORITY), - "invalid thread priority" ); + wxT("invalid thread priority") ); wxCriticalSectionLocker lock(m_critsect); - switch ( p_internal->GetState() ) + switch ( m_internal->GetState() ) { case STATE_NEW: // thread not yet started, priority will be set when it is - p_internal->SetPriority(prio); + m_internal->SetPriority(prio); break; case STATE_RUNNING: @@ -535,7 +1065,7 @@ void wxThread::SetPriority(unsigned int prio) struct sched_param sparam; sparam.sched_priority = prio; - if ( pthread_setschedparam(p_internal->GetId(), + if ( pthread_setschedparam(m_internal->GetId(), SCHED_OTHER, &sparam) != 0 ) { wxLogError(_("Failed to set thread priority %d."), prio); @@ -546,7 +1076,7 @@ void wxThread::SetPriority(unsigned int prio) case STATE_EXITED: default: - wxFAIL_MSG("impossible to set thread priority in this state"); + wxFAIL_MSG(wxT("impossible to set thread priority in this state")); } } @@ -554,12 +1084,12 @@ unsigned int wxThread::GetPriority() const { wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); - return p_internal->GetPriority(); + return m_internal->GetPriority(); } -unsigned long wxThread::GetID() const +unsigned long wxThread::GetId() const { - return (unsigned long)p_internal->GetId(); + return (unsigned long)m_internal->GetId(); } // ----------------------------------------------------------------------------- @@ -568,35 +1098,56 @@ 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 ( p_internal->GetState() != STATE_RUNNING ) + if ( m_internal->GetState() != STATE_RUNNING ) { - wxLogDebug("Can't pause thread which is not running."); + wxLogDebug(wxT("Can't pause thread which is not running.")); return wxTHREAD_NOT_RUNNING; } - p_internal->SetState(STATE_PAUSED); + 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); return wxTHREAD_NO_ERROR; } wxThreadError wxThread::Resume() { + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + _T("a thread can't resume itself") ); + wxCriticalSectionLocker lock(m_critsect); - if ( p_internal->GetState() == STATE_PAUSED ) - { - p_internal->Resume(); + wxThreadState state = m_internal->GetState(); - return wxTHREAD_NO_ERROR; - } - else + switch ( state ) { - wxLogDebug("Attempt to resume a thread which is not paused."); + case STATE_PAUSED: + wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."), + GetId()); + + m_internal->Resume(); - return wxTHREAD_MISC_ERROR; + return wxTHREAD_NO_ERROR; + + case STATE_EXITED: + wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."), + GetId()); + return wxTHREAD_NO_ERROR; + + default: + wxLogDebug(_T("Attempt to resume a thread which is not paused.")); + + return wxTHREAD_MISC_ERROR; } } @@ -604,47 +1155,97 @@ wxThreadError wxThread::Resume() // exiting thread // ----------------------------------------------------------------------------- -wxThread::ExitCode wxThread::Delete() +wxThread::ExitCode wxThread::Wait() { + wxCHECK_MSG( This() != this, (ExitCode)-1, + _T("a thread can't wait for itself") ); + + wxCHECK_MSG( !m_isDetached, (ExitCode)-1, + _T("can't wait for detached thread") ); + + m_internal->Wait(); + + return m_internal->GetExitCode(); +} + +wxThreadError wxThread::Delete(ExitCode *rc) +{ + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + _T("a thread can't delete itself") ); + m_critsect.Enter(); - wxThreadState state = p_internal->GetState(); - m_critsect.Leave(); + wxThreadState state = m_internal->GetState(); // ask the thread to stop - p_internal->SetCancelFlag(); + m_internal->SetCancelFlag(); + + 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 + m_internal->SignalRun(); + + // fall through + case STATE_EXITED: // nothing to do break; case STATE_PAUSED: - // resume the thread first - Resume(); + // resume the thread first (don't call our Resume() because this + // would dead lock when it tries to enter m_critsect) + m_internal->Resume(); // fall through default: // wait until the thread stops - p_internal->Wait(); + m_internal->Wait(); + + if ( rc ) + { + wxASSERT_MSG( !m_isDetached, + _T("no return code for detached threads") ); + + // if it's a joinable thread, it's not deleted yet + *rc = m_internal->GetExitCode(); + } } - return NULL; + return wxTHREAD_NO_ERROR; } wxThreadError wxThread::Kill() { - switch ( p_internal->GetState() ) + wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, + _T("a thread can't kill itself") ); + + switch ( m_internal->GetState() ) { case STATE_NEW: case STATE_EXITED: return wxTHREAD_NOT_RUNNING; + case STATE_PAUSED: + // resume the thread first + Resume(); + + // fall through + default: -#ifdef HAVE_PTHREAD_CANCEL - if ( pthread_cancel(p_internal->GetId()) != 0 ) +#ifdef HAVE_PTHREAD_CANCEL + if ( pthread_cancel(m_internal->GetId()) != 0 ) #endif { wxLogError(_("Failed to terminate a thread.")); @@ -652,50 +1253,135 @@ wxThreadError wxThread::Kill() return wxTHREAD_MISC_ERROR; } + if ( m_isDetached ) + { + // if we use cleanup function, this will be done from + // PthreadCleanup() +#if !HAVE_THREAD_CLEANUP_FUNCTIONS + ScheduleThreadForDeletion(); + + // don't call OnExit() here, it can only be called in the + // threads context and we're in the context of another thread + + DeleteThread(this); +#endif // HAVE_THREAD_CLEANUP_FUNCTIONS + } + else + { + m_internal->SetExitCode(EXITCODE_CANCELLED); + } + return wxTHREAD_NO_ERROR; } } -void wxThread::Exit(void *status) +void wxThread::Exit(ExitCode status) { - // first call user-level clean up code + 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 + 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 + // common case) while the main thread calls any of functions entering + // 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!) - p_internal->SignalExit(); + m_internal->SignalExit(); - p_internal->SetState(STATE_EXITED); + // leave the critical section before entering the dtor which tries to + // enter it + m_critsect.Leave(); - // delete both C++ thread object and terminate the OS thread object - delete this; + // delete C++ thread object if this is a detached thread - user is + // responsible for doing this for joinable ones + if ( m_isDetached ) + { + // FIXME I'm feeling bad about it - what if another thread function is + // called (in another thread context) now? It will try to access + // half destroyed object which will probably result in something + // very bad - but we can't protect this by a crit section unless + // we make it a global object, but this would mean that we can + // only call one thread function at a time :-( + DeleteThread(this); + } + + // terminate the thread (pthread_exit() never returns) pthread_exit(status); + + wxFAIL_MSG(_T("pthread_exit() failed")); } // also test whether we were paused bool wxThread::TestDestroy() { - wxCriticalSectionLocker lock(m_critsect); + wxASSERT_MSG( This() == this, + _T("wxThread::TestDestroy() can only be called in the " + "context of the same thread") ); + + m_critsect.Enter(); - if ( p_internal->GetState() == STATE_PAUSED ) + if ( m_internal->GetState() == STATE_PAUSED ) { - // leave the crit section or the other threads will stop too if they try - // to call any of (seemingly harmless) IsXXX() functions while we sleep - m_critsect.Leave(); + m_internal->SetReallyPaused(TRUE); - p_internal->Pause(); + // leave the crit section or the other threads will stop too if they + // try to call any of (seemingly harmless) IsXXX() functions while we + // sleep + m_critsect.Leave(); - // enter it back before it's finally left in lock object dtor - m_critsect.Enter(); + m_internal->Pause(); + } + else + { + // thread wasn't requested to pause, nothing to do + m_critsect.Leave(); } - return p_internal->WasCancelled(); + return m_internal->WasCancelled(); } wxThread::~wxThread() { +#ifdef __WXDEBUG__ + m_critsect.Enter(); + + // check that the thread either exited or couldn't be created + if ( m_internal->GetState() != STATE_EXITED && + m_internal->GetState() != STATE_NEW ) + { + wxLogDebug(_T("The thread %ld is being destroyed although it is still " + "running! The application may crash."), GetId()); + } + + m_critsect.Leave(); +#endif // __WXDEBUG__ + + delete m_internal; + // 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); + } } // ----------------------------------------------------------------------------- @@ -706,14 +1392,14 @@ bool wxThread::IsRunning() const { wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); - return p_internal->GetState() == STATE_RUNNING; + return m_internal->GetState() == STATE_RUNNING; } bool wxThread::IsAlive() const { wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect); - switch ( p_internal->GetState() ) + switch ( m_internal->GetState() ) { case STATE_RUNNING: case STATE_PAUSED: @@ -724,6 +1410,13 @@ bool wxThread::IsAlive() const } } +bool wxThread::IsPaused() const +{ + wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect); + + return (m_internal->GetState() == STATE_PAUSED); +} + //-------------------------------------------------------------------- // wxThreadModule //-------------------------------------------------------------------- @@ -751,36 +1444,62 @@ bool wxThreadModule::OnInit() return FALSE; } - gs_mutexGui = new wxMutex(); + gs_tidMain = pthread_self(); - //wxThreadGuiInit(); +#if wxUSE_GUI + gs_mutexGui = new wxMutex(); - gs_tidMain = pthread_self(); 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; } void wxThreadModule::OnExit() { - wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" ); + wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") ); + + // are there any threads left which are being deleted right now? + size_t nThreadsBeingDeleted; + { + MutexLock lock(gs_mutexDeleteThread); + nThreadsBeingDeleted = gs_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(); + } // terminate any threads left size_t count = gs_allThreads.GetCount(); if ( count != 0u ) - wxLogDebug("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++ ) { - gs_allThreads[n]->Delete(); + // Delete calls the destructor which removes the current entry. We + // should only delete the first one each time. + gs_allThreads[0]->Delete(); } +#if wxUSE_GUI // destroy GUI mutex gs_mutexGui->Unlock(); - //wxThreadGuiExit(); - delete gs_mutexGui; +#endif // wxUSE_GUI // and free TLD slot (void)pthread_key_delete(gs_keySelf); @@ -790,14 +1509,63 @@ void wxThreadModule::OnExit() // global functions // ---------------------------------------------------------------------------- +static void ScheduleThreadForDeletion() +{ + MutexLock lock(gs_mutexDeleteThread); + + if ( gs_nThreadsBeingDeleted == 0 ) + { + gs_condAllDeleted = new wxCondition; + } + + gs_nThreadsBeingDeleted++; + + wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"), + gs_nThreadsBeingDeleted, + gs_nThreadsBeingDeleted == 1 ? "" : "s"); +} + +static void DeleteThread(wxThread *This) +{ + // gs_mutexDeleteThread should be unlocked before signalling the condition + // or wxThreadModule::OnExit() would deadlock + { + MutexLock lock(gs_mutexDeleteThread); + + wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); + + delete This; + + 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); + + if ( !--gs_nThreadsBeingDeleted ) + { + // no more threads left, signal it + gs_condAllDeleted->Signal(); + + delete gs_condAllDeleted; + gs_condAllDeleted = (wxCondition *)NULL; + } +} + void wxMutexGuiEnter() { - gs_mutexGui->Lock(); +#if wxUSE_GUI + gs_mutexGui->Lock(); +#endif // wxUSE_GUI } void wxMutexGuiLeave() { - gs_mutexGui->Unlock(); +#if wxUSE_GUI + gs_mutexGui->Unlock(); +#endif // wxUSE_GUI } #endif