X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0eb949e11fc9ef4aa72c072ba9d1025ed08ce199..ad653fa23069c5d9378247084f03c9a718c3ad62:/src/unix/threadpsx.cpp?ds=sidebyside diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index a133ba9fa0..8f36dd3ba7 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -45,6 +45,7 @@ #include #include #include +#include // needed for at least __QNX__ #ifdef HAVE_SCHED_H #include #endif @@ -53,31 +54,22 @@ #include #endif -// we use wxFFile under Linux in GetCPUCount() -#ifdef __LINUX__ - #include "wx/ffile.h" - // For setpriority. - #include - #include +#ifdef HAVE_ABI_FORCEDUNWIND + #include #endif -#ifdef __VMS - #define THR_ID(thr) ((long long)(thr)->GetId()) -#else - #define THR_ID(thr) ((long)(thr)->GetId()) +#ifdef HAVE_SETPRIORITY + #include // for setpriority() #endif -#ifdef __WXMAC__ - - // implement wxCriticalSection using mutexes -wxCriticalSection::wxCriticalSection( wxCriticalSectionType critSecType ) - : m_mutex( critSecType == wxCRITSEC_DEFAULT ? wxMUTEX_RECURSIVE : wxMUTEX_DEFAULT ) { } -wxCriticalSection::~wxCriticalSection() { } +// we use wxFFile under Linux in GetCPUCount() +#ifdef __LINUX__ + #include "wx/ffile.h" +#endif -void wxCriticalSection::Enter() { (void)m_mutex.Lock(); } -void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); } +#define THR_ID_CAST(id) (reinterpret_cast(id)) +#define THR_ID(thr) THR_ID_CAST((thr)->GetId()) -#endif // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -95,10 +87,10 @@ enum wxThreadState static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1; // trace mask for wxThread operations -#define TRACE_THREADS _T("thread") +#define TRACE_THREADS wxT("thread") // you can get additional debugging messages for the semaphore operations -#define TRACE_SEMA _T("semaphore") +#define TRACE_SEMA wxT("semaphore") // ---------------------------------------------------------------------------- // private functions @@ -129,7 +121,11 @@ static wxArrayThread gs_allThreads; static wxMutex *gs_mutexAllThreads = NULL; // the id of the main thread -static pthread_t gs_tidMain = (pthread_t)-1; +// +// we suppose that 0 is not a valid pthread_t value but in principle this might +// be false (e.g. if it's a selector-like value), wxThread::IsMain() would need +// to be updated in such case +wxThreadIdType wxThread::ms_idMainThread = 0; // the key for the pointer to the associated wxThread object static pthread_key_t gs_keySelf; @@ -139,16 +135,18 @@ static pthread_key_t gs_keySelf; static size_t gs_nThreadsBeingDeleted = 0; // a mutex to protect gs_nThreadsBeingDeleted -static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL; +static wxMutex *gs_mutexDeleteThread = NULL; // and a condition variable which will be signaled when all // gs_nThreadsBeingDeleted will have been deleted -static wxCondition *gs_condAllDeleted = (wxCondition *)NULL; +static wxCondition *gs_condAllDeleted = NULL; +#ifndef __WXOSX__ // this mutex must be acquired before any call to a GUI function // (it's not inside #if wxUSE_GUI because this file is compiled as part // of wxBase) static wxMutex *gs_mutexGui = NULL; +#endif // when we wait for a thread to exit, we're blocking on a condition which the // thread signals in its SignalExit() method -- but this condition can't be a @@ -189,6 +187,8 @@ private: private: pthread_mutex_t m_mutex; bool m_isOk; + wxMutexType m_type; + unsigned long m_owningThread; // wxConditionInternal uses our m_mutex friend class wxConditionInternal; @@ -203,6 +203,9 @@ extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int); wxMutexInternal::wxMutexInternal(wxMutexType mutexType) { + m_type = mutexType; + m_owningThread = 0; + int err; switch ( mutexType ) { @@ -234,7 +237,7 @@ wxMutexInternal::wxMutexInternal(wxMutexType mutexType) break; default: - wxFAIL_MSG( _T("unknown mutex type") ); + wxFAIL_MSG( wxT("unknown mutex type") ); // fall through case wxMUTEX_DEFAULT: @@ -263,6 +266,12 @@ wxMutexInternal::~wxMutexInternal() wxMutexError wxMutexInternal::Lock() { + if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0)) + { + if (m_owningThread == wxThread::GetCurrentId()) + return wxMUTEX_DEAD_LOCK; + } + return HandleLockResult(pthread_mutex_lock(&m_mutex)); } @@ -318,26 +327,30 @@ wxMutexError wxMutexInternal::Lock(unsigned long ms) wxMutexError wxMutexInternal::HandleLockResult(int err) { + // wxPrintf( "err %d\n", err ); + switch ( err ) { case EDEADLK: // only error checking mutexes return this value and so it's an // unexpected situation -- hence use assert, not wxLogDebug - wxFAIL_MSG( _T("mutex deadlock prevented") ); + wxFAIL_MSG( wxT("mutex deadlock prevented") ); return wxMUTEX_DEAD_LOCK; case EINVAL: - wxLogDebug(_T("pthread_mutex_[timed]lock(): mutex not initialized")); + wxLogDebug(wxT("pthread_mutex_[timed]lock(): mutex not initialized")); break; case ETIMEDOUT: return wxMUTEX_TIMEOUT; case 0: + if (m_type == wxMUTEX_DEFAULT) + m_owningThread = wxThread::GetCurrentId(); return wxMUTEX_NO_ERROR; default: - wxLogApiError(_T("pthread_mutex_[timed]lock()"), err); + wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err); } return wxMUTEX_MISC_ERROR; @@ -355,14 +368,16 @@ wxMutexError wxMutexInternal::TryLock() return wxMUTEX_BUSY; case EINVAL: - wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized.")); + wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized.")); break; case 0: + if (m_type == wxMUTEX_DEFAULT) + m_owningThread = wxThread::GetCurrentId(); return wxMUTEX_NO_ERROR; default: - wxLogApiError(_T("pthread_mutex_trylock()"), err); + wxLogApiError(wxT("pthread_mutex_trylock()"), err); } return wxMUTEX_MISC_ERROR; @@ -370,6 +385,8 @@ wxMutexError wxMutexInternal::TryLock() wxMutexError wxMutexInternal::Unlock() { + m_owningThread = 0; + int err = pthread_mutex_unlock(&m_mutex); switch ( err ) { @@ -378,14 +395,14 @@ wxMutexError wxMutexInternal::Unlock() return wxMUTEX_UNLOCKED; case EINVAL: - wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized.")); + wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized.")); break; case 0: return wxMUTEX_NO_ERROR; default: - wxLogApiError(_T("pthread_mutex_unlock()"), err); + wxLogApiError(wxT("pthread_mutex_unlock()"), err); } return wxMUTEX_MISC_ERROR; @@ -434,7 +451,7 @@ wxConditionInternal::wxConditionInternal(wxMutex& mutex) if ( !m_isOk ) { - wxLogApiError(_T("pthread_cond_init()"), err); + wxLogApiError(wxT("pthread_cond_init()"), err); } } @@ -445,7 +462,7 @@ wxConditionInternal::~wxConditionInternal() int err = pthread_cond_destroy(&m_cond); if ( err != 0 ) { - wxLogApiError(_T("pthread_cond_destroy()"), err); + wxLogApiError(wxT("pthread_cond_destroy()"), err); } } } @@ -455,7 +472,7 @@ wxCondError wxConditionInternal::Wait() int err = pthread_cond_wait(&m_cond, GetPMutex()); if ( err != 0 ) { - wxLogApiError(_T("pthread_cond_wait()"), err); + wxLogApiError(wxT("pthread_cond_wait()"), err); return wxCOND_MISC_ERROR; } @@ -465,7 +482,7 @@ wxCondError wxConditionInternal::Wait() wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds) { - wxLongLong curtime = wxGetLocalTimeMillis(); + wxLongLong curtime = wxGetUTCTimeMillis(); curtime += milliseconds; wxLongLong temp = curtime / 1000; int sec = temp.GetLo(); @@ -488,7 +505,7 @@ wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds) return wxCOND_NO_ERROR; default: - wxLogApiError(_T("pthread_cond_timedwait()"), err); + wxLogApiError(wxT("pthread_cond_timedwait()"), err); } return wxCOND_MISC_ERROR; @@ -499,7 +516,7 @@ wxCondError wxConditionInternal::Signal() int err = pthread_cond_signal(&m_cond); if ( err != 0 ) { - wxLogApiError(_T("pthread_cond_signal()"), err); + wxLogApiError(wxT("pthread_cond_signal()"), err); return wxCOND_MISC_ERROR; } @@ -512,7 +529,7 @@ wxCondError wxConditionInternal::Broadcast() int err = pthread_cond_broadcast(&m_cond); if ( err != 0 ) { - wxLogApiError(_T("pthread_cond_broadcast()"), err); + wxLogApiError(wxT("pthread_cond_broadcast()"), err); return wxCOND_MISC_ERROR; } @@ -561,7 +578,7 @@ wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) if ( (initialcount < 0 || maxcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) ) { - wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") ); + wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") ); m_isOk = false; } @@ -581,15 +598,15 @@ wxSemaError wxSemaphoreInternal::Wait() while ( m_count == 0 ) { wxLogTrace(TRACE_SEMA, - _T("Thread %ld waiting for semaphore to become signalled"), - wxThread::GetCurrentId()); + wxT("Thread %p waiting for semaphore to become signalled"), + THR_ID_CAST(wxThread::GetCurrentId())); if ( m_cond.Wait() != wxCOND_NO_ERROR ) return wxSEMA_MISC_ERROR; wxLogTrace(TRACE_SEMA, - _T("Thread %ld finished waiting for semaphore, count = %lu"), - wxThread::GetCurrentId(), (unsigned long)m_count); + wxT("Thread %p finished waiting for semaphore, count = %lu"), + THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count); } m_count--; @@ -655,8 +672,8 @@ wxSemaError wxSemaphoreInternal::Post() m_count++; wxLogTrace(TRACE_SEMA, - _T("Thread %ld about to signal semaphore, count = %lu"), - wxThread::GetCurrentId(), (unsigned long)m_count); + wxT("Thread %p about to signal semaphore, count = %lu"), + THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count); return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR : wxSEMA_MISC_ERROR; @@ -693,6 +710,8 @@ public: static void *PthreadStart(wxThread *thread); // thread actions + // create the thread + wxThreadError Create(wxThread *thread, unsigned int stackSize); // start the thread wxThreadError Run(); // unblock the thread allowing it to run @@ -712,24 +731,26 @@ public: wxThreadState GetState() const { return m_state; } void SetState(wxThreadState state) { -#ifdef __WXDEBUG__ - static const wxChar *stateNames[] = +#if wxUSE_LOG_TRACE + static const wxChar *const stateNames[] = { - _T("NEW"), - _T("RUNNING"), - _T("PAUSED"), - _T("EXITED"), + wxT("NEW"), + wxT("RUNNING"), + wxT("PAUSED"), + wxT("EXITED"), }; - wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."), - (long)GetId(), stateNames[m_state], stateNames[state]); -#endif // __WXDEBUG__ + wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."), + THR_ID(this), stateNames[m_state], stateNames[state]); +#endif // wxUSE_LOG_TRACE m_state = state; } // id pthread_t GetId() const { return m_threadId; } pthread_t *GetIdPtr() { return &m_threadId; } + // "created" flag + bool WasCreated() const { return m_created; } // "cancelled" flag void SetCancelFlag() { m_cancelled = true; } bool WasCancelled() const { return m_cancelled; } @@ -760,6 +781,9 @@ private: wxThreadState m_state; // see wxThreadState enum int m_prio; // in wxWidgets units: from 0 to 100 + // this flag is set when the thread was successfully created + bool m_created; + // this flag is set when the thread should terminate bool m_cancelled; @@ -798,14 +822,14 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; - wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread)); + wxLogTrace(TRACE_THREADS, wxT("Thread %p started."), THR_ID(pthread)); // 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 ) { - wxLogSysError(rc, _("Cannot start thread: error writing TLS")); + wxLogSysError(rc, _("Cannot start thread: error writing TLS.")); return (void *)-1; } @@ -836,7 +860,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { // call the main entry wxLogTrace(TRACE_THREADS, - _T("Thread %ld about to enter its Entry()."), + wxT("Thread %p about to enter its Entry()."), THR_ID(pthread)); wxTRY @@ -844,9 +868,21 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) pthread->m_exitcode = thread->Entry(); wxLogTrace(TRACE_THREADS, - _T("Thread %ld Entry() returned %lu."), + wxT("Thread %p Entry() returned %lu."), THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); } +#ifdef HAVE_ABI_FORCEDUNWIND + // When using common C++ ABI under Linux we must always rethrow this + // special exception used to unwind the stack when the thread was + // cancelled, otherwise the thread library would simply terminate the + // program, see http://udrepper.livejournal.com/21541.html + catch ( abi::__forced_unwind& ) + { + wxCriticalSectionLocker lock(thread->m_critsect); + pthread->SetState(STATE_EXITED); + throw; + } +#endif // HAVE_ABI_FORCEDUNWIND wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) { @@ -927,8 +963,9 @@ void wxThreadInternal::Cleanup(wxThread *thread) wxThreadInternal::wxThreadInternal() { m_state = STATE_NEW; + m_created = false; m_cancelled = false; - m_prio = WXTHREAD_DEFAULT_PRIORITY; + m_prio = wxPRIORITY_DEFAULT; m_threadId = 0; m_exitcode = 0; @@ -944,6 +981,132 @@ wxThreadInternal::~wxThreadInternal() { } +#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE + #define WXUNUSED_STACKSIZE(identifier) identifier +#else + #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier) +#endif + +wxThreadError wxThreadInternal::Create(wxThread *thread, + unsigned int WXUNUSED_STACKSIZE(stackSize)) +{ + if ( 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_PTHREAD_ATTR_SETSTACKSIZE + if (stackSize) + pthread_attr_setstacksize(&attr, stackSize); +#endif + +#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS + int policy; + if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 ) + { + wxLogError(_("Cannot retrieve thread scheduling 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 = GetPriority(); + + if ( min_prio == -1 || max_prio == -1 ) + { + wxLogError(_("Cannot get priority range for scheduling policy %d."), + policy); + } + else if ( max_prio == min_prio ) + { + if ( prio != wxPRIORITY_DEFAULT ) + { + // 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; + if ( pthread_attr_getschedparam(&attr, &sp) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed")); + } + + sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100; + + if ( pthread_attr_setschedparam(&attr, &sp) != 0 ) + { + wxFAIL_MSG(wxT("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 + if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 ) + { + wxFAIL_MSG(wxT("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 ( thread->IsDetached() ) + { + if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed")); + } + + // never try to join detached threads + Detach(); + } + //else: threads are created joinable by default, it's ok + + // create the new OS thread object + int rc = pthread_create + ( + GetIdPtr(), + &attr, + wxPthreadStart, + (void *)thread + ); + + if ( pthread_attr_destroy(&attr) != 0 ) + { + wxFAIL_MSG(wxT("pthread_attr_destroy() failed")); + } + + if ( rc != 0 ) + { + SetState(STATE_EXITED); + + return wxTHREAD_NO_RESOURCE; + } + + m_created = true; + return wxTHREAD_NO_ERROR; +} + wxThreadError wxThreadInternal::Run() { wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING, @@ -959,15 +1122,25 @@ wxThreadError wxThreadInternal::Run() void wxThreadInternal::Wait() { - wxCHECK_RET( !m_isDetached, _T("can't wait for a detached thread") ); + wxCHECK_RET( !m_isDetached, wxT("can't wait for a detached thread") ); // if the thread we're waiting for is waiting for the GUI mutex, we will // deadlock so make sure we release it temporarily if ( wxThread::IsMain() ) + { +#ifdef __WXOSX__ + // give the thread we're waiting for chance to do the GUI call + // it might be in, we don't do this conditionally as the to be waited on + // thread might have to acquire the mutex later but before terminating + if ( wxGuiOwnedByMainThread() ) + wxMutexGuiLeave(); +#else wxMutexGuiLeave(); +#endif + } wxLogTrace(TRACE_THREADS, - _T("Starting to wait for thread %ld to exit."), + wxT("Starting to wait for thread %p to exit."), THR_ID(this)); // to avoid memory leaks we should call pthread_join(), but it must only be @@ -994,9 +1167,11 @@ void wxThreadInternal::Wait() } } +#ifndef __WXOSX__ // reacquire GUI mutex if ( wxThread::IsMain() ) wxMutexGuiEnter(); +#endif } void wxThreadInternal::Pause() @@ -1007,7 +1182,7 @@ void wxThreadInternal::Pause() wxT("thread must first be paused with wxThread::Pause().") ); wxLogTrace(TRACE_THREADS, - _T("Thread %ld goes to sleep."), THR_ID(this)); + wxT("Thread %p goes to sleep."), THR_ID(this)); // wait until the semaphore is Post()ed from Resume() m_semSuspend.Wait(); @@ -1023,7 +1198,7 @@ void wxThreadInternal::Resume() if ( IsReallyPaused() ) { wxLogTrace(TRACE_THREADS, - _T("Waking up thread %ld"), THR_ID(this)); + wxT("Waking up thread %p"), THR_ID(this)); // wake up Pause() m_semSuspend.Post(); @@ -1034,7 +1209,7 @@ void wxThreadInternal::Resume() else { wxLogTrace(TRACE_THREADS, - _T("Thread %ld is not yet really paused"), THR_ID(this)); + wxT("Thread %p is not yet really paused"), THR_ID(this)); } SetState(STATE_RUNNING); @@ -1049,11 +1224,6 @@ wxThread *wxThread::This() return (wxThread *)pthread_getspecific(gs_keySelf); } -bool wxThread::IsMain() -{ - return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1; -} - void wxThread::Yield() { #ifdef HAVE_SCHED_YIELD @@ -1075,7 +1245,7 @@ int wxThread::GetCPUCount() // it has 0 size but still can be read from) wxLogNull nolog; - wxFFile file(_T("/proc/cpuinfo")); + wxFFile file(wxT("/proc/cpuinfo")); if ( file.IsOpened() ) { // slurp the whole file @@ -1083,17 +1253,17 @@ int wxThread::GetCPUCount() if ( file.ReadAll(&s) ) { // (ab)use Replace() to find the number of "processor: num" strings - size_t count = s.Replace(_T("processor\t:"), _T("")); + size_t count = s.Replace(wxT("processor\t:"), wxT("")); if ( count > 0 ) { return count; } - wxLogDebug(_T("failed to parse /proc/cpuinfo")); + wxLogDebug(wxT("failed to parse /proc/cpuinfo")); } else { - wxLogDebug(_T("failed to read /proc/cpuinfo")); + wxLogDebug(wxT("failed to read /proc/cpuinfo")); } } #endif // different ways to get number of CPUs @@ -1102,38 +1272,31 @@ int wxThread::GetCPUCount() return -1; } -// VMS is a 64 bit system and threads have 64 bit pointers. -// FIXME: also needed for other systems???? -#ifdef __VMS -unsigned long long wxThread::GetCurrentId() +wxThreadIdType wxThread::GetCurrentId() { - return (unsigned long long)pthread_self(); + return (wxThreadIdType)pthread_self(); } -#else // !__VMS - -unsigned long wxThread::GetCurrentId() -{ - return (unsigned long)pthread_self(); -} - -#endif // __VMS/!__VMS - bool wxThread::SetConcurrency(size_t level) { -#ifdef HAVE_THR_SETCONCURRENCY +#ifdef HAVE_PTHREAD_SET_CONCURRENCY + int rc = pthread_setconcurrency( level ); +#elif defined(HAVE_THR_SETCONCURRENCY) int rc = thr_setconcurrency(level); +#else // !HAVE_THR_SETCONCURRENCY + // ok only for the default value + int rc = level == 0 ? 0 : -1; +#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY + if ( rc != 0 ) { - wxLogSysError(rc, _T("thr_setconcurrency() failed")); + wxLogSysError(rc, _("Failed to set thread concurrency level to %lu"), + static_cast(level)); + return false; } - return rc == 0; -#else // !HAVE_THR_SETCONCURRENCY - // ok only for the default value - return level == 0; -#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY + return true; } // ----------------------------------------------------------------------------- @@ -1154,136 +1317,25 @@ wxThread::wxThread(wxThreadKind kind) m_isDetached = kind == wxTHREAD_DETACHED; } -#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE - #define WXUNUSED_STACKSIZE(identifier) identifier -#else - #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier) -#endif - -wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize)) +wxThreadError wxThread::Create(unsigned int stackSize) { - 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_PTHREAD_ATTR_SETSTACKSIZE - if (stackSize) - pthread_attr_setstacksize(&attr, stackSize); -#endif - -#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS - int policy; - if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 ) - { - wxLogError(_("Cannot retrieve thread scheduling 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 ) - { - wxLogError(_("Cannot get priority range for scheduling policy %d."), - 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; - 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 - 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 - ( - m_internal->GetIdPtr(), - &attr, - wxPthreadStart, - (void *)this - ); - - if ( pthread_attr_destroy(&attr) != 0 ) - { - wxFAIL_MSG(_T("pthread_attr_destroy() failed")); - } - - if ( rc != 0 ) - { - m_internal->SetState(STATE_EXITED); - - return wxTHREAD_NO_RESOURCE; - } + wxCriticalSectionLocker lock(m_critsect); - return wxTHREAD_NO_ERROR; + return m_internal->Create(this, stackSize); } wxThreadError wxThread::Run() { wxCriticalSectionLocker lock(m_critsect); - wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR, - wxT("must call wxThread::Create() first") ); + // Create the thread if it wasn't created yet with an explicit + // Create() call: + if ( !m_internal->WasCreated() ) + { + wxThreadError rv = m_internal->Create(this, 0); + if ( rv != wxTHREAD_NO_ERROR ) + return rv; + } return m_internal->Run(); } @@ -1294,8 +1346,7 @@ wxThreadError wxThread::Run() void wxThread::SetPriority(unsigned int prio) { - wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) && - ((int)prio <= (int)WXTHREAD_MAX_PRIORITY), + wxCHECK_RET( wxPRIORITY_MIN <= prio && prio <= wxPRIORITY_MAX, wxT("invalid thread priority") ); wxCriticalSectionLocker lock(m_critsect); @@ -1321,8 +1372,7 @@ void wxThread::SetPriority(unsigned int prio) // // FIXME this is not true for 2.6!! - // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY - // to Unix priorities 20..-20 + // map wx priorites 0..100 to Unix priorities 20..-20 if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 ) { wxLogError(_("Failed to set thread priority %d."), prio); @@ -1367,7 +1417,7 @@ wxThreadIdType wxThread::GetId() const wxThreadError wxThread::Pause() { wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, - _T("a thread can't pause itself") ); + wxT("a thread can't pause itself") ); wxCriticalSectionLocker lock(m_critsect); @@ -1388,7 +1438,7 @@ wxThreadError wxThread::Pause() wxThreadError wxThread::Resume() { wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, - _T("a thread can't resume itself") ); + wxT("a thread can't resume itself") ); wxCriticalSectionLocker lock(m_critsect); @@ -1397,20 +1447,20 @@ wxThreadError wxThread::Resume() switch ( state ) { case STATE_PAUSED: - wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."), - GetId()); + wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."), + THR_ID(this)); m_internal->Resume(); return wxTHREAD_NO_ERROR; case STATE_EXITED: - wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."), - GetId()); + wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."), + THR_ID(this)); return wxTHREAD_NO_ERROR; default: - wxLogDebug(_T("Attempt to resume a thread which is not paused.")); + wxLogDebug(wxT("Attempt to resume a thread which is not paused.")); return wxTHREAD_MISC_ERROR; } @@ -1420,23 +1470,23 @@ wxThreadError wxThread::Resume() // exiting thread // ----------------------------------------------------------------------------- -wxThread::ExitCode wxThread::Wait() +wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode)) { wxCHECK_MSG( This() != this, (ExitCode)-1, - _T("a thread can't wait for itself") ); + wxT("a thread can't wait for itself") ); wxCHECK_MSG( !m_isDetached, (ExitCode)-1, - _T("can't wait for detached thread") ); + wxT("can't wait for detached thread") ); m_internal->Wait(); return m_internal->GetExitCode(); } -wxThreadError wxThread::Delete(ExitCode *rc) +wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode)) { wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, - _T("a thread can't delete itself") ); + wxT("a thread can't delete itself") ); bool isDetached = m_isDetached; @@ -1448,6 +1498,8 @@ wxThreadError wxThread::Delete(ExitCode *rc) m_critsect.Leave(); + OnDelete(); + switch ( state ) { case STATE_NEW: @@ -1483,13 +1535,20 @@ wxThreadError wxThread::Delete(ExitCode *rc) //else: can't wait for detached threads } + if (state == STATE_NEW) + return wxTHREAD_MISC_ERROR; + // for coherency with the MSW implementation, signal the user that + // Delete() was called on a thread which didn't start to run yet. + return wxTHREAD_NO_ERROR; } wxThreadError wxThread::Kill() { wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR, - _T("a thread can't kill itself") ); + wxT("a thread can't kill itself") ); + + OnKill(); switch ( m_internal->GetState() ) { @@ -1540,7 +1599,7 @@ 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") ); + wxT("wxThread::Exit() can only be called in the context of the same thread") ); if ( m_isDetached ) { @@ -1583,14 +1642,14 @@ void wxThread::Exit(ExitCode status) // terminate the thread (pthread_exit() never returns) pthread_exit(status); - wxFAIL_MSG(_T("pthread_exit() failed")); + wxFAIL_MSG(wxT("pthread_exit() failed")); } // 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") ); + wxT("wxThread::TestDestroy() can only be called in the context of the same thread") ); m_critsect.Enter(); @@ -1616,19 +1675,17 @@ bool wxThread::TestDestroy() 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."), - (long)GetId()); + wxLogDebug(wxT("The thread %p is being destroyed although it is still running! The application may crash."), + THR_ID(this)); } m_critsect.Leave(); -#endif // __WXDEBUG__ delete m_internal; @@ -1677,6 +1734,11 @@ bool wxThread::IsPaused() const // wxThreadModule //-------------------------------------------------------------------- +#ifdef __WXOSX__ +void wxOSXThreadModuleOnInit(); +void wxOSXThreadModuleOnExit(); +#endif + class wxThreadModule : public wxModule { public: @@ -1699,12 +1761,16 @@ bool wxThreadModule::OnInit() return false; } - gs_tidMain = pthread_self(); + wxThread::ms_idMainThread = wxThread::GetCurrentId(); gs_mutexAllThreads = new wxMutex(); +#ifdef __WXOSX__ + wxOSXThreadModuleOnInit(); +#else gs_mutexGui = new wxMutex(); gs_mutexGui->Lock(); +#endif gs_mutexDeleteThread = new wxMutex(); gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread); @@ -1726,7 +1792,7 @@ void wxThreadModule::OnExit() if ( nThreadsBeingDeleted > 0 ) { wxLogTrace(TRACE_THREADS, - _T("Waiting for %lu threads to disappear"), + wxT("Waiting for %lu threads to disappear"), (unsigned long)nThreadsBeingDeleted); // have to wait until all of them disappear @@ -1757,9 +1823,13 @@ void wxThreadModule::OnExit() delete gs_mutexAllThreads; +#ifdef __WXOSX__ + wxOSXThreadModuleOnExit(); +#else // destroy GUI mutex gs_mutexGui->Unlock(); delete gs_mutexGui; +#endif // and free TLD slot (void)pthread_key_delete(gs_keySelf); @@ -1778,25 +1848,26 @@ static void ScheduleThreadForDeletion() gs_nThreadsBeingDeleted++; - wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"), + wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"), (unsigned long)gs_nThreadsBeingDeleted, - gs_nThreadsBeingDeleted == 1 ? _T("") : _T("s")); + gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s")); } static void DeleteThread(wxThread *This) { - // gs_mutexDeleteThread should be unlocked before signalling the condition - // or wxThreadModule::OnExit() would deadlock - wxMutexLocker locker( *gs_mutexDeleteThread ); - - wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); + wxLogTrace(TRACE_THREADS, wxT("Thread %p auto deletes."), THR_ID(This)); delete This; + // only lock gs_mutexDeleteThread after deleting the thread to avoid + // calling out into user code with it locked as this may result in + // deadlocks if the thread dtor deletes another thread (see #11501) + wxMutexLocker locker( *gs_mutexDeleteThread ); + wxCHECK_RET( gs_nThreadsBeingDeleted > 0, - _T("no threads scheduled for deletion, yet we delete one?") ); + wxT("no threads scheduled for deletion, yet we delete one?") ); - wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."), + wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."), (unsigned long)gs_nThreadsBeingDeleted - 1); if ( !--gs_nThreadsBeingDeleted ) @@ -1806,6 +1877,8 @@ static void DeleteThread(wxThread *This) } } +#ifndef __DARWIN__ + void wxMutexGuiEnterImpl() { gs_mutexGui->Lock(); @@ -1816,6 +1889,8 @@ void wxMutexGuiLeaveImpl() gs_mutexGui->Unlock(); } +#endif + // ---------------------------------------------------------------------------- // include common implementation code // ----------------------------------------------------------------------------