// Name: threadpsx.cpp
// Purpose: wxThread (Posix) Implementation
// Author: Original from Wolfram Gloger/Guilhem Lavaux
-// Modified by:
+// Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
// Created: 04/22/98
// RCS-ID: $Id$
// Copyright: (c) Wolfram Gloger (1996, 1997)
// Guilhem Lavaux (1998)
-// Vadim Zeitlin (1999)
+// Vadim Zeitlin (1999-2002)
// Robert Roebling (1999)
+// K. S. Sreeram (2002)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "thread.h"
-#endif
-
-// With simple makefiles, we must ignore the file body if not using
-// threads.
-#include "wx/setup.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
#if wxUSE_THREADS
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/dynarray.h"
+#include "wx/timer.h"
+#include "wx/stopwatch.h"
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <time.h>
-
-#if HAVE_SCHED_H
+#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
+#ifdef HAVE_THR_SETCONCURRENCY
+ #include <thread.h>
+#endif
+
+// we use wxFFile under Linux in GetCPUCount()
+#ifdef __LINUX__
+ #include "wx/ffile.h"
+ // For setpriority.
+ #include <sys/time.h>
+ #include <sys/resource.h>
+#endif
+
+#ifdef __VMS
+ #define THR_ID(thr) ((long long)(thr)->GetId())
+#else
+ #define THR_ID(thr) ((long)(thr)->GetId())
+#endif
+
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
STATE_EXITED // thread doesn't exist any more
};
+// the exit value of a thread which has been cancelled
+static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
+
+// trace mask for wxThread operations
+#define TRACE_THREADS _T("thread")
+
+// you can get additional debugging messages for the semaphore operations
+#define TRACE_SEMA _T("semaphore")
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static void ScheduleThreadForDeletion();
+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
static wxArrayThread gs_allThreads;
// the id of the main thread
-static pthread_t gs_tidMain;
+static pthread_t gs_tidMain = (pthread_t)-1;
// the key for the pointer to the associated wxThread object
static pthread_key_t gs_keySelf;
+// the number of threads which are being deleted - the program won't exit
+// until there are any left
+static size_t gs_nThreadsBeingDeleted = 0;
+
+// a mutex to protect gs_nThreadsBeingDeleted
+static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
+
+// and a condition variable which will be signaled when all
+// gs_nThreadsBeingDeleted will have been deleted
+static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
+
// this mutex must be acquired before any call to a GUI function
-static wxMutex *gs_mutexGui;
+// (it's not inside #if wxUSE_GUI because this file is compiled as part
+// of wxBase)
+static wxMutex *gs_mutexGui = NULL;
+
+// 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
// ============================================================================
-// implementation
+// wxMutex implementation
// ============================================================================
-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------
+// this is a simple wrapper around pthread_mutex_t which provides error
+// checking
class wxMutexInternal
{
public:
- pthread_mutex_t p_mutex;
+ wxMutexInternal(wxMutexType mutexType);
+ ~wxMutexInternal();
+
+ wxMutexError Lock();
+ wxMutexError TryLock();
+ wxMutexError Unlock();
+
+ bool IsOk() const { return m_isOk; }
+
+private:
+ pthread_mutex_t m_mutex;
+ bool m_isOk;
+
+ // wxConditionInternal uses our m_mutex
+ friend class wxConditionInternal;
};
-wxMutex::wxMutex()
+#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)
{
- p_internal = new wxMutexInternal;
-
- pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
- m_locked = 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);
+
+ 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;
+ }
+#else // no recursive mutexes
+ err = EINVAL;
+#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+ break;
+
+ default:
+ wxFAIL_MSG( _T("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);
+ }
}
-wxMutex::~wxMutex()
+wxMutexInternal::~wxMutexInternal()
{
- if (m_locked > 0)
- wxLogDebug(_T("Freeing a locked mutex (%d locks)"), m_locked);
+ if ( m_isOk )
+ {
+ int err = pthread_mutex_destroy(&m_mutex);
+ if ( err != 0 )
+ {
+ wxLogApiError( wxT("pthread_mutex_destroy()"), err);
+ }
+ }
+}
- pthread_mutex_destroy( &(p_internal->p_mutex) );
- delete p_internal;
+wxMutexError wxMutexInternal::Lock()
+{
+ int err = pthread_mutex_lock(&m_mutex);
+ switch ( err )
+ {
+ case EDEADLK:
+ // only error checking mutexes return this value and so it's an
+ // unexpected situation -- hence use assert, not wxLogDebug
+ wxFAIL_MSG( _T("mutex deadlock prevented") );
+ return wxMUTEX_DEAD_LOCK;
+
+ case EINVAL:
+ wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
+ break;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+
+ default:
+ wxLogApiError(_T("pthread_mutex_lock()"), err);
+ }
+
+ return wxMUTEX_MISC_ERROR;
}
-wxMutexError wxMutex::Lock()
+wxMutexError wxMutexInternal::TryLock()
{
- int err = pthread_mutex_lock( &(p_internal->p_mutex) );
- if (err == EDEADLK)
+ int err = pthread_mutex_trylock(&m_mutex);
+ switch ( err )
{
- wxLogDebug(_T("Locking this mutex would lead to deadlock!"));
+ case EBUSY:
+ // not an error: mutex is already locked, but we're prepared for
+ // this
+ return wxMUTEX_BUSY;
- return wxMUTEX_DEAD_LOCK;
+ case EINVAL:
+ wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
+ break;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+
+ default:
+ wxLogApiError(_T("pthread_mutex_trylock()"), err);
}
- m_locked++;
+ return wxMUTEX_MISC_ERROR;
+}
- return wxMUTEX_NO_ERROR;
+wxMutexError wxMutexInternal::Unlock()
+{
+ int err = pthread_mutex_unlock(&m_mutex);
+ switch ( err )
+ {
+ case EPERM:
+ // we don't own the mutex
+ return wxMUTEX_UNLOCKED;
+
+ case EINVAL:
+ wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
+ break;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+
+ default:
+ wxLogApiError(_T("pthread_mutex_unlock()"), err);
+ }
+
+ return wxMUTEX_MISC_ERROR;
}
-wxMutexError wxMutex::TryLock()
+// ===========================================================================
+// wxCondition implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// 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();
+
+ bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
+
+ wxCondError Wait();
+ wxCondError WaitTimeout(unsigned long milliseconds);
+
+ 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;
+ pthread_cond_t m_cond;
+
+ bool m_isOk;
+};
+
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+ : m_mutex(mutex)
{
- if (m_locked)
+ int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
+
+ m_isOk = err == 0;
+
+ if ( !m_isOk )
{
- return wxMUTEX_BUSY;
+ wxLogApiError(_T("pthread_cond_init()"), err);
}
+}
- int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
- switch (err)
+wxConditionInternal::~wxConditionInternal()
+{
+ if ( m_isOk )
{
- case EBUSY: return wxMUTEX_BUSY;
+ int err = pthread_cond_destroy(&m_cond);
+ if ( err != 0 )
+ {
+ wxLogApiError(_T("pthread_cond_destroy()"), err);
+ }
}
+}
+
+wxCondError wxConditionInternal::Wait()
+{
+ int err = pthread_cond_wait(&m_cond, GetPMutex());
+ if ( err != 0 )
+ {
+ wxLogApiError(_T("pthread_cond_wait()"), err);
- m_locked++;
+ return wxCOND_MISC_ERROR;
+ }
- return wxMUTEX_NO_ERROR;
+ return wxCOND_NO_ERROR;
}
-wxMutexError wxMutex::Unlock()
+wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
{
- if (m_locked > 0)
+ wxLongLong curtime = wxGetLocalTimeMillis();
+ curtime += milliseconds;
+ wxLongLong temp = curtime / 1000;
+ int sec = temp.GetLo();
+ temp *= 1000;
+ temp = curtime - temp;
+ int millis = temp.GetLo();
+
+ timespec tspec;
+
+ tspec.tv_sec = sec;
+ tspec.tv_nsec = millis * 1000L * 1000L;
+
+ int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
+ switch ( err )
{
- m_locked--;
+ case ETIMEDOUT:
+ return wxCOND_TIMEOUT;
+
+ case 0:
+ return wxCOND_NO_ERROR;
+
+ default:
+ wxLogApiError(_T("pthread_cond_timedwait()"), err);
}
- else
+
+ return wxCOND_MISC_ERROR;
+}
+
+wxCondError wxConditionInternal::Signal()
+{
+ int err = pthread_cond_signal(&m_cond);
+ if ( err != 0 )
{
- wxLogDebug(_T("Unlocking not locked mutex."));
+ wxLogApiError(_T("pthread_cond_signal()"), err);
- return wxMUTEX_UNLOCKED;
+ return wxCOND_MISC_ERROR;
}
- pthread_mutex_unlock( &(p_internal->p_mutex) );
+ return wxCOND_NO_ERROR;
+}
- return wxMUTEX_NO_ERROR;
+wxCondError wxConditionInternal::Broadcast()
+{
+ int err = pthread_cond_broadcast(&m_cond);
+ if ( err != 0 )
+ {
+ wxLogApiError(_T("pthread_cond_broadcast()"), err);
+
+ return wxCOND_MISC_ERROR;
+ }
+
+ return wxCOND_NO_ERROR;
}
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================
-class wxConditionInternal
+// ---------------------------------------------------------------------------
+// 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:
- pthread_cond_t p_condition;
+ wxSemaphoreInternal(int initialcount, int maxcount);
+
+ bool IsOk() const { return m_isOk; }
+
+ wxSemaError Wait();
+ wxSemaError TryWait();
+ wxSemaError WaitTimeout(unsigned long milliseconds);
+
+ wxSemaError Post();
+
+private:
+ wxMutex m_mutex;
+ wxCondition m_cond;
+
+ size_t m_count,
+ m_maxcount;
+
+ bool m_isOk;
};
-wxCondition::wxCondition()
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+ : m_cond(m_mutex)
{
- p_internal = new wxConditionInternal;
- pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
+
+ if ( (initialcount < 0 || maxcount < 0) ||
+ ((maxcount > 0) && (initialcount > maxcount)) )
+ {
+ wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
+
+ m_isOk = FALSE;
+ }
+ else
+ {
+ m_maxcount = (size_t)maxcount;
+ m_count = (size_t)initialcount;
+ }
+
+ m_isOk = m_mutex.IsOk() && m_cond.IsOk();
}
-wxCondition::~wxCondition()
+wxSemaError wxSemaphoreInternal::Wait()
{
- pthread_cond_destroy( &(p_internal->p_condition) );
+ wxMutexLocker locker(m_mutex);
- delete p_internal;
+ while ( m_count == 0 )
+ {
+ wxLogTrace(TRACE_SEMA,
+ _T("Thread %ld waiting for semaphore to become signalled"),
+ wxThread::GetCurrentId());
+
+ if ( m_cond.Wait() != wxCOND_NO_ERROR )
+ return wxSEMA_MISC_ERROR;
+
+ wxLogTrace(TRACE_SEMA,
+ _T("Thread %ld finished waiting for semaphore, count = %lu"),
+ wxThread::GetCurrentId(), (unsigned long)m_count);
+ }
+
+ m_count--;
+
+ return wxSEMA_NO_ERROR;
}
-void wxCondition::Wait(wxMutex& mutex)
+wxSemaError wxSemaphoreInternal::TryWait()
{
- pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
+ wxMutexLocker locker(m_mutex);
+
+ if ( m_count == 0 )
+ return wxSEMA_BUSY;
+
+ m_count--;
+
+ return wxSEMA_NO_ERROR;
}
-bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
{
- struct timespec tspec;
+ wxMutexLocker locker(m_mutex);
+
+ wxLongLong startTime = wxGetLocalTimeMillis();
+
+ while ( m_count == 0 )
+ {
+ wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+ long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
+ if ( remainingTime <= 0 )
+ {
+ // timeout
+ return wxSEMA_TIMEOUT;
+ }
+
+ switch ( m_cond.WaitTimeout(remainingTime) )
+ {
+ case wxCOND_TIMEOUT:
+ return wxSEMA_TIMEOUT;
+
+ default:
+ return wxSEMA_MISC_ERROR;
+
+ case wxCOND_NO_ERROR:
+ ;
+ }
+ }
- tspec.tv_sec = time(0L)+sec;
- tspec.tv_nsec = nsec;
- return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
+ m_count--;
+
+ return wxSEMA_NO_ERROR;
}
-void wxCondition::Signal()
+wxSemaError wxSemaphoreInternal::Post()
{
- pthread_cond_signal( &(p_internal->p_condition) );
+ wxMutexLocker locker(m_mutex);
+
+ if ( m_maxcount > 0 && m_count == m_maxcount )
+ {
+ return wxSEMA_OVERFLOW;
+ }
+
+ m_count++;
+
+ wxLogTrace(TRACE_SEMA,
+ _T("Thread %ld about to signal semaphore, count = %lu"),
+ wxThread::GetCurrentId(), (unsigned long)m_count);
+
+ return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
+ : wxSEMA_MISC_ERROR;
}
-void wxCondition::Broadcast()
+// ===========================================================================
+// wxThread implementation
+// ===========================================================================
+
+// the thread callback functions must have the C linkage
+extern "C"
{
- pthread_cond_broadcast( &(p_internal->p_condition) );
-}
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+#ifdef wxHAVE_PTHREAD_CLEANUP
+ // thread exit function
+ void wxPthreadCleanup(void *ptr);
+#endif // wxHAVE_PTHREAD_CLEANUP
+
+void *wxPthreadStart(void *ptr);
+
+} // extern "C"
+
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
class wxThreadInternal
{
~wxThreadInternal();
// thread entry function
- static void *PthreadStart(void *ptr);
-
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
- // thread exit function
- static void PthreadCleanup(void *ptr);
-#endif
+ static void *PthreadStart(wxThread *thread);
// 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();
// 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)
+ {
+#ifdef __WXDEBUG__
+ static const wxChar *stateNames[] =
+ {
+ _T("NEW"),
+ _T("RUNNING"),
+ _T("PAUSED"),
+ _T("EXITED"),
+ };
+
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
+ (long)GetId(), stateNames[m_state], stateNames[state]);
+#endif // __WXDEBUG__
+
+ m_state = state;
+ }
// id
pthread_t GetId() const { return m_threadId; }
pthread_t *GetIdPtr() { return &m_threadId; }
// "cancelled" flag
void SetCancelFlag() { m_cancelled = TRUE; }
bool WasCancelled() const { return m_cancelled; }
+ // exit code
+ void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
+ wxThread::ExitCode GetExitCode() const { return m_exitcode; }
+
+ // the pause flag
+ void SetReallyPaused(bool paused) { m_isPaused = paused; }
+ bool IsReallyPaused() const { return m_isPaused; }
+
+ // tell the thread that it is a detached one
+ void Detach()
+ {
+ wxCriticalSectionLocker lock(m_csJoinFlag);
+
+ m_shouldBeJoined = FALSE;
+ m_isDetached = TRUE;
+ }
+
+#ifdef wxHAVE_PTHREAD_CLEANUP
+ // this is used by wxPthreadCleanup() only
+ static void Cleanup(wxThread *thread);
+#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
- // set when the thread should terminate
+ // this flag is set when the thread should terminate
bool m_cancelled;
- // this (mutex, cond) pair is used to synchronize the main thread and this
- // thread in several situations:
- // 1. The thread function blocks until condition is signaled by Run() when
- // it's initially created - this allows thread creation in "suspended"
- // 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;
+ // this flag is set when the thread is blocking on m_semSuspend
+ bool m_isPaused;
+
+ // the thread exit code - only used for joinable (!detached) threads and
+ // is only valid after the thread termination
+ wxThread::ExitCode m_exitcode;
+
+ // many threads may call Wait(), but only one of them should call
+ // pthread_join(), so we have to keep track of this
+ wxCriticalSection m_csJoinFlag;
+ bool m_shouldBeJoined;
+ bool m_isDetached;
- // another (mutex, cond) pair for Pause()/Resume() usage
- //
- // VZ: it's possible that we might reuse the mutex and condition from above
- // for this too, but as I'm not at all sure that it won't create subtle
- // problems with race conditions between, say, Pause() and Delete() I
- // prefer this may be a bit less efficient but much safer solution
- wxMutex m_mutexSuspend;
- wxCondition m_condSuspend;
+ // this semaphore is posted by Run() and the threads Entry() is not
+ // called before it is done
+ wxSemaphore m_semRun;
+
+ // this one is signaled when the thread should resume after having been
+ // Pause()d
+ wxSemaphore m_semSuspend;
};
-void *wxThreadInternal::PthreadStart(void *ptr)
+// ----------------------------------------------------------------------------
+// thread startup and exit functions
+// ----------------------------------------------------------------------------
+
+void *wxPthreadStart(void *ptr)
+{
+ return wxThreadInternal::PthreadStart((wxThread *)ptr);
+}
+
+void *wxThreadInternal::PthreadStart(wxThread *thread)
{
- wxThread *thread = (wxThread *)ptr;
- wxThreadInternal *pthread = thread->p_internal;
- void *status;
+ wxThreadInternal *pthread = thread->m_internal;
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld 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 )
{
return (void *)-1;
}
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
- // Install the cleanup handler.
- pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
-#endif
- // wait for the condition to be signaled from Run()
- // mutex state: currently locked by the thread which created us
- pthread->m_cond.Wait(pthread->m_mutex);
- // mutex state: locked again on exit of Wait()
+ // have to declare this before pthread_cleanup_push() which defines a
+ // block!
+ bool dontRunAtAll;
+
+#ifdef wxHAVE_PTHREAD_CLEANUP
+ // install the cleanup handler which will be called if the thread is
+ // cancelled
+ pthread_cleanup_push(wxPthreadCleanup, thread);
+#endif // wxHAVE_PTHREAD_CLEANUP
- // call the main entry
- status = thread->Entry();
+ // wait for the semaphore to be posted from Run()
+ pthread->m_semRun.Wait();
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ // test whether we should run the run at all - may be it was deleted
+ // before it started to Run()?
+ {
+ wxCriticalSectionLocker lock(thread->m_critsect);
+
+ dontRunAtAll = pthread->GetState() == STATE_NEW &&
+ pthread->WasCancelled();
+ }
+
+ if ( !dontRunAtAll )
+ {
+ // call the main entry
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld about to enter its Entry()."),
+ THR_ID(pthread));
+
+ pthread->m_exitcode = thread->Entry();
+
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld Entry() returned %lu."),
+ THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+
+ {
+ wxCriticalSectionLocker lock(thread->m_critsect);
+
+ // 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)
+ pthread->SetState(STATE_EXITED);
+ }
+ }
+
+ // 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!
+#ifdef wxHAVE_PTHREAD_CLEANUP
+ // remove the cleanup handler without executing it
pthread_cleanup_pop(FALSE);
-#endif
+#endif // wxHAVE_PTHREAD_CLEANUP
- // terminate the thread
- thread->Exit(status);
+ if ( dontRunAtAll )
+ {
+ // FIXME: deleting a possibly joinable thread here???
+ delete thread;
+
+ return EXITCODE_CANCELLED;
+ }
+ else
+ {
+ // terminate the thread
+ thread->Exit(pthread->m_exitcode);
- wxFAIL_MSG(_T("wxThread::Exit() can't return."));
+ wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
- return NULL;
+ return NULL;
+ }
}
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
-// Only called when the thread is explicitely killed.
+#ifdef wxHAVE_PTHREAD_CLEANUP
-void wxThreadInternal::PthreadCleanup(void *ptr)
+// this handler is called when the thread is cancelled
+extern "C" void wxPthreadCleanup(void *ptr)
{
- wxThread *thread = (wxThread *) ptr;
+ wxThreadInternal::Cleanup((wxThread *)ptr);
+}
- // The thread is already considered as finished.
- if (thread->p_internal->GetState() == STATE_EXITED)
- return;
+void wxThreadInternal::Cleanup(wxThread *thread)
+{
+ {
+ wxCriticalSectionLocker lock(thread->m_critsect);
+ if ( thread->m_internal->GetState() == STATE_EXITED )
+ {
+ // thread is already considered as finished.
+ return;
+ }
+ }
- // first call user-level clean up code
- thread->OnExit();
+ // exit the thread gracefully
+ thread->Exit(EXITCODE_CANCELLED);
+}
- // 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);
+#endif // wxHAVE_PTHREAD_CLEANUP
- thread->p_internal->SignalExit();
-}
-#endif
+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
wxThreadInternal::wxThreadInternal()
{
m_state = STATE_NEW;
m_cancelled = FALSE;
+ m_prio = WXTHREAD_DEFAULT_PRIORITY;
+ m_threadId = 0;
+ m_exitcode = 0;
- // 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();
+ // set to TRUE only when the thread starts waiting on m_semSuspend
+ m_isPaused = FALSE;
- // this mutex is used in Pause()/Resume() and is also locked all the time
- // unless the thread is paused
- m_mutexSuspend.Lock();
+ // defaults for joinable threads
+ m_shouldBeJoined = TRUE;
+ m_isDetached = FALSE;
}
wxThreadInternal::~wxThreadInternal()
{
- // GL: moved to SignalExit
- // m_mutexSuspend.Unlock();
-
- // note that m_mutex will be unlocked by the thread which waits for our
- // termination
-
- // In the case, we didn't start the thread, all these mutex are locked:
- // we must unlock them.
- if (m_mutex.IsLocked())
- m_mutex.Unlock();
-
- if (m_end_mutex.IsLocked())
- m_end_mutex.Unlock();
-
- if (m_mutexSuspend.IsLocked())
- m_mutexSuspend.Unlock();
}
wxThreadError wxThreadInternal::Run()
{
wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
- _T("thread may only be started once after successful Create()") );
+ wxT("thread may only be started once after 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 -
- // otherwise we might signal the condition before anybody is waiting for it
- wxMutexLocker lock(m_mutex);
- m_cond.Signal();
+ SetState(STATE_RUNNING);
- m_state = STATE_RUNNING;
+ // wake up threads waiting for our start
+ SignalRun();
return wxTHREAD_NO_ERROR;
-
- // now the mutex is unlocked back - but just to allow Wait() function to
- // terminate by relocking it, so the net result is that the worker thread
- // starts executing and the mutex is still locked
}
void wxThreadInternal::Wait()
{
- wxCHECK_RET( WasCancelled(), _T("thread should have been cancelled first") );
+ wxCHECK_RET( !m_isDetached, _T("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() )
wxMutexGuiLeave();
- // entering Wait() releases the mutex thus allowing SignalExit() to acquire
- // it and to signal us its termination
- m_cond.Wait(m_end_mutex);
+ wxLogTrace(TRACE_THREADS,
+ _T("Starting to wait for thread %ld to exit."),
+ THR_ID(this));
- // 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_end_mutex.Unlock();
+ // 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
+ {
+ wxCriticalSectionLocker lock(m_csJoinFlag);
+
+ if ( m_shouldBeJoined )
+ {
+ // FIXME shouldn't we set cancellation type to DISABLED here? If
+ // we're cancelled inside pthread_join(), things will almost
+ // certainly break - but if we disable the cancellation, we
+ // might deadlock
+ if ( pthread_join(GetId(), &m_exitcode) != 0 )
+ {
+ // 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"));
+ }
- // After that, we wait for the real end of the other thread.
- pthread_join(GetId(), NULL);
+ m_shouldBeJoined = FALSE;
+ }
+ }
// reacquire GUI mutex
if ( wxThread::IsMain() )
wxMutexGuiEnter();
}
-void wxThreadInternal::SignalExit()
-{
- // GL: Unlock mutexSuspend here.
- m_mutexSuspend.Unlock();
-
- // as mutex is currently locked, this will block until some other thread
- // (normally the same which created this one) unlocks it by entering Wait()
- m_end_mutex.Lock();
-
- // wake up all the threads waiting for our termination
- m_cond.Broadcast();
-
- // after this call mutex will be finally unlocked
- m_end_mutex.Unlock();
-}
-
void wxThreadInternal::Pause()
{
// the state is set from the thread which pauses us first, this function
// is called later so the state should have been already set
wxCHECK_RET( m_state == STATE_PAUSED,
- _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
- // before it had time to call Wait()
- if ( WasCancelled() )
- return;
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld goes to sleep."), THR_ID(this));
- // wait until the condition is signaled from Resume()
- m_condSuspend.Wait(m_mutexSuspend);
+ // wait until the semaphore is Post()ed from Resume()
+ m_semSuspend.Wait();
}
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.") );
+
+ // the thread might be not actually paused yet - if there were no call to
+ // TestDestroy() since the last call to Pause() for example
+ if ( IsReallyPaused() )
+ {
+ wxLogTrace(TRACE_THREADS,
+ _T("Waking up thread %ld"), THR_ID(this));
- // we will be able to lock this mutex only when Pause() starts waiting
- wxMutexLocker lock(m_mutexSuspend);
- m_condSuspend.Signal();
+ // wake up Pause()
+ m_semSuspend.Post();
+
+ // reset the flag
+ SetReallyPaused(FALSE);
+ }
+ else
+ {
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld is not yet really paused"), THR_ID(this));
+ }
SetState(STATE_RUNNING);
}
// -----------------------------------------------------------------------------
-// static functions
+// wxThread static functions
// -----------------------------------------------------------------------------
wxThread *wxThread::This()
bool wxThread::IsMain()
{
- return (bool)pthread_equal(pthread_self(), gs_tidMain);
+ return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1;
}
void wxThread::Yield()
{
+#ifdef HAVE_SCHED_YIELD
sched_yield();
+#endif
}
void wxThread::Sleep(unsigned long milliseconds)
{
- wxUsleep(milliseconds);
+ wxMilliSleep(milliseconds);
+}
+
+int wxThread::GetCPUCount()
+{
+#if 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"));
+ if ( file.IsOpened() )
+ {
+ // slurp the whole file
+ wxString s;
+ if ( file.ReadAll(&s) )
+ {
+ // (ab)use Replace() to find the number of "processor: num" strings
+ size_t count = s.Replace(_T("processor\t:"), _T(""));
+ if ( count > 0 )
+ {
+ return count;
+ }
+
+ wxLogDebug(_T("failed to parse /proc/cpuinfo"));
+ }
+ else
+ {
+ wxLogDebug(_T("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;
+}
+
+// VMS is a 64 bit system and threads have 64 bit pointers.
+// FIXME: also needed for other systems????
+#ifdef __VMS
+unsigned long long wxThread::GetCurrentId()
+{
+ return (unsigned long long)pthread_self();
+}
+
+#else // !__VMS
+
+unsigned long wxThread::GetCurrentId()
+{
+ return (unsigned long)pthread_self();
+}
+
+#endif // __VMS/!__VMS
+
+
+bool wxThread::SetConcurrency(size_t level)
+{
+#ifdef HAVE_THR_SETCONCURRENCY
+ int rc = thr_setconcurrency(level);
+ if ( rc != 0 )
+ {
+ wxLogSysError(rc, _T("thr_setconcurrency() failed"));
+ }
+
+ return rc == 0;
+#else // !HAVE_THR_SETCONCURRENCY
+ // ok only for the default value
+ return level == 0;
+#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
}
// -----------------------------------------------------------------------------
// creating thread
// -----------------------------------------------------------------------------
-wxThread::wxThread()
+wxThread::wxThread(wxThreadKind kind)
{
// add this thread to the global list of all threads
gs_allThreads.Add(this);
- p_internal = new wxThreadInternal();
+ m_internal = new wxThreadInternal();
+
+ m_isDetached = kind == wxTHREAD_DETACHED;
}
-wxThreadError wxThread::Create()
+#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 (p_internal->GetState() != STATE_NEW)
+ 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 prio;
- if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
+ int policy;
+ if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
{
wxLogError(_("Cannot retrieve thread scheduling policy."));
}
- int min_prio = sched_get_priority_min(prio),
- max_prio = sched_get_priority_max(prio);
+#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."),
- prio);
+ 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;
- pthread_attr_getschedparam(&attr, &sp);
- sp.sched_priority = min_prio +
- (p_internal->GetPriority()*(max_prio-min_prio))/100;
- pthread_attr_setschedparam(&attr, &sp);
+ if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
+ {
+ wxFAIL_MSG(_T("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"));
+ }
}
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
// this will make the threads created by this process really concurrent
- pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
+ if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
+ {
+ wxFAIL_MSG(_T("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(_T("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(p_internal->GetIdPtr(), &attr,
- wxThreadInternal::PthreadStart, (void *)this);
- pthread_attr_destroy(&attr);
+ int rc = pthread_create
+ (
+ m_internal->GetIdPtr(),
+ &attr,
+ wxPthreadStart,
+ (void *)this
+ );
+
+ if ( pthread_attr_destroy(&attr) != 0 )
+ {
+ wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
+ }
if ( rc != 0 )
{
- p_internal->SetState(STATE_EXITED);
+ m_internal->SetState(STATE_EXITED);
+
return wxTHREAD_NO_RESOURCE;
}
wxThreadError wxThread::Run()
{
- return p_internal->Run();
+ wxCriticalSectionLocker lock(m_critsect);
+
+ wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR,
+ wxT("must call wxThread::Create() first") );
+
+ return m_internal->Run();
}
// -----------------------------------------------------------------------------
{
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);
- switch ( p_internal->GetState() )
+ switch ( m_internal->GetState() )
{
case STATE_NEW:
// thread not yet started, priority will be set when it is
- p_internal->SetPriority(prio);
+ m_internal->SetPriority(prio);
break;
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*prio)/5 + 20) == -1 )
+ {
+ wxLogError(_("Failed to set thread priority %d."), prio);
+ }
+#else // __LINUX__
{
struct sched_param sparam;
sparam.sched_priority = prio;
- if ( pthread_setschedparam(p_internal->GetId(),
+ if ( pthread_setschedparam(m_internal->GetId(),
SCHED_OTHER, &sparam) != 0 )
{
wxLogError(_("Failed to set thread priority %d."), prio);
}
}
+#endif // __LINUX__
#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
break;
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"));
}
}
{
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
- return p_internal->GetPriority();
+ return m_internal->GetPriority();
}
-unsigned long wxThread::GetID() const
+wxThreadIdType wxThread::GetId() const
{
- return (unsigned long)p_internal->GetId();
+ return (wxThreadIdType) m_internal->GetId();
}
// -----------------------------------------------------------------------------
wxThreadError wxThread::Pause()
{
+ wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+ _T("a thread can't pause itself") );
+
wxCriticalSectionLocker lock(m_critsect);
- if ( p_internal->GetState() != STATE_RUNNING )
+ if ( m_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;
}
- p_internal->SetState(STATE_PAUSED);
+ // just set a flag, the thread will be really paused only during the next
+ // call to TestDestroy()
+ m_internal->SetState(STATE_PAUSED);
return wxTHREAD_NO_ERROR;
}
wxThreadError wxThread::Resume()
{
+ wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+ _T("a thread can't resume itself") );
+
wxCriticalSectionLocker lock(m_critsect);
- if ( p_internal->GetState() == STATE_PAUSED )
- {
- m_critsect.Leave();
- p_internal->Resume();
- m_critsect.Enter();
+ wxThreadState state = m_internal->GetState();
- return wxTHREAD_NO_ERROR;
- }
- else
+ switch ( state )
{
- wxLogDebug(_T("Attempt to resume a thread which is not paused."));
+ case STATE_PAUSED:
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
+ GetId());
+
+ m_internal->Resume();
- return wxTHREAD_MISC_ERROR;
+ return wxTHREAD_NO_ERROR;
+
+ case STATE_EXITED:
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."),
+ GetId());
+ return wxTHREAD_NO_ERROR;
+
+ default:
+ wxLogDebug(_T("Attempt to resume a thread which is not paused."));
+
+ return wxTHREAD_MISC_ERROR;
}
}
// exiting thread
// -----------------------------------------------------------------------------
-wxThread::ExitCode wxThread::Delete()
+wxThread::ExitCode wxThread::Wait()
+{
+ wxCHECK_MSG( This() != this, (ExitCode)-1,
+ _T("a thread can't wait for itself") );
+
+ wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
+ _T("can't wait for detached thread") );
+
+ m_internal->Wait();
+
+ return m_internal->GetExitCode();
+}
+
+wxThreadError wxThread::Delete(ExitCode *rc)
{
- if (IsPaused())
- Resume();
+ wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+ _T("a thread can't delete itself") );
+
+ bool isDetached = m_isDetached;
m_critsect.Enter();
- wxThreadState state = p_internal->GetState();
+ wxThreadState state = m_internal->GetState();
// ask the thread to stop
- p_internal->SetCancelFlag();
+ m_internal->SetCancelFlag();
m_critsect.Leave();
switch ( state )
{
case STATE_NEW:
+ // we need to wake up the thread so that PthreadStart() will
+ // terminate - right now it's blocking on run semaphore in
+ // PthreadStart()
+ m_internal->SignalRun();
+
+ // fall through
+
case STATE_EXITED:
// nothing to do
break;
case STATE_PAUSED:
// resume the thread first
- Resume();
+ m_internal->Resume();
// fall through
default:
- // wait until the thread stops
- p_internal->Wait();
+ if ( !isDetached )
+ {
+ // wait until the thread stops
+ m_internal->Wait();
+
+ if ( rc )
+ {
+ // return the exit code of the thread
+ *rc = m_internal->GetExitCode();
+ }
+ }
+ //else: can't wait for detached threads
}
- //GL: As we must auto-destroy, the destruction must happen here.
- delete this;
- return NULL;
+ return wxTHREAD_NO_ERROR;
}
wxThreadError wxThread::Kill()
{
- switch ( p_internal->GetState() )
+ wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+ _T("a thread can't kill itself") );
+
+ switch ( m_internal->GetState() )
{
case STATE_NEW:
case STATE_EXITED:
return wxTHREAD_NOT_RUNNING;
+ case STATE_PAUSED:
+ // resume the thread first
+ Resume();
+
+ // fall through
+
default:
-#ifdef HAVE_PTHREAD_CANCEL
- if ( pthread_cancel(p_internal->GetId()) != 0 )
+#ifdef HAVE_PTHREAD_CANCEL
+ if ( pthread_cancel(m_internal->GetId()) != 0 )
#endif
{
wxLogError(_("Failed to terminate a thread."));
return wxTHREAD_MISC_ERROR;
}
- //GL: As we must auto-destroy, the destruction must happen here (2).
- delete this;
+
+ if ( m_isDetached )
+ {
+ // if we use cleanup function, this will be done from
+ // wxPthreadCleanup()
+#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 // wxHAVE_PTHREAD_CLEANUP
+ }
+ else
+ {
+ m_internal->SetExitCode(EXITCODE_CANCELLED);
+ }
return wxTHREAD_NO_ERROR;
}
}
-void wxThread::Exit(void *status)
+void wxThread::Exit(ExitCode status)
{
- // first call user-level clean up code
- OnExit();
+ wxASSERT_MSG( This() == this,
+ _T("wxThread::Exit() can only be called in the context of the same thread") );
+
+ 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();
+ }
- // next wake up the threads waiting for us (OTOH, this function won't return
- // until someone waited for us!)
- p_internal->SignalExit();
+ // 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();
- p_internal->SetState(STATE_EXITED);
+ // delete C++ thread object if this is a detached thread - user is
+ // responsible for doing this for joinable ones
+ if ( m_isDetached )
+ {
+ // FIXME I'm feeling bad about it - what if another thread function is
+ // called (in another thread context) now? It will try to access
+ // half destroyed object which will probably result in something
+ // very bad - but we can't protect this by a crit section unless
+ // we make it a global object, but this would mean that we can
+ // only call one thread function at a time :-(
+ DeleteThread(this);
+ }
+ else
+ {
+ m_critsect.Enter();
+ m_internal->SetState(STATE_EXITED);
+ m_critsect.Leave();
+ }
- // delete both C++ thread object and terminate the OS thread object
- // GL: This is very ugly and buggy ...
-// delete this;
+ // terminate the thread (pthread_exit() never returns)
pthread_exit(status);
+
+ wxFAIL_MSG(_T("pthread_exit() failed"));
}
// also test whether we were paused
bool wxThread::TestDestroy()
{
- wxCriticalSectionLocker lock(m_critsect);
+ wxASSERT_MSG( This() == this,
+ _T("wxThread::TestDestroy() can only be called in the context of the same thread") );
+
+ m_critsect.Enter();
- if ( p_internal->GetState() == STATE_PAUSED )
+ if ( m_internal->GetState() == STATE_PAUSED )
{
- // leave the crit section or the other threads will stop too if they try
- // to call any of (seemingly harmless) IsXXX() functions while we sleep
- m_critsect.Leave();
+ m_internal->SetReallyPaused(TRUE);
- p_internal->Pause();
+ // leave the crit section or the other threads will stop too if they
+ // try to call any of (seemingly harmless) IsXXX() functions while we
+ // sleep
+ m_critsect.Leave();
- // enter it back before it's finally left in lock object dtor
- m_critsect.Enter();
+ m_internal->Pause();
+ }
+ else
+ {
+ // thread wasn't requested to pause, nothing to do
+ m_critsect.Leave();
}
- return p_internal->WasCancelled();
+ return m_internal->WasCancelled();
}
wxThread::~wxThread()
{
+#ifdef __WXDEBUG__
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."));
+
+ // 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."),
+ (long)GetId());
+ }
m_critsect.Leave();
+#endif // __WXDEBUG__
+
+ delete m_internal;
- delete p_internal;
// remove this thread from the global array
gs_allThreads.Remove(this);
}
{
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
- return p_internal->GetState() == STATE_RUNNING;
+ return m_internal->GetState() == STATE_RUNNING;
}
bool wxThread::IsAlive() const
{
wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
- switch ( p_internal->GetState() )
+ switch ( m_internal->GetState() )
{
case STATE_RUNNING:
case STATE_PAUSED:
{
wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
- return (p_internal->GetState() == STATE_PAUSED);
+ return (m_internal->GetState() == STATE_PAUSED);
}
//--------------------------------------------------------------------
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;
}
- gs_mutexGui = new wxMutex();
-
gs_tidMain = pthread_self();
+ gs_mutexGui = new wxMutex();
gs_mutexGui->Lock();
+ gs_mutexDeleteThread = new wxMutex();
+ gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );
+
return TRUE;
}
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") );
+
+ // are there any threads left which are being deleted right now?
+ size_t nThreadsBeingDeleted;
+
+ {
+ wxMutexLocker lock( *gs_mutexDeleteThread );
+ nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
+
+ if ( nThreadsBeingDeleted > 0 )
+ {
+ wxLogTrace(TRACE_THREADS,
+ _T("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 )
- wxLogDebug(_T("Some threads were not terminated by the application."));
+ {
+ wxLogDebug(wxT("%lu threads were not terminated by the application."),
+ (unsigned long)count);
+ }
for ( size_t n = 0u; n < count; n++ )
{
- // Delete calls the destructor which removes the current entry. We
- // should only delete the first one each time.
+ // 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();
-
delete gs_mutexGui;
// and free TLD slot
(void)pthread_key_delete(gs_keySelf);
+
+ delete gs_condAllDeleted;
+ delete gs_mutexDeleteThread;
}
// ----------------------------------------------------------------------------
// global functions
// ----------------------------------------------------------------------------
+static void ScheduleThreadForDeletion()
+{
+ wxMutexLocker lock( *gs_mutexDeleteThread );
+
+ gs_nThreadsBeingDeleted++;
+
+ wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+ (unsigned long)gs_nThreadsBeingDeleted,
+ gs_nThreadsBeingDeleted == 1 ? "" : "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());
+
+ delete This;
+
+ wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
+ _T("no threads scheduled for deletion, yet we delete one?") );
+
+ wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
+ (unsigned long)gs_nThreadsBeingDeleted - 1);
+
+ if ( !--gs_nThreadsBeingDeleted )
+ {
+ // no more threads left, signal it
+ gs_condAllDeleted->Signal();
+ }
+}
+
void wxMutexGuiEnter()
{
- gs_mutexGui->Lock();
+ gs_mutexGui->Lock();
}
void wxMutexGuiLeave()
{
- gs_mutexGui->Unlock();
+ gs_mutexGui->Unlock();
}
-#endif
- // wxUSE_THREADS
+// ----------------------------------------------------------------------------
+// include common implementation code
+// ----------------------------------------------------------------------------
+
+#include "wx/thrimpl.cpp"
+
+#endif // wxUSE_THREADS
+
projects / wxWidgets.git / blobdiff