// 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
/////////////////////////////////////////////////////////////////////////////
#pragma implementation "thread.h"
#endif
-// With simple makefiles, we must ignore the file body if not using
-// threads.
-#include "wx/setup.h"
+#include "wx/defs.h"
#if wxUSE_THREADS
#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
+#ifdef HAVE_THR_SETCONCURRENCY
+ #include <thread.h>
+#endif
+
+// we use wxFFile under Linux in GetCPUCount()
+#ifdef __LINUX__
+ #include "wx/ffile.h"
+#endif
+
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
static void ScheduleThreadForDeletion();
static void DeleteThread(wxThread *This);
-// ----------------------------------------------------------------------------
-// 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
// ----------------------------------------------------------------------------
static size_t gs_nThreadsBeingDeleted = 0;
// a mutex to protect gs_nThreadsBeingDeleted
-static pthread_mutex_t gs_mutexDeleteThread = PTHREAD_MUTEX_INITIALIZER;
+static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
// and a condition variable which will be signaled when all
// gs_nThreadsBeingDeleted will have been deleted
#endif // wxUSE_GUI
// ============================================================================
-// implementation
+// wxMutex implementation
// ============================================================================
-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------
class wxMutexInternal
{
public:
+ wxMutexInternal();
+ ~wxMutexInternal();
+
+ wxMutexError Lock();
+ wxMutexError TryLock();
+ wxMutexError Unlock();
+
+private:
pthread_mutex_t m_mutex;
+
+ friend class wxConditionInternal;
};
+wxMutexInternal::wxMutexInternal()
+{
+ // 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
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+
+ 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
+ pthread_mutex_init(&m_mutex, NULL);
+
+ // used by TryLock() below
+ #define NO_RECURSIVE_MUTEXES
+#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+}
+
+wxMutexInternal::~wxMutexInternal()
+{
+ pthread_mutex_destroy(&m_mutex);
+}
+
+wxMutexError wxMutexInternal::Lock()
+{
+ int err = pthread_mutex_lock(&m_mutex);
+ switch ( err )
+ {
+ case EDEADLK:
+ wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+ return wxMUTEX_DEAD_LOCK;
+
+ default:
+ wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
+ // fall through
+
+ case EINVAL:
+ wxLogDebug(_T("Failed to lock the mutex."));
+ return wxMUTEX_MISC_ERROR;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+ }
+}
+
+wxMutexError wxMutexInternal::TryLock()
+{
+ int err = pthread_mutex_trylock(&m_mutex);
+ switch ( err )
+ {
+ case EBUSY:
+ return wxMUTEX_BUSY;
+
+ default:
+ wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
+ // fall through
+
+ case EINVAL:
+ wxLogDebug(_T("Failed to try to lock the mutex."));
+ return wxMUTEX_MISC_ERROR;
+
+ case 0:
+ 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;
+
+ default:
+ wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
+ // fall through
+
+ case EINVAL:
+ wxLogDebug(_T("Failed to unlock the mutex."));
+ return wxMUTEX_MISC_ERROR;
+
+ case 0:
+ return wxMUTEX_NO_ERROR;
+ }
+}
+
+// ----------------------------------------------------------------------------
+// wxMutex
+// ----------------------------------------------------------------------------
+
+// TODO: this is completely generic, move it to common code?
+
wxMutex::wxMutex()
{
m_internal = new wxMutexInternal;
- pthread_mutex_init(&(m_internal->m_mutex),
- (pthread_mutexattr_t*) NULL );
m_locked = 0;
}
wxMutex::~wxMutex()
{
- if (m_locked > 0)
+ if ( m_locked > 0 )
wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
- pthread_mutex_destroy( &(m_internal->m_mutex) );
delete m_internal;
}
wxMutexError wxMutex::Lock()
{
- int err = pthread_mutex_lock( &(m_internal->m_mutex) );
- if (err == EDEADLK)
- {
- wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+ wxMutexError err = m_internal->Lock();
- return wxMUTEX_DEAD_LOCK;
+ if ( !err )
+ {
+ m_locked++;
}
- m_locked++;
-
- return wxMUTEX_NO_ERROR;
+ return err;
}
wxMutexError wxMutex::TryLock()
{
- if (m_locked)
+ if ( m_locked )
{
- return wxMUTEX_BUSY;
+#ifdef NO_RECURSIVE_MUTEXES
+ return wxMUTEX_DEAD_LOCK;
+#else // have recursive mutexes on this platform
+ // we will succeed in locking it when we have it already locked
+ return wxMUTEX_NO_ERROR;
+#endif // recursive/non-recursive mutexes
}
- int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
- switch (err)
+ wxMutexError err = m_internal->TryLock();
+ if ( !err )
{
- case EBUSY: return wxMUTEX_BUSY;
+ m_locked++;
}
- m_locked++;
-
- return wxMUTEX_NO_ERROR;
+ return err;
}
wxMutexError wxMutex::Unlock()
{
- if (m_locked > 0)
+ if ( m_locked > 0 )
{
m_locked--;
}
return wxMUTEX_UNLOCKED;
}
- pthread_mutex_unlock( &(m_internal->m_mutex) );
-
- return wxMUTEX_NO_ERROR;
+ return m_internal->Unlock();
}
-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ===========================================================================
+// wxCondition implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxConditionInternal
+// ---------------------------------------------------------------------------
-// notice that we must use a mutex with POSIX condition variables to ensure
-// that the worker thread doesn't signal condition before the waiting thread
-// starts to wait for it
class wxConditionInternal
{
public:
- wxConditionInternal();
+ wxConditionInternal(wxMutex& mutex);
~wxConditionInternal();
void Wait();
- bool WaitWithTimeout(const timespec* ts);
+
+ bool Wait( const timespec *ts );
void Signal();
+
void Broadcast();
private:
- pthread_mutex_t m_mutex;
- pthread_cond_t m_condition;
+ // get the POSIX mutex associated with us
+ pthread_mutex_t *GetMutex() const { return &m_mutex.m_internal->m_mutex; }
+
+ wxMutex& m_mutex;
+ pthread_cond_t m_cond;
};
-wxConditionInternal::wxConditionInternal()
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+ : m_mutex(mutex)
{
- if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
+ if ( pthread_cond_init( &m_cond, NULL ) != 0 )
{
- // this is supposed to never happen
- wxFAIL_MSG( _T("pthread_cond_init() failed") );
+ wxLogDebug(_T("pthread_cond_init() failed"));
}
+}
- if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t*)NULL) != 0 )
+wxConditionInternal::~wxConditionInternal()
+{
+ if ( pthread_cond_destroy( &m_cond ) != 0 )
{
- // neither this
- wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
+ wxLogDebug(_T("pthread_cond_destroy() failed"));
}
+}
- // 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 )
+void wxConditionInternal::Wait()
+{
+ if ( pthread_cond_wait( &m_cond, GetMutex() ) != 0 )
{
- wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
+ wxLogDebug(_T("pthread_cond_wait() failed"));
}
}
-wxConditionInternal::~wxConditionInternal()
+bool wxConditionInternal::Wait( const timespec *ts )
{
- if ( pthread_cond_destroy( &m_condition ) != 0 )
+ int result = pthread_cond_timedwait( &m_cond, GetMutex(), ts );
+ if ( result == ETIMEDOUT )
+ return FALSE;
+
+ if ( result != 0 )
{
- wxLogDebug(_T("Failed to destroy condition variable (some "
- "threads are probably still waiting on it?)"));
+ wxLogDebug(_T("pthread_cond_timedwait() failed"));
}
- if ( pthread_mutex_unlock( &m_mutex ) != 0 )
- {
- wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
+ return TRUE;
+}
+
+void wxConditionInternal::Signal()
+{
+ int result = pthread_cond_signal( &m_cond );
+ if ( result != 0 )
+{
+ wxFAIL_MSG( _T("pthread_cond_signal() failed") );
}
+}
- if ( pthread_mutex_destroy( &m_mutex ) != 0 )
- {
- wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
+void wxConditionInternal::Broadcast()
+{
+ int result = pthread_cond_broadcast( &m_cond );
+ if ( result != 0 )
+{
+ wxFAIL_MSG( _T("pthread_cond_broadcast() failed") );
}
}
-void wxConditionInternal::Wait()
+
+// ---------------------------------------------------------------------------
+// wxCondition
+// ---------------------------------------------------------------------------
+
+wxCondition::wxCondition(wxMutex& mutex)
+{
+ m_internal = new wxConditionInternal( mutex );
+}
+
+wxCondition::~wxCondition()
+{
+ delete m_internal;
+}
+
+void wxCondition::Wait()
+{
+ m_internal->Wait();
+}
+
+bool wxCondition::Wait( unsigned long timeout_millis )
+{
+ wxLongLong curtime = wxGetLocalTimeMillis();
+ curtime += timeout_millis;
+ wxLongLong temp = curtime / 1000;
+ int sec = temp.GetLo();
+ temp = temp * 1000;
+ temp = curtime - temp;
+ int millis = temp.GetLo();
+
+ timespec tspec;
+
+ tspec.tv_sec = sec;
+ tspec.tv_nsec = millis * 1000L * 1000L;
+
+ return m_internal->Wait(&tspec);
+}
+
+void wxCondition::Signal()
+{
+ m_internal->Signal();
+}
+
+void wxCondition::Broadcast()
+{
+ m_internal->Broadcast();
+}
+
+// ===========================================================================
+// wxSemaphore implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxSemaphoreInternal
+// ---------------------------------------------------------------------------
+
+class wxSemaphoreInternal
{
- if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
+public:
+ wxSemaphoreInternal( int initialcount, int maxcount );
+
+ void Wait();
+ bool TryWait();
+
+ bool Wait( unsigned long timeout_millis );
+
+ void Post();
+
+private:
+ wxMutex m_mutex;
+ wxCondition m_cond;
+
+ int count,
+ maxcount;
+};
+
+wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount )
+ : m_cond(m_mutex)
+{
+
+ if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) )
{
- // not supposed to ever happen
- wxFAIL_MSG( _T("pthread_cond_wait() failed") );
+ wxFAIL_MSG( _T("wxSemaphore: invalid initial count") );
}
+
+ maxcount = maxcount;
+ count = initialcount;
}
-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
+void wxSemaphoreInternal::Wait()
{
- switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
+ wxMutexLocker locker(m_mutex);
+
+ while ( count <= 0 )
{
- case 0:
- // condition signaled
- return TRUE;
+ m_cond.Wait();
+ }
- default:
- wxLogDebug(_T("pthread_cond_timedwait() failed"));
+ count--;
+}
- // fall through
+bool wxSemaphoreInternal::TryWait()
+{
+ wxMutexLocker locker(m_mutex);
- case ETIMEDOUT:
- case EINTR:
- // wait interrupted or timeout elapsed
- return FALSE;
- }
+ if ( count <= 0 )
+ return FALSE;
+
+ count--;
+
+ return TRUE;
}
-void wxConditionInternal::Signal()
+bool wxSemaphoreInternal::Wait( unsigned long timeout_millis )
{
- MutexLock lock(m_mutex);
+ wxMutexLocker locker(m_mutex);
+
+ wxLongLong startTime = wxGetLocalTimeMillis();
- if ( pthread_cond_signal( &m_condition ) != 0 )
+ while ( count <= 0 )
{
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_signal() failed"));
+ wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+ long remainingTime = (long)timeout_millis - (long)elapsed.GetLo();
+ if ( remainingTime <= 0 )
+ return FALSE;
+
+ bool result = m_cond.Wait( remainingTime );
+ if ( !result )
+ return FALSE;
}
+
+ count--;
+
+ return TRUE;
}
-void wxConditionInternal::Broadcast()
+void wxSemaphoreInternal::Post()
{
- MutexLock lock(m_mutex);
+ wxMutexLocker locker(m_mutex);
- if ( pthread_cond_broadcast( &m_condition ) != 0 )
+ if ( maxcount > 0 && count == maxcount )
{
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
+ wxFAIL_MSG( _T("wxSemaphore::Post() overflow") );
}
+
+ count++;
+
+ m_cond.Signal();
}
-wxCondition::wxCondition()
+// --------------------------------------------------------------------------
+// wxSemaphore
+// --------------------------------------------------------------------------
+
+wxSemaphore::wxSemaphore( int initialcount, int maxcount )
{
- m_internal = new wxConditionInternal;
+ m_internal = new wxSemaphoreInternal( initialcount, maxcount );
}
-wxCondition::~wxCondition()
+wxSemaphore::~wxSemaphore()
{
delete m_internal;
}
-void wxCondition::Wait()
+void wxSemaphore::Wait()
{
m_internal->Wait();
}
-bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
+bool wxSemaphore::TryWait()
{
- timespec tspec;
-
- tspec.tv_sec = time(0L) + sec; // FIXME is time(0) correct here?
- tspec.tv_nsec = nsec;
-
- return m_internal->WaitWithTimeout(&tspec);
+ return m_internal->TryWait();
}
-void wxCondition::Signal()
+bool wxSemaphore::Wait( unsigned long timeout_millis )
{
- m_internal->Signal();
+ return m_internal->Wait( timeout_millis );
}
-void wxCondition::Broadcast()
+void wxSemaphore::Post()
{
- m_internal->Broadcast();
+ m_internal->Post();
}
-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+// This class is used by wxThreadInternal to support Delete() on
+// a detached thread
+class wxRefCountedCondition
+{
+public:
+ // start with a initial reference count of 1
+ wxRefCountedCondition()
+ {
+ m_refCount = 1;
+ m_signaled = FALSE;
+
+ m_mutex = new wxMutex();
+ m_cond = new wxCondition( *m_mutex );
+ }
+
+ // increment the reference count
+ void AddRef()
+ {
+ wxMutexLocker locker( *m_mutex );
+
+ m_refCount++;
+ }
+
+ // decrement the reference count if reference count is zero then delete the
+ // object
+ void DeleteRef()
+ {
+ bool shouldDelete = FALSE;
+
+ m_mutex->Lock();
+
+ if ( --m_refCount == 0 )
+ {
+ shouldDelete = TRUE;
+ }
+
+ m_mutex->Unlock();
+
+ if ( shouldDelete )
+ {
+ delete this;
+ }
+ }
+
+
+ // sets the object to signaled this signal will be a persistent signal all
+ // further Wait()s on the object will return without blocking
+ void SetSignaled()
+ {
+ wxMutexLocker locker( *m_mutex );
+
+ m_signaled = TRUE;
+
+ m_cond->Broadcast();
+ }
+
+ // wait till the object is signaled if the object was already signaled then
+ // return immediately
+ void Wait()
+ {
+ wxMutexLocker locker( *m_mutex );
+
+ if ( !m_signaled )
+ {
+ m_cond->Wait();
+ }
+ }
+
+private:
+ int m_refCount;
+
+ wxMutex *m_mutex;
+ wxCondition *m_cond;
+
+ bool m_signaled;
+
+ // Cannot delete this object directly, call DeleteRef() instead
+ ~wxRefCountedCondition()
+ {
+ delete m_cond;
+ delete m_mutex;
+ }
+
+ // suppress gcc warning about the class having private dtor and not having
+ // friend (so what??)
+ friend class wxDummyFriend;
+};
+
+// ===========================================================================
+// wxThread implementation
+// ===========================================================================
+
+// the thread callback functions must have the C linkage
+extern "C"
+{
+
+#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
void Wait();
// wake up threads waiting for our termination
void SignalExit();
+ // wake up threads waiting for our start
+ void SignalRun() { m_semRun.Post(); }
// go to sleep until Resume() is called
void Pause();
// resume the thread
void 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() { m_shouldBeJoined = m_shouldBroadcast = FALSE; }
+ void Detach()
+ {
+ m_shouldBeJoined = m_shouldBroadcast = 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
wxThreadState m_state; // see wxThreadState enum
// this flag is set when the thread should terminate
bool m_cancelled;
+ // 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;
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;
+ wxSemaphore m_semSuspend;
// finally this one is signalled when the thread exits
- wxCondition m_condEnd;
+ // we are using a reference counted condition to support
+ // Delete() for a detached thread
+ wxRefCountedCondition *m_condEnd;
};
// ----------------------------------------------------------------------------
// 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;
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
+
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
int rc = pthread_setspecific(gs_keySelf, thread);
return (void *)-1;
}
+ // have to declare this before pthread_cleanup_push() which defines a
+ // block!
+ bool dontRunAtAll;
+
#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();
- // call the main entry
- pthread->m_exitcode = thread->Entry();
+ // test whether we should run the run at all - may be it was deleted
+ // before it started to Run()?
+ {
+ wxCriticalSectionLocker lock(thread->m_critsect);
- wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
- pthread->GetId());
+ dontRunAtAll = pthread->GetState() == STATE_NEW &&
+ pthread->WasCancelled();
+ }
+ if ( !dontRunAtAll )
{
- wxCriticalSectionLocker lock(thread->m_critsect);
+ // call the main entry
+ pthread->m_exitcode = thread->Entry();
- wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
pthread->GetId());
- // change the state of the thread to "exited" so that PthreadCleanup
- // handler won't do anything from now (if it's called before we do
- // pthread_cleanup_pop below)
- pthread->SetState(STATE_EXITED);
+ {
+ wxCriticalSectionLocker lock(thread->m_critsect);
+
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
+ pthread->GetId());
+
+ // change the state of the thread to "exited" so that
+ // wxPthreadCleanup handler won't do anything from now (if it's
+ // called before we do pthread_cleanup_pop below)
+ pthread->SetState(STATE_EXITED);
+ }
}
// NB: at least under Linux, pthread_cleanup_push/pop are macros and pop
pthread_cleanup_pop(FALSE);
#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
- // terminate the thread
- thread->Exit(pthread->m_exitcode);
+ if ( dontRunAtAll )
+ {
+ delete thread;
+
+ return EXITCODE_CANCELLED;
+ }
+ else
+ {
+ // terminate the thread
+ thread->Exit(pthread->m_exitcode);
- wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
+ wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
- return NULL;
+ return NULL;
+ }
}
#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_semSuspend
+ m_isPaused = FALSE;
+
// defaults for joinable threads
m_shouldBeJoined = TRUE;
m_shouldBroadcast = TRUE;
+ m_isDetached = FALSE;
+
+ m_condEnd = new wxRefCountedCondition();
}
wxThreadInternal::~wxThreadInternal()
{
+ m_condEnd->DeleteRef();
}
wxThreadError wxThreadInternal::Run()
wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
wxT("thread may only be started once after Create()") );
- m_condRun.Signal();
+ SignalRun();
SetState(STATE_RUNNING);
if ( wxThread::IsMain() )
wxMutexGuiLeave();
+ bool isDetached = m_isDetached;
+ wxThreadIdType id = (wxThreadIdType) 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();
- // to avoid memory leaks we should call pthread_join(), but it must only
- // be done once
- wxCriticalSectionLocker lock(m_csJoinFlag);
+ // a reference counting condition is used to handle the
+ // case where a detached thread deletes itself
+ // before m_condEnd->Wait() returns
+ // in this case the deletion of the condition object is deferred until
+ // all Wait()ing threads have finished calling DeleteRef()
+ m_condEnd->AddRef();
+ m_condEnd->Wait();
+ m_condEnd->DeleteRef();
+
+ wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id);
- if ( m_shouldBeJoined )
+ // we can't use any member variables any more if the thread is detached
+ // because it could be already deleted
+ if ( !isDetached )
{
- // 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 )
+ // to avoid memory leaks we should call pthread_join(), but it must
+ // only be done once
+ wxCriticalSectionLocker lock(m_csJoinFlag);
+
+ if ( m_shouldBeJoined )
{
- wxLogError(_T("Failed to join a thread, potential memory leak "
- "detected - please restart the program"));
- }
+ // 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((pthread_t)id, &m_exitcode) != 0 )
+ {
+ wxLogError(_("Failed to join a thread, potential memory leak "
+ "detected - please restart the program"));
+ }
- m_shouldBeJoined = FALSE;
+ m_shouldBeJoined = FALSE;
+ }
}
// reacquire GUI mutex
// wake up all the threads waiting for our termination - if there are any
if ( m_shouldBroadcast )
{
- m_condEnd.Broadcast();
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
+ GetId());
+
+ m_condEnd->SetSignaled();
}
}
wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
- // wait until the condition is signaled from Resume()
- m_condSuspend.Wait();
+ // wait until the semaphore is Post()ed from Resume()
+ m_semSuspend.Wait();
}
void wxThreadInternal::Resume()
wxCHECK_RET( m_state == STATE_PAUSED,
wxT("can't resume thread which is not suspended.") );
- wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
+ // 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"), GetId());
- // wake up Pause()
- 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"),
+ GetId());
+ }
SetState(STATE_RUNNING);
}
void wxThread::Yield()
{
+#ifdef HAVE_SCHED_YIELD
sched_yield();
+#endif
}
void wxThread::Sleep(unsigned long milliseconds)
wxUsleep(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" strings
+ size_t count = s.Replace(_T("processor"), _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;
+}
+
+#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
+ 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
// -----------------------------------------------------------------------------
m_isDetached = kind == wxTHREAD_DETACHED;
}
-wxThreadError wxThread::Create()
+wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
{
if ( m_internal->GetState() != STATE_NEW )
{
wxLogError(_("Cannot retrieve thread scheduling policy."));
}
- int min_prio = sched_get_priority_min(policy),
- max_prio = sched_get_priority_max(policy),
+#ifdef __VMS__
+ /* the pthread.h contains too many spaces. This is a work-around */
+# undef sched_get_priority_max
+#undef sched_get_priority_min
+#define sched_get_priority_max(_pol_) \
+ (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
+#define sched_get_priority_min(_pol_) \
+ (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
+#endif
+
+ int max_prio = sched_get_priority_max(policy),
+ min_prio = sched_get_priority_min(policy),
prio = m_internal->GetPriority();
if ( min_prio == -1 || max_prio == -1 )
(
m_internal->GetIdPtr(),
&attr,
- wxThreadInternal::PthreadStart,
+ wxPthreadStart,
(void *)this
);
return m_internal->GetPriority();
}
-unsigned long wxThread::GetId() const
+wxThreadIdType wxThread::GetId() const
{
- return (unsigned long)m_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 ( m_internal->GetState() != STATE_RUNNING )
return wxTHREAD_NOT_RUNNING;
}
+ wxLogTrace(TRACE_THREADS, _T("Asking thread %ld to pause."),
+ GetId());
+
// just set a flag, the thread will be really paused only during the next
// call to TestDestroy()
m_internal->SetState(STATE_PAUSED);
wxThreadError wxThread::Resume()
{
- m_critsect.Enter();
+ wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+ _T("a thread can't resume itself") );
- wxThreadState state = m_internal->GetState();
+ wxCriticalSectionLocker lock(m_critsect);
- // the thread might be not actually paused yet - if there were no call to
- // TestDestroy() since the last call to Pause(), so avoid that
- // TestDestroy() deadlocks trying to enter m_critsect by leaving it before
- // calling Resume()
- m_critsect.Leave();
+ wxThreadState state = m_internal->GetState();
switch ( state )
{
case STATE_PAUSED:
- wxLogTrace(TRACE_THREADS, _T("Thread %ld is suspended, resuming."),
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
GetId());
m_internal->Resume();
wxThreadError wxThread::Delete(ExitCode *rc)
{
+ wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
+ _T("a thread can't delete itself") );
+
m_critsect.Enter();
wxThreadState state = m_internal->GetState();
switch ( state )
{
case STATE_NEW:
+ // we need to wake up the thread so that PthreadStart() will
+ // terminate - right now it's blocking on m_semRun
+ m_internal->SignalRun();
+
+ // fall through
+
case STATE_EXITED:
// nothing to do
break;
if ( m_isDetached )
{
// if we use cleanup function, this will be done from
- // PthreadCleanup()
+ // wxPthreadCleanup()
#if !HAVE_THREAD_CLEANUP_FUNCTIONS
ScheduleThreadForDeletion();
- OnExit();
+ // don't call OnExit() here, it can only be called in the
+ // threads context and we're in the context of another thread
DeleteThread(this);
#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
void wxThread::Exit(ExitCode status)
{
+ wxASSERT_MSG( This() == this,
+ _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
// also test whether we were paused
bool wxThread::TestDestroy()
{
+ wxASSERT_MSG( This() == this,
+ _T("wxThread::TestDestroy() can only be called in the "
+ "context of the same thread") );
+
m_critsect.Enter();
if ( m_internal->GetState() == STATE_PAUSED )
{
+ m_internal->SetReallyPaused(TRUE);
+
// leave the crit section or the other threads will stop too if they
// try to call any of (seemingly harmless) IsXXX() functions while we
// sleep
if ( m_internal->GetState() != STATE_EXITED &&
m_internal->GetState() != STATE_NEW )
{
- wxLogDebug(_T("The thread is being destroyed although it is still "
- "running! The application may crash."));
+ wxLogDebug(_T("The thread %ld is being destroyed although it is still "
+ "running! The application may crash."), GetId());
}
m_critsect.Leave();
// remove this thread from the global array
gs_allThreads.Remove(this);
+
+ // detached thread will decrement this counter in DeleteThread(), but it
+ // is not called for the joinable threads, so do it here
+ if ( !m_isDetached )
+ {
+ wxMutexLocker lock( *gs_mutexDeleteThread );
+
+ gs_nThreadsBeingDeleted--;
+
+ wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
+ gs_nThreadsBeingDeleted - 1);
+ }
}
// -----------------------------------------------------------------------------
gs_mutexGui->Lock();
#endif // wxUSE_GUI
+ 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 %u threads to disappear"),
+ 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("Some threads were not terminated by the application."));
+ {
+ wxLogDebug(wxT("%u threads were not terminated by the application."),
+ 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 threads waiting to be deleted"),
- gs_nThreadsBeingDeleted);
+ wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
+ 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
- {
- 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,
+ 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);
if ( !--gs_nThreadsBeingDeleted )
{
// no more threads left, signal it
gs_condAllDeleted->Signal();
-
- delete gs_condAllDeleted;
- gs_condAllDeleted = (wxCondition *)NULL;
}
}
projects / wxWidgets.git / blobdiff