// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "thread.h"
-#endif
-
-#include "wx/defs.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
#if wxUSE_THREADS
#include "wx/intl.h"
#include "wx/dynarray.h"
#include "wx/timer.h"
+#include "wx/stopwatch.h"
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <time.h>
-#if HAVE_SCHED_H
+#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
#include <sys/resource.h>
#endif
+#ifdef __VMS
+ #define THR_ID(thr) ((long long)(thr)->GetId())
+#else
+ #define THR_ID(thr) ((long)(thr)->GetId())
+#endif
+
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// an (non owning) array of pointers to threads
-WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
// an entry for a thread we can wait for
static wxArrayThread gs_allThreads;
// the id of the main thread
-static pthread_t gs_tidMain;
+static pthread_t gs_tidMain = (pthread_t)-1;
// the key for the pointer to the associated wxThread object
static pthread_key_t gs_keySelf;
// gs_nThreadsBeingDeleted will have been deleted
static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
-#if wxUSE_GUI
- // this mutex must be acquired before any call to a GUI function
- static wxMutex *gs_mutexGui;
-#endif // wxUSE_GUI
+// this mutex must be acquired before any call to a GUI function
+// (it's not inside #if wxUSE_GUI because this file is compiled as part
+// of wxBase)
+static wxMutex *gs_mutexGui = NULL;
// 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
friend class wxConditionInternal;
};
-#ifdef HAVE_PTHREAD_MUTEXATTR_T
+#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
+ wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
// on some systems pthread_mutexattr_settype() is not in the headers (but it is
// in the library, otherwise we wouldn't compile this code at all)
extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
while ( m_count == 0 )
{
wxLogTrace(TRACE_SEMA,
- "Thread %ld waiting for semaphore to become signalled",
+ _T("Thread %ld waiting for semaphore to become signalled"),
wxThread::GetCurrentId());
if ( m_cond.Wait() != wxCOND_NO_ERROR )
return wxSEMA_MISC_ERROR;
wxLogTrace(TRACE_SEMA,
- "Thread %ld finished waiting for semaphore, count = %lu",
+ _T("Thread %ld finished waiting for semaphore, count = %lu"),
wxThread::GetCurrentId(), (unsigned long)m_count);
}
m_count++;
wxLogTrace(TRACE_SEMA,
- "Thread %ld about to signal semaphore, count = %lu",
+ _T("Thread %ld about to signal semaphore, count = %lu"),
wxThread::GetCurrentId(), (unsigned long)m_count);
return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
extern "C"
{
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// thread exit function
void wxPthreadCleanup(void *ptr);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
void *wxPthreadStart(void *ptr);
m_isDetached = TRUE;
}
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// this is used by wxPthreadCleanup() only
static void Cleanup(wxThread *thread);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
private:
pthread_t m_threadId; // id of the thread
wxThreadState m_state; // see wxThreadState enum
- int m_prio; // in wxWindows units: from 0 to 100
+ int m_prio; // in wxWidgets units: from 0 to 100
// this flag is set when the thread should terminate
bool m_cancelled;
{
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
-
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread));
+
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
int rc = pthread_setspecific(gs_keySelf, thread);
// block!
bool dontRunAtAll;
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// install the cleanup handler which will be called if the thread is
// cancelled
pthread_cleanup_push(wxPthreadCleanup, thread);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
// wait for the semaphore to be posted from Run()
pthread->m_semRun.Wait();
if ( !dontRunAtAll )
{
// call the main entry
- wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."),
-#ifdef __VMS
- (long long)pthread->GetId());
-#else
- (long)pthread->GetId());
-#endif
-
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld about to enter its Entry()."),
+ THR_ID(pthread));
+
pthread->m_exitcode = thread->Entry();
- wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."),
-#ifdef __VMS
- (long long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
-#else
- (long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
-#endif
-
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld Entry() returned %lu."),
+ THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+
{
wxCriticalSectionLocker lock(thread->m_critsect);
// NB: at least under Linux, pthread_cleanup_push/pop are macros and pop
// contains the matching '}' for the '{' in push, so they must be used
// in the same block!
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// remove the cleanup handler without executing it
pthread_cleanup_pop(FALSE);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
if ( dontRunAtAll )
{
}
}
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
// this handler is called when the thread is cancelled
extern "C" void wxPthreadCleanup(void *ptr)
thread->Exit(EXITCODE_CANCELLED);
}
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
// ----------------------------------------------------------------------------
// wxThreadInternal
wxMutexGuiLeave();
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
-
+ _T("Starting to wait for thread %ld to exit."),
+ THR_ID(this));
+
// 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
{
// 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"));
+ wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
}
m_shouldBeJoined = FALSE;
wxCHECK_RET( m_state == STATE_PAUSED,
wxT("thread must first be paused with wxThread::Pause().") );
-#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
-
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld goes to sleep."), THR_ID(this));
+
// wait until the semaphore is Post()ed from Resume()
m_semSuspend.Wait();
}
// TestDestroy() since the last call to Pause() for example
if ( IsReallyPaused() )
{
-#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
-
+ wxLogTrace(TRACE_THREADS,
+ _T("Waking up thread %ld"), THR_ID(this));
+
// wake up Pause()
m_semSuspend.Post();
}
else
{
- wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
-#ifdef __VMS
- (long long)GetId());
-#else
- (long)GetId());
-#endif
+ wxLogTrace(TRACE_THREADS,
+ _T("Thread %ld is not yet really paused"), THR_ID(this));
}
SetState(STATE_RUNNING);
bool wxThread::IsMain()
{
- return (bool)pthread_equal(pthread_self(), gs_tidMain);
+ return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1;
}
void wxThread::Yield()
void wxThread::Sleep(unsigned long milliseconds)
{
- wxUsleep(milliseconds);
+ wxMilliSleep(milliseconds);
}
int wxThread::GetCPUCount()
return -1;
}
+// VMS is a 64 bit system and threads have 64 bit pointers.
+// FIXME: also needed for other systems????
#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
+}
+
+#else // !__VMS
+
unsigned long wxThread::GetCurrentId()
{
return (unsigned long)pthread_self();
-#endif
}
+#endif // __VMS/!__VMS
+
+
bool wxThread::SetConcurrency(size_t level)
{
#ifdef HAVE_THR_SETCONCURRENCY
m_isDetached = kind == wxTHREAD_DETACHED;
}
-wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+ #define WXUNUSED_STACKSIZE(identifier) identifier
+#else
+ #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier)
+#endif
+
+wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))
{
if ( m_internal->GetState() != STATE_NEW )
{
pthread_attr_t attr;
pthread_attr_init(&attr);
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+ if (stackSize)
+ pthread_attr_setstacksize(&attr, stackSize);
+#endif
+
#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
int policy;
if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
return wxTHREAD_NO_RESOURCE;
}
- m_internal->SetState( STATE_NEW );
-
return wxTHREAD_NO_ERROR;
}
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;
+ // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
+ // a priority other than 0. Instead, we use the BSD setpriority
+ // which alllows us to set a 'nice' value between 20 to -20. Only
+ // super user can set a value less than zero (more negative yields
+ // higher priority). setpriority set the static priority of a
+ // process, but this is OK since Linux is configured as a thread
+ // per process.
+ //
+ // FIXME this is not true for 2.6!!
- if (setpriority(PRIO_PROCESS, 0, iPrio) == -1)
- {
- wxLogError(_("Failed to set thread priority %d."), prio);
- }
+ // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
+ // to Unix priorities 20..-20
+ if ( setpriority(PRIO_PROCESS, 0, -(2*prio)/5 + 20) == -1 )
+ {
+ wxLogError(_("Failed to set thread priority %d."), prio);
}
#else // __LINUX__
{
{
// if we use cleanup function, this will be done from
// wxPthreadCleanup()
-#if !HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifndef wxHAVE_PTHREAD_CLEANUP
ScheduleThreadForDeletion();
// don't call OnExit() here, it can only be called in the
// threads context and we're in the context of another thread
DeleteThread(this);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
}
else
{
void wxThread::Exit(ExitCode status)
{
wxASSERT_MSG( This() == this,
- _T("wxThread::Exit() can only be called in the "
- "context of the same thread") );
+ _T("wxThread::Exit() can only be called in the context of the same thread") );
if ( m_isDetached )
{
// only call one thread function at a time :-(
DeleteThread(this);
}
+ else
+ {
+ m_critsect.Enter();
+ m_internal->SetState(STATE_EXITED);
+ m_critsect.Leave();
+ }
// terminate the thread (pthread_exit() never returns)
pthread_exit(status);
bool wxThread::TestDestroy()
{
wxASSERT_MSG( This() == this,
- _T("wxThread::TestDestroy() can only be called in the "
- "context of the same thread") );
+ _T("wxThread::TestDestroy() can only be called in the context of the same thread") );
m_critsect.Enter();
if ( m_internal->GetState() != STATE_EXITED &&
m_internal->GetState() != STATE_NEW )
{
- wxLogDebug(_T("The thread %ld is being destroyed although it is still "
- "running! The application may crash."), GetId());
+ wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."),
+ (long)GetId());
}
m_critsect.Leave();
int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
if ( rc != 0 )
{
- wxLogSysError(rc, _("Thread module initialization failed: "
- "failed to create thread key"));
+ wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
return FALSE;
}
gs_tidMain = pthread_self();
-#if wxUSE_GUI
gs_mutexGui = new wxMutex();
-
gs_mutexGui->Lock();
-#endif // wxUSE_GUI
gs_mutexDeleteThread = new wxMutex();
gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );
gs_allThreads[0]->Delete();
}
-#if wxUSE_GUI
// destroy GUI mutex
gs_mutexGui->Unlock();
-
delete gs_mutexGui;
-#endif // wxUSE_GUI
// and free TLD slot
(void)pthread_key_delete(gs_keySelf);
void wxMutexGuiEnter()
{
-#if wxUSE_GUI
gs_mutexGui->Lock();
-#endif // wxUSE_GUI
}
void wxMutexGuiLeave()
{
-#if wxUSE_GUI
gs_mutexGui->Unlock();
-#endif // wxUSE_GUI
}
// ----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff