X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/862cc6f9cd505cc5ac1b568bf72f1736a6cf8379..dc26b37a91938777fcd582bf06619fb1a9e04277:/src/unix/threadpsx.cpp?ds=sidebyside diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp index b5cdd32588..130ea38598 100644 --- a/src/unix/threadpsx.cpp +++ b/src/unix/threadpsx.cpp @@ -24,12 +24,13 @@ #pragma implementation "thread.h" #endif -#include "wx/thread.h" +// With simple makefiles, we must ignore the file body if not using +// threads. +#include "wx/setup.h" -#if !wxUSE_THREADS - #error This file needs wxUSE_THREADS -#endif +#if wxUSE_THREADS +#include "wx/thread.h" #include "wx/module.h" #include "wx/utils.h" #include "wx/log.h" @@ -42,7 +43,7 @@ #include #include -#ifdef HAVE_SCHED_H +#if HAVE_SCHED_H #include #endif @@ -50,15 +51,19 @@ // constants // ---------------------------------------------------------------------------- -enum thread_state +// the possible states of the thread and transitions from them +enum wxThreadState { STATE_NEW, // didn't start execution yet (=> RUNNING) - STATE_RUNNING, - STATE_PAUSED, - STATE_CANCELED, - STATE_EXITED + STATE_RUNNING, // running (=> PAUSED or EXITED) + STATE_PAUSED, // suspended (=> RUNNING or EXITED) + STATE_EXITED // thread doesn't exist any more }; +// ---------------------------------------------------------------------------- +// types +// ---------------------------------------------------------------------------- + WX_DEFINE_ARRAY(wxThread *, wxArrayThread); // ----------------------------------------------------------------------------- @@ -96,6 +101,7 @@ public: wxMutex::wxMutex() { p_internal = new wxMutexInternal; + pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL ); m_locked = 0; } @@ -103,7 +109,7 @@ wxMutex::wxMutex() wxMutex::~wxMutex() { if (m_locked > 0) - wxLogDebug("Freeing a locked mutex (%d locks)", m_locked); + wxLogDebug(_T("Freeing a locked mutex (%d locks)"), m_locked); pthread_mutex_destroy( &(p_internal->p_mutex) ); delete p_internal; @@ -114,7 +120,7 @@ wxMutexError wxMutex::Lock() int err = pthread_mutex_lock( &(p_internal->p_mutex) ); if (err == EDEADLK) { - wxLogDebug("Locking this mutex would lead to deadlock!"); + wxLogDebug(_T("Locking this mutex would lead to deadlock!")); return wxMUTEX_DEAD_LOCK; } @@ -150,7 +156,7 @@ wxMutexError wxMutex::Unlock() } else { - wxLogDebug("Unlocking not locked mutex."); + wxLogDebug(_T("Unlocking not locked mutex.")); return wxMUTEX_UNLOCKED; } @@ -220,11 +226,16 @@ public: // thread entry function static void *PthreadStart(void *ptr); +#if HAVE_THREAD_CLEANUP_FUNCTIONS + // thread exit function + static void PthreadCleanup(void *ptr); +#endif + // thread actions // start the thread wxThreadError Run(); // ask the thread to terminate - void Cancel(); + void Wait(); // wake up threads waiting for our termination void SignalExit(); // go to sleep until Resume() is called @@ -237,19 +248,19 @@ public: int GetPriority() const { return m_prio; } void SetPriority(int prio) { m_prio = prio; } // state - thread_state GetState() const { return m_state; } - void SetState(thread_state state) { m_state = state; } + wxThreadState GetState() const { return m_state; } + void SetState(wxThreadState state) { m_state = state; } // id - pthread_t GetId() const { return thread_id; } + pthread_t GetId() const { return m_threadId; } + pthread_t *GetIdPtr() { return &m_threadId; } // "cancelled" flag + void SetCancelFlag() { m_cancelled = TRUE; } bool WasCancelled() const { return m_cancelled; } -//private: -- should be! - pthread_t thread_id; - private: - thread_state m_state; // see thread_state enum - int m_prio; // in wxWindows units: from 0 to 100 + pthread_t m_threadId; // id of the thread + wxThreadState m_state; // see wxThreadState enum + int m_prio; // in wxWindows units: from 0 to 100 // set when the thread should terminate bool m_cancelled; @@ -261,7 +272,9 @@ private: // state // 2. The Delete() function blocks until the condition is signaled when the // thread exits. - wxMutex m_mutex; + // GL: On Linux, this may fail because we can have a deadlock in either + // SignalExit() or Wait(): so we add m_end_mutex for the finalization. + wxMutex m_mutex, m_end_mutex; wxCondition m_cond; // another (mutex, cond) pair for Pause()/Resume() usage @@ -278,32 +291,62 @@ void *wxThreadInternal::PthreadStart(void *ptr) { wxThread *thread = (wxThread *)ptr; wxThreadInternal *pthread = thread->p_internal; + void *status; int rc = pthread_setspecific(gs_keySelf, thread); if ( rc != 0 ) { - wxLogSysError(rc, _("Can not start thread: error writing TLS.")); + wxLogSysError(rc, _("Cannot start thread: error writing TLS")); return (void *)-1; } +#if HAVE_THREAD_CLEANUP_FUNCTIONS + // Install the cleanup handler. + pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr); +#endif // wait for the condition to be signaled from Run() // mutex state: currently locked by the thread which created us pthread->m_cond.Wait(pthread->m_mutex); - // mutex state: locked again on exit of Wait() // call the main entry - void* status = thread->Entry(); + status = thread->Entry(); + +#if HAVE_THREAD_CLEANUP_FUNCTIONS + pthread_cleanup_pop(FALSE); +#endif // terminate the thread thread->Exit(status); - wxFAIL_MSG("wxThread::Exit() can't return."); + wxFAIL_MSG(_T("wxThread::Exit() can't return.")); return NULL; } +#if HAVE_THREAD_CLEANUP_FUNCTIONS +// Only called when the thread is explicitely killed. + +void wxThreadInternal::PthreadCleanup(void *ptr) +{ + wxThread *thread = (wxThread *) ptr; + + // The thread is already considered as finished. + if (thread->p_internal->GetState() == STATE_EXITED) + return; + + // first call user-level clean up code + thread->OnExit(); + + // next wake up the threads waiting for us (OTOH, this function won't retur + // until someone waited for us!) + thread->p_internal->SetState(STATE_EXITED); + + thread->p_internal->SignalExit(); +} +#endif + wxThreadInternal::wxThreadInternal() { m_state = STATE_NEW; @@ -312,6 +355,11 @@ wxThreadInternal::wxThreadInternal() // this mutex is locked during almost all thread lifetime - it will only be // unlocked in the very end m_mutex.Lock(); + + // this mutex is used by wxThreadInternal::Wait() and by + // wxThreadInternal::SignalExit(). We don't use m_mutex because of a + // possible deadlock in either Wait() or SignalExit(). + m_end_mutex.Lock(); // this mutex is used in Pause()/Resume() and is also locked all the time // unless the thread is paused @@ -320,16 +368,28 @@ wxThreadInternal::wxThreadInternal() wxThreadInternal::~wxThreadInternal() { - m_mutexSuspend.Unlock(); + // GL: moved to SignalExit + // m_mutexSuspend.Unlock(); // note that m_mutex will be unlocked by the thread which waits for our // termination + + // In the case, we didn't start the thread, all these mutex are locked: + // we must unlock them. + if (m_mutex.IsLocked()) + m_mutex.Unlock(); + + if (m_end_mutex.IsLocked()) + m_end_mutex.Unlock(); + + if (m_mutexSuspend.IsLocked()) + m_mutexSuspend.Unlock(); } wxThreadError wxThreadInternal::Run() { wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING, - "thread may only be started once after successful Create()" ); + _T("thread may only be started once after successful Create()") ); // the mutex was locked on Create(), so we will be able to lock it again // only when the thread really starts executing and enters the wait - @@ -346,24 +406,25 @@ wxThreadError wxThreadInternal::Run() // starts executing and the mutex is still locked } -void wxThreadInternal::Cancel() +void wxThreadInternal::Wait() { + wxCHECK_RET( WasCancelled(), _T("thread should have been cancelled first") ); + // if the thread we're waiting for is waiting for the GUI mutex, we will // deadlock so make sure we release it temporarily if ( wxThread::IsMain() ) wxMutexGuiLeave(); - // nobody ever writes this variable so it's safe to not use any - // synchronization here - m_cancelled = TRUE; - // entering Wait() releases the mutex thus allowing SignalExit() to acquire // it and to signal us its termination - m_cond.Wait(m_mutex); + m_cond.Wait(m_end_mutex); // mutex is still in the locked state - relocked on exit from Wait(), so // unlock it - we don't need it any more, the thread has already terminated - m_mutex.Unlock(); + m_end_mutex.Unlock(); + + // After that, we wait for the real end of the other thread. + pthread_join(GetId(), NULL); // reacquire GUI mutex if ( wxThread::IsMain() ) @@ -372,26 +433,31 @@ void wxThreadInternal::Cancel() void wxThreadInternal::SignalExit() { + // GL: Unlock mutexSuspend here. + m_mutexSuspend.Unlock(); + // as mutex is currently locked, this will block until some other thread // (normally the same which created this one) unlocks it by entering Wait() - m_mutex.Lock(); + m_end_mutex.Lock(); // wake up all the threads waiting for our termination m_cond.Broadcast(); // after this call mutex will be finally unlocked - m_mutex.Unlock(); + m_end_mutex.Unlock(); } void wxThreadInternal::Pause() { + // the state is set from the thread which pauses us first, this function + // is called later so the state should have been already set wxCHECK_RET( m_state == STATE_PAUSED, - "thread must first be paused with wxThread::Pause()." ); + _T("thread must first be paused with wxThread::Pause().") ); // don't pause the thread which is being terminated - this would lead to // deadlock if the thread is paused after Delete() had called Resume() but - // before it had time to call Cancel() - if ( m_cancelled ) + // before it had time to call Wait() + if ( WasCancelled() ) return; // wait until the condition is signaled from Resume() @@ -401,7 +467,7 @@ void wxThreadInternal::Pause() void wxThreadInternal::Resume() { wxCHECK_RET( m_state == STATE_PAUSED, - "can't resume thread which is not suspended." ); + _T("can't resume thread which is not suspended.") ); // we will be able to lock this mutex only when Pause() starts waiting wxMutexLocker lock(m_mutexSuspend); @@ -459,7 +525,7 @@ wxThreadError wxThread::Create() int prio; if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 ) { - wxLogError(_("Can not retrieve thread scheduling policy.")); + wxLogError(_("Cannot retrieve thread scheduling policy.")); } int min_prio = sched_get_priority_min(prio), @@ -467,7 +533,7 @@ wxThreadError wxThread::Create() if ( min_prio == -1 || max_prio == -1 ) { - wxLogError(_("Can not get priority range for scheduling policy %d."), + wxLogError(_("Cannot get priority range for scheduling policy %d."), prio); } else @@ -480,8 +546,13 @@ wxThreadError wxThread::Create() } #endif // HAVE_THREAD_PRIORITY_FUNCTIONS +#ifdef HAVE_PTHREAD_ATTR_SETSCOPE + // this will make the threads created by this process really concurrent + pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); +#endif // HAVE_PTHREAD_ATTR_SETSCOPE + // create the new OS thread object - int rc = pthread_create(&p_internal->thread_id, &attr, + int rc = pthread_create(p_internal->GetIdPtr(), &attr, wxThreadInternal::PthreadStart, (void *)this); pthread_attr_destroy(&attr); @@ -507,7 +578,7 @@ void wxThread::SetPriority(unsigned int prio) { wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) && ((int)prio <= (int)WXTHREAD_MAX_PRIORITY), - "invalid thread priority" ); + _T("invalid thread priority") ); wxCriticalSectionLocker lock(m_critsect); @@ -536,7 +607,7 @@ void wxThread::SetPriority(unsigned int prio) case STATE_EXITED: default: - wxFAIL_MSG("impossible to set thread priority in this state"); + wxFAIL_MSG(_T("impossible to set thread priority in this state")); } } @@ -549,7 +620,7 @@ unsigned int wxThread::GetPriority() const unsigned long wxThread::GetID() const { - return (unsigned long)p_internal->thread_id; + return (unsigned long)p_internal->GetId(); } // ----------------------------------------------------------------------------- @@ -562,7 +633,7 @@ wxThreadError wxThread::Pause() if ( p_internal->GetState() != STATE_RUNNING ) { - wxLogDebug("Can't pause thread which is not running."); + wxLogDebug(_T("Can't pause thread which is not running.")); return wxTHREAD_NOT_RUNNING; } @@ -578,13 +649,15 @@ wxThreadError wxThread::Resume() if ( p_internal->GetState() == STATE_PAUSED ) { + m_critsect.Leave(); p_internal->Resume(); + m_critsect.Enter(); return wxTHREAD_NO_ERROR; } else { - wxLogDebug("Attempt to resume a thread which is not paused."); + wxLogDebug(_T("Attempt to resume a thread which is not paused.")); return wxTHREAD_MISC_ERROR; } @@ -596,8 +669,15 @@ wxThreadError wxThread::Resume() wxThread::ExitCode wxThread::Delete() { + if (IsPaused()) + Resume(); + m_critsect.Enter(); - thread_state state = p_internal->GetState(); + wxThreadState state = p_internal->GetState(); + + // ask the thread to stop + p_internal->SetCancelFlag(); + m_critsect.Leave(); switch ( state ) @@ -614,9 +694,11 @@ wxThread::ExitCode wxThread::Delete() // fall through default: - // set the flag telling to the thread to stop and wait - p_internal->Cancel(); + // wait until the thread stops + p_internal->Wait(); } + //GL: As we must auto-destroy, the destruction must happen here. + delete this; return NULL; } @@ -638,6 +720,8 @@ wxThreadError wxThread::Kill() return wxTHREAD_MISC_ERROR; } + //GL: As we must auto-destroy, the destruction must happen here (2). + delete this; return wxTHREAD_NO_ERROR; } @@ -655,14 +739,15 @@ void wxThread::Exit(void *status) p_internal->SetState(STATE_EXITED); // delete both C++ thread object and terminate the OS thread object - delete this; + // GL: This is very ugly and buggy ... +// delete this; pthread_exit(status); } // also test whether we were paused bool wxThread::TestDestroy() { - wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect); + wxCriticalSectionLocker lock(m_critsect); if ( p_internal->GetState() == STATE_PAUSED ) { @@ -681,6 +766,14 @@ bool wxThread::TestDestroy() wxThread::~wxThread() { + m_critsect.Enter(); + if (p_internal->GetState() != STATE_EXITED && + p_internal->GetState() != STATE_NEW) + wxLogDebug(_T("The thread is being destroyed althought it is still running ! The application may crash.")); + + m_critsect.Leave(); + + delete p_internal; // remove this thread from the global array gs_allThreads.Remove(this); } @@ -711,6 +804,13 @@ bool wxThread::IsAlive() const } } +bool wxThread::IsPaused() const +{ + wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect); + + return (p_internal->GetState() == STATE_PAUSED); +} + //-------------------------------------------------------------------- // wxThreadModule //-------------------------------------------------------------------- @@ -729,19 +829,19 @@ IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule) bool wxThreadModule::OnInit() { - if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 ) + int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */); + if ( rc != 0 ) { - wxLogError(_("Thread module initialization failed: " - "failed to create pthread key.")); + wxLogSysError(rc, _("Thread module initialization failed: " + "failed to create thread key")); return FALSE; } gs_mutexGui = new wxMutex(); - //wxThreadGuiInit(); - gs_tidMain = pthread_self(); + gs_mutexGui->Lock(); return TRUE; @@ -749,12 +849,12 @@ bool wxThreadModule::OnInit() void wxThreadModule::OnExit() { - wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" ); + wxASSERT_MSG( wxThread::IsMain(), _T("only main thread can be here") ); // terminate any threads left size_t count = gs_allThreads.GetCount(); if ( count != 0u ) - wxLogDebug("Some threads were not terminated by the application."); + wxLogDebug(_T("Some threads were not terminated by the application.")); for ( size_t n = 0u; n < count; n++ ) { @@ -764,8 +864,6 @@ void wxThreadModule::OnExit() // destroy GUI mutex gs_mutexGui->Unlock(); - //wxThreadGuiExit(); - delete gs_mutexGui; // and free TLD slot @@ -786,3 +884,5 @@ void wxMutexGuiLeave() gs_mutexGui->Unlock(); } +#endif + // wxUSE_THREADS