X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8a077f2872e0082e27580e0a653ba92409792cf1..5a1e0e91a1ca5ec98b0eeb335cda757d1261ed08:/src/unix/threadpsx.cpp diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 14e588268a..5d7c3bcd2a 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 @@ -27,13 +27,16 @@ #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/stopwatch.h" + +#ifndef WX_PRECOMP + #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 @@ -109,6 +112,9 @@ WX_DEFINE_ARRAY_PTR(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 = (pthread_t)-1; @@ -157,11 +163,16 @@ 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; @@ -170,7 +181,8 @@ private: friend class wxConditionInternal; }; -#ifdef HAVE_PTHREAD_MUTEXATTR_T +#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); @@ -238,7 +250,61 @@ wxMutexInternal::~wxMutexInternal() wxMutexError wxMutexInternal::Lock() { - int err = pthread_mutex_lock(&m_mutex); + 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) +{ switch ( err ) { case EDEADLK: @@ -248,19 +314,23 @@ wxMutexError wxMutexInternal::Lock() return wxMUTEX_DEAD_LOCK; case EINVAL: - wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized.")); + wxLogDebug(_T("pthread_mutex_[timed]lock(): mutex not initialized")); break; + case ETIMEDOUT: + return wxMUTEX_TIMEOUT; + case 0: return wxMUTEX_NO_ERROR; default: - wxLogApiError(_T("pthread_mutex_lock()"), err); + wxLogApiError(_T("pthread_mutex_[timed]lock()"), err); } return wxMUTEX_MISC_ERROR; } + wxMutexError wxMutexInternal::TryLock() { int err = pthread_mutex_trylock(&m_mutex); @@ -480,7 +550,7 @@ wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount) { wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") ); - m_isOk = FALSE; + m_isOk = false; } else { @@ -648,7 +718,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; } @@ -663,8 +733,8 @@ public: { wxCriticalSectionLocker lock(m_csJoinFlag); - m_shouldBeJoined = FALSE; - m_isDetached = TRUE; + m_shouldBeJoined = false; + m_isDetached = true; } #ifdef wxHAVE_PTHREAD_CLEANUP @@ -760,7 +830,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."), - THR_ID(pthread), (unsigned long)pthread->m_exitcode); + THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); { wxCriticalSectionLocker lock(thread->m_critsect); @@ -772,12 +842,21 @@ 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! + // 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); + + #ifdef __DECCXX + #pragma message restore + #endif #endif // wxHAVE_PTHREAD_CLEANUP if ( dontRunAtAll ) @@ -808,6 +887,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 ) @@ -830,17 +910,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() @@ -893,7 +973,7 @@ void wxThreadInternal::Wait() wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program")); } - m_shouldBeJoined = FALSE; + m_shouldBeJoined = false; } } @@ -932,7 +1012,7 @@ void wxThreadInternal::Resume() m_semSuspend.Post(); // reset the flag - SetReallyPaused(FALSE); + SetReallyPaused(false); } else { @@ -971,7 +1051,14 @@ void wxThread::Sleep(unsigned long 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; @@ -997,13 +1084,6 @@ int wxThread::GetCPUCount() 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 @@ -1051,7 +1131,11 @@ 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(); @@ -1215,42 +1299,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*prio)/5 + 20) == -1 ) + { + wxLogError(_("Failed to set thread priority %d."), prio); } #else // __LINUX__ { @@ -1431,13 +1494,14 @@ 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 @@ -1457,6 +1521,7 @@ wxThreadError wxThread::Kill() } return wxTHREAD_NO_ERROR; +#endif // HAVE_PTHREAD_CANCEL } } @@ -1490,6 +1555,7 @@ 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 { @@ -1514,7 +1580,7 @@ bool wxThread::TestDestroy() 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 @@ -1541,7 +1607,8 @@ wxThread::~wxThread() 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(_T("The thread %ld is being destroyed although it is still running! The application may crash."), + (long)GetId()); } m_critsect.Leave(); @@ -1550,7 +1617,11 @@ wxThread::~wxThread() delete m_internal; // remove this thread from the global array - gs_allThreads.Remove(this); + { + wxMutexLocker lock(*gs_mutexAllThreads); + + gs_allThreads.Remove(this); + } } // ----------------------------------------------------------------------------- @@ -1572,10 +1643,10 @@ bool wxThread::IsAlive() const { case STATE_RUNNING: case STATE_PAUSED: - return TRUE; + return true; default: - return FALSE; + return false; } } @@ -1609,18 +1680,20 @@ bool wxThreadModule::OnInit() { wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key")); - return FALSE; + return false; } gs_tidMain = pthread_self(); + gs_mutexAllThreads = new wxMutex(); + gs_mutexGui = new wxMutex(); gs_mutexGui->Lock(); gs_mutexDeleteThread = new wxMutex(); - gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread ); + gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread); - return TRUE; + return true; } void wxThreadModule::OnExit() @@ -1645,13 +1718,19 @@ void wxThreadModule::OnExit() } } - // terminate any threads left - size_t count = gs_allThreads.GetCount(); - if ( count != 0u ) + size_t count; + { - wxLogDebug(wxT("%lu threads were not terminated by the application."), - (unsigned long)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++ ) { @@ -1660,6 +1739,8 @@ void wxThreadModule::OnExit() gs_allThreads[0]->Delete(); } + delete gs_mutexAllThreads; + // destroy GUI mutex gs_mutexGui->Unlock(); delete gs_mutexGui; @@ -1683,7 +1764,7 @@ static void ScheduleThreadForDeletion() wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"), (unsigned long)gs_nThreadsBeingDeleted, - gs_nThreadsBeingDeleted == 1 ? "" : "s"); + gs_nThreadsBeingDeleted == 1 ? _T("") : _T("s")); } static void DeleteThread(wxThread *This) @@ -1726,4 +1807,3 @@ void wxMutexGuiLeave() #include "wx/thrimpl.cpp" #endif // wxUSE_THREADS -