// 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
/////////////////////////////////////////////////////////////////////////////
#include "wx/log.h"
#include "wx/intl.h"
#include "wx/dynarray.h"
+#include "wx/timer.h"
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <time.h>
-
#if HAVE_SCHED_H
#include <sched.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
// ----------------------------------------------------------------------------
// the exit value of a thread which has been cancelled
static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
-// our trace mask
+// 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
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
-// same as wxMutexLocker but for "native" mutex
-class MutexLock
-{
-public:
- MutexLock(pthread_mutex_t& mutex)
- {
- m_mutex = &mutex;
- if ( pthread_mutex_lock(m_mutex) != 0 )
- {
- wxLogDebug(_T("pthread_mutex_lock() failed"));
- }
- }
-
- ~MutexLock()
- {
- if ( pthread_mutex_unlock(m_mutex) != 0 )
- {
- wxLogDebug(_T("pthread_mutex_unlock() failed"));
- }
- }
-
-private:
- pthread_mutex_t *m_mutex;
-};
-
-// ----------------------------------------------------------------------------
-// types
-// ----------------------------------------------------------------------------
-
+// an (non owning) array of pointers to threads
WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+// an entry for a thread we can wait for
+
// -----------------------------------------------------------------------------
// global data
// -----------------------------------------------------------------------------
static size_t gs_nThreadsBeingDeleted = 0;
// a mutex to protect gs_nThreadsBeingDeleted
-static pthread_mutex_t gs_mutexDeleteThread;
+static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
// and a condition variable which will be signaled when all
// gs_nThreadsBeingDeleted will have been deleted
static wxMutex *gs_mutexGui;
#endif // wxUSE_GUI
+// 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:
+ 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()
-{
- m_internal = new wxMutexInternal;
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
+// 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
- // 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
+wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
+{
+ 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_internal->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_internal->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_internal->m_mutex), NULL);
+ err = EINVAL;
#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+ break;
+
+ default:
+ wxFAIL_MSG( _T("unknown mutex type") );
+ // fall through
- m_locked = 0;
+ 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(wxT("Freeing a locked mutex (%d locks)"), m_locked);
-
- pthread_mutex_destroy( &(m_internal->m_mutex) );
- delete m_internal;
+ if ( m_isOk )
+ {
+ int err = pthread_mutex_destroy(&m_mutex);
+ if ( err != 0 )
+ {
+ wxLogApiError( wxT("pthread_mutex_destroy()"), err);
+ }
+ }
}
-wxMutexError wxMutex::Lock()
+wxMutexError wxMutexInternal::Lock()
{
- int err = pthread_mutex_lock( &(m_internal->m_mutex) );
- if (err == EDEADLK)
+ int err = pthread_mutex_lock(&m_mutex);
+ switch ( err )
{
- wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+ 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;
- return wxMUTEX_DEAD_LOCK;
- }
+ case 0:
+ return wxMUTEX_NO_ERROR;
- m_locked++;
+ default:
+ wxLogApiError(_T("pthread_mutex_lock()"), err);
+ }
- return wxMUTEX_NO_ERROR;
+ return wxMUTEX_MISC_ERROR;
}
-wxMutexError wxMutex::TryLock()
+wxMutexError wxMutexInternal::TryLock()
{
- if (m_locked)
+ int err = pthread_mutex_trylock(&m_mutex);
+ switch ( err )
{
- return wxMUTEX_BUSY;
- }
+ case EBUSY:
+ // not an error: mutex is already locked, but we're prepared for
+ // this
+ return wxMUTEX_BUSY;
- int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
- switch (err)
- {
- case EBUSY: return wxMUTEX_BUSY;
- }
+ case EINVAL:
+ wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
+ break;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
- m_locked++;
+ default:
+ wxLogApiError(_T("pthread_mutex_trylock()"), err);
+ }
- return wxMUTEX_NO_ERROR;
+ return wxMUTEX_MISC_ERROR;
}
-wxMutexError wxMutex::Unlock()
+wxMutexError wxMutexInternal::Unlock()
{
- if (m_locked > 0)
+ int err = pthread_mutex_unlock(&m_mutex);
+ switch ( err )
{
- m_locked--;
- }
- else
- {
- wxLogDebug(wxT("Unlocking not locked mutex."));
+ case EPERM:
+ // we don't own the mutex
+ return wxMUTEX_UNLOCKED;
- return wxMUTEX_UNLOCKED;
- }
+ case EINVAL:
+ wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
+ break;
- pthread_mutex_unlock( &(m_internal->m_mutex) );
+ case 0:
+ return wxMUTEX_NO_ERROR;
- return wxMUTEX_NO_ERROR;
+ default:
+ wxLogApiError(_T("pthread_mutex_unlock()"), err);
+ }
+
+ return wxMUTEX_MISC_ERROR;
}
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ===========================================================================
+// wxCondition implementation
+// ===========================================================================
-// The native POSIX condition variables are dumb: if the condition is signaled
-// before another thread starts to wait on it, the signal is lost and so this
-// other thread will be never woken up. It's much more convenient to us to
-// remember that the condition was signaled and to return from Wait()
-// immediately in this case (this is more like Win32 automatic event objects)
+// ---------------------------------------------------------------------------
+// wxConditionInternal
+// ---------------------------------------------------------------------------
+// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
+// with a pthread_mutex_t)
class wxConditionInternal
{
public:
- wxConditionInternal();
+ wxConditionInternal(wxMutex& mutex);
~wxConditionInternal();
- void Wait();
- bool WaitWithTimeout(const timespec* ts);
+ bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
- void Signal();
- void Broadcast();
+ wxCondError Wait();
+ wxCondError WaitTimeout(unsigned long milliseconds);
- void WaitDone();
- bool ShouldWait();
- bool HasWaiters();
+ wxCondError Signal();
+ wxCondError Broadcast();
private:
- bool m_wasSignaled; // TRUE if condition was signaled while
- // nobody waited for it
- size_t m_nWaiters; // TRUE if someone already waits for us
+ // get the POSIX mutex associated with us
+ pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }
- pthread_mutex_t m_mutexProtect; // protects access to vars above
+ wxMutex& m_mutex;
+ pthread_cond_t m_cond;
- pthread_mutex_t m_mutex; // the mutex used with the condition
- pthread_cond_t m_condition; // the condition itself
+ bool m_isOk;
};
-wxConditionInternal::wxConditionInternal()
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+ : m_mutex(mutex)
{
- m_wasSignaled = FALSE;
- m_nWaiters = 0;
-
- if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
- {
- // this is supposed to never happen
- wxFAIL_MSG( _T("pthread_cond_init() failed") );
- }
+ int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
- if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t *)NULL) != 0 ||
- pthread_mutex_init(&m_mutexProtect, NULL) != 0 )
- {
- // neither this
- wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
- }
+ m_isOk = err == 0;
- // initially the mutex is locked, so no thread can Signal() or Broadcast()
- // until another thread starts to Wait()
- if ( pthread_mutex_lock(&m_mutex) != 0 )
+ if ( !m_isOk )
{
- wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
+ wxLogApiError(_T("pthread_cond_init()"), err);
}
}
wxConditionInternal::~wxConditionInternal()
{
- if ( pthread_cond_destroy( &m_condition ) != 0 )
+ if ( m_isOk )
{
- wxLogDebug(_T("Failed to destroy condition variable (some "
- "threads are probably still waiting on it?)"));
+ int err = pthread_cond_destroy(&m_cond);
+ if ( err != 0 )
+ {
+ wxLogApiError(_T("pthread_cond_destroy()"), err);
+ }
}
+}
- if ( pthread_mutex_unlock( &m_mutex ) != 0 )
+wxCondError wxConditionInternal::Wait()
+{
+ int err = pthread_cond_wait(&m_cond, GetPMutex());
+ if ( err != 0 )
{
- wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
- }
+ wxLogApiError(_T("pthread_cond_wait()"), err);
- if ( pthread_mutex_destroy( &m_mutex ) != 0 ||
- pthread_mutex_destroy( &m_mutexProtect ) != 0 )
- {
- wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
+ return wxCOND_MISC_ERROR;
}
+
+ return wxCOND_NO_ERROR;
}
-void wxConditionInternal::WaitDone()
+wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
{
- MutexLock lock(m_mutexProtect);
+ wxLongLong curtime = wxGetLocalTimeMillis();
+ curtime += milliseconds;
+ wxLongLong temp = curtime / 1000;
+ int sec = temp.GetLo();
+ temp *= 1000;
+ temp = curtime - temp;
+ int millis = temp.GetLo();
- m_wasSignaled = FALSE;
- m_nWaiters--;
-}
+ timespec tspec;
-bool wxConditionInternal::ShouldWait()
-{
- MutexLock lock(m_mutexProtect);
+ tspec.tv_sec = sec;
+ tspec.tv_nsec = millis * 1000L * 1000L;
- if ( m_wasSignaled )
+ int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
+ switch ( err )
{
- // the condition was signaled before we started to wait, reset the
- // flag and return
- m_wasSignaled = FALSE;
+ case ETIMEDOUT:
+ return wxCOND_TIMEOUT;
- return FALSE;
- }
+ case 0:
+ return wxCOND_NO_ERROR;
- // we start to wait for it
- m_nWaiters++;
+ default:
+ wxLogApiError(_T("pthread_cond_timedwait()"), err);
+ }
- return TRUE;
+ return wxCOND_MISC_ERROR;
}
-bool wxConditionInternal::HasWaiters()
+wxCondError wxConditionInternal::Signal()
{
- MutexLock lock(m_mutexProtect);
-
- if ( m_nWaiters )
+ int err = pthread_cond_signal(&m_cond);
+ if ( err != 0 )
{
- // someone waits for us, signal the condition normally
- return TRUE;
- }
+ wxLogApiError(_T("pthread_cond_signal()"), err);
- // nobody waits for us and may be never will - so just remember that the
- // condition was signaled and don't do anything else
- m_wasSignaled = TRUE;
+ return wxCOND_MISC_ERROR;
+ }
- return FALSE;
+ return wxCOND_NO_ERROR;
}
-void wxConditionInternal::Wait()
+wxCondError wxConditionInternal::Broadcast()
{
- if ( ShouldWait() )
+ int err = pthread_cond_broadcast(&m_cond);
+ if ( err != 0 )
{
- if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
- {
- // not supposed to ever happen
- wxFAIL_MSG( _T("pthread_cond_wait() failed") );
- }
+ wxLogApiError(_T("pthread_cond_broadcast()"), err);
+
+ return wxCOND_MISC_ERROR;
}
- WaitDone();
+ return wxCOND_NO_ERROR;
}
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// 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
{
- bool ok;
+public:
+ wxSemaphoreInternal(int initialcount, int maxcount);
- if ( ShouldWait() )
- {
- switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
- {
- case 0:
- // condition signaled
- ok = TRUE;
- break;
+ bool IsOk() const { return m_isOk; }
- default:
- wxLogDebug(_T("pthread_cond_timedwait() failed"));
+ wxSemaError Wait();
+ wxSemaError TryWait();
+ wxSemaError WaitTimeout(unsigned long milliseconds);
- // fall through
+ wxSemaError Post();
- case ETIMEDOUT:
- case EINTR:
- // wait interrupted or timeout elapsed
- ok = FALSE;
- }
+private:
+ wxMutex m_mutex;
+ wxCondition m_cond;
+
+ size_t m_count,
+ m_maxcount;
+
+ bool m_isOk;
+};
+
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+ : m_cond(m_mutex)
+{
+
+ if ( (initialcount < 0 || maxcount < 0) ||
+ ((maxcount > 0) && (initialcount > maxcount)) )
+ {
+ wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
+
+ m_isOk = FALSE;
}
else
{
- // the condition had already been signaled before
- ok = TRUE;
+ m_maxcount = (size_t)maxcount;
+ m_count = (size_t)initialcount;
}
- WaitDone();
-
- return ok;
+ m_isOk = m_mutex.IsOk() && m_cond.IsOk();
}
-void wxConditionInternal::Signal()
+wxSemaError wxSemaphoreInternal::Wait()
{
- if ( HasWaiters() )
+ wxMutexLocker locker(m_mutex);
+
+ while ( m_count == 0 )
{
- MutexLock lock(m_mutex);
+ wxLogTrace(TRACE_SEMA,
+ "Thread %ld waiting for semaphore to become signalled",
+ wxThread::GetCurrentId());
- if ( pthread_cond_signal( &m_condition ) != 0 )
- {
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_signal() failed"));
- }
+ if ( m_cond.Wait() != wxCOND_NO_ERROR )
+ return wxSEMA_MISC_ERROR;
+
+ wxLogTrace(TRACE_SEMA,
+ "Thread %ld finished waiting for semaphore, count = %lu",
+ wxThread::GetCurrentId(), (unsigned long)m_count);
}
+
+ m_count--;
+
+ return wxSEMA_NO_ERROR;
+}
+
+wxSemaError wxSemaphoreInternal::TryWait()
+{
+ wxMutexLocker locker(m_mutex);
+
+ if ( m_count == 0 )
+ return wxSEMA_BUSY;
+
+ m_count--;
+
+ return wxSEMA_NO_ERROR;
}
-void wxConditionInternal::Broadcast()
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
{
- if ( HasWaiters() )
+ wxMutexLocker locker(m_mutex);
+
+ wxLongLong startTime = wxGetLocalTimeMillis();
+
+ while ( m_count == 0 )
{
- MutexLock lock(m_mutex);
+ wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+ long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
+ if ( remainingTime <= 0 )
+ {
+ // timeout
+ return wxSEMA_TIMEOUT;
+ }
- if ( pthread_cond_broadcast( &m_condition ) != 0 )
+ switch ( m_cond.WaitTimeout(remainingTime) )
{
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
+ case wxCOND_TIMEOUT:
+ return wxSEMA_TIMEOUT;
+
+ default:
+ return wxSEMA_MISC_ERROR;
+
+ case wxCOND_NO_ERROR:
+ ;
}
}
-}
-wxCondition::wxCondition()
-{
- m_internal = new wxConditionInternal;
-}
+ m_count--;
-wxCondition::~wxCondition()
-{
- delete m_internal;
+ return wxSEMA_NO_ERROR;
}
-void wxCondition::Wait()
+wxSemaError wxSemaphoreInternal::Post()
{
- m_internal->Wait();
-}
+ wxMutexLocker locker(m_mutex);
-bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
-{
- timespec tspec;
+ if ( m_maxcount > 0 && m_count == m_maxcount )
+ {
+ return wxSEMA_OVERFLOW;
+ }
- tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here?
- tspec.tv_nsec = nsec;
+ m_count++;
- return m_internal->WaitWithTimeout(&tspec);
-}
+ wxLogTrace(TRACE_SEMA,
+ "Thread %ld about to signal semaphore, count = %lu",
+ wxThread::GetCurrentId(), (unsigned long)m_count);
-void wxCondition::Signal()
-{
- m_internal->Signal();
+ 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"
{
- m_internal->Broadcast();
-}
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+ // thread exit function
+ void wxPthreadCleanup(void *ptr);
+#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+
+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();
- // wake up threads waiting for our start
- void SignalRun() { m_condRun.Signal(); }
// 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; }
// tell the thread that it is a detached one
void Detach()
{
- m_shouldBeJoined = m_shouldBroadcast = FALSE;
+ 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
+ // this is used by wxPthreadCleanup() only
+ static void Cleanup(wxThread *thread);
+#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
private:
pthread_t m_threadId; // id of the thread
// this flag is set when the thread should terminate
bool m_cancelled;
- // this flag is set when the thread is blocking on m_condSuspend
+ // 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
// pthread_join(), so we have to keep track of this
wxCriticalSection m_csJoinFlag;
bool m_shouldBeJoined;
- bool m_shouldBroadcast;
bool m_isDetached;
- // VZ: it's possible that we might do with less than three different
- // condition objects - for example, m_condRun and m_condEnd a priori
- // won't be used in the same time. But for now I prefer this may be a
- // bit less efficient but safer solution of having distinct condition
- // variables for each purpose.
-
- // this condition is signaled by Run() and the threads Entry() is not
+ // this semaphore is posted by Run() and the threads Entry() is not
// called before it is done
- wxCondition m_condRun;
+ wxSemaphore m_semRun;
// this one is signaled when the thread should resume after having been
// Pause()d
- wxCondition m_condSuspend;
-
- // finally this one is signalled when the thread exits
- wxCondition m_condEnd;
+ wxSemaphore m_semSuspend;
};
// ----------------------------------------------------------------------------
// thread startup and exit functions
// ----------------------------------------------------------------------------
-void *wxThreadInternal::PthreadStart(void *ptr)
+void *wxPthreadStart(void *ptr)
+{
+ return wxThreadInternal::PthreadStart((wxThread *)ptr);
+}
+
+void *wxThreadInternal::PthreadStart(wxThread *thread)
{
- wxThread *thread = (wxThread *)ptr;
wxThreadInternal *pthread = thread->m_internal;
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long long)pthread->GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long)pthread->GetId());
+#endif
+
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
int rc = pthread_setspecific(gs_keySelf, thread);
#if HAVE_THREAD_CLEANUP_FUNCTIONS
// install the cleanup handler which will be called if the thread is
// cancelled
- pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+ pthread_cleanup_push(wxPthreadCleanup, thread);
#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
- // wait for the condition to be signaled from Run()
- pthread->m_condRun.Wait();
+ // wait for the semaphore to be posted from Run()
+ pthread->m_semRun.Wait();
// test whether we should run the run at all - may be it was deleted
// before it started to Run()?
if ( !dontRunAtAll )
{
// call the main entry
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."),
+#ifdef __VMS
+ (long long)pthread->GetId());
+#else
+ (long)pthread->GetId());
+#endif
+
pthread->m_exitcode = thread->Entry();
- wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
- pthread->GetId());
-
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."),
+#ifdef __VMS
+ (long long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
+#else
+ (long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
+#endif
+
{
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
- // PthreadCleanup handler won't do anything from now (if it's
+ // wxPthreadCleanup handler won't do anything from now (if it's
// called before we do pthread_cleanup_pop below)
pthread->SetState(STATE_EXITED);
}
if ( dontRunAtAll )
{
+ // FIXME: deleting a possibly joinable thread here???
delete thread;
return EXITCODE_CANCELLED;
#if HAVE_THREAD_CLEANUP_FUNCTIONS
// this handler is called when the thread is cancelled
-void wxThreadInternal::PthreadCleanup(void *ptr)
+extern "C" void wxPthreadCleanup(void *ptr)
{
- wxThread *thread = (wxThread *) ptr;
+ wxThreadInternal::Cleanup((wxThread *)ptr);
+}
+void wxThreadInternal::Cleanup(wxThread *thread)
+{
{
wxCriticalSectionLocker lock(thread->m_critsect);
if ( thread->m_internal->GetState() == STATE_EXITED )
m_threadId = 0;
m_exitcode = 0;
- // set to TRUE only when the thread starts waiting on m_condSuspend
+ // 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;
}
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, _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();
- bool isDetached = m_isDetached;
- long id = (long)GetId();
- 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)
- m_condEnd.Wait();
-
- 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 )
+ wxLogTrace(TRACE_THREADS,
+#ifdef __VMS
+ _T("Starting to wait for thread %ld to exit."), (long long)GetId());
+#else
+ _T("Starting to wait for thread %ld to exit."), (long)GetId());
+#endif
+
+ // 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 )
{
+ // 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"));
}
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.Broadcast();
- }
-}
-
void wxThreadInternal::Pause()
{
// the state is set from the thread which pauses us first, this function
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());
-
- // wait until the condition is signaled from Resume()
- m_condSuspend.Wait();
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long long)GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long)GetId());
+#endif
+
+ // wait until the semaphore is Post()ed from Resume()
+ m_semSuspend.Wait();
}
void wxThreadInternal::Resume()
// TestDestroy() since the last call to Pause() for example
if ( IsReallyPaused() )
{
- wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
-
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long long)GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long)GetId());
+#endif
+
// wake up Pause()
- m_condSuspend.Signal();
+ m_semSuspend.Post();
// reset the flag
SetReallyPaused(FALSE);
else
{
wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
- GetId());
+#ifdef __VMS
+ (long long)GetId());
+#else
+ (long)GetId());
+#endif
}
SetState(STATE_RUNNING);
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(_T("processor\t:"), _T(""));
if ( count > 0 )
{
return count;
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()
+{
+ return (unsigned long)pthread_self();
+#endif
+}
+
bool wxThread::SetConcurrency(size_t level)
{
#ifdef HAVE_THR_SETCONCURRENCY
m_isDetached = kind == wxTHREAD_DETACHED;
}
-wxThreadError wxThread::Create()
+wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
{
if ( m_internal->GetState() != STATE_NEW )
{
#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();
(
m_internal->GetIdPtr(),
&attr,
- wxThreadInternal::PthreadStart,
+ wxPthreadStart,
(void *)this
);
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.
+ {
+ float fPrio;
+ float pSpan;
+ int iPrio;
+
+ // Map Wx priorites (WXTHREAD_MIN_PRIORITY -
+ // WXTHREAD_MAX_PRIORITY) into BSD priorities (20 - -20).
+ // Do calculation of values instead of hard coding them
+ // to make maintenance easier.
+
+ pSpan = ((float)(WXTHREAD_MAX_PRIORITY - WXTHREAD_MIN_PRIORITY)) / 2.0;
+
+ // prio starts as ................... // value => (0) >= p <= (n)
+
+ fPrio = ((float)prio) - pSpan; // value => (-n) >= p <= (+n)
+
+ fPrio = 0.0 - fPrio; // value => (+n) <= p >= (-n)
+
+ fPrio = fPrio * (20. / pSpan) + .5; // value => (20) <= p >= (-20)
+
+ iPrio = (int)fPrio;
+
+ // Clamp prio from 20 - -20;
+ iPrio = (iPrio > 20) ? 20 : iPrio;
+ iPrio = (iPrio < -20) ? -20 : iPrio;
+
+ if (setpriority(PRIO_PROCESS, 0, iPrio) == -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;
return m_internal->GetPriority();
}
-unsigned long wxThread::GetId() const
+wxThreadIdType wxThread::GetId() const
{
- return (unsigned long)m_internal->GetId();
+ return (wxThreadIdType) m_internal->GetId();
}
// -----------------------------------------------------------------------------
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);
wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
_T("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();
switch ( state )
{
case STATE_NEW:
// we need to wake up the thread so that PthreadStart() will
- // terminate - right now it's blocking on m_condRun
+ // 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
}
return wxTHREAD_NO_ERROR;
if ( m_isDetached )
{
// if we use cleanup function, this will be done from
- // PthreadCleanup()
+ // wxPthreadCleanup()
#if !HAVE_THREAD_CLEANUP_FUNCTIONS
ScheduleThreadForDeletion();
_T("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
// 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();
-
// delete C++ thread object if this is a detached thread - user is
// responsible for doing this for joinable ones
if ( m_isDetached )
// 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 )
- {
- MutexLock lock(gs_mutexDeleteThread);
- gs_nThreadsBeingDeleted--;
-
- wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
- gs_nThreadsBeingDeleted - 1);
- }
}
// -----------------------------------------------------------------------------
gs_mutexGui->Lock();
#endif // wxUSE_GUI
- // under Solaris we get a warning from CC when using
- // PTHREAD_MUTEX_INITIALIZER, so do it dynamically
- pthread_mutex_init(&gs_mutexDeleteThread, NULL);
+ gs_mutexDeleteThread = new wxMutex();
+ gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );
return TRUE;
}
// are there any threads left which are being deleted right now?
size_t nThreadsBeingDeleted;
+
{
- MutexLock lock(gs_mutexDeleteThread);
+ wxMutexLocker lock( *gs_mutexDeleteThread );
nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
- }
- if ( nThreadsBeingDeleted > 0 )
- {
- wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
- 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();
+ // 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(wxT("%u threads were not terminated by the application."),
- count);
+ wxLogDebug(wxT("%lu threads were not terminated by the application."),
+ (unsigned long)count);
}
for ( size_t n = 0u; n < count; n++ )
// and free TLD slot
(void)pthread_key_delete(gs_keySelf);
+
+ delete gs_condAllDeleted;
+ delete gs_mutexDeleteThread;
}
// ----------------------------------------------------------------------------
static void ScheduleThreadForDeletion()
{
- MutexLock lock(gs_mutexDeleteThread);
-
- if ( gs_nThreadsBeingDeleted == 0 )
- {
- gs_condAllDeleted = new wxCondition;
- }
+ wxMutexLocker lock( *gs_mutexDeleteThread );
gs_nThreadsBeingDeleted++;
- wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
- gs_nThreadsBeingDeleted,
+ wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+ (unsigned long)gs_nThreadsBeingDeleted,
gs_nThreadsBeingDeleted == 1 ? "" : "s");
}
{
// gs_mutexDeleteThread should be unlocked before signalling the condition
// or wxThreadModule::OnExit() would deadlock
- {
- MutexLock lock(gs_mutexDeleteThread);
+ wxMutexLocker locker( *gs_mutexDeleteThread );
- wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
- delete This;
+ delete This;
- wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
- _T("no threads scheduled for deletion, yet we delete "
- "one?") );
- }
+ wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
+ _T("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, _T("%lu scheduled for deletion threads left."),
+ (unsigned long)gs_nThreadsBeingDeleted - 1);
if ( !--gs_nThreadsBeingDeleted )
{
// no more threads left, signal it
gs_condAllDeleted->Signal();
-
- delete gs_condAllDeleted;
- gs_condAllDeleted = (wxCondition *)NULL;
}
}
#endif // wxUSE_GUI
}
-#endif
- // wxUSE_THREADS
+// ----------------------------------------------------------------------------
+// include common implementation code
+// ----------------------------------------------------------------------------
+
+#include "wx/thrimpl.cpp"
+
+#endif // wxUSE_THREADS
+
projects / wxWidgets.git / blobdiff