X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c0badb709a86b91a203416784b649e3d00c699c7..ba86da30cf1a2a8429f3af465cbb6c9f52b307fb:/src/unix/threadpsx.cpp diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index 1e538342f7..db3063e48e 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -27,18 +27,19 @@ #if wxUSE_THREADS #include "wx/thread.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 "wx/module.h" -#include "wx/stopwatch.h" - #include #include #include @@ -113,6 +114,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; @@ -124,11 +128,11 @@ 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; // 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 @@ -161,14 +165,21 @@ 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; @@ -183,6 +194,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 ) { @@ -243,7 +257,69 @@ wxMutexInternal::~wxMutexInternal() 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: @@ -253,19 +329,25 @@ 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: + if (m_type == wxMUTEX_DEFAULT) + m_owningThread = wxThread::GetCurrentId(); 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); @@ -281,6 +363,8 @@ wxMutexError wxMutexInternal::TryLock() break; case 0: + if (m_type == wxMUTEX_DEFAULT) + m_owningThread = wxThread::GetCurrentId(); return wxMUTEX_NO_ERROR; default: @@ -292,6 +376,8 @@ wxMutexError wxMutexInternal::TryLock() wxMutexError wxMutexInternal::Unlock() { + m_owningThread = 0; + int err = pthread_mutex_unlock(&m_mutex); switch ( err ) { @@ -503,14 +589,14 @@ wxSemaError wxSemaphoreInternal::Wait() while ( m_count == 0 ) { wxLogTrace(TRACE_SEMA, - _T("Thread %ld waiting for semaphore to become signalled"), + _T("Thread %p waiting for semaphore to become signalled"), 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"), + _T("Thread %p finished waiting for semaphore, count = %lu"), wxThread::GetCurrentId(), (unsigned long)m_count); } @@ -577,7 +663,7 @@ wxSemaError wxSemaphoreInternal::Post() m_count++; wxLogTrace(TRACE_SEMA, - _T("Thread %ld about to signal semaphore, count = %lu"), + _T("Thread %p about to signal semaphore, count = %lu"), wxThread::GetCurrentId(), (unsigned long)m_count); return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR @@ -643,8 +729,8 @@ public: _T("EXITED"), }; - wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."), - (long)GetId(), stateNames[m_state], stateNames[state]); + wxLogTrace(TRACE_THREADS, _T("Thread %p: %s => %s."), + GetId(), stateNames[m_state], stateNames[state]); #endif // __WXDEBUG__ m_state = state; @@ -720,7 +806,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; - wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread)); + wxLogTrace(TRACE_THREADS, _T("Thread %p started."), THR_ID(pthread)); // associate the thread pointer with the newly created thread so that // wxThread::This() will work @@ -758,14 +844,18 @@ void *wxThreadInternal::PthreadStart(wxThread *thread) { // call the main entry wxLogTrace(TRACE_THREADS, - _T("Thread %ld about to enter its Entry()."), + _T("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."), - THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); + wxLogTrace(TRACE_THREADS, + _T("Thread %p Entry() returned %lu."), + THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); + } + wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) { wxCriticalSectionLocker lock(thread->m_critsect); @@ -885,7 +975,7 @@ void wxThreadInternal::Wait() wxMutexGuiLeave(); wxLogTrace(TRACE_THREADS, - _T("Starting to wait for thread %ld to exit."), + _T("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 @@ -925,7 +1015,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)); + _T("Thread %p goes to sleep."), THR_ID(this)); // wait until the semaphore is Post()ed from Resume() m_semSuspend.Wait(); @@ -941,7 +1031,7 @@ void wxThreadInternal::Resume() if ( IsReallyPaused() ) { wxLogTrace(TRACE_THREADS, - _T("Waking up thread %ld"), THR_ID(this)); + _T("Waking up thread %p"), THR_ID(this)); // wake up Pause() m_semSuspend.Post(); @@ -952,7 +1042,7 @@ void wxThreadInternal::Resume() else { wxLogTrace(TRACE_THREADS, - _T("Thread %ld is not yet really paused"), THR_ID(this)); + _T("Thread %p is not yet really paused"), THR_ID(this)); } SetState(STATE_RUNNING); @@ -979,14 +1069,16 @@ void wxThread::Yield() #endif } -void wxThread::Sleep(unsigned long milliseconds) -{ - wxMilliSleep(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; @@ -1012,13 +1104,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 @@ -1066,7 +1151,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(); @@ -1242,7 +1331,7 @@ void wxThread::SetPriority(unsigned int 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 ) + if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 ) { wxLogError(_("Failed to set thread priority %d."), prio); } @@ -1316,7 +1405,7 @@ wxThreadError wxThread::Resume() switch ( state ) { case STATE_PAUSED: - wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."), + wxLogTrace(TRACE_THREADS, _T("Thread %p suspended, resuming."), GetId()); m_internal->Resume(); @@ -1324,7 +1413,7 @@ wxThreadError wxThread::Resume() return wxTHREAD_NO_ERROR; case STATE_EXITED: - wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."), + wxLogTrace(TRACE_THREADS, _T("Thread %p exited, won't resume."), GetId()); return wxTHREAD_NO_ERROR; @@ -1473,7 +1562,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 @@ -1548,7 +1641,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); + } } // ----------------------------------------------------------------------------- @@ -1612,11 +1709,13 @@ bool wxThreadModule::OnInit() 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; } @@ -1643,13 +1742,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++ ) { @@ -1658,6 +1763,8 @@ void wxThreadModule::OnExit() gs_allThreads[0]->Delete(); } + delete gs_mutexAllThreads; + // destroy GUI mutex gs_mutexGui->Unlock(); delete gs_mutexGui; @@ -1681,7 +1788,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) @@ -1690,14 +1797,14 @@ static void DeleteThread(wxThread *This) // or wxThreadModule::OnExit() would deadlock wxMutexLocker locker( *gs_mutexDeleteThread ); - wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId()); + wxLogTrace(TRACE_THREADS, _T("Thread %p 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("%lu scheduled for deletion threads left."), + wxLogTrace(TRACE_THREADS, _T("%lu threads remain scheduled for deletion."), (unsigned long)gs_nThreadsBeingDeleted - 1); if ( !--gs_nThreadsBeingDeleted ) @@ -1707,12 +1814,12 @@ static void DeleteThread(wxThread *This) } } -void wxMutexGuiEnter() +void wxMutexGuiEnterImpl() { gs_mutexGui->Lock(); } -void wxMutexGuiLeave() +void wxMutexGuiLeaveImpl() { gs_mutexGui->Unlock(); }