X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7bfe6a32e0be5a4e4b349d25ccaf87a1ed9ab127..abd474ea63667f727940a009cc3e0b23ba9f418f:/src/unix/threadpsx.cpp?ds=sidebyside diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index d87748e03f..22fefee76d 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: threadpsx.cpp +// Name: src/unix/threadpsx.cpp // Purpose: wxThread (Posix) Implementation // Author: Original from Wolfram Gloger/Guilhem Lavaux // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore @@ -21,28 +21,32 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "thread.h" -#endif - -#include "wx/defs.h" +// for compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" #if wxUSE_THREADS #include "wx/thread.h" -#include "wx/module.h" -#include "wx/utils.h" -#include "wx/log.h" -#include "wx/intl.h" -#include "wx/dynarray.h" -#include "wx/timer.h" +#include "wx/except.h" + +#ifndef WX_PRECOMP + #include "wx/app.h" + #include "wx/dynarray.h" + #include "wx/intl.h" + #include "wx/log.h" + #include "wx/utils.h" + #include "wx/timer.h" + #include "wx/stopwatch.h" + #include "wx/module.h" +#endif #include #include #include #include #include -#if HAVE_SCHED_H +#include // needed for at least __QNX__ +#ifdef HAVE_SCHED_H #include #endif @@ -53,11 +57,12 @@ // we use wxFFile under Linux in GetCPUCount() #ifdef __LINUX__ #include "wx/ffile.h" - // For setpriority. - #include - #include + #include // for setpriority() #endif +#define THR_ID_CAST(id) (reinterpret_cast(id)) +#define THR_ID(thr) THR_ID_CAST((thr)->GetId()) + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- @@ -75,10 +80,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 @@ -92,7 +97,7 @@ static void DeleteThread(wxThread *This); // ---------------------------------------------------------------------------- // an (non owning) array of pointers to threads -WX_DEFINE_ARRAY(wxThread *, wxArrayThread); +WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread); // an entry for a thread we can wait for @@ -105,8 +110,15 @@ WX_DEFINE_ARRAY(wxThread *, wxArrayThread); // be left in memory static wxArrayThread gs_allThreads; +// a mutex to protect gs_allThreads +static wxMutex *gs_mutexAllThreads = NULL; + // the id of the main thread -static pthread_t gs_tidMain; +// +// 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; @@ -116,16 +128,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; -#if wxUSE_GUI - // this mutex must be acquired before any call to a GUI function - static wxMutex *gs_mutexGui; -#endif // wxUSE_GUI +#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 @@ -153,21 +167,38 @@ public: ~wxMutexInternal(); wxMutexError Lock(); + wxMutexError Lock(unsigned long ms); wxMutexError TryLock(); wxMutexError Unlock(); bool IsOk() const { return m_isOk; } +private: + // convert the result of pthread_mutex_[timed]lock() call to wx return code + wxMutexError HandleLockResult(int err); + private: pthread_mutex_t m_mutex; bool m_isOk; + wxMutexType m_type; + unsigned long m_owningThread; // wxConditionInternal uses our m_mutex friend class wxConditionInternal; }; +#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \ + wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL) +// on some systems pthread_mutexattr_settype() is not in the headers (but it is +// in the library, otherwise we wouldn't compile this code at all) +extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int); +#endif + wxMutexInternal::wxMutexInternal(wxMutexType mutexType) { + m_type = mutexType; + m_owningThread = 0; + int err; switch ( mutexType ) { @@ -199,7 +230,7 @@ wxMutexInternal::wxMutexInternal(wxMutexType mutexType) break; default: - wxFAIL_MSG( _T("unknown mutex type") ); + wxFAIL_MSG( wxT("unknown mutex type") ); // fall through case wxMUTEX_DEFAULT: @@ -210,7 +241,7 @@ wxMutexInternal::wxMutexInternal(wxMutexType mutexType) m_isOk = err == 0; if ( !m_isOk ) { - wxLogApiError("pthread_mutex_init()", err); + wxLogApiError( wxT("pthread_mutex_init()"), err); } } @@ -221,36 +252,104 @@ wxMutexInternal::~wxMutexInternal() int err = pthread_mutex_destroy(&m_mutex); if ( err != 0 ) { - wxLogApiError("pthread_mutex_destroy()", err); + wxLogApiError( wxT("pthread_mutex_destroy()"), err); } } } wxMutexError wxMutexInternal::Lock() { - int err = pthread_mutex_lock(&m_mutex); + if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0)) + { + if (m_owningThread == wxThread::GetCurrentId()) + return wxMUTEX_DEAD_LOCK; + } + + return HandleLockResult(pthread_mutex_lock(&m_mutex)); +} + +wxMutexError wxMutexInternal::Lock(unsigned long ms) +{ +#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK + static const long MSEC_IN_SEC = 1000; + static const long NSEC_IN_MSEC = 1000000; + static const long NSEC_IN_USEC = 1000; + static const long NSEC_IN_SEC = MSEC_IN_SEC * NSEC_IN_MSEC; + + time_t seconds = ms/MSEC_IN_SEC; + long nanoseconds = (ms % MSEC_IN_SEC) * NSEC_IN_MSEC; + timespec ts = { 0, 0 }; + + // normally we should use clock_gettime(CLOCK_REALTIME) here but this + // function is in librt and we don't link with it currently, so use + // gettimeofday() instead -- if it turns out that this is really too + // imprecise, we should modify configure to check if clock_gettime() is + // available and whether it requires -lrt and use it instead +#if 0 + if ( clock_gettime(CLOCK_REALTIME, &ts) == 0 ) + { + } +#else + struct timeval tv; + if ( wxGetTimeOfDay(&tv) != -1 ) + { + ts.tv_sec = tv.tv_sec; + ts.tv_nsec = tv.tv_usec*NSEC_IN_USEC; + } +#endif + else // fall back on system timer + { + ts.tv_sec = time(NULL); + } + + ts.tv_sec += seconds; + ts.tv_nsec += nanoseconds; + if ( ts.tv_nsec > NSEC_IN_SEC ) + { + ts.tv_sec += 1; + ts.tv_nsec -= NSEC_IN_SEC; + } + + return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts)); +#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK + wxUnusedVar(ms); + + return wxMUTEX_MISC_ERROR; +#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK +} + +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_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_lock()"), err); + wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err); } return wxMUTEX_MISC_ERROR; } + wxMutexError wxMutexInternal::TryLock() { int err = pthread_mutex_trylock(&m_mutex); @@ -262,14 +361,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; @@ -277,6 +378,8 @@ wxMutexError wxMutexInternal::TryLock() wxMutexError wxMutexInternal::Unlock() { + m_owningThread = 0; + int err = pthread_mutex_unlock(&m_mutex); switch ( err ) { @@ -285,14 +388,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; @@ -341,7 +444,7 @@ wxConditionInternal::wxConditionInternal(wxMutex& mutex) if ( !m_isOk ) { - wxLogApiError(_T("pthread_cond_init()"), err); + wxLogApiError(wxT("pthread_cond_init()"), err); } } @@ -352,7 +455,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); } } } @@ -362,7 +465,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; } @@ -395,7 +498,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; @@ -406,7 +509,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; } @@ -419,7 +522,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; } @@ -468,9 +571,9 @@ 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; + m_isOk = false; } else { @@ -488,15 +591,15 @@ wxSemaError wxSemaphoreInternal::Wait() while ( m_count == 0 ) { wxLogTrace(TRACE_SEMA, - "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, - "Thread %ld finished waiting for semaphore, count = %u", - wxThread::GetCurrentId(), m_count); + wxT("Thread %p finished waiting for semaphore, count = %lu"), + THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count); } m_count--; @@ -532,8 +635,17 @@ wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds) return wxSEMA_TIMEOUT; } - if ( m_cond.Wait(remainingTime) != wxCOND_NO_ERROR ) - return wxSEMA_MISC_ERROR; + switch ( m_cond.WaitTimeout(remainingTime) ) + { + case wxCOND_TIMEOUT: + return wxSEMA_TIMEOUT; + + default: + return wxSEMA_MISC_ERROR; + + case wxCOND_NO_ERROR: + ; + } } m_count--; @@ -553,9 +665,9 @@ wxSemaError wxSemaphoreInternal::Post() m_count++; wxLogTrace(TRACE_SEMA, - "Thread %ld about to signal semaphore, count = %u", - wxThread::GetCurrentId(), 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; } @@ -568,10 +680,10 @@ wxSemaError wxSemaphoreInternal::Post() extern "C" { -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // thread exit function void wxPthreadCleanup(void *ptr); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP void *wxPthreadStart(void *ptr); @@ -610,18 +722,18 @@ 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."), - 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; } @@ -629,7 +741,7 @@ public: pthread_t GetId() const { return m_threadId; } pthread_t *GetIdPtr() { return &m_threadId; } // "cancelled" flag - void SetCancelFlag() { m_cancelled = TRUE; } + void SetCancelFlag() { m_cancelled = true; } bool WasCancelled() const { return m_cancelled; } // exit code void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; } @@ -644,19 +756,19 @@ public: { wxCriticalSectionLocker lock(m_csJoinFlag); - m_shouldBeJoined = FALSE; - m_isDetached = TRUE; + m_shouldBeJoined = false; + m_isDetached = true; } -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // this is used by wxPthreadCleanup() only static void Cleanup(wxThread *thread); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP 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 + int m_prio; // in wxWidgets units: from 0 to 100 // this flag is set when the thread should terminate bool m_cancelled; @@ -696,7 +808,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; - wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId()); + 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 @@ -712,11 +824,11 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) // block! bool dontRunAtAll; -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // install the cleanup handler which will be called if the thread is // cancelled pthread_cleanup_push(wxPthreadCleanup, thread); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP // wait for the semaphore to be posted from Run() pthread->m_semRun.Wait(); @@ -733,13 +845,19 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) if ( !dontRunAtAll ) { // call the main entry - wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."), - pthread->GetId()); + wxLogTrace(TRACE_THREADS, + wxT("Thread %p about to enter its Entry()."), + THR_ID(pthread)); - pthread->m_exitcode = thread->Entry(); + wxTRY + { + pthread->m_exitcode = thread->Entry(); - wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."), - pthread->GetId(), (unsigned long)pthread->m_exitcode); + wxLogTrace(TRACE_THREADS, + wxT("Thread %p Entry() returned %lu."), + THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); + } + wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) { wxCriticalSectionLocker lock(thread->m_critsect); @@ -751,13 +869,22 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) } } - // 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 + // NB: pthread_cleanup_push/pop() are macros and pop contains the matching + // '}' for the '{' in push, so they must be used in the same block! +#ifdef wxHAVE_PTHREAD_CLEANUP + #ifdef __DECCXX + // under Tru64 we get a warning from macro expansion + #pragma message save + #pragma message disable(declbutnotref) + #endif + // remove the cleanup handler without executing it pthread_cleanup_pop(FALSE); -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS + + #ifdef __DECCXX + #pragma message restore + #endif +#endif // wxHAVE_PTHREAD_CLEANUP if ( dontRunAtAll ) { @@ -777,7 +904,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) } } -#if HAVE_THREAD_CLEANUP_FUNCTIONS +#ifdef wxHAVE_PTHREAD_CLEANUP // this handler is called when the thread is cancelled extern "C" void wxPthreadCleanup(void *ptr) @@ -787,6 +914,7 @@ extern "C" void wxPthreadCleanup(void *ptr) void wxThreadInternal::Cleanup(wxThread *thread) { + if (pthread_getspecific(gs_keySelf) == 0) return; { wxCriticalSectionLocker lock(thread->m_critsect); if ( thread->m_internal->GetState() == STATE_EXITED ) @@ -800,7 +928,7 @@ void wxThreadInternal::Cleanup(wxThread *thread) thread->Exit(EXITCODE_CANCELLED); } -#endif // HAVE_THREAD_CLEANUP_FUNCTIONS +#endif // wxHAVE_PTHREAD_CLEANUP // ---------------------------------------------------------------------------- // wxThreadInternal @@ -809,17 +937,17 @@ void wxThreadInternal::Cleanup(wxThread *thread) wxThreadInternal::wxThreadInternal() { m_state = STATE_NEW; - m_cancelled = FALSE; + m_cancelled = false; m_prio = WXTHREAD_DEFAULT_PRIORITY; m_threadId = 0; m_exitcode = 0; - // set to TRUE only when the thread starts waiting on m_semSuspend - m_isPaused = FALSE; + // set to true only when the thread starts waiting on m_semSuspend + m_isPaused = false; // defaults for joinable threads - m_shouldBeJoined = TRUE; - m_isDetached = FALSE; + m_shouldBeJoined = true; + m_isDetached = false; } wxThreadInternal::~wxThreadInternal() @@ -841,15 +969,26 @@ 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."), GetId()); + 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 // done once so use a critical section to serialize the code below @@ -862,23 +1001,24 @@ void wxThreadInternal::Wait() // 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)GetId(), &m_exitcode) != 0 ) + if ( pthread_join(GetId(), &m_exitcode) != 0 ) { // this is a serious problem, so use wxLogError and not // wxLogDebug: it is possible to bring the system to its knees // by creating too many threads and not joining them quite // easily - wxLogError(_("Failed to join a thread, potential memory leak " - "detected - please restart the program")); + wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program")); } - m_shouldBeJoined = FALSE; + m_shouldBeJoined = false; } } +#ifndef __WXOSX__ // reacquire GUI mutex if ( wxThread::IsMain() ) wxMutexGuiEnter(); +#endif } void wxThreadInternal::Pause() @@ -888,7 +1028,8 @@ void wxThreadInternal::Pause() wxCHECK_RET( m_state == STATE_PAUSED, wxT("thread must first be paused with wxThread::Pause().") ); - wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId()); + wxLogTrace(TRACE_THREADS, + wxT("Thread %p goes to sleep."), THR_ID(this)); // wait until the semaphore is Post()ed from Resume() m_semSuspend.Wait(); @@ -903,18 +1044,19 @@ void wxThreadInternal::Resume() // TestDestroy() since the last call to Pause() for example if ( IsReallyPaused() ) { - wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId()); + wxLogTrace(TRACE_THREADS, + wxT("Waking up thread %p"), THR_ID(this)); // wake up Pause() m_semSuspend.Post(); // reset the flag - SetReallyPaused(FALSE); + SetReallyPaused(false); } else { - wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"), - GetId()); + wxLogTrace(TRACE_THREADS, + wxT("Thread %p is not yet really paused"), THR_ID(this)); } SetState(STATE_RUNNING); @@ -929,11 +1071,6 @@ wxThread *wxThread::This() return (wxThread *)pthread_getspecific(gs_keySelf); } -bool wxThread::IsMain() -{ - return (bool)pthread_equal(pthread_self(), gs_tidMain); -} - void wxThread::Yield() { #ifdef HAVE_SCHED_YIELD @@ -941,72 +1078,60 @@ void wxThread::Yield() #endif } -void wxThread::Sleep(unsigned long milliseconds) -{ - wxUsleep(milliseconds); -} - int wxThread::GetCPUCount() { -#if defined(__LINUX__) && wxUSE_FFILE +#if defined(_SC_NPROCESSORS_ONLN) + // this works for Solaris and Linux 2.6 + int rc = sysconf(_SC_NPROCESSORS_ONLN); + if ( rc != -1 ) + { + return rc; + } +#elif 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")); + wxFFile file(wxT("/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("")); + // (ab)use Replace() to find the number of "processor: num" strings + 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")); } } -#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() +wxThreadIdType wxThread::GetCurrentId() { - return (unsigned long)pthread_self(); -#endif + return (wxThreadIdType)pthread_self(); } + bool wxThread::SetConcurrency(size_t level) { #ifdef HAVE_THR_SETCONCURRENCY int rc = thr_setconcurrency(level); if ( rc != 0 ) { - wxLogSysError(rc, _T("thr_setconcurrency() failed")); + wxLogSysError(rc, wxT("thr_setconcurrency() failed")); } return rc == 0; @@ -1023,14 +1148,24 @@ bool wxThread::SetConcurrency(size_t level) wxThread::wxThread(wxThreadKind kind) { // add this thread to the global list of all threads - gs_allThreads.Add(this); + { + wxMutexLocker lock(*gs_mutexAllThreads); + + gs_allThreads.Add(this); + } m_internal = new wxThreadInternal(); m_isDetached = kind == wxTHREAD_DETACHED; } -wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) +#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)) { if ( m_internal->GetState() != STATE_NEW ) { @@ -1042,6 +1177,11 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) 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 ) @@ -1084,14 +1224,14 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) struct sched_param sp; if ( pthread_attr_getschedparam(&attr, &sp) != 0 ) { - wxFAIL_MSG(_T("pthread_attr_getschedparam() failed")); + 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(_T("pthread_attr_setschedparam(priority) failed")); + wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed")); } } #endif // HAVE_THREAD_PRIORITY_FUNCTIONS @@ -1100,7 +1240,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) // 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")); + wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed")); } #endif // HAVE_PTHREAD_ATTR_SETSCOPE @@ -1111,7 +1251,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) { if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 ) { - wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed")); + wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed")); } // never try to join detached threads @@ -1130,7 +1270,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize)) if ( pthread_attr_destroy(&attr) != 0 ) { - wxFAIL_MSG(_T("pthread_attr_destroy() failed")); + wxFAIL_MSG(wxT("pthread_attr_destroy() failed")); } if ( rc != 0 ) @@ -1176,42 +1316,21 @@ void wxThread::SetPriority(unsigned int prio) case STATE_PAUSED: #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS #if defined(__LINUX__) -// On Linux, pthread_setschedparam with SCHED_OTHER does not allow -// a priority other than 0. Instead, we use the BSD setpriority -// which alllows us to set a 'nice' value between 20 to -20. Only -// super user can set a value less than zero (more negative yields -// higher priority). setpriority set the static priority of a process, -// but this is OK since Linux is configured as a thread per process. - { - float fPrio; - float pSpan; - int iPrio; - - // Map Wx priorites (WXTHREAD_MIN_PRIORITY - - // WXTHREAD_MAX_PRIORITY) into BSD priorities (20 - -20). - // Do calculation of values instead of hard coding them - // to make maintenance easier. - - pSpan = ((float)(WXTHREAD_MAX_PRIORITY - WXTHREAD_MIN_PRIORITY)) / 2.0; - - // prio starts as ................... // value => (0) >= p <= (n) - - fPrio = ((float)prio) - pSpan; // value => (-n) >= p <= (+n) - - fPrio = 0.0 - fPrio; // value => (+n) <= p >= (-n) - - fPrio = fPrio * (20. / pSpan) + .5; // value => (20) <= p >= (-20) - - iPrio = (int)fPrio; - - // Clamp prio from 20 - -20; - iPrio = (iPrio > 20) ? 20 : iPrio; - iPrio = (iPrio < -20) ? -20 : iPrio; + // On Linux, pthread_setschedparam with SCHED_OTHER does not allow + // a priority other than 0. Instead, we use the BSD setpriority + // which alllows us to set a 'nice' value between 20 to -20. Only + // super user can set a value less than zero (more negative yields + // higher priority). setpriority set the static priority of a + // process, but this is OK since Linux is configured as a thread + // per process. + // + // FIXME this is not true for 2.6!! - if (setpriority(PRIO_PROCESS, 0, iPrio) == -1) - { - wxLogError(_("Failed to set thread priority %d."), prio); - } + // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY + // to Unix priorities 20..-20 + if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 ) + { + wxLogError(_("Failed to set thread priority %d."), prio); } #else // __LINUX__ { @@ -1253,7 +1372,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); @@ -1274,7 +1393,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); @@ -1283,20 +1402,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; } @@ -1306,23 +1425,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; @@ -1334,6 +1453,8 @@ wxThreadError wxThread::Delete(ExitCode *rc) m_critsect.Leave(); + OnDelete(); + switch ( state ) { case STATE_NEW: @@ -1369,13 +1490,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() ) { @@ -1392,25 +1520,26 @@ wxThreadError wxThread::Kill() default: #ifdef HAVE_PTHREAD_CANCEL if ( pthread_cancel(m_internal->GetId()) != 0 ) -#endif +#endif // HAVE_PTHREAD_CANCEL { wxLogError(_("Failed to terminate a thread.")); return wxTHREAD_MISC_ERROR; } +#ifdef HAVE_PTHREAD_CANCEL if ( m_isDetached ) { // if we use cleanup function, this will be done from // wxPthreadCleanup() -#if !HAVE_THREAD_CLEANUP_FUNCTIONS +#ifndef wxHAVE_PTHREAD_CLEANUP 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 +#endif // wxHAVE_PTHREAD_CLEANUP } else { @@ -1418,14 +1547,14 @@ wxThreadError wxThread::Kill() } return wxTHREAD_NO_ERROR; +#endif // HAVE_PTHREAD_CANCEL } } 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 ) { @@ -1439,7 +1568,11 @@ void wxThread::Exit(ExitCode status) // 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(); + wxTRY + { + OnExit(); + } + wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) // delete C++ thread object if this is a detached thread - user is // responsible for doing this for joinable ones @@ -1452,26 +1585,32 @@ void wxThread::Exit(ExitCode status) // we make it a global object, but this would mean that we can // only call one thread function at a time :-( DeleteThread(this); + pthread_setspecific(gs_keySelf, 0); + } + else + { + m_critsect.Enter(); + m_internal->SetState(STATE_EXITED); + m_critsect.Leave(); } // 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(); if ( m_internal->GetState() == STATE_PAUSED ) { - m_internal->SetReallyPaused(TRUE); + 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 @@ -1491,24 +1630,26 @@ 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."), 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; // remove this thread from the global array - gs_allThreads.Remove(this); + { + wxMutexLocker lock(*gs_mutexAllThreads); + + gs_allThreads.Remove(this); + } } // ----------------------------------------------------------------------------- @@ -1530,10 +1671,10 @@ bool wxThread::IsAlive() const { case STATE_RUNNING: case STATE_PAUSED: - return TRUE; + return true; default: - return FALSE; + return false; } } @@ -1548,6 +1689,11 @@ bool wxThread::IsPaused() const // wxThreadModule //-------------------------------------------------------------------- +#ifdef __WXOSX__ +void wxOSXThreadModuleOnInit(); +void wxOSXThreadModuleOnExit(); +#endif + class wxThreadModule : public wxModule { public: @@ -1565,24 +1711,26 @@ bool wxThreadModule::OnInit() int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */); if ( rc != 0 ) { - wxLogSysError(rc, _("Thread module initialization failed: " - "failed to create thread key")); + wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key")); - return FALSE; + return false; } - gs_tidMain = pthread_self(); + wxThread::ms_idMainThread = wxThread::GetCurrentId(); -#if wxUSE_GUI - gs_mutexGui = new wxMutex(); + gs_mutexAllThreads = new wxMutex(); +#ifdef __WXOSX__ + wxOSXThreadModuleOnInit(); +#else + gs_mutexGui = new wxMutex(); gs_mutexGui->Lock(); -#endif // wxUSE_GUI +#endif gs_mutexDeleteThread = new wxMutex(); - gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread ); + gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread); - return TRUE; + return true; } void wxThreadModule::OnExit() @@ -1598,21 +1746,28 @@ void wxThreadModule::OnExit() if ( nThreadsBeingDeleted > 0 ) { - wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"), - nThreadsBeingDeleted); + wxLogTrace(TRACE_THREADS, + wxT("Waiting for %lu threads to disappear"), + (unsigned long)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 ) + size_t count; + { - wxLogDebug(wxT("%u threads were not terminated by the application."), - count); - } + wxMutexLocker lock(*gs_mutexAllThreads); + + // terminate any threads left + count = gs_allThreads.GetCount(); + if ( count != 0u ) + { + wxLogDebug(wxT("%lu threads were not terminated by the application."), + (unsigned long)count); + } + } // unlock mutex before deleting the threads as they lock it in their dtor for ( size_t n = 0u; n < count; n++ ) { @@ -1621,12 +1776,15 @@ void wxThreadModule::OnExit() gs_allThreads[0]->Delete(); } -#if wxUSE_GUI + delete gs_mutexAllThreads; + +#ifdef __WXOSX__ + wxOSXThreadModuleOnExit(); +#else // destroy GUI mutex gs_mutexGui->Unlock(); - delete gs_mutexGui; -#endif // wxUSE_GUI +#endif // and free TLD slot (void)pthread_key_delete(gs_keySelf); @@ -1645,26 +1803,27 @@ static void ScheduleThreadForDeletion() gs_nThreadsBeingDeleted++; - wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"), - gs_nThreadsBeingDeleted, - gs_nThreadsBeingDeleted == 1 ? "" : "s"); + wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"), + (unsigned long)gs_nThreadsBeingDeleted, + 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("%u scheduled for deletion threads left."), - gs_nThreadsBeingDeleted - 1); + wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."), + (unsigned long)gs_nThreadsBeingDeleted - 1); if ( !--gs_nThreadsBeingDeleted ) { @@ -1673,20 +1832,20 @@ static void DeleteThread(wxThread *This) } } -void wxMutexGuiEnter() +#ifndef __WXOSX__ + +void wxMutexGuiEnterImpl() { -#if wxUSE_GUI gs_mutexGui->Lock(); -#endif // wxUSE_GUI } -void wxMutexGuiLeave() +void wxMutexGuiLeaveImpl() { -#if wxUSE_GUI gs_mutexGui->Unlock(); -#endif // wxUSE_GUI } +#endif + // ---------------------------------------------------------------------------- // include common implementation code // ---------------------------------------------------------------------------- @@ -1694,4 +1853,3 @@ void wxMutexGuiLeave() #include "wx/thrimpl.cpp" #endif // wxUSE_THREADS -