//... => /* ... */

[wxWidgets.git] / src / unix / threadpsx.cpp

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 475d0b72b82bfab52a5bda92f3f5c45f534b2d0c..c3a6ff6268926000bc4c4a1a76dd366e4ab6010a 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -101,6 +101,7 @@ public:
 wxMutex::wxMutex()
 {
     p_internal = new wxMutexInternal;
 wxMutex::wxMutex()
 {
     p_internal = new wxMutexInternal;

+    

     pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
     m_locked = 0;
 }
     pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
     m_locked = 0;
 }


@@ -108,7 +109,7 @@ wxMutex::wxMutex()
 wxMutex::~wxMutex()
 {
     if (m_locked > 0)
 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;
 
     pthread_mutex_destroy( &(p_internal->p_mutex) );
     delete p_internal;


@@ -119,7 +120,7 @@ wxMutexError wxMutex::Lock()
     int err = pthread_mutex_lock( &(p_internal->p_mutex) );
     if (err == EDEADLK)
     {
     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;
     }
 
         return wxMUTEX_DEAD_LOCK;
     }


@@ -155,7 +156,7 @@ wxMutexError wxMutex::Unlock()
     }
     else
     {
     }
     else
     {

-        wxLogDebug("Unlocking not locked mutex.");
+        wxLogDebug(_T("Unlocking not locked mutex."));

 
         return wxMUTEX_UNLOCKED;
     }
 
         return wxMUTEX_UNLOCKED;
     }


@@ -225,6 +226,11 @@ public:
     // thread entry function
     static void *PthreadStart(void *ptr);
 
     // 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();
     // thread actions
         // start the thread
     wxThreadError Run();


@@ -266,7 +272,9 @@ private:
     //     state
     //  2. The Delete() function blocks until the condition is signaled when the
     //     thread exits.
     //     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
     wxCondition m_cond;
 
     // another (mutex, cond) pair for Pause()/Resume() usage


@@ -283,6 +291,7 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 {
     wxThread *thread = (wxThread *)ptr;
     wxThreadInternal *pthread = thread->p_internal;
 {
     wxThread *thread = (wxThread *)ptr;
     wxThreadInternal *pthread = thread->p_internal;

+    void *status;

 
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
 
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )


@@ -291,24 +300,53 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 
         return (void *)-1;
     }
 
         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);
 
     // 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
     // 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);
 
 
     // terminate the thread
     thread->Exit(status);
 

-    wxFAIL_MSG("wxThread::Exit() can't return.");
+    wxFAIL_MSG(_T("wxThread::Exit() can't return."));

 
     return NULL;
 }
 
 
     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;
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;


@@ -317,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 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
 
     // this mutex is used in Pause()/Resume() and is also locked all the time
     // unless the thread is paused


@@ -325,16 +368,28 @@ wxThreadInternal::wxThreadInternal()
 
 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
 
     // 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,
 }
 
 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 -
 
     // 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 -


@@ -353,7 +408,7 @@ wxThreadError wxThreadInternal::Run()
 
 void wxThreadInternal::Wait()
 {
 
 void wxThreadInternal::Wait()
 {

-    wxCHECK_RET( WasCancelled(), "thread should have been cancelled first" );
+    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 the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily


@@ -362,11 +417,14 @@ void wxThreadInternal::Wait()
 
     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination
 
     // 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
 
     // 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() )
 
     // reacquire GUI mutex
     if ( wxThread::IsMain() )


@@ -375,15 +433,18 @@ void wxThreadInternal::Wait()
 
 void wxThreadInternal::SignalExit()
 {
 
 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()
     // 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
 
     // 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()
 }
 
 void wxThreadInternal::Pause()


@@ -391,7 +452,7 @@ 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,
     // 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
 
     // 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


@@ -406,7 +467,7 @@ void wxThreadInternal::Pause()
 void wxThreadInternal::Resume()
 {
     wxCHECK_RET( m_state == STATE_PAUSED,
 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);
 
     // we will be able to lock this mutex only when Pause() starts waiting
     wxMutexLocker lock(m_mutexSuspend);


@@ -453,9 +514,7 @@ wxThread::wxThread()
 
 wxThreadError wxThread::Create()
 {
 
 wxThreadError wxThread::Create()
 {

-    // Maybe we could think about recreate the thread once it has exited.
-    if (p_internal->GetState() != STATE_NEW &&
-        p_internal->GetState() != STATE_EXITED)
+    if (p_internal->GetState() != STATE_NEW)

         return wxTHREAD_RUNNING;
 
     // set up the thread attribute: right now, we only set thread priority
         return wxTHREAD_RUNNING;
 
     // set up the thread attribute: right now, we only set thread priority


@@ -519,7 +578,7 @@ void wxThread::SetPriority(unsigned int prio)
 {
     wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
                  ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
 {
     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);
 
 
     wxCriticalSectionLocker lock(m_critsect);
 


@@ -548,7 +607,7 @@ void wxThread::SetPriority(unsigned int prio)
 
         case STATE_EXITED:
         default:
 
         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"));

     }
 }
 
     }
 }
 


@@ -574,7 +633,7 @@ wxThreadError wxThread::Pause()
 
     if ( p_internal->GetState() != STATE_RUNNING )
     {
 
     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;
     }
 
         return wxTHREAD_NOT_RUNNING;
     }


@@ -590,13 +649,15 @@ wxThreadError wxThread::Resume()
 
     if ( p_internal->GetState() == STATE_PAUSED )
     {
 
     if ( p_internal->GetState() == STATE_PAUSED )
     {

+        m_critsect.Leave();

         p_internal->Resume();
         p_internal->Resume();

+        m_critsect.Enter();

 
         return wxTHREAD_NO_ERROR;
     }
     else
     {
 
         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;
     }
 
         return wxTHREAD_MISC_ERROR;
     }


@@ -608,13 +669,17 @@ wxThreadError wxThread::Resume()
 
 wxThread::ExitCode wxThread::Delete()
 {
 
 wxThread::ExitCode wxThread::Delete()
 {

+    if (IsPaused())
+      Resume();
+

     m_critsect.Enter();
     wxThreadState state = p_internal->GetState();
     m_critsect.Enter();
     wxThreadState state = p_internal->GetState();

-    m_critsect.Leave();

 
     // ask the thread to stop
     p_internal->SetCancelFlag();
 
 
     // ask the thread to stop
     p_internal->SetCancelFlag();
 

+    m_critsect.Leave();
+

     switch ( state )
     {
         case STATE_NEW:
     switch ( state )
     {
         case STATE_NEW:


@@ -632,6 +697,8 @@ wxThread::ExitCode wxThread::Delete()
             // wait until the thread stops
             p_internal->Wait();
     }
             // wait until the thread stops
             p_internal->Wait();
     }

+    //GL: As we must auto-destroy, the destruction must happen here.
+    delete this;

 
     return NULL;
 }
 
     return NULL;
 }


@@ -653,6 +720,8 @@ wxThreadError wxThread::Kill()
 
                 return wxTHREAD_MISC_ERROR;
             }
 
                 return wxTHREAD_MISC_ERROR;
             }

+           //GL: As we must auto-destroy, the destruction must happen here (2).
+           delete this;

 
             return wxTHREAD_NO_ERROR;
     }
 
             return wxTHREAD_NO_ERROR;
     }


@@ -697,6 +766,14 @@ bool wxThread::TestDestroy()
 
 wxThread::~wxThread()
 {
 
 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);
 }
     // remove this thread from the global array
     gs_allThreads.Remove(this);
 }


@@ -727,6 +804,13 @@ bool wxThread::IsAlive() const
     }
 }
 
     }
 }
 

+bool wxThread::IsPaused() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+    return (p_internal->GetState() == STATE_PAUSED);
+}
+

 //--------------------------------------------------------------------
 // wxThreadModule
 //--------------------------------------------------------------------
 //--------------------------------------------------------------------
 // wxThreadModule
 //--------------------------------------------------------------------


@@ -756,9 +840,8 @@ bool wxThreadModule::OnInit()
 
     gs_mutexGui = new wxMutex();
 
 
     gs_mutexGui = new wxMutex();
 

-    //wxThreadGuiInit();
-

     gs_tidMain = pthread_self();
     gs_tidMain = pthread_self();

+

     gs_mutexGui->Lock();
 
     return TRUE;
     gs_mutexGui->Lock();
 
     return TRUE;


@@ -766,23 +849,23 @@ bool wxThreadModule::OnInit()
 
 void wxThreadModule::OnExit()
 {
 
 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 )
 
     // 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++ )
     {
 
     for ( size_t n = 0u; n < count; n++ )
     {

-        gs_allThreads[n]->Delete();
+       // Delete calls the destructor which removes the current entry. We
+       // should only delete the first one each time.
+        gs_allThreads[0]->Delete();

     }
 
     // destroy GUI mutex
     gs_mutexGui->Unlock();
 
     }
 
     // destroy GUI mutex
     gs_mutexGui->Unlock();
 

-    //wxThreadGuiExit();
-

     delete gs_mutexGui;
 
     // and free TLD slot
     delete gs_mutexGui;
 
     // and free TLD slot