#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 <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 size_t gs_nThreadsBeingDeleted = 0;
// a mutex to protect gs_nThreadsBeingDeleted
-static pthread_mutex_t gs_mutexDeleteThread = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t gs_mutexDeleteThread;
// and a condition variable which will be signaled when all
// gs_nThreadsBeingDeleted will have been deleted
{
m_internal = new wxMutexInternal;
- pthread_mutex_init(&(m_internal->m_mutex),
- (pthread_mutexattr_t*) NULL );
+ // 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_internal->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;
+#else // no recursive mutexes
+ pthread_mutex_init(&(m_internal->m_mutex), NULL);
+#endif // HAVE_PTHREAD_MUTEXATTR_T/...
+
m_locked = 0;
}
// wxCondition (Posix implementation)
//--------------------------------------------------------------------
-// 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
+// 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)
+
class wxConditionInternal
{
public:
void Signal();
void Broadcast();
+ void WaitDone();
+ bool ShouldWait();
+ bool HasWaiters();
+
private:
- pthread_mutex_t m_mutex;
- pthread_cond_t m_condition;
+ bool m_wasSignaled; // TRUE if condition was signaled while
+ // nobody waited for it
+ size_t m_nWaiters; // TRUE if someone already waits for us
+
+ pthread_mutex_t m_mutexProtect; // protects access to vars above
+
+ pthread_mutex_t m_mutex; // the mutex used with the condition
+ pthread_cond_t m_condition; // the condition itself
};
wxConditionInternal::wxConditionInternal()
{
+ 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") );
}
- if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t*)NULL) != 0 )
+ 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") );
wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
}
- if ( pthread_mutex_destroy( &m_mutex ) != 0 )
+ if ( pthread_mutex_destroy( &m_mutex ) != 0 ||
+ pthread_mutex_destroy( &m_mutexProtect ) != 0 )
{
wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
}
}
+void wxConditionInternal::WaitDone()
+{
+ MutexLock lock(m_mutexProtect);
+
+ m_wasSignaled = FALSE;
+ m_nWaiters--;
+}
+
+bool wxConditionInternal::ShouldWait()
+{
+ MutexLock lock(m_mutexProtect);
+
+ if ( m_wasSignaled )
+ {
+ // the condition was signaled before we started to wait, reset the
+ // flag and return
+ m_wasSignaled = FALSE;
+
+ return FALSE;
+ }
+
+ // we start to wait for it
+ m_nWaiters++;
+
+ return TRUE;
+}
+
+bool wxConditionInternal::HasWaiters()
+{
+ MutexLock lock(m_mutexProtect);
+
+ if ( m_nWaiters )
+ {
+ // someone waits for us, signal the condition normally
+ return TRUE;
+ }
+
+ // 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 FALSE;
+}
+
void wxConditionInternal::Wait()
{
- if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
+ if ( ShouldWait() )
{
- // not supposed to ever happen
- wxFAIL_MSG( _T("pthread_cond_wait() failed") );
+ if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
+ {
+ // not supposed to ever happen
+ wxFAIL_MSG( _T("pthread_cond_wait() failed") );
+ }
}
+
+ WaitDone();
}
bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
{
- switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
+ bool ok;
+
+ if ( ShouldWait() )
{
- case 0:
- // condition signaled
- return TRUE;
+ switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
+ {
+ case 0:
+ // condition signaled
+ ok = TRUE;
+ break;
- default:
- wxLogDebug(_T("pthread_cond_timedwait() failed"));
+ default:
+ wxLogDebug(_T("pthread_cond_timedwait() failed"));
- // fall through
+ // fall through
- case ETIMEDOUT:
- case EINTR:
- // wait interrupted or timeout elapsed
- return FALSE;
+ case ETIMEDOUT:
+ case EINTR:
+ // wait interrupted or timeout elapsed
+ ok = FALSE;
+ }
+ }
+ else
+ {
+ // the condition had already been signaled before
+ ok = TRUE;
}
+
+ WaitDone();
+
+ return ok;
}
void wxConditionInternal::Signal()
{
- MutexLock lock(m_mutex);
-
- if ( pthread_cond_signal( &m_condition ) != 0 )
+ if ( HasWaiters() )
{
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_signal() failed"));
+ MutexLock lock(m_mutex);
+
+ if ( pthread_cond_signal( &m_condition ) != 0 )
+ {
+ // shouldn't ever happen
+ wxFAIL_MSG(_T("pthread_cond_signal() failed"));
+ }
}
}
void wxConditionInternal::Broadcast()
{
- MutexLock lock(m_mutex);
-
- if ( pthread_cond_broadcast( &m_condition ) != 0 )
+ if ( HasWaiters() )
{
- // shouldn't ever happen
- wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
+ MutexLock lock(m_mutex);
+
+ if ( pthread_cond_broadcast( &m_condition ) != 0 )
+ {
+ // shouldn't ever happen
+ wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
+ }
}
}
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 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; }
// this flag is set when the thread should terminate
bool m_cancelled;
+ // this flag is set when the thread is blocking on m_condSuspend
+ 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
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
// wait for the condition to be signaled from Run()
pthread->m_condRun.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
+ // PthreadCleanup 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
m_threadId = 0;
m_exitcode = 0;
+ // set to TRUE only when the thread starts waiting on m_condSuspend
+ m_isPaused = FALSE;
+
// defaults for joinable threads
m_shouldBeJoined = TRUE;
m_shouldBroadcast = TRUE;
+ m_isDetached = FALSE;
}
wxThreadInternal::~wxThreadInternal()
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;
+#ifdef __VMS
+ long long id = (long long)GetId();
+#else
+ long id = (long)GetId();
+#endif
+ wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
+ id);
+
// wait until the thread terminates (we're blocking in _another_ thread,
// of course)
m_condEnd.Wait();
- // to avoid memory leaks we should call pthread_join(), but it must only
- // be done once
- wxCriticalSectionLocker lock(m_csJoinFlag);
+ 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 )
{
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
+ GetId());
+
m_condEnd.Broadcast();
}
}
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_condSuspend.Signal();
+ // 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;
+}
+
+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
// -----------------------------------------------------------------------------
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 )
return m_internal->GetPriority();
}
+#ifdef __VMS
+unsigned long long wxThread::GetId() const
+{
+ return (unsigned long long)m_internal->GetId();
+#else
unsigned long wxThread::GetId() const
{
return (unsigned long)m_internal->GetId();
+#endif
}
// -----------------------------------------------------------------------------
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_condRun
+ m_internal->SignalRun();
+
+ // fall through
+
case STATE_EXITED:
// nothing to do
break;
#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 )
+ {
+ 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);
+
return TRUE;
}
// 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++ )
{
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)
"one?") );
}
+ wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
+ gs_nThreadsBeingDeleted - 1);
+
if ( !--gs_nThreadsBeingDeleted )
{
// no more threads left, signal it
projects / wxWidgets.git / blobdiff