Changed two conflicting defines in defs.h

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

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index edd373cdc467c86356acf5a00ba3c8628b69f153..8fc3c664e1dde6b5a573205f46bcf5b64ae10845 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(_T("Freeing a locked mutex (%d locks)"), m_locked);
+        wxLogDebug(wxT("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(_T("Locking this mutex would lead to deadlock!"));
+        wxLogDebug(wxT("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(_T("Unlocking not locked mutex."));
+        wxLogDebug(wxT("Unlocking not locked mutex."));

 
         return wxMUTEX_UNLOCKED;
     }
 
         return wxMUTEX_UNLOCKED;
     }


@@ -271,6 +272,8 @@ 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.

+    // 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;
 
     wxMutex     m_mutex, m_end_mutex;
     wxCondition m_cond;
 


@@ -299,7 +302,7 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     }
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // Install the cleanup handler.
     }
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // Install the cleanup handler.

-//    pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+    pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);

 #endif
 
     // wait for the condition to be signaled from Run()
 #endif
 
     // wait for the condition to be signaled from Run()


@@ -311,13 +314,13 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     status = thread->Entry();
 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     status = thread->Entry();
 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS

-//    pthread_cleanup_pop(FALSE);
+    pthread_cleanup_pop(FALSE);

 #endif
 
     // terminate the thread
     thread->Exit(status);
 
 #endif
 
     // terminate the thread
     thread->Exit(status);
 

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

 
     return NULL;
 }
 
     return NULL;
 }


@@ -348,6 +351,8 @@ wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
     m_cancelled = FALSE;
 {
     m_state = STATE_NEW;
     m_cancelled = FALSE;

+    m_prio = WXTHREAD_DEFAULT_PRIORITY;
+    m_threadId = 0;

 
     // this mutex is locked during almost all thread lifetime - it will only be
     // unlocked in the very end
 
     // this mutex is locked during almost all thread lifetime - it will only be
     // unlocked in the very end


@@ -371,14 +376,22 @@ wxThreadInternal::~wxThreadInternal()
     // 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
 

-    // m_end_mutex can be unlocked here.
-    m_end_mutex.Unlock();
+    // 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,

-                 _T("thread may only be started once after successful Create()") );
+                 wxT("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 -


@@ -397,7 +410,7 @@ wxThreadError wxThreadInternal::Run()
 
 void wxThreadInternal::Wait()
 {
 
 void wxThreadInternal::Wait()
 {

-    wxCHECK_RET( WasCancelled(), _T("thread should have been cancelled first") );
+    wxCHECK_RET( WasCancelled(), wxT("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


@@ -441,7 +454,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,

-                 _T("thread must first be paused with wxThread::Pause().") );
+                 wxT("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


@@ -456,7 +469,7 @@ void wxThreadInternal::Pause()
 void wxThreadInternal::Resume()
 {
     wxCHECK_RET( m_state == STATE_PAUSED,
 void wxThreadInternal::Resume()
 {
     wxCHECK_RET( m_state == STATE_PAUSED,

-                 _T("can't resume thread which is not suspended.") );
+                 wxT("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);


@@ -525,6 +538,17 @@ wxThreadError wxThread::Create()
         wxLogError(_("Cannot get priority range for scheduling policy %d."),
                    prio);
     }
         wxLogError(_("Cannot get priority range for scheduling policy %d."),
                    prio);
     }

+    else if ( max_prio == min_prio )
+    {
+        if ( p_internal->GetPriority() != WXTHREAD_DEFAULT_PRIORITY )
+        {
+            // notify the programmer that this doesn't work here
+            wxLogWarning(_("Thread priority setting is ignored."));
+        }
+        //else: we have default priority, so don't complain
+
+        // anyhow, don't do anything because priority is just ignored
+    }

     else
     {
         struct sched_param sp;
     else
     {
         struct sched_param sp;


@@ -556,6 +580,9 @@ wxThreadError wxThread::Create()
 
 wxThreadError wxThread::Run()
 {
 
 wxThreadError wxThread::Run()
 {

+    wxCHECK_MSG( p_internal->GetId(), wxTHREAD_MISC_ERROR,
+                 wxT("must call wxThread::Create() first") );
+

     return p_internal->Run();
 }
 
     return p_internal->Run();
 }
 


@@ -567,7 +594,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),

-                 _T("invalid thread priority") );
+                 wxT("invalid thread priority") );

 
     wxCriticalSectionLocker lock(m_critsect);
 
 
     wxCriticalSectionLocker lock(m_critsect);
 


@@ -596,7 +623,7 @@ void wxThread::SetPriority(unsigned int prio)
 
         case STATE_EXITED:
         default:
 
         case STATE_EXITED:
         default:

-            wxFAIL_MSG(_T("impossible to set thread priority in this state"));
+            wxFAIL_MSG(wxT("impossible to set thread priority in this state"));

     }
 }
 
     }
 }
 


@@ -622,7 +649,7 @@ wxThreadError wxThread::Pause()
 
     if ( p_internal->GetState() != STATE_RUNNING )
     {
 
     if ( p_internal->GetState() != STATE_RUNNING )
     {

-        wxLogDebug(_T("Can't pause thread which is not running."));
+        wxLogDebug(wxT("Can't pause thread which is not running."));

 
         return wxTHREAD_NOT_RUNNING;
     }
 
         return wxTHREAD_NOT_RUNNING;
     }


@@ -646,7 +673,7 @@ wxThreadError wxThread::Resume()
     }
     else
     {
     }
     else
     {

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


@@ -658,6 +685,9 @@ 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();
 


@@ -683,6 +713,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;
 }


@@ -704,6 +736,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;
     }


@@ -748,6 +782,18 @@ bool wxThread::TestDestroy()
 
 wxThread::~wxThread()
 {
 
 wxThread::~wxThread()
 {

+    m_critsect.Enter();
+    if ( p_internal->GetState() != STATE_EXITED &&
+         p_internal->GetState() != STATE_NEW )
+    {
+        wxLogDebug(wxT("The thread is being destroyed although 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);
 }


@@ -823,16 +869,18 @@ bool wxThreadModule::OnInit()
 
 void wxThreadModule::OnExit()
 {
 
 void wxThreadModule::OnExit()
 {

-    wxASSERT_MSG( wxThread::IsMain(), _T("only main thread can be here") );
+    wxASSERT_MSG( wxThread::IsMain(), wxT("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(_T("Some threads were not terminated by the application."));
+        wxLogDebug(wxT("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
     }
 
     // destroy GUI mutex