/////////////////////////////////////////////////////////////////////////////
-// Name: threadpsx.cpp
+// Name: src/unix/threadpsx.cpp
// Purpose: wxThread (Posix) Implementation
// Author: Original from Wolfram Gloger/Guilhem Lavaux
// Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "thread.h"
-#endif
-
-#include "wx/defs.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
#if wxUSE_THREADS
#include "wx/thread.h"
-#include "wx/module.h"
-#include "wx/utils.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
-#include "wx/timer.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 <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <time.h>
-#if HAVE_SCHED_H
+#include <sys/time.h> // needed for at least __QNX__
+#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
// 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))
+#define THR_ID(thr) THR_ID_CAST((thr)->GetId())
+
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// the exit value of a thread which has been cancelled
static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
-// our trace mask
-#define TRACE_THREADS _T("thread")
+// trace mask for wxThread operations
+#define TRACE_THREADS wxT("thread")
+
+// you can get additional debugging messages for the semaphore operations
+#define TRACE_SEMA wxT("semaphore")
// ----------------------------------------------------------------------------
// private functions
static void DeleteThread(wxThread *This);
// ----------------------------------------------------------------------------
-// types
+// private classes
// ----------------------------------------------------------------------------
-WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+// an (non owning) array of pointers to threads
+WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
+
+// an entry for a thread we can wait for
// -----------------------------------------------------------------------------
// global data
// 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;
+//
+// we suppose that 0 is not a valid pthread_t value but in principle this might
+// be false (e.g. if it's a selector-like value), wxThread::IsMain() would need
+// to be updated in such case
+wxThreadIdType wxThread::ms_idMainThread = 0;
// the key for the pointer to the associated wxThread object
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;
-#if wxUSE_GUI
- // this mutex must be acquired before any call to a GUI function
- static wxMutex *gs_mutexGui;
-#endif // wxUSE_GUI
+#ifndef __WXOSX__
+// 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
+// of wxBase)
+static wxMutex *gs_mutexGui = NULL;
+#endif
+
+// when we wait for a thread to exit, we're blocking on a condition which the
+// thread signals in its SignalExit() method -- but this condition can't be a
+// member of the thread itself as a detached thread may delete itself at any
+// moment and accessing the condition member of the thread after this would
+// result in a disaster
+//
+// so instead we maintain a global list of the structs below for the threads
+// we're interested in waiting on
// ============================================================================
// wxMutex implementation
// wxMutexInternal
// ----------------------------------------------------------------------------
+// this is a simple wrapper around pthread_mutex_t which provides error
+// checking
class wxMutexInternal
{
public:
- wxMutexInternal();
+ wxMutexInternal(wxMutexType mutexType);
~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;
};
-wxMutexInternal::wxMutexInternal()
+#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
+ wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
+// on some systems pthread_mutexattr_settype() is not in the headers (but it is
+// in the library, otherwise we wouldn't compile this code at all)
+extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
+#endif
+
+wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
{
- // support recursive locks like Win32, i.e. a thread can lock a mutex which
- // it had itself already locked
- //
- // but initialization of recursive mutexes is non portable <sigh>, so try
- // several methods
+ m_type = mutexType;
+ m_owningThread = 0;
+
+ int err;
+ switch ( mutexType )
+ {
+ case wxMUTEX_RECURSIVE:
+ // support recursive locks like Win32, i.e. a thread can lock a
+ // mutex which it had itself already locked
+ //
+ // unfortunately initialization of recursive mutexes is non
+ // portable, so try several methods
#ifdef HAVE_PTHREAD_MUTEXATTR_T
- pthread_mutexattr_t attr;
- pthread_mutexattr_init(&attr);
- pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+ {
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
- pthread_mutex_init(&m_mutex, &attr);
+ err = pthread_mutex_init(&m_mutex, &attr);
+ }
#elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
- // we can use this only as initializer so we have to assign it first to a
- // temp var - assigning directly to m_mutex wouldn't even compile
- pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
- m_mutex = mutex;
+ // we can use this only as initializer so we have to assign it
+ // first to a temp var - assigning directly to m_mutex wouldn't
+ // even compile
+ {
+ pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+ m_mutex = mutex;
+ }
#else // no recursive mutexes
- pthread_mutex_init(&m_mutex, NULL);
-
- // used by TryLock() below
- #define NO_RECURSIVE_MUTEXES
+ err = EINVAL;
#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+ break;
+
+ default:
+ wxFAIL_MSG( wxT("unknown mutex type") );
+ // fall through
+
+ case wxMUTEX_DEFAULT:
+ err = pthread_mutex_init(&m_mutex, NULL);
+ break;
+ }
+
+ m_isOk = err == 0;
+ if ( !m_isOk )
+ {
+ wxLogApiError( wxT("pthread_mutex_init()"), err);
+ }
}
wxMutexInternal::~wxMutexInternal()
{
- pthread_mutex_destroy(&m_mutex);
+ if ( m_isOk )
+ {
+ int err = pthread_mutex_destroy(&m_mutex);
+ if ( err != 0 )
+ {
+ wxLogApiError( wxT("pthread_mutex_destroy()"), err);
+ }
+ }
}
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:
- wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+ // only error checking mutexes return this value and so it's an
+ // unexpected situation -- hence use assert, not wxLogDebug
+ wxFAIL_MSG( wxT("mutex deadlock prevented") );
return wxMUTEX_DEAD_LOCK;
- default:
- wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
- // fall through
-
case EINVAL:
- wxLogDebug(_T("Failed to lock the mutex."));
- return wxMUTEX_MISC_ERROR;
+ wxLogDebug(wxT("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(wxT("pthread_mutex_[timed]lock()"), err);
}
+
+ return wxMUTEX_MISC_ERROR;
}
+
wxMutexError wxMutexInternal::TryLock()
{
int err = pthread_mutex_trylock(&m_mutex);
switch ( err )
{
case EBUSY:
+ // not an error: mutex is already locked, but we're prepared for
+ // this
return wxMUTEX_BUSY;
- default:
- wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
- // fall through
-
case EINVAL:
- wxLogDebug(_T("Failed to try to lock the mutex."));
- return wxMUTEX_MISC_ERROR;
+ wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized."));
+ break;
case 0:
+ if (m_type == wxMUTEX_DEFAULT)
+ m_owningThread = wxThread::GetCurrentId();
return wxMUTEX_NO_ERROR;
+
+ default:
+ wxLogApiError(wxT("pthread_mutex_trylock()"), err);
}
+
+ return wxMUTEX_MISC_ERROR;
}
wxMutexError wxMutexInternal::Unlock()
{
+ m_owningThread = 0;
+
int err = pthread_mutex_unlock(&m_mutex);
switch ( err )
{
// we don't own the mutex
return wxMUTEX_UNLOCKED;
- default:
- wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
- // fall through
-
case EINVAL:
- wxLogDebug(_T("Failed to unlock the mutex."));
- return wxMUTEX_MISC_ERROR;
+ wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized."));
+ break;
case 0:
return wxMUTEX_NO_ERROR;
- }
-}
-
-// ----------------------------------------------------------------------------
-// wxMutex
-// ----------------------------------------------------------------------------
-
-// TODO: this is completely generic, move it to common code?
-
-wxMutex::wxMutex()
-{
- m_internal = new wxMutexInternal;
-
- m_locked = 0;
-}
-
-wxMutex::~wxMutex()
-{
- if ( m_locked > 0 )
- wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
-
- delete m_internal;
-}
-
-wxMutexError wxMutex::Lock()
-{
- wxMutexError err = m_internal->Lock();
- if ( !err )
- {
- m_locked++;
- }
-
- return err;
-}
-
-wxMutexError wxMutex::TryLock()
-{
- if ( m_locked )
- {
-#ifdef NO_RECURSIVE_MUTEXES
- return wxMUTEX_DEAD_LOCK;
-#else // have recursive mutexes on this platform
- // we will succeed in locking it when we have it already locked
- return wxMUTEX_NO_ERROR;
-#endif // recursive/non-recursive mutexes
- }
-
- wxMutexError err = m_internal->TryLock();
- if ( !err )
- {
- m_locked++;
- }
-
- return err;
-}
-
-wxMutexError wxMutex::Unlock()
-{
- if ( m_locked > 0 )
- {
- m_locked--;
- }
- else
- {
- wxLogDebug(wxT("Unlocking not locked mutex."));
-
- return wxMUTEX_UNLOCKED;
+ default:
+ wxLogApiError(wxT("pthread_mutex_unlock()"), err);
}
- return m_internal->Unlock();
+ return wxMUTEX_MISC_ERROR;
}
// ===========================================================================
// wxConditionInternal
// ---------------------------------------------------------------------------
+// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
+// with a pthread_mutex_t)
class wxConditionInternal
{
public:
- wxConditionInternal( wxMutex *mutex );
+ wxConditionInternal(wxMutex& mutex);
~wxConditionInternal();
- void Wait();
-
- bool Wait( const timespec *ts );
+ bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
- void Signal();
+ wxCondError Wait();
+ wxCondError WaitTimeout(unsigned long milliseconds);
- void Broadcast();
+ wxCondError Signal();
+ wxCondError Broadcast();
private:
+ // get the POSIX mutex associated with us
+ pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }
- wxMutex *m_mutex;
+ wxMutex& m_mutex;
pthread_cond_t m_cond;
+
+ bool m_isOk;
};
-wxConditionInternal::wxConditionInternal( wxMutex *mutex )
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+ : m_mutex(mutex)
{
- m_mutex = mutex;
- if ( pthread_cond_init( &m_cond, NULL ) != 0 )
- {
- wxLogDebug(_T("pthread_cond_init() failed"));
- }
-}
+ int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
-wxConditionInternal::~wxConditionInternal()
-{
- if ( pthread_cond_destroy( &m_cond ) != 0 )
- {
- wxLogDebug(_T("pthread_cond_destroy() failed"));
- }
-}
+ m_isOk = err == 0;
-void wxConditionInternal::Wait()
-{
- if ( pthread_cond_wait( &m_cond, &(m_mutex->m_internal->m_mutex) ) != 0 )
+ if ( !m_isOk )
{
- wxLogDebug(_T("pthread_cond_wait() failed"));
- }
-}
-
-bool wxConditionInternal::Wait( const timespec *ts )
-{
- int result = pthread_cond_timedwait( &m_cond,
- &(m_mutex->m_internal->m_mutex),
- ts );
- if ( result == ETIMEDOUT )
- return FALSE;
-
- wxASSERT_MSG( result == 0, _T("pthread_cond_timedwait() failed") );
-
- return TRUE;
-}
-
-void wxConditionInternal::Signal()
-{
- int result = pthread_cond_signal( &m_cond );
- if ( result != 0 )
-{
- wxFAIL_MSG( _T("pthread_cond_signal() failed") );
+ wxLogApiError(wxT("pthread_cond_init()"), err);
}
}
-void wxConditionInternal::Broadcast()
-{
- int result = pthread_cond_broadcast( &m_cond );
- if ( result != 0 )
+wxConditionInternal::~wxConditionInternal()
{
- wxFAIL_MSG( _T("pthread_cond_broadcast() failed") );
+ if ( m_isOk )
+ {
+ int err = pthread_cond_destroy(&m_cond);
+ if ( err != 0 )
+ {
+ wxLogApiError(wxT("pthread_cond_destroy()"), err);
+ }
}
}
-
-// ---------------------------------------------------------------------------
-// wxCondition
-// ---------------------------------------------------------------------------
-
-wxCondition::wxCondition( wxMutex *mutex )
+wxCondError wxConditionInternal::Wait()
{
- if ( !mutex )
+ int err = pthread_cond_wait(&m_cond, GetPMutex());
+ if ( err != 0 )
{
- wxFAIL_MSG( _T("NULL mutex in wxCondition ctor") );
+ wxLogApiError(wxT("pthread_cond_wait()"), err);
- m_internal = NULL;
+ return wxCOND_MISC_ERROR;
}
- else
- {
- m_internal = new wxConditionInternal( mutex );
- }
-}
-wxCondition::~wxCondition()
-{
- delete m_internal;
-}
-
-void wxCondition::Wait()
-{
- if ( m_internal )
- m_internal->Wait();
+ return wxCOND_NO_ERROR;
}
-bool wxCondition::Wait( unsigned long timeout_millis )
+wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
{
- wxCHECK_MSG( m_internal, FALSE, _T("can't wait on uninitalized condition") );
-
- wxLongLong curtime = wxGetLocalTimeMillis();
- curtime += timeout_millis;
+ wxLongLong curtime = wxGetUTCTimeMillis();
+ curtime += milliseconds;
wxLongLong temp = curtime / 1000;
int sec = temp.GetLo();
- temp = temp * 1000;
+ temp *= 1000;
temp = curtime - temp;
int millis = temp.GetLo();
tspec.tv_sec = sec;
tspec.tv_nsec = millis * 1000L * 1000L;
- return m_internal->Wait(&tspec);
+ int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
+ switch ( err )
+ {
+ case ETIMEDOUT:
+ return wxCOND_TIMEOUT;
+
+ case 0:
+ return wxCOND_NO_ERROR;
+
+ default:
+ wxLogApiError(wxT("pthread_cond_timedwait()"), err);
+ }
+
+ return wxCOND_MISC_ERROR;
}
-void wxCondition::Signal()
+wxCondError wxConditionInternal::Signal()
{
- if ( m_internal )
- m_internal->Signal();
+ int err = pthread_cond_signal(&m_cond);
+ if ( err != 0 )
+ {
+ wxLogApiError(wxT("pthread_cond_signal()"), err);
+
+ return wxCOND_MISC_ERROR;
+ }
+
+ return wxCOND_NO_ERROR;
}
-void wxCondition::Broadcast()
+wxCondError wxConditionInternal::Broadcast()
{
- if ( m_internal )
- m_internal->Broadcast();
+ int err = pthread_cond_broadcast(&m_cond);
+ if ( err != 0 )
+ {
+ wxLogApiError(wxT("pthread_cond_broadcast()"), err);
+
+ return wxCOND_MISC_ERROR;
+ }
+
+ return wxCOND_NO_ERROR;
}
// ===========================================================================
// wxSemaphoreInternal
// ---------------------------------------------------------------------------
+// we implement the semaphores using mutexes and conditions instead of using
+// the sem_xxx() POSIX functions because they're not widely available and also
+// because it's impossible to implement WaitTimeout() using them
class wxSemaphoreInternal
{
public:
- wxSemaphoreInternal( int initialcount, int maxcount );
+ wxSemaphoreInternal(int initialcount, int maxcount);
- void Wait();
- bool TryWait();
+ bool IsOk() const { return m_isOk; }
- bool Wait( unsigned long timeout_millis );
+ wxSemaError Wait();
+ wxSemaError TryWait();
+ wxSemaError WaitTimeout(unsigned long milliseconds);
- void Post();
+ wxSemaError Post();
private:
wxMutex m_mutex;
wxCondition m_cond;
- int count,
- maxcount;
+ size_t m_count,
+ m_maxcount;
+
+ bool m_isOk;
};
-wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount )
- : m_cond(&m_mutex)
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+ : m_cond(m_mutex)
{
- if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) )
+ if ( (initialcount < 0 || maxcount < 0) ||
+ ((maxcount > 0) && (initialcount > maxcount)) )
{
- wxFAIL_MSG( _T("wxSemaphore: invalid initial count") );
- }
-
- maxcount = maxcount;
- count = initialcount;
-}
-
-void wxSemaphoreInternal::Wait()
-{
- wxMutexLocker locker(m_mutex);
+ wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") );
- while ( count <= 0 )
- {
- m_cond.Wait();
+ m_isOk = false;
}
-
- count--;
-}
-
-bool wxSemaphoreInternal::TryWait()
-{
- wxMutexLocker locker(m_mutex);
-
- if ( count <= 0 )
- return FALSE;
-
- count--;
-
- return TRUE;
-}
-
-bool wxSemaphoreInternal::Wait( unsigned long timeout_millis )
-{
- wxMutexLocker locker(m_mutex);
-
- wxLongLong startTime = wxGetLocalTimeMillis();
-
- while ( count <= 0 )
+ else
{
- wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
- long remainingTime = (long)timeout_millis - (long)elapsed.GetLo();
- if ( remainingTime <= 0 )
- return FALSE;
-
- bool result = m_cond.Wait( remainingTime );
- if ( !result )
- return FALSE;
+ m_maxcount = (size_t)maxcount;
+ m_count = (size_t)initialcount;
}
- count--;
-
- return TRUE;
+ m_isOk = m_mutex.IsOk() && m_cond.IsOk();
}
-void wxSemaphoreInternal::Post()
+wxSemaError wxSemaphoreInternal::Wait()
{
wxMutexLocker locker(m_mutex);
- if ( maxcount > 0 && count == maxcount )
+ while ( m_count == 0 )
{
- wxFAIL_MSG( _T("wxSemaphore::Post() overflow") );
- }
+ wxLogTrace(TRACE_SEMA,
+ wxT("Thread %p waiting for semaphore to become signalled"),
+ THR_ID_CAST(wxThread::GetCurrentId()));
- count++;
+ if ( m_cond.Wait() != wxCOND_NO_ERROR )
+ return wxSEMA_MISC_ERROR;
- m_cond.Signal();
-}
+ wxLogTrace(TRACE_SEMA,
+ wxT("Thread %p finished waiting for semaphore, count = %lu"),
+ THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
+ }
-// --------------------------------------------------------------------------
-// wxSemaphore
-// --------------------------------------------------------------------------
+ m_count--;
-wxSemaphore::wxSemaphore( int initialcount, int maxcount )
-{
- m_internal = new wxSemaphoreInternal( initialcount, maxcount );
+ return wxSEMA_NO_ERROR;
}
-wxSemaphore::~wxSemaphore()
+wxSemaError wxSemaphoreInternal::TryWait()
{
- delete m_internal;
-}
-
-void wxSemaphore::Wait()
-{
- m_internal->Wait();
-}
+ wxMutexLocker locker(m_mutex);
-bool wxSemaphore::TryWait()
-{
- return m_internal->TryWait();
-}
+ if ( m_count == 0 )
+ return wxSEMA_BUSY;
-bool wxSemaphore::Wait( unsigned long timeout_millis )
-{
- return m_internal->Wait( timeout_millis );
-}
+ m_count--;
-void wxSemaphore::Post()
-{
- m_internal->Post();
+ return wxSEMA_NO_ERROR;
}
-// This class is used by wxThreadInternal to support Delete() on
-// a detached thread
-class wxRefCountedCondition
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
{
-public:
- // start with a initial reference count of 1
- wxRefCountedCondition()
- {
- m_refCount = 1;
- m_signaled = FALSE;
-
- m_mutex = new wxMutex();
- m_cond = new wxCondition( m_mutex );
- }
-
- // increment the reference count
- void AddRef()
- {
- wxMutexLocker locker( *m_mutex );
+ wxMutexLocker locker(m_mutex);
- m_refCount++;
- }
+ wxLongLong startTime = wxGetLocalTimeMillis();
- // decrement the reference count if reference count is zero then delete the
- // object
- void DeleteRef()
+ while ( m_count == 0 )
{
- bool shouldDelete = FALSE;
-
- m_mutex->Lock();
-
- if ( --m_refCount == 0 )
+ wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+ long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
+ if ( remainingTime <= 0 )
{
- shouldDelete = TRUE;
+ // timeout
+ return wxSEMA_TIMEOUT;
}
- m_mutex->Unlock();
-
- if ( shouldDelete )
+ switch ( m_cond.WaitTimeout(remainingTime) )
{
- delete this;
- }
- }
-
-
- // sets the object to signaled this signal will be a persistent signal all
- // further Wait()s on the object will return without blocking
- void SetSignaled()
- {
- wxMutexLocker locker( *m_mutex );
-
- m_signaled = TRUE;
-
- m_cond->Broadcast();
- }
+ case wxCOND_TIMEOUT:
+ return wxSEMA_TIMEOUT;
- // wait till the object is signaled if the object was already signaled then
- // return immediately
- void Wait()
- {
- wxMutexLocker locker( *m_mutex );
+ default:
+ return wxSEMA_MISC_ERROR;
- if ( !m_signaled )
- {
- m_cond->Wait();
+ case wxCOND_NO_ERROR:
+ ;
}
}
-private:
- int m_refCount;
+ m_count--;
- wxMutex *m_mutex;
- wxCondition *m_cond;
+ return wxSEMA_NO_ERROR;
+}
- bool m_signaled;
+wxSemaError wxSemaphoreInternal::Post()
+{
+ wxMutexLocker locker(m_mutex);
- // Cannot delete this object directly, call DeleteRef() instead
- ~wxRefCountedCondition()
+ if ( m_maxcount > 0 && m_count == m_maxcount )
{
- delete m_cond;
- delete m_mutex;
+ return wxSEMA_OVERFLOW;
}
- // suppress gcc warning about the class having private dtor and not having
- // friend (so what??)
- friend class wxDummyFriend;
-};
+ m_count++;
+
+ wxLogTrace(TRACE_SEMA,
+ wxT("Thread %p about to signal semaphore, count = %lu"),
+ THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
+
+ return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
+ : wxSEMA_MISC_ERROR;
+}
// ===========================================================================
// wxThread implementation
extern "C"
{
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// thread exit function
void wxPthreadCleanup(void *ptr);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
void *wxPthreadStart(void *ptr);
// thread actions
// start the thread
wxThreadError Run();
+ // unblock the thread allowing it to run
+ void SignalRun() { m_semRun.Post(); }
// ask the thread to terminate
void Wait();
- // wake up threads waiting for our termination
- void SignalExit();
- // wake up threads waiting for our start
- void SignalRun() { m_semRun.Post(); }
// go to sleep until Resume() is called
void Pause();
// resume the thread
void SetPriority(int prio) { m_prio = prio; }
// state
wxThreadState GetState() const { return m_state; }
- void SetState(wxThreadState state) { m_state = state; }
+ void SetState(wxThreadState state)
+ {
+#if wxUSE_LOG_TRACE
+ static const wxChar *const stateNames[] =
+ {
+ wxT("NEW"),
+ wxT("RUNNING"),
+ wxT("PAUSED"),
+ wxT("EXITED"),
+ };
+
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."),
+ THR_ID(this), stateNames[m_state], stateNames[state]);
+#endif // wxUSE_LOG_TRACE
+
+ m_state = state;
+ }
// id
pthread_t GetId() const { return m_threadId; }
pthread_t *GetIdPtr() { return &m_threadId; }
// "cancelled" flag
- void SetCancelFlag() { m_cancelled = TRUE; }
+ void SetCancelFlag() { m_cancelled = true; }
bool WasCancelled() const { return m_cancelled; }
// exit code
void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
// tell the thread that it is a detached one
void Detach()
{
- m_shouldBeJoined = m_shouldBroadcast = FALSE;
- m_isDetached = TRUE;
+ wxCriticalSectionLocker lock(m_csJoinFlag);
+
+ m_shouldBeJoined = false;
+ m_isDetached = true;
}
- // but even detached threads need to notifyus about their termination
- // sometimes - tell the thread that it should do it
- void Notify() { m_shouldBroadcast = TRUE; }
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// this is used by wxPthreadCleanup() only
static void Cleanup(wxThread *thread);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
private:
pthread_t m_threadId; // id of the thread
wxThreadState m_state; // see wxThreadState enum
- int m_prio; // in wxWindows units: from 0 to 100
+ int m_prio; // in wxWidgets units: from 0 to 100
// this flag is set when the thread should terminate
bool m_cancelled;
// pthread_join(), so we have to keep track of this
wxCriticalSection m_csJoinFlag;
bool m_shouldBeJoined;
- bool m_shouldBroadcast;
bool m_isDetached;
// this semaphore is posted by Run() and the threads Entry() is not
// this one is signaled when the thread should resume after having been
// Pause()d
wxSemaphore m_semSuspend;
-
- // finally this one is signalled when the thread exits
- // we are using a reference counted condition to support
- // Delete() for a detached thread
- wxRefCountedCondition *m_condEnd;
};
// ----------------------------------------------------------------------------
{
wxThreadInternal *pthread = thread->m_internal;
- wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p started."), THR_ID(pthread));
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
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;
}
// block!
bool dontRunAtAll;
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// install the cleanup handler which will be called if the thread is
// cancelled
pthread_cleanup_push(wxPthreadCleanup, thread);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
// wait for the semaphore to be posted from Run()
pthread->m_semRun.Wait();
if ( !dontRunAtAll )
{
// call the main entry
- pthread->m_exitcode = thread->Entry();
+ wxLogTrace(TRACE_THREADS,
+ wxT("Thread %p about to enter its Entry()."),
+ THR_ID(pthread));
+
+ wxTRY
+ {
+ pthread->m_exitcode = thread->Entry();
- wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
- pthread->GetId());
+ wxLogTrace(TRACE_THREADS,
+ wxT("Thread %p Entry() returned %lu."),
+ THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+ }
+ wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
{
wxCriticalSectionLocker lock(thread->m_critsect);
- wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
- pthread->GetId());
-
// change the state of the thread to "exited" so that
// wxPthreadCleanup handler won't do anything from now (if it's
// called before we do pthread_cleanup_pop below)
}
}
- // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop
- // contains the matching '}' for the '{' in push, so they must be used
- // in the same block!
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
+ // '}' for the '{' in push, so they must be used in the same block!
+#ifdef wxHAVE_PTHREAD_CLEANUP
+ #ifdef __DECCXX
+ // under Tru64 we get a warning from macro expansion
+ #pragma message save
+ #pragma message disable(declbutnotref)
+ #endif
+
// remove the cleanup handler without executing it
pthread_cleanup_pop(FALSE);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+
+ #ifdef __DECCXX
+ #pragma message restore
+ #endif
+#endif // wxHAVE_PTHREAD_CLEANUP
if ( dontRunAtAll )
{
+ // FIXME: deleting a possibly joinable thread here???
delete thread;
return EXITCODE_CANCELLED;
}
}
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// this handler is called when the thread is cancelled
extern "C" void wxPthreadCleanup(void *ptr)
void wxThreadInternal::Cleanup(wxThread *thread)
{
+ if (pthread_getspecific(gs_keySelf) == 0) return;
{
wxCriticalSectionLocker lock(thread->m_critsect);
if ( thread->m_internal->GetState() == STATE_EXITED )
thread->Exit(EXITCODE_CANCELLED);
}
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
// ----------------------------------------------------------------------------
// wxThreadInternal
wxThreadInternal::wxThreadInternal()
{
m_state = STATE_NEW;
- m_cancelled = FALSE;
+ m_cancelled = false;
m_prio = WXTHREAD_DEFAULT_PRIORITY;
m_threadId = 0;
m_exitcode = 0;
- // set to TRUE only when the thread starts waiting on m_semSuspend
- m_isPaused = FALSE;
+ // set to true only when the thread starts waiting on m_semSuspend
+ m_isPaused = false;
// defaults for joinable threads
- m_shouldBeJoined = TRUE;
- m_shouldBroadcast = TRUE;
- m_isDetached = FALSE;
-
- m_condEnd = new wxRefCountedCondition();
+ m_shouldBeJoined = true;
+ m_isDetached = false;
}
wxThreadInternal::~wxThreadInternal()
{
- m_condEnd->DeleteRef();
}
wxThreadError wxThreadInternal::Run()
wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
wxT("thread may only be started once after Create()") );
- SignalRun();
-
SetState(STATE_RUNNING);
+ // wake up threads waiting for our start
+ SignalRun();
+
return wxTHREAD_NO_ERROR;
}
void wxThreadInternal::Wait()
{
+ wxCHECK_RET( !m_isDetached, wxT("can't wait for a detached thread") );
+
// 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() )
+ {
+#ifdef __WXOSX__
+ // give the thread we're waiting for chance to do the GUI call
+ // it might be in, we don't do this conditionally as the to be waited on
+ // thread might have to acquire the mutex later but before terminating
+ if ( wxGuiOwnedByMainThread() )
+ wxMutexGuiLeave();
+#else
wxMutexGuiLeave();
-
- bool isDetached = m_isDetached;
- wxThreadIdType id = (wxThreadIdType) GetId();
+#endif
+ }
wxLogTrace(TRACE_THREADS,
- _T("Starting to wait for thread %ld to exit."), id);
-
- // wait until the thread terminates (we're blocking in _another_ thread,
- // of course)
+ wxT("Starting to wait for thread %p to exit."),
+ THR_ID(this));
- // a reference counting condition is used to handle the
- // case where a detached thread deletes itself
- // before m_condEnd->Wait() returns
- // in this case the deletion of the condition object is deferred until
- // all Wait()ing threads have finished calling DeleteRef()
- m_condEnd->AddRef();
- m_condEnd->Wait();
- m_condEnd->DeleteRef();
-
- wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id);
-
- // we can't use any member variables any more if the thread is detached
- // because it could be already deleted
- if ( !isDetached )
+ // to avoid memory leaks we should call pthread_join(), but it must only be
+ // done once so use a critical section to serialize the code below
{
- // to avoid memory leaks we should call pthread_join(), but it must
- // only be done once
wxCriticalSectionLocker lock(m_csJoinFlag);
if ( m_shouldBeJoined )
// we're cancelled inside pthread_join(), things will almost
// certainly break - but if we disable the cancellation, we
// might deadlock
- if ( pthread_join((pthread_t)id, &m_exitcode) != 0 )
+ if ( pthread_join(GetId(), &m_exitcode) != 0 )
{
- wxLogError(_("Failed to join a thread, potential memory leak "
- "detected - please restart the program"));
+ // this is a serious problem, so use wxLogError and not
+ // wxLogDebug: it is possible to bring the system to its knees
+ // by creating too many threads and not joining them quite
+ // easily
+ wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
}
- m_shouldBeJoined = FALSE;
+ m_shouldBeJoined = false;
}
}
+#ifndef __WXOSX__
// reacquire GUI mutex
if ( wxThread::IsMain() )
wxMutexGuiEnter();
-}
-
-void wxThreadInternal::SignalExit()
-{
- wxLogTrace(TRACE_THREADS, _T("Thread %ld about to exit."), GetId());
-
- SetState(STATE_EXITED);
-
- // wake up all the threads waiting for our termination - if there are any
- if ( m_shouldBroadcast )
- {
- wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
- GetId());
-
- m_condEnd->SetSignaled();
- }
+#endif
}
void wxThreadInternal::Pause()
wxCHECK_RET( m_state == STATE_PAUSED,
wxT("thread must first be paused with wxThread::Pause().") );
- wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
+ wxLogTrace(TRACE_THREADS,
+ wxT("Thread %p goes to sleep."), THR_ID(this));
// wait until the semaphore is Post()ed from Resume()
m_semSuspend.Wait();
// TestDestroy() since the last call to Pause() for example
if ( IsReallyPaused() )
{
- wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
+ wxLogTrace(TRACE_THREADS,
+ wxT("Waking up thread %p"), THR_ID(this));
// wake up Pause()
m_semSuspend.Post();
// reset the flag
- SetReallyPaused(FALSE);
+ SetReallyPaused(false);
}
else
{
- wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
- GetId());
+ wxLogTrace(TRACE_THREADS,
+ wxT("Thread %p is not yet really paused"), THR_ID(this));
}
SetState(STATE_RUNNING);
return (wxThread *)pthread_getspecific(gs_keySelf);
}
-bool wxThread::IsMain()
-{
- return (bool)pthread_equal(pthread_self(), gs_tidMain);
-}
-
void wxThread::Yield()
{
#ifdef HAVE_SCHED_YIELD
#endif
}
-void wxThread::Sleep(unsigned long milliseconds)
-{
- wxUsleep(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;
- wxFFile file(_T("/proc/cpuinfo"));
+ wxFFile file(wxT("/proc/cpuinfo"));
if ( file.IsOpened() )
{
// slurp the whole file
wxString s;
if ( file.ReadAll(&s) )
{
- // (ab)use Replace() to find the number of "processor" strings
- size_t count = s.Replace(_T("processor"), _T(""));
+ // (ab)use Replace() to find the number of "processor: num" strings
+ size_t count = s.Replace(wxT("processor\t:"), wxT(""));
if ( count > 0 )
{
return count;
}
- wxLogDebug(_T("failed to parse /proc/cpuinfo"));
+ wxLogDebug(wxT("failed to parse /proc/cpuinfo"));
}
else
{
- wxLogDebug(_T("failed to read /proc/cpuinfo"));
+ wxLogDebug(wxT("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
return -1;
}
-#ifdef __VMS
- // VMS is a 64 bit system and threads have 64 bit pointers.
- // ??? also needed for other systems????
-unsigned long long wxThread::GetCurrentId()
-{
- return (unsigned long long)pthread_self();
-#else
-unsigned long wxThread::GetCurrentId()
+wxThreadIdType wxThread::GetCurrentId()
{
- return (unsigned long)pthread_self();
-#endif
+ return (wxThreadIdType)pthread_self();
}
+
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);
+#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 )
{
- wxLogSysError(rc, _T("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;
}
// -----------------------------------------------------------------------------
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();
m_isDetached = kind == wxTHREAD_DETACHED;
}
-wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
+#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))
{
if ( m_internal->GetState() != STATE_NEW )
{
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 )
struct sched_param sp;
if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_getschedparam() failed"));
+ 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(_T("pthread_attr_setschedparam(priority) failed"));
+ wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));
}
}
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
// this will make the threads created by this process really concurrent
if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
+ wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
}
#endif // HAVE_PTHREAD_ATTR_SETSCOPE
{
if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed"));
+ wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
}
// never try to join detached threads
if ( pthread_attr_destroy(&attr) != 0 )
{
- wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
+ wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
}
if ( rc != 0 )
case STATE_RUNNING:
case STATE_PAUSED:
#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
+#if defined(__LINUX__)
+ // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
+ // a priority other than 0. Instead, we use the BSD setpriority
+ // which alllows us to set a 'nice' value between 20 to -20. Only
+ // super user can set a value less than zero (more negative yields
+ // higher priority). setpriority set the static priority of a
+ // process, but this is OK since Linux is configured as a thread
+ // per process.
+ //
+ // FIXME this is not true for 2.6!!
+
+ // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
+ // to Unix priorities 20..-20
+ if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
+ {
+ wxLogError(_("Failed to set thread priority %d."), prio);
+ }
+#else // __LINUX__
{
struct sched_param sparam;
sparam.sched_priority = prio;
wxLogError(_("Failed to set thread priority %d."), prio);
}
}
+#endif // __LINUX__
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
break;
wxThreadError wxThread::Pause()
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't pause itself") );
+ wxT("a thread can't pause itself") );
wxCriticalSectionLocker lock(m_critsect);
return wxTHREAD_NOT_RUNNING;
}
- wxLogTrace(TRACE_THREADS, _T("Asking thread %ld to pause."),
- GetId());
-
// just set a flag, the thread will be really paused only during the next
// call to TestDestroy()
m_internal->SetState(STATE_PAUSED);
wxThreadError wxThread::Resume()
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't resume itself") );
+ wxT("a thread can't resume itself") );
wxCriticalSectionLocker lock(m_critsect);
switch ( state )
{
case STATE_PAUSED:
- wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
- GetId());
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."),
+ THR_ID(this));
m_internal->Resume();
return wxTHREAD_NO_ERROR;
case STATE_EXITED:
- wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."),
- GetId());
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."),
+ THR_ID(this));
return wxTHREAD_NO_ERROR;
default:
- 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;
}
// exiting thread
// -----------------------------------------------------------------------------
-wxThread::ExitCode wxThread::Wait()
+wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode))
{
wxCHECK_MSG( This() != this, (ExitCode)-1,
- _T("a thread can't wait for itself") );
+ wxT("a thread can't wait for itself") );
wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
- _T("can't wait for detached thread") );
+ wxT("can't wait for detached thread") );
m_internal->Wait();
return m_internal->GetExitCode();
}
-wxThreadError wxThread::Delete(ExitCode *rc)
+wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode))
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't delete itself") );
+ wxT("a thread can't delete itself") );
+
+ bool isDetached = m_isDetached;
m_critsect.Enter();
wxThreadState state = m_internal->GetState();
// ask the thread to stop
m_internal->SetCancelFlag();
- if ( m_isDetached )
- {
- // detached threads won't broadcast about their termination by default
- // because usually nobody waits for them - but here we do, so ask the
- // thread to notify us
- m_internal->Notify();
- }
-
m_critsect.Leave();
+ OnDelete();
+
switch ( state )
{
case STATE_NEW:
// we need to wake up the thread so that PthreadStart() will
- // terminate - right now it's blocking on m_semRun
+ // terminate - right now it's blocking on run semaphore in
+ // PthreadStart()
m_internal->SignalRun();
// fall through
break;
case STATE_PAUSED:
- // resume the thread first (don't call our Resume() because this
- // would dead lock when it tries to enter m_critsect)
+ // resume the thread first
m_internal->Resume();
// fall through
default:
- // wait until the thread stops
- m_internal->Wait();
-
- if ( rc )
+ if ( !isDetached )
{
- wxASSERT_MSG( !m_isDetached,
- _T("no return code for detached threads") );
+ // wait until the thread stops
+ m_internal->Wait();
- // if it's a joinable thread, it's not deleted yet
- *rc = m_internal->GetExitCode();
+ if ( rc )
+ {
+ // return the exit code of the thread
+ *rc = m_internal->GetExitCode();
+ }
}
+ //else: can't wait for detached threads
}
+ if (state == STATE_NEW)
+ return wxTHREAD_MISC_ERROR;
+ // 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;
}
wxThreadError wxThread::Kill()
{
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
- _T("a thread can't kill itself") );
+ wxT("a thread can't kill itself") );
+
+ OnKill();
switch ( m_internal->GetState() )
{
default:
#ifdef HAVE_PTHREAD_CANCEL
if ( pthread_cancel(m_internal->GetId()) != 0 )
-#endif
+#endif // HAVE_PTHREAD_CANCEL
{
wxLogError(_("Failed to terminate a thread."));
return wxTHREAD_MISC_ERROR;
}
+#ifdef HAVE_PTHREAD_CANCEL
if ( m_isDetached )
{
// if we use cleanup function, this will be done from
// wxPthreadCleanup()
-#if !HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifndef wxHAVE_PTHREAD_CLEANUP
ScheduleThreadForDeletion();
// don't call OnExit() here, it can only be called in the
// threads context and we're in the context of another thread
DeleteThread(this);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
}
else
{
}
return wxTHREAD_NO_ERROR;
+#endif // HAVE_PTHREAD_CANCEL
}
}
void wxThread::Exit(ExitCode status)
{
wxASSERT_MSG( This() == this,
- _T("wxThread::Exit() can only be called in the "
- "context of the same thread") );
+ wxT("wxThread::Exit() can only be called in the context of the same thread") );
- // from the moment we call OnExit(), the main program may terminate at any
- // moment, so mark this thread as being already in process of being
- // deleted or wxThreadModule::OnExit() will try to delete it again
- ScheduleThreadForDeletion();
+ if ( m_isDetached )
+ {
+ // from the moment we call OnExit(), the main program may terminate at
+ // any moment, so mark this thread as being already in process of being
+ // deleted or wxThreadModule::OnExit() will try to delete it again
+ ScheduleThreadForDeletion();
+ }
// don't enter m_critsect before calling OnExit() because the user code
// 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();
-
- // now do enter it because SignalExit() will change our state
- m_critsect.Enter();
-
- // next wake up the threads waiting for us (OTOH, this function won't return
- // until someone waited for us!)
- m_internal->SignalExit();
-
- // leave the critical section before entering the dtor which tries to
- // enter it
- m_critsect.Leave();
+ 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
// we make it a global object, but this would mean that we can
// only call one thread function at a time :-(
DeleteThread(this);
+ pthread_setspecific(gs_keySelf, 0);
+ }
+ else
+ {
+ m_critsect.Enter();
+ m_internal->SetState(STATE_EXITED);
+ m_critsect.Leave();
}
// terminate the thread (pthread_exit() never returns)
pthread_exit(status);
- wxFAIL_MSG(_T("pthread_exit() failed"));
+ wxFAIL_MSG(wxT("pthread_exit() failed"));
}
// also test whether we were paused
bool wxThread::TestDestroy()
{
wxASSERT_MSG( This() == this,
- _T("wxThread::TestDestroy() can only be called in the "
- "context of the same thread") );
+ wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );
m_critsect.Enter();
if ( m_internal->GetState() == STATE_PAUSED )
{
- m_internal->SetReallyPaused(TRUE);
+ m_internal->SetReallyPaused(true);
// leave the crit section or the other threads will stop too if they
// try to call any of (seemingly harmless) IsXXX() functions while we
wxThread::~wxThread()
{
-#ifdef __WXDEBUG__
m_critsect.Enter();
// check that the thread either exited or couldn't be created
if ( m_internal->GetState() != STATE_EXITED &&
m_internal->GetState() != STATE_NEW )
{
- wxLogDebug(_T("The thread %ld is being destroyed although it is still "
- "running! The application may crash."), GetId());
+ wxLogDebug(wxT("The thread %p is being destroyed although it is still running! The application may crash."),
+ THR_ID(this));
}
m_critsect.Leave();
-#endif // __WXDEBUG__
delete m_internal;
// remove this thread from the global array
- gs_allThreads.Remove(this);
-
- // detached thread will decrement this counter in DeleteThread(), but it
- // is not called for the joinable threads, so do it here
- if ( !m_isDetached )
{
- wxMutexLocker lock( *gs_mutexDeleteThread );
-
- gs_nThreadsBeingDeleted--;
+ wxMutexLocker lock(*gs_mutexAllThreads);
- wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
- gs_nThreadsBeingDeleted - 1);
+ gs_allThreads.Remove(this);
}
}
{
case STATE_RUNNING:
case STATE_PAUSED:
- return TRUE;
+ return true;
default:
- return FALSE;
+ return false;
}
}
// wxThreadModule
//--------------------------------------------------------------------
+#ifdef __WXOSX__
+void wxOSXThreadModuleOnInit();
+void wxOSXThreadModuleOnExit();
+#endif
+
class wxThreadModule : public wxModule
{
public:
int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
if ( rc != 0 )
{
- wxLogSysError(rc, _("Thread module initialization failed: "
- "failed to create thread key"));
+ wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
- return FALSE;
+ return false;
}
- gs_tidMain = pthread_self();
+ wxThread::ms_idMainThread = wxThread::GetCurrentId();
-#if wxUSE_GUI
- gs_mutexGui = new wxMutex();
+ gs_mutexAllThreads = new wxMutex();
+#ifdef __WXOSX__
+ wxOSXThreadModuleOnInit();
+#else
+ gs_mutexGui = new wxMutex();
gs_mutexGui->Lock();
-#endif // wxUSE_GUI
+#endif
gs_mutexDeleteThread = new wxMutex();
- gs_condAllDeleted = new wxCondition( gs_mutexDeleteThread );
+ gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);
- return TRUE;
+ return true;
}
void wxThreadModule::OnExit()
nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
if ( nThreadsBeingDeleted > 0 )
-{
- wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
- nThreadsBeingDeleted);
+ {
+ wxLogTrace(TRACE_THREADS,
+ wxT("Waiting for %lu threads to disappear"),
+ (unsigned long)nThreadsBeingDeleted);
// have to wait until all of them disappear
gs_condAllDeleted->Wait();
}
}
- // terminate any threads left
- size_t count = gs_allThreads.GetCount();
- if ( count != 0u )
+ size_t count;
+
{
- wxLogDebug(wxT("%u threads were not terminated by the application."),
- 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++ )
{
gs_allThreads[0]->Delete();
}
-#if wxUSE_GUI
+ delete gs_mutexAllThreads;
+
+#ifdef __WXOSX__
+ wxOSXThreadModuleOnExit();
+#else
// destroy GUI mutex
gs_mutexGui->Unlock();
-
delete gs_mutexGui;
-#endif // wxUSE_GUI
+#endif
// and free TLD slot
(void)pthread_key_delete(gs_keySelf);
gs_nThreadsBeingDeleted++;
- wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
- gs_nThreadsBeingDeleted,
- gs_nThreadsBeingDeleted == 1 ? "" : "s");
+ wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"),
+ (unsigned long)gs_nThreadsBeingDeleted,
+ gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s"));
}
static void DeleteThread(wxThread *This)
{
- // gs_mutexDeleteThread should be unlocked before signalling the condition
- // or wxThreadModule::OnExit() would deadlock
- wxMutexLocker locker( *gs_mutexDeleteThread );
-
- wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
+ wxLogTrace(TRACE_THREADS, wxT("Thread %p auto deletes."), THR_ID(This));
delete This;
+ // only lock gs_mutexDeleteThread after deleting the thread to avoid
+ // calling out into user code with it locked as this may result in
+ // deadlocks if the thread dtor deletes another thread (see #11501)
+ wxMutexLocker locker( *gs_mutexDeleteThread );
+
wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
- _T("no threads scheduled for deletion, yet we delete "
- "one?") );
+ wxT("no threads scheduled for deletion, yet we delete one?") );
- wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
- gs_nThreadsBeingDeleted - 1);
+ wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."),
+ (unsigned long)gs_nThreadsBeingDeleted - 1);
if ( !--gs_nThreadsBeingDeleted )
{
}
}
-void wxMutexGuiEnter()
+#ifndef __WXOSX__
+
+void wxMutexGuiEnterImpl()
{
-#if wxUSE_GUI
gs_mutexGui->Lock();
-#endif // wxUSE_GUI
}
-void wxMutexGuiLeave()
+void wxMutexGuiLeaveImpl()
{
-#if wxUSE_GUI
gs_mutexGui->Unlock();
-#endif // wxUSE_GUI
}
#endif
- // wxUSE_THREADS
+
+// ----------------------------------------------------------------------------
+// include common implementation code
+// ----------------------------------------------------------------------------
+
+#include "wx/thrimpl.cpp"
+
+#endif // wxUSE_THREADS
projects / wxWidgets.git / blobdiff