Disable wxUSE_ENH_METAFILE for wxGTK builds.

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

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 7e784e285f9a4e8fcea700ee40597a34f8cd32c6..8f36dd3ba76db5bd831baf0754ef60758267f093 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -54,10 +54,17 @@
     #include <thread.h>
 #endif
 
     #include <thread.h>
 #endif
 

+#ifdef HAVE_ABI_FORCEDUNWIND
+    #include <cxxabi.h>
+#endif
+
+#ifdef HAVE_SETPRIORITY
+    #include <sys/resource.h>   // for setpriority()
+#endif
+

 // we use wxFFile under Linux in GetCPUCount()
 #ifdef __LINUX__
     #include "wx/ffile.h"
 // we use wxFFile under Linux in GetCPUCount()
 #ifdef __LINUX__
     #include "wx/ffile.h"

-    #include <sys/resource.h>   // for setpriority()

 #endif
 
 #define THR_ID_CAST(id)  (reinterpret_cast<void*>(id))
 #endif
 
 #define THR_ID_CAST(id)  (reinterpret_cast<void*>(id))


@@ -475,7 +482,7 @@ wxCondError wxConditionInternal::Wait()
 
 wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
 {
 
 wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
 {

-    wxLongLong curtime = wxGetLocalTimeMillis();
+    wxLongLong curtime = wxGetUTCTimeMillis();

     curtime += milliseconds;
     wxLongLong temp = curtime / 1000;
     int sec = temp.GetLo();
     curtime += milliseconds;
     wxLongLong temp = curtime / 1000;
     int sec = temp.GetLo();


@@ -703,6 +710,8 @@ public:
     static void *PthreadStart(wxThread *thread);
 
     // thread actions
     static void *PthreadStart(wxThread *thread);
 
     // thread actions

+         // create the thread
+    wxThreadError Create(wxThread *thread, unsigned int stackSize);

         // start the thread
     wxThreadError Run();
         // unblock the thread allowing it to run
         // start the thread
     wxThreadError Run();
         // unblock the thread allowing it to run


@@ -740,6 +749,8 @@ public:
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }

+        // "created" flag
+    bool WasCreated() const { return m_created; }

         // "cancelled" flag
     void SetCancelFlag() { m_cancelled = true; }
     bool WasCancelled() const { return m_cancelled; }
         // "cancelled" flag
     void SetCancelFlag() { m_cancelled = true; }
     bool WasCancelled() const { return m_cancelled; }


@@ -770,6 +781,9 @@ private:
     wxThreadState m_state;      // see wxThreadState enum
     int           m_prio;       // in wxWidgets units: from 0 to 100
 
     wxThreadState m_state;      // see wxThreadState enum
     int           m_prio;       // in wxWidgets units: from 0 to 100
 

+    // this flag is set when the thread was successfully created
+    bool m_created;
+

     // this flag is set when the thread should terminate
     bool m_cancelled;
 
     // this flag is set when the thread should terminate
     bool m_cancelled;
 


@@ -815,7 +829,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
     {
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
     {

-        wxLogSysError(rc, _("Cannot start thread: error writing TLS"));
+        wxLogSysError(rc, _("Cannot start thread: error writing TLS."));

 
         return (void *)-1;
     }
 
         return (void *)-1;
     }


@@ -857,6 +871,18 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
                        wxT("Thread %p Entry() returned %lu."),
                        THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
         }
                        wxT("Thread %p Entry() returned %lu."),
                        THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
         }

+#ifdef HAVE_ABI_FORCEDUNWIND
+        // When using common C++ ABI under Linux we must always rethrow this
+        // special exception used to unwind the stack when the thread was
+        // cancelled, otherwise the thread library would simply terminate the
+        // program, see http://udrepper.livejournal.com/21541.html
+        catch ( abi::__forced_unwind& )
+        {
+            wxCriticalSectionLocker lock(thread->m_critsect);
+            pthread->SetState(STATE_EXITED);
+            throw;
+        }
+#endif // HAVE_ABI_FORCEDUNWIND

         wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 
         {
         wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 
         {


@@ -937,8 +963,9 @@ void wxThreadInternal::Cleanup(wxThread *thread)
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;

+    m_created = false;

     m_cancelled = false;
     m_cancelled = false;

-    m_prio = WXTHREAD_DEFAULT_PRIORITY;
+    m_prio = wxPRIORITY_DEFAULT;

     m_threadId = 0;
     m_exitcode = 0;
 
     m_threadId = 0;
     m_exitcode = 0;
 


@@ -954,6 +981,132 @@ wxThreadInternal::~wxThreadInternal()
 {
 }
 
 {
 }
 

+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    #define WXUNUSED_STACKSIZE(identifier)  identifier
+#else
+    #define WXUNUSED_STACKSIZE(identifier)  WXUNUSED(identifier)
+#endif
+
+wxThreadError wxThreadInternal::Create(wxThread *thread,
+                                       unsigned int WXUNUSED_STACKSIZE(stackSize))
+{
+    if ( GetState() != STATE_NEW )
+    {
+        // don't recreate thread
+        return wxTHREAD_RUNNING;
+    }
+
+    // set up the thread attribute: right now, we only set thread priority
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    if (stackSize)
+      pthread_attr_setstacksize(&attr, stackSize);
+#endif
+
+#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
+    int policy;
+    if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
+    {
+        wxLogError(_("Cannot retrieve thread scheduling policy."));
+    }
+
+#ifdef __VMS__
+   /* the pthread.h contains too many spaces. This is a work-around */
+# undef sched_get_priority_max
+#undef sched_get_priority_min
+#define sched_get_priority_max(_pol_) \
+     (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
+#define sched_get_priority_min(_pol_) \
+     (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
+#endif
+
+    int max_prio = sched_get_priority_max(policy),
+        min_prio = sched_get_priority_min(policy),
+        prio = GetPriority();
+
+    if ( min_prio == -1 || max_prio == -1 )
+    {
+        wxLogError(_("Cannot get priority range for scheduling policy %d."),
+                   policy);
+    }
+    else if ( max_prio == min_prio )
+    {
+        if ( prio != wxPRIORITY_DEFAULT )
+        {
+            // 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;
+        if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
+        {
+            wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed"));
+        }
+
+        sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
+
+        if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
+        {
+            wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));
+        }
+    }
+#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
+
+#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
+    // this will make the threads created by this process really concurrent
+    if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
+    {
+        wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
+    }
+#endif // HAVE_PTHREAD_ATTR_SETSCOPE
+
+    // VZ: assume that this one is always available (it's rather fundamental),
+    //     if this function is ever missing we should try to use
+    //     pthread_detach() instead (after thread creation)
+    if ( thread->IsDetached() )
+    {
+        if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
+        {
+            wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
+        }
+
+        // never try to join detached threads
+        Detach();
+    }
+    //else: threads are created joinable by default, it's ok
+
+    // create the new OS thread object
+    int rc = pthread_create
+             (
+                GetIdPtr(),
+                &attr,
+                wxPthreadStart,
+                (void *)thread
+             );
+
+    if ( pthread_attr_destroy(&attr) != 0 )
+    {
+        wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
+    }
+
+    if ( rc != 0 )
+    {
+        SetState(STATE_EXITED);
+
+        return wxTHREAD_NO_RESOURCE;
+    }
+
+    m_created = true;
+    return wxTHREAD_NO_ERROR;
+}
+

 wxThreadError wxThreadInternal::Run()
 {
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
 wxThreadError wxThreadInternal::Run()
 {
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,


@@ -1127,18 +1280,23 @@ wxThreadIdType wxThread::GetCurrentId()
 
 bool wxThread::SetConcurrency(size_t level)
 {
 
 bool wxThread::SetConcurrency(size_t level)
 {

-#ifdef HAVE_THR_SETCONCURRENCY
+#ifdef HAVE_PTHREAD_SET_CONCURRENCY
+    int rc = pthread_setconcurrency( level );
+#elif defined(HAVE_THR_SETCONCURRENCY)

     int rc = thr_setconcurrency(level);
     int rc = thr_setconcurrency(level);

+#else // !HAVE_THR_SETCONCURRENCY
+    // ok only for the default value
+    int rc = level == 0 ? 0 : -1;
+#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
+

     if ( rc != 0 )
     {
     if ( rc != 0 )
     {

-        wxLogSysError(rc, wxT("thr_setconcurrency() failed"));
+        wxLogSysError(rc, _("Failed to set thread concurrency level to %lu"),
+                      static_cast<unsigned long>(level));
+        return false;

     }
 
     }
 

-    return rc == 0;
-#else // !HAVE_THR_SETCONCURRENCY
-    // ok only for the default value
-    return level == 0;
-#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
+    return true;

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -1159,136 +1317,25 @@ wxThread::wxThread(wxThreadKind kind)
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 

-#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
-    #define WXUNUSED_STACKSIZE(identifier)  identifier
-#else
-    #define WXUNUSED_STACKSIZE(identifier)  WXUNUSED(identifier)
-#endif
-
-wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))
+wxThreadError wxThread::Create(unsigned int stackSize)

 {
 {

-    if ( m_internal->GetState() != STATE_NEW )
-    {
-        // don't recreate thread
-        return wxTHREAD_RUNNING;
-    }
-
-    // set up the thread attribute: right now, we only set thread priority
-    pthread_attr_t attr;
-    pthread_attr_init(&attr);
-
-#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
-    if (stackSize)
-      pthread_attr_setstacksize(&attr, stackSize);
-#endif
-
-#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
-    int policy;
-    if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
-    {
-        wxLogError(_("Cannot retrieve thread scheduling policy."));
-    }
-
-#ifdef __VMS__
-   /* the pthread.h contains too many spaces. This is a work-around */
-# undef sched_get_priority_max
-#undef sched_get_priority_min
-#define sched_get_priority_max(_pol_) \
-     (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
-#define sched_get_priority_min(_pol_) \
-     (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
-#endif
-
-    int max_prio = sched_get_priority_max(policy),
-        min_prio = sched_get_priority_min(policy),
-        prio = m_internal->GetPriority();
-
-    if ( min_prio == -1 || max_prio == -1 )
-    {
-        wxLogError(_("Cannot get priority range for scheduling policy %d."),
-                   policy);
-    }
-    else if ( max_prio == min_prio )
-    {
-        if ( prio != 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;
-        if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
-        {
-            wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed"));
-        }
-
-        sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
-
-        if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
-        {
-            wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));
-        }
-    }
-#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
-
-#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
-    // this will make the threads created by this process really concurrent
-    if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
-    {
-        wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
-    }
-#endif // HAVE_PTHREAD_ATTR_SETSCOPE
-
-    // VZ: assume that this one is always available (it's rather fundamental),
-    //     if this function is ever missing we should try to use
-    //     pthread_detach() instead (after thread creation)
-    if ( m_isDetached )
-    {
-        if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
-        {
-            wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
-        }
-
-        // never try to join detached threads
-        m_internal->Detach();
-    }
-    //else: threads are created joinable by default, it's ok
-
-    // create the new OS thread object
-    int rc = pthread_create
-             (
-                m_internal->GetIdPtr(),
-                &attr,
-                wxPthreadStart,
-                (void *)this
-             );
-
-    if ( pthread_attr_destroy(&attr) != 0 )
-    {
-        wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
-    }
-
-    if ( rc != 0 )
-    {
-        m_internal->SetState(STATE_EXITED);
-
-        return wxTHREAD_NO_RESOURCE;
-    }
+    wxCriticalSectionLocker lock(m_critsect);

 
 

-    return wxTHREAD_NO_ERROR;
+    return m_internal->Create(this, stackSize);

 }
 
 wxThreadError wxThread::Run()
 {
     wxCriticalSectionLocker lock(m_critsect);
 
 }
 
 wxThreadError wxThread::Run()
 {
     wxCriticalSectionLocker lock(m_critsect);
 

-    wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR,
-                 wxT("must call wxThread::Create() first") );
+    // Create the thread if it wasn't created yet with an explicit
+    // Create() call:
+    if ( !m_internal->WasCreated() )
+    {
+        wxThreadError rv = m_internal->Create(this, 0);
+        if ( rv != wxTHREAD_NO_ERROR )
+            return rv;
+    }

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


@@ -1299,8 +1346,7 @@ wxThreadError wxThread::Run()
 
 void wxThread::SetPriority(unsigned int prio)
 {
 
 void wxThread::SetPriority(unsigned int prio)
 {

-    wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
-                 ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
+    wxCHECK_RET( wxPRIORITY_MIN <= prio && prio <= wxPRIORITY_MAX,

                  wxT("invalid thread priority") );
 
     wxCriticalSectionLocker lock(m_critsect);
                  wxT("invalid thread priority") );
 
     wxCriticalSectionLocker lock(m_critsect);


@@ -1326,8 +1372,7 @@ void wxThread::SetPriority(unsigned int prio)
             //
             // FIXME this is not true for 2.6!!
 
             //
             // FIXME this is not true for 2.6!!
 

-            // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
-            // to Unix priorities 20..-20
+            // map wx priorites 0..100 to Unix priorities 20..-20

             if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
             {
                 wxLogError(_("Failed to set thread priority %d."), prio);
             if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
             {
                 wxLogError(_("Failed to set thread priority %d."), prio);


@@ -1425,7 +1470,7 @@ wxThreadError wxThread::Resume()
 // exiting thread
 // -----------------------------------------------------------------------------
 
 // exiting thread
 // -----------------------------------------------------------------------------
 

-wxThread::ExitCode wxThread::Wait()
+wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode))

 {
     wxCHECK_MSG( This() != this, (ExitCode)-1,
                  wxT("a thread can't wait for itself") );
 {
     wxCHECK_MSG( This() != this, (ExitCode)-1,
                  wxT("a thread can't wait for itself") );


@@ -1438,7 +1483,7 @@ wxThread::ExitCode wxThread::Wait()
     return m_internal->GetExitCode();
 }
 
     return m_internal->GetExitCode();
 }
 

-wxThreadError wxThread::Delete(ExitCode *rc)
+wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode))

 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
                  wxT("a thread can't delete itself") );
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
                  wxT("a thread can't delete itself") );


@@ -1453,6 +1498,8 @@ wxThreadError wxThread::Delete(ExitCode *rc)
 
     m_critsect.Leave();
 
 
     m_critsect.Leave();
 

+    OnDelete();
+

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


@@ -1487,10 +1534,10 @@ wxThreadError wxThread::Delete(ExitCode *rc)
             }
             //else: can't wait for detached threads
     }
             }
             //else: can't wait for detached threads
     }

-    
+

     if (state == STATE_NEW)
         return wxTHREAD_MISC_ERROR;
     if (state == STATE_NEW)
         return wxTHREAD_MISC_ERROR;

-            // for coherency with the MSW implementation, signal the user that 
+            // for coherency with the MSW implementation, signal the user that

             // Delete() was called on a thread which didn't start to run yet.
 
     return wxTHREAD_NO_ERROR;
             // Delete() was called on a thread which didn't start to run yet.
 
     return wxTHREAD_NO_ERROR;


@@ -1501,6 +1548,8 @@ wxThreadError wxThread::Kill()
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
                  wxT("a thread can't kill itself") );
 
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
                  wxT("a thread can't kill itself") );
 

+    OnKill();
+

     switch ( m_internal->GetState() )
     {
         case STATE_NEW:
     switch ( m_internal->GetState() )
     {
         case STATE_NEW:


@@ -1828,7 +1877,7 @@ static void DeleteThread(wxThread *This)
     }
 }
 
     }
 }
 

-#ifndef __WXOSX__
+#ifndef __DARWIN__

 
 void wxMutexGuiEnterImpl()
 {
 
 void wxMutexGuiEnterImpl()
 {