1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/unix/threadpsx.cpp
3 // Purpose: wxThread (Posix) Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux
5 // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
8 // Copyright: (c) Wolfram Gloger (1996, 1997)
9 // Guilhem Lavaux (1998)
10 // Vadim Zeitlin (1999-2002)
11 // Robert Roebling (1999)
12 // K. S. Sreeram (2002)
13 // Licence: wxWindows licence
14 /////////////////////////////////////////////////////////////////////////////
16 // ============================================================================
18 // ============================================================================
20 // ----------------------------------------------------------------------------
22 // ----------------------------------------------------------------------------
24 // for compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
29 #include "wx/thread.h"
30 #include "wx/except.h"
34 #include "wx/dynarray.h"
39 #include "wx/stopwatch.h"
40 #include "wx/module.h"
52 #ifdef HAVE_THR_SETCONCURRENCY
56 // we use wxFFile under Linux in GetCPUCount()
61 #include <sys/resource.h>
65 #define THR_ID(thr) ((long long)(thr)->GetId())
67 #define THR_ID(thr) ((long)(thr)->GetId())
70 // ----------------------------------------------------------------------------
72 // ----------------------------------------------------------------------------
74 // the possible states of the thread and transitions from them
77 STATE_NEW
, // didn't start execution yet (=> RUNNING)
78 STATE_RUNNING
, // running (=> PAUSED or EXITED)
79 STATE_PAUSED
, // suspended (=> RUNNING or EXITED)
80 STATE_EXITED
// thread doesn't exist any more
83 // the exit value of a thread which has been cancelled
84 static const wxThread::ExitCode EXITCODE_CANCELLED
= (wxThread::ExitCode
)-1;
86 // trace mask for wxThread operations
87 #define TRACE_THREADS _T("thread")
89 // you can get additional debugging messages for the semaphore operations
90 #define TRACE_SEMA _T("semaphore")
92 // ----------------------------------------------------------------------------
94 // ----------------------------------------------------------------------------
96 static void ScheduleThreadForDeletion();
97 static void DeleteThread(wxThread
*This
);
99 // ----------------------------------------------------------------------------
101 // ----------------------------------------------------------------------------
103 // an (non owning) array of pointers to threads
104 WX_DEFINE_ARRAY_PTR(wxThread
*, wxArrayThread
);
106 // an entry for a thread we can wait for
108 // -----------------------------------------------------------------------------
110 // -----------------------------------------------------------------------------
112 // we keep the list of all threads created by the application to be able to
113 // terminate them on exit if there are some left - otherwise the process would
115 static wxArrayThread gs_allThreads
;
117 // a mutex to protect gs_allThreads
118 static wxMutex
*gs_mutexAllThreads
= NULL
;
120 // the id of the main thread
121 static pthread_t gs_tidMain
= (pthread_t
)-1;
123 // the key for the pointer to the associated wxThread object
124 static pthread_key_t gs_keySelf
;
126 // the number of threads which are being deleted - the program won't exit
127 // until there are any left
128 static size_t gs_nThreadsBeingDeleted
= 0;
130 // a mutex to protect gs_nThreadsBeingDeleted
131 static wxMutex
*gs_mutexDeleteThread
= NULL
;
133 // and a condition variable which will be signaled when all
134 // gs_nThreadsBeingDeleted will have been deleted
135 static wxCondition
*gs_condAllDeleted
= NULL
;
137 // this mutex must be acquired before any call to a GUI function
138 // (it's not inside #if wxUSE_GUI because this file is compiled as part
140 static wxMutex
*gs_mutexGui
= NULL
;
142 // when we wait for a thread to exit, we're blocking on a condition which the
143 // thread signals in its SignalExit() method -- but this condition can't be a
144 // member of the thread itself as a detached thread may delete itself at any
145 // moment and accessing the condition member of the thread after this would
146 // result in a disaster
148 // so instead we maintain a global list of the structs below for the threads
149 // we're interested in waiting on
151 // ============================================================================
152 // wxMutex implementation
153 // ============================================================================
155 // ----------------------------------------------------------------------------
157 // ----------------------------------------------------------------------------
159 // this is a simple wrapper around pthread_mutex_t which provides error
161 class wxMutexInternal
164 wxMutexInternal(wxMutexType mutexType
);
168 wxMutexError
Lock(unsigned long ms
);
169 wxMutexError
TryLock();
170 wxMutexError
Unlock();
172 bool IsOk() const { return m_isOk
; }
175 // convert the result of pthread_mutex_[timed]lock() call to wx return code
176 wxMutexError
HandleLockResult(int err
);
179 pthread_mutex_t m_mutex
;
182 unsigned long m_owningThread
;
184 // wxConditionInternal uses our m_mutex
185 friend class wxConditionInternal
;
188 #if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
189 wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
190 // on some systems pthread_mutexattr_settype() is not in the headers (but it is
191 // in the library, otherwise we wouldn't compile this code at all)
192 extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t
*, int);
195 wxMutexInternal::wxMutexInternal(wxMutexType mutexType
)
203 case wxMUTEX_RECURSIVE
:
204 // support recursive locks like Win32, i.e. a thread can lock a
205 // mutex which it had itself already locked
207 // unfortunately initialization of recursive mutexes is non
208 // portable, so try several methods
209 #ifdef HAVE_PTHREAD_MUTEXATTR_T
211 pthread_mutexattr_t attr
;
212 pthread_mutexattr_init(&attr
);
213 pthread_mutexattr_settype(&attr
, PTHREAD_MUTEX_RECURSIVE
);
215 err
= pthread_mutex_init(&m_mutex
, &attr
);
217 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
218 // we can use this only as initializer so we have to assign it
219 // first to a temp var - assigning directly to m_mutex wouldn't
222 pthread_mutex_t mutex
= PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
;
225 #else // no recursive mutexes
227 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
231 wxFAIL_MSG( _T("unknown mutex type") );
234 case wxMUTEX_DEFAULT
:
235 err
= pthread_mutex_init(&m_mutex
, NULL
);
242 wxLogApiError( wxT("pthread_mutex_init()"), err
);
246 wxMutexInternal::~wxMutexInternal()
250 int err
= pthread_mutex_destroy(&m_mutex
);
253 wxLogApiError( wxT("pthread_mutex_destroy()"), err
);
258 wxMutexError
wxMutexInternal::Lock()
260 if ((m_type
== wxMUTEX_DEFAULT
) && (m_owningThread
!= 0))
262 if (m_owningThread
== wxThread::GetCurrentId())
263 return wxMUTEX_DEAD_LOCK
;
266 return HandleLockResult(pthread_mutex_lock(&m_mutex
));
269 wxMutexError
wxMutexInternal::Lock(unsigned long ms
)
271 #ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
272 static const long MSEC_IN_SEC
= 1000;
273 static const long NSEC_IN_MSEC
= 1000000;
274 static const long NSEC_IN_USEC
= 1000;
275 static const long NSEC_IN_SEC
= MSEC_IN_SEC
* NSEC_IN_MSEC
;
277 time_t seconds
= ms
/MSEC_IN_SEC
;
278 long nanoseconds
= (ms
% MSEC_IN_SEC
) * NSEC_IN_MSEC
;
279 timespec ts
= { 0, 0 };
281 // normally we should use clock_gettime(CLOCK_REALTIME) here but this
282 // function is in librt and we don't link with it currently, so use
283 // gettimeofday() instead -- if it turns out that this is really too
284 // imprecise, we should modify configure to check if clock_gettime() is
285 // available and whether it requires -lrt and use it instead
287 if ( clock_gettime(CLOCK_REALTIME
, &ts
) == 0 )
292 if ( wxGetTimeOfDay(&tv
) != -1 )
294 ts
.tv_sec
= tv
.tv_sec
;
295 ts
.tv_nsec
= tv
.tv_usec
*NSEC_IN_USEC
;
298 else // fall back on system timer
300 ts
.tv_sec
= time(NULL
);
303 ts
.tv_sec
+= seconds
;
304 ts
.tv_nsec
+= nanoseconds
;
305 if ( ts
.tv_nsec
> NSEC_IN_SEC
)
308 ts
.tv_nsec
-= NSEC_IN_SEC
;
311 return HandleLockResult(pthread_mutex_timedlock(&m_mutex
, &ts
));
312 #else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
315 return wxMUTEX_MISC_ERROR
;
316 #endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
319 wxMutexError
wxMutexInternal::HandleLockResult(int err
)
321 // wxPrintf( "err %d\n", err );
326 // only error checking mutexes return this value and so it's an
327 // unexpected situation -- hence use assert, not wxLogDebug
328 wxFAIL_MSG( _T("mutex deadlock prevented") );
329 return wxMUTEX_DEAD_LOCK
;
332 wxLogDebug(_T("pthread_mutex_[timed]lock(): mutex not initialized"));
336 return wxMUTEX_TIMEOUT
;
339 if (m_type
== wxMUTEX_DEFAULT
)
340 m_owningThread
= wxThread::GetCurrentId();
341 return wxMUTEX_NO_ERROR
;
344 wxLogApiError(_T("pthread_mutex_[timed]lock()"), err
);
347 return wxMUTEX_MISC_ERROR
;
351 wxMutexError
wxMutexInternal::TryLock()
353 int err
= pthread_mutex_trylock(&m_mutex
);
357 // not an error: mutex is already locked, but we're prepared for
362 wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
366 if (m_type
== wxMUTEX_DEFAULT
)
367 m_owningThread
= wxThread::GetCurrentId();
368 return wxMUTEX_NO_ERROR
;
371 wxLogApiError(_T("pthread_mutex_trylock()"), err
);
374 return wxMUTEX_MISC_ERROR
;
377 wxMutexError
wxMutexInternal::Unlock()
381 int err
= pthread_mutex_unlock(&m_mutex
);
385 // we don't own the mutex
386 return wxMUTEX_UNLOCKED
;
389 wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
393 return wxMUTEX_NO_ERROR
;
396 wxLogApiError(_T("pthread_mutex_unlock()"), err
);
399 return wxMUTEX_MISC_ERROR
;
402 // ===========================================================================
403 // wxCondition implementation
404 // ===========================================================================
406 // ---------------------------------------------------------------------------
407 // wxConditionInternal
408 // ---------------------------------------------------------------------------
410 // this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
411 // with a pthread_mutex_t)
412 class wxConditionInternal
415 wxConditionInternal(wxMutex
& mutex
);
416 ~wxConditionInternal();
418 bool IsOk() const { return m_isOk
&& m_mutex
.IsOk(); }
421 wxCondError
WaitTimeout(unsigned long milliseconds
);
423 wxCondError
Signal();
424 wxCondError
Broadcast();
427 // get the POSIX mutex associated with us
428 pthread_mutex_t
*GetPMutex() const { return &m_mutex
.m_internal
->m_mutex
; }
431 pthread_cond_t m_cond
;
436 wxConditionInternal::wxConditionInternal(wxMutex
& mutex
)
439 int err
= pthread_cond_init(&m_cond
, NULL
/* default attributes */);
445 wxLogApiError(_T("pthread_cond_init()"), err
);
449 wxConditionInternal::~wxConditionInternal()
453 int err
= pthread_cond_destroy(&m_cond
);
456 wxLogApiError(_T("pthread_cond_destroy()"), err
);
461 wxCondError
wxConditionInternal::Wait()
463 int err
= pthread_cond_wait(&m_cond
, GetPMutex());
466 wxLogApiError(_T("pthread_cond_wait()"), err
);
468 return wxCOND_MISC_ERROR
;
471 return wxCOND_NO_ERROR
;
474 wxCondError
wxConditionInternal::WaitTimeout(unsigned long milliseconds
)
476 wxLongLong curtime
= wxGetLocalTimeMillis();
477 curtime
+= milliseconds
;
478 wxLongLong temp
= curtime
/ 1000;
479 int sec
= temp
.GetLo();
481 temp
= curtime
- temp
;
482 int millis
= temp
.GetLo();
487 tspec
.tv_nsec
= millis
* 1000L * 1000L;
489 int err
= pthread_cond_timedwait( &m_cond
, GetPMutex(), &tspec
);
493 return wxCOND_TIMEOUT
;
496 return wxCOND_NO_ERROR
;
499 wxLogApiError(_T("pthread_cond_timedwait()"), err
);
502 return wxCOND_MISC_ERROR
;
505 wxCondError
wxConditionInternal::Signal()
507 int err
= pthread_cond_signal(&m_cond
);
510 wxLogApiError(_T("pthread_cond_signal()"), err
);
512 return wxCOND_MISC_ERROR
;
515 return wxCOND_NO_ERROR
;
518 wxCondError
wxConditionInternal::Broadcast()
520 int err
= pthread_cond_broadcast(&m_cond
);
523 wxLogApiError(_T("pthread_cond_broadcast()"), err
);
525 return wxCOND_MISC_ERROR
;
528 return wxCOND_NO_ERROR
;
531 // ===========================================================================
532 // wxSemaphore implementation
533 // ===========================================================================
535 // ---------------------------------------------------------------------------
536 // wxSemaphoreInternal
537 // ---------------------------------------------------------------------------
539 // we implement the semaphores using mutexes and conditions instead of using
540 // the sem_xxx() POSIX functions because they're not widely available and also
541 // because it's impossible to implement WaitTimeout() using them
542 class wxSemaphoreInternal
545 wxSemaphoreInternal(int initialcount
, int maxcount
);
547 bool IsOk() const { return m_isOk
; }
550 wxSemaError
TryWait();
551 wxSemaError
WaitTimeout(unsigned long milliseconds
);
565 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount
, int maxcount
)
569 if ( (initialcount
< 0 || maxcount
< 0) ||
570 ((maxcount
> 0) && (initialcount
> maxcount
)) )
572 wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
578 m_maxcount
= (size_t)maxcount
;
579 m_count
= (size_t)initialcount
;
582 m_isOk
= m_mutex
.IsOk() && m_cond
.IsOk();
585 wxSemaError
wxSemaphoreInternal::Wait()
587 wxMutexLocker
locker(m_mutex
);
589 while ( m_count
== 0 )
591 wxLogTrace(TRACE_SEMA
,
592 _T("Thread %ld waiting for semaphore to become signalled"),
593 wxThread::GetCurrentId());
595 if ( m_cond
.Wait() != wxCOND_NO_ERROR
)
596 return wxSEMA_MISC_ERROR
;
598 wxLogTrace(TRACE_SEMA
,
599 _T("Thread %ld finished waiting for semaphore, count = %lu"),
600 wxThread::GetCurrentId(), (unsigned long)m_count
);
605 return wxSEMA_NO_ERROR
;
608 wxSemaError
wxSemaphoreInternal::TryWait()
610 wxMutexLocker
locker(m_mutex
);
617 return wxSEMA_NO_ERROR
;
620 wxSemaError
wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds
)
622 wxMutexLocker
locker(m_mutex
);
624 wxLongLong startTime
= wxGetLocalTimeMillis();
626 while ( m_count
== 0 )
628 wxLongLong elapsed
= wxGetLocalTimeMillis() - startTime
;
629 long remainingTime
= (long)milliseconds
- (long)elapsed
.GetLo();
630 if ( remainingTime
<= 0 )
633 return wxSEMA_TIMEOUT
;
636 switch ( m_cond
.WaitTimeout(remainingTime
) )
639 return wxSEMA_TIMEOUT
;
642 return wxSEMA_MISC_ERROR
;
644 case wxCOND_NO_ERROR
:
651 return wxSEMA_NO_ERROR
;
654 wxSemaError
wxSemaphoreInternal::Post()
656 wxMutexLocker
locker(m_mutex
);
658 if ( m_maxcount
> 0 && m_count
== m_maxcount
)
660 return wxSEMA_OVERFLOW
;
665 wxLogTrace(TRACE_SEMA
,
666 _T("Thread %ld about to signal semaphore, count = %lu"),
667 wxThread::GetCurrentId(), (unsigned long)m_count
);
669 return m_cond
.Signal() == wxCOND_NO_ERROR
? wxSEMA_NO_ERROR
673 // ===========================================================================
674 // wxThread implementation
675 // ===========================================================================
677 // the thread callback functions must have the C linkage
681 #ifdef wxHAVE_PTHREAD_CLEANUP
682 // thread exit function
683 void wxPthreadCleanup(void *ptr
);
684 #endif // wxHAVE_PTHREAD_CLEANUP
686 void *wxPthreadStart(void *ptr
);
690 // ----------------------------------------------------------------------------
692 // ----------------------------------------------------------------------------
694 class wxThreadInternal
700 // thread entry function
701 static void *PthreadStart(wxThread
*thread
);
706 // unblock the thread allowing it to run
707 void SignalRun() { m_semRun
.Post(); }
708 // ask the thread to terminate
710 // go to sleep until Resume() is called
717 int GetPriority() const { return m_prio
; }
718 void SetPriority(int prio
) { m_prio
= prio
; }
720 wxThreadState
GetState() const { return m_state
; }
721 void SetState(wxThreadState state
)
724 static const wxChar
*stateNames
[] =
732 wxLogTrace(TRACE_THREADS
, _T("Thread %ld: %s => %s."),
733 (long)GetId(), stateNames
[m_state
], stateNames
[state
]);
734 #endif // __WXDEBUG__
739 pthread_t
GetId() const { return m_threadId
; }
740 pthread_t
*GetIdPtr() { return &m_threadId
; }
742 void SetCancelFlag() { m_cancelled
= true; }
743 bool WasCancelled() const { return m_cancelled
; }
745 void SetExitCode(wxThread::ExitCode exitcode
) { m_exitcode
= exitcode
; }
746 wxThread::ExitCode
GetExitCode() const { return m_exitcode
; }
749 void SetReallyPaused(bool paused
) { m_isPaused
= paused
; }
750 bool IsReallyPaused() const { return m_isPaused
; }
752 // tell the thread that it is a detached one
755 wxCriticalSectionLocker
lock(m_csJoinFlag
);
757 m_shouldBeJoined
= false;
761 #ifdef wxHAVE_PTHREAD_CLEANUP
762 // this is used by wxPthreadCleanup() only
763 static void Cleanup(wxThread
*thread
);
764 #endif // wxHAVE_PTHREAD_CLEANUP
767 pthread_t m_threadId
; // id of the thread
768 wxThreadState m_state
; // see wxThreadState enum
769 int m_prio
; // in wxWidgets units: from 0 to 100
771 // this flag is set when the thread should terminate
774 // this flag is set when the thread is blocking on m_semSuspend
777 // the thread exit code - only used for joinable (!detached) threads and
778 // is only valid after the thread termination
779 wxThread::ExitCode m_exitcode
;
781 // many threads may call Wait(), but only one of them should call
782 // pthread_join(), so we have to keep track of this
783 wxCriticalSection m_csJoinFlag
;
784 bool m_shouldBeJoined
;
787 // this semaphore is posted by Run() and the threads Entry() is not
788 // called before it is done
789 wxSemaphore m_semRun
;
791 // this one is signaled when the thread should resume after having been
793 wxSemaphore m_semSuspend
;
796 // ----------------------------------------------------------------------------
797 // thread startup and exit functions
798 // ----------------------------------------------------------------------------
800 void *wxPthreadStart(void *ptr
)
802 return wxThreadInternal::PthreadStart((wxThread
*)ptr
);
805 void *wxThreadInternal::PthreadStart(wxThread
*thread
)
807 wxThreadInternal
*pthread
= thread
->m_internal
;
809 wxLogTrace(TRACE_THREADS
, _T("Thread %ld started."), THR_ID(pthread
));
811 // associate the thread pointer with the newly created thread so that
812 // wxThread::This() will work
813 int rc
= pthread_setspecific(gs_keySelf
, thread
);
816 wxLogSysError(rc
, _("Cannot start thread: error writing TLS"));
821 // have to declare this before pthread_cleanup_push() which defines a
825 #ifdef wxHAVE_PTHREAD_CLEANUP
826 // install the cleanup handler which will be called if the thread is
828 pthread_cleanup_push(wxPthreadCleanup
, thread
);
829 #endif // wxHAVE_PTHREAD_CLEANUP
831 // wait for the semaphore to be posted from Run()
832 pthread
->m_semRun
.Wait();
834 // test whether we should run the run at all - may be it was deleted
835 // before it started to Run()?
837 wxCriticalSectionLocker
lock(thread
->m_critsect
);
839 dontRunAtAll
= pthread
->GetState() == STATE_NEW
&&
840 pthread
->WasCancelled();
845 // call the main entry
846 wxLogTrace(TRACE_THREADS
,
847 _T("Thread %ld about to enter its Entry()."),
852 pthread
->m_exitcode
= thread
->Entry();
854 wxLogTrace(TRACE_THREADS
,
855 _T("Thread %ld Entry() returned %lu."),
856 THR_ID(pthread
), wxPtrToUInt(pthread
->m_exitcode
));
858 wxCATCH_ALL( wxTheApp
->OnUnhandledException(); )
861 wxCriticalSectionLocker
lock(thread
->m_critsect
);
863 // change the state of the thread to "exited" so that
864 // wxPthreadCleanup handler won't do anything from now (if it's
865 // called before we do pthread_cleanup_pop below)
866 pthread
->SetState(STATE_EXITED
);
870 // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
871 // '}' for the '{' in push, so they must be used in the same block!
872 #ifdef wxHAVE_PTHREAD_CLEANUP
874 // under Tru64 we get a warning from macro expansion
876 #pragma message disable(declbutnotref)
879 // remove the cleanup handler without executing it
880 pthread_cleanup_pop(FALSE
);
883 #pragma message restore
885 #endif // wxHAVE_PTHREAD_CLEANUP
889 // FIXME: deleting a possibly joinable thread here???
892 return EXITCODE_CANCELLED
;
896 // terminate the thread
897 thread
->Exit(pthread
->m_exitcode
);
899 wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
905 #ifdef wxHAVE_PTHREAD_CLEANUP
907 // this handler is called when the thread is cancelled
908 extern "C" void wxPthreadCleanup(void *ptr
)
910 wxThreadInternal::Cleanup((wxThread
*)ptr
);
913 void wxThreadInternal::Cleanup(wxThread
*thread
)
915 if (pthread_getspecific(gs_keySelf
) == 0) return;
917 wxCriticalSectionLocker
lock(thread
->m_critsect
);
918 if ( thread
->m_internal
->GetState() == STATE_EXITED
)
920 // thread is already considered as finished.
925 // exit the thread gracefully
926 thread
->Exit(EXITCODE_CANCELLED
);
929 #endif // wxHAVE_PTHREAD_CLEANUP
931 // ----------------------------------------------------------------------------
933 // ----------------------------------------------------------------------------
935 wxThreadInternal::wxThreadInternal()
939 m_prio
= WXTHREAD_DEFAULT_PRIORITY
;
943 // set to true only when the thread starts waiting on m_semSuspend
946 // defaults for joinable threads
947 m_shouldBeJoined
= true;
948 m_isDetached
= false;
951 wxThreadInternal::~wxThreadInternal()
955 wxThreadError
wxThreadInternal::Run()
957 wxCHECK_MSG( GetState() == STATE_NEW
, wxTHREAD_RUNNING
,
958 wxT("thread may only be started once after Create()") );
960 SetState(STATE_RUNNING
);
962 // wake up threads waiting for our start
965 return wxTHREAD_NO_ERROR
;
968 void wxThreadInternal::Wait()
970 wxCHECK_RET( !m_isDetached
, _T("can't wait for a detached thread") );
972 // if the thread we're waiting for is waiting for the GUI mutex, we will
973 // deadlock so make sure we release it temporarily
974 if ( wxThread::IsMain() )
977 wxLogTrace(TRACE_THREADS
,
978 _T("Starting to wait for thread %ld to exit."),
981 // to avoid memory leaks we should call pthread_join(), but it must only be
982 // done once so use a critical section to serialize the code below
984 wxCriticalSectionLocker
lock(m_csJoinFlag
);
986 if ( m_shouldBeJoined
)
988 // FIXME shouldn't we set cancellation type to DISABLED here? If
989 // we're cancelled inside pthread_join(), things will almost
990 // certainly break - but if we disable the cancellation, we
992 if ( pthread_join(GetId(), &m_exitcode
) != 0 )
994 // this is a serious problem, so use wxLogError and not
995 // wxLogDebug: it is possible to bring the system to its knees
996 // by creating too many threads and not joining them quite
998 wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
1001 m_shouldBeJoined
= false;
1005 // reacquire GUI mutex
1006 if ( wxThread::IsMain() )
1010 void wxThreadInternal::Pause()
1012 // the state is set from the thread which pauses us first, this function
1013 // is called later so the state should have been already set
1014 wxCHECK_RET( m_state
== STATE_PAUSED
,
1015 wxT("thread must first be paused with wxThread::Pause().") );
1017 wxLogTrace(TRACE_THREADS
,
1018 _T("Thread %ld goes to sleep."), THR_ID(this));
1020 // wait until the semaphore is Post()ed from Resume()
1021 m_semSuspend
.Wait();
1024 void wxThreadInternal::Resume()
1026 wxCHECK_RET( m_state
== STATE_PAUSED
,
1027 wxT("can't resume thread which is not suspended.") );
1029 // the thread might be not actually paused yet - if there were no call to
1030 // TestDestroy() since the last call to Pause() for example
1031 if ( IsReallyPaused() )
1033 wxLogTrace(TRACE_THREADS
,
1034 _T("Waking up thread %ld"), THR_ID(this));
1037 m_semSuspend
.Post();
1040 SetReallyPaused(false);
1044 wxLogTrace(TRACE_THREADS
,
1045 _T("Thread %ld is not yet really paused"), THR_ID(this));
1048 SetState(STATE_RUNNING
);
1051 // -----------------------------------------------------------------------------
1052 // wxThread static functions
1053 // -----------------------------------------------------------------------------
1055 wxThread
*wxThread::This()
1057 return (wxThread
*)pthread_getspecific(gs_keySelf
);
1060 bool wxThread::IsMain()
1062 return (bool)pthread_equal(pthread_self(), gs_tidMain
) || gs_tidMain
== (pthread_t
)-1;
1065 void wxThread::Yield()
1067 #ifdef HAVE_SCHED_YIELD
1072 int wxThread::GetCPUCount()
1074 #if defined(_SC_NPROCESSORS_ONLN)
1075 // this works for Solaris and Linux 2.6
1076 int rc
= sysconf(_SC_NPROCESSORS_ONLN
);
1081 #elif defined(__LINUX__) && wxUSE_FFILE
1082 // read from proc (can't use wxTextFile here because it's a special file:
1083 // it has 0 size but still can be read from)
1086 wxFFile
file(_T("/proc/cpuinfo"));
1087 if ( file
.IsOpened() )
1089 // slurp the whole file
1091 if ( file
.ReadAll(&s
) )
1093 // (ab)use Replace() to find the number of "processor: num" strings
1094 size_t count
= s
.Replace(_T("processor\t:"), _T(""));
1100 wxLogDebug(_T("failed to parse /proc/cpuinfo"));
1104 wxLogDebug(_T("failed to read /proc/cpuinfo"));
1107 #endif // different ways to get number of CPUs
1113 // VMS is a 64 bit system and threads have 64 bit pointers.
1114 // FIXME: also needed for other systems????
1116 unsigned long long wxThread::GetCurrentId()
1118 return (unsigned long long)pthread_self();
1123 unsigned long wxThread::GetCurrentId()
1125 return (unsigned long)pthread_self();
1128 #endif // __VMS/!__VMS
1131 bool wxThread::SetConcurrency(size_t level
)
1133 #ifdef HAVE_THR_SETCONCURRENCY
1134 int rc
= thr_setconcurrency(level
);
1137 wxLogSysError(rc
, _T("thr_setconcurrency() failed"));
1141 #else // !HAVE_THR_SETCONCURRENCY
1142 // ok only for the default value
1144 #endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
1147 // -----------------------------------------------------------------------------
1149 // -----------------------------------------------------------------------------
1151 wxThread::wxThread(wxThreadKind kind
)
1153 // add this thread to the global list of all threads
1155 wxMutexLocker
lock(*gs_mutexAllThreads
);
1157 gs_allThreads
.Add(this);
1160 m_internal
= new wxThreadInternal();
1162 m_isDetached
= kind
== wxTHREAD_DETACHED
;
1165 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1166 #define WXUNUSED_STACKSIZE(identifier) identifier
1168 #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier)
1171 wxThreadError
wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize
))
1173 if ( m_internal
->GetState() != STATE_NEW
)
1175 // don't recreate thread
1176 return wxTHREAD_RUNNING
;
1179 // set up the thread attribute: right now, we only set thread priority
1180 pthread_attr_t attr
;
1181 pthread_attr_init(&attr
);
1183 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1185 pthread_attr_setstacksize(&attr
, stackSize
);
1188 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1190 if ( pthread_attr_getschedpolicy(&attr
, &policy
) != 0 )
1192 wxLogError(_("Cannot retrieve thread scheduling policy."));
1196 /* the pthread.h contains too many spaces. This is a work-around */
1197 # undef sched_get_priority_max
1198 #undef sched_get_priority_min
1199 #define sched_get_priority_max(_pol_) \
1200 (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
1201 #define sched_get_priority_min(_pol_) \
1202 (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
1205 int max_prio
= sched_get_priority_max(policy
),
1206 min_prio
= sched_get_priority_min(policy
),
1207 prio
= m_internal
->GetPriority();
1209 if ( min_prio
== -1 || max_prio
== -1 )
1211 wxLogError(_("Cannot get priority range for scheduling policy %d."),
1214 else if ( max_prio
== min_prio
)
1216 if ( prio
!= WXTHREAD_DEFAULT_PRIORITY
)
1218 // notify the programmer that this doesn't work here
1219 wxLogWarning(_("Thread priority setting is ignored."));
1221 //else: we have default priority, so don't complain
1223 // anyhow, don't do anything because priority is just ignored
1227 struct sched_param sp
;
1228 if ( pthread_attr_getschedparam(&attr
, &sp
) != 0 )
1230 wxFAIL_MSG(_T("pthread_attr_getschedparam() failed"));
1233 sp
.sched_priority
= min_prio
+ (prio
*(max_prio
- min_prio
))/100;
1235 if ( pthread_attr_setschedparam(&attr
, &sp
) != 0 )
1237 wxFAIL_MSG(_T("pthread_attr_setschedparam(priority) failed"));
1240 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1242 #ifdef HAVE_PTHREAD_ATTR_SETSCOPE
1243 // this will make the threads created by this process really concurrent
1244 if ( pthread_attr_setscope(&attr
, PTHREAD_SCOPE_SYSTEM
) != 0 )
1246 wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
1248 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
1250 // VZ: assume that this one is always available (it's rather fundamental),
1251 // if this function is ever missing we should try to use
1252 // pthread_detach() instead (after thread creation)
1255 if ( pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
) != 0 )
1257 wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed"));
1260 // never try to join detached threads
1261 m_internal
->Detach();
1263 //else: threads are created joinable by default, it's ok
1265 // create the new OS thread object
1266 int rc
= pthread_create
1268 m_internal
->GetIdPtr(),
1274 if ( pthread_attr_destroy(&attr
) != 0 )
1276 wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
1281 m_internal
->SetState(STATE_EXITED
);
1283 return wxTHREAD_NO_RESOURCE
;
1286 return wxTHREAD_NO_ERROR
;
1289 wxThreadError
wxThread::Run()
1291 wxCriticalSectionLocker
lock(m_critsect
);
1293 wxCHECK_MSG( m_internal
->GetId(), wxTHREAD_MISC_ERROR
,
1294 wxT("must call wxThread::Create() first") );
1296 return m_internal
->Run();
1299 // -----------------------------------------------------------------------------
1301 // -----------------------------------------------------------------------------
1303 void wxThread::SetPriority(unsigned int prio
)
1305 wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY
<= (int)prio
) &&
1306 ((int)prio
<= (int)WXTHREAD_MAX_PRIORITY
),
1307 wxT("invalid thread priority") );
1309 wxCriticalSectionLocker
lock(m_critsect
);
1311 switch ( m_internal
->GetState() )
1314 // thread not yet started, priority will be set when it is
1315 m_internal
->SetPriority(prio
);
1320 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1321 #if defined(__LINUX__)
1322 // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
1323 // a priority other than 0. Instead, we use the BSD setpriority
1324 // which alllows us to set a 'nice' value between 20 to -20. Only
1325 // super user can set a value less than zero (more negative yields
1326 // higher priority). setpriority set the static priority of a
1327 // process, but this is OK since Linux is configured as a thread
1330 // FIXME this is not true for 2.6!!
1332 // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
1333 // to Unix priorities 20..-20
1334 if ( setpriority(PRIO_PROCESS
, 0, -(2*(int)prio
)/5 + 20) == -1 )
1336 wxLogError(_("Failed to set thread priority %d."), prio
);
1340 struct sched_param sparam
;
1341 sparam
.sched_priority
= prio
;
1343 if ( pthread_setschedparam(m_internal
->GetId(),
1344 SCHED_OTHER
, &sparam
) != 0 )
1346 wxLogError(_("Failed to set thread priority %d."), prio
);
1350 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1355 wxFAIL_MSG(wxT("impossible to set thread priority in this state"));
1359 unsigned int wxThread::GetPriority() const
1361 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1363 return m_internal
->GetPriority();
1366 wxThreadIdType
wxThread::GetId() const
1368 return (wxThreadIdType
) m_internal
->GetId();
1371 // -----------------------------------------------------------------------------
1373 // -----------------------------------------------------------------------------
1375 wxThreadError
wxThread::Pause()
1377 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1378 _T("a thread can't pause itself") );
1380 wxCriticalSectionLocker
lock(m_critsect
);
1382 if ( m_internal
->GetState() != STATE_RUNNING
)
1384 wxLogDebug(wxT("Can't pause thread which is not running."));
1386 return wxTHREAD_NOT_RUNNING
;
1389 // just set a flag, the thread will be really paused only during the next
1390 // call to TestDestroy()
1391 m_internal
->SetState(STATE_PAUSED
);
1393 return wxTHREAD_NO_ERROR
;
1396 wxThreadError
wxThread::Resume()
1398 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1399 _T("a thread can't resume itself") );
1401 wxCriticalSectionLocker
lock(m_critsect
);
1403 wxThreadState state
= m_internal
->GetState();
1408 wxLogTrace(TRACE_THREADS
, _T("Thread %ld suspended, resuming."),
1411 m_internal
->Resume();
1413 return wxTHREAD_NO_ERROR
;
1416 wxLogTrace(TRACE_THREADS
, _T("Thread %ld exited, won't resume."),
1418 return wxTHREAD_NO_ERROR
;
1421 wxLogDebug(_T("Attempt to resume a thread which is not paused."));
1423 return wxTHREAD_MISC_ERROR
;
1427 // -----------------------------------------------------------------------------
1429 // -----------------------------------------------------------------------------
1431 wxThread::ExitCode
wxThread::Wait()
1433 wxCHECK_MSG( This() != this, (ExitCode
)-1,
1434 _T("a thread can't wait for itself") );
1436 wxCHECK_MSG( !m_isDetached
, (ExitCode
)-1,
1437 _T("can't wait for detached thread") );
1441 return m_internal
->GetExitCode();
1444 wxThreadError
wxThread::Delete(ExitCode
*rc
)
1446 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1447 _T("a thread can't delete itself") );
1449 bool isDetached
= m_isDetached
;
1452 wxThreadState state
= m_internal
->GetState();
1454 // ask the thread to stop
1455 m_internal
->SetCancelFlag();
1462 // we need to wake up the thread so that PthreadStart() will
1463 // terminate - right now it's blocking on run semaphore in
1465 m_internal
->SignalRun();
1474 // resume the thread first
1475 m_internal
->Resume();
1482 // wait until the thread stops
1487 // return the exit code of the thread
1488 *rc
= m_internal
->GetExitCode();
1491 //else: can't wait for detached threads
1494 return wxTHREAD_NO_ERROR
;
1497 wxThreadError
wxThread::Kill()
1499 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR
,
1500 _T("a thread can't kill itself") );
1502 switch ( m_internal
->GetState() )
1506 return wxTHREAD_NOT_RUNNING
;
1509 // resume the thread first
1515 #ifdef HAVE_PTHREAD_CANCEL
1516 if ( pthread_cancel(m_internal
->GetId()) != 0 )
1517 #endif // HAVE_PTHREAD_CANCEL
1519 wxLogError(_("Failed to terminate a thread."));
1521 return wxTHREAD_MISC_ERROR
;
1524 #ifdef HAVE_PTHREAD_CANCEL
1527 // if we use cleanup function, this will be done from
1528 // wxPthreadCleanup()
1529 #ifndef wxHAVE_PTHREAD_CLEANUP
1530 ScheduleThreadForDeletion();
1532 // don't call OnExit() here, it can only be called in the
1533 // threads context and we're in the context of another thread
1536 #endif // wxHAVE_PTHREAD_CLEANUP
1540 m_internal
->SetExitCode(EXITCODE_CANCELLED
);
1543 return wxTHREAD_NO_ERROR
;
1544 #endif // HAVE_PTHREAD_CANCEL
1548 void wxThread::Exit(ExitCode status
)
1550 wxASSERT_MSG( This() == this,
1551 _T("wxThread::Exit() can only be called in the context of the same thread") );
1555 // from the moment we call OnExit(), the main program may terminate at
1556 // any moment, so mark this thread as being already in process of being
1557 // deleted or wxThreadModule::OnExit() will try to delete it again
1558 ScheduleThreadForDeletion();
1561 // don't enter m_critsect before calling OnExit() because the user code
1562 // might deadlock if, for example, it signals a condition in OnExit() (a
1563 // common case) while the main thread calls any of functions entering
1564 // m_critsect on us (almost all of them do)
1569 wxCATCH_ALL( wxTheApp
->OnUnhandledException(); )
1571 // delete C++ thread object if this is a detached thread - user is
1572 // responsible for doing this for joinable ones
1575 // FIXME I'm feeling bad about it - what if another thread function is
1576 // called (in another thread context) now? It will try to access
1577 // half destroyed object which will probably result in something
1578 // very bad - but we can't protect this by a crit section unless
1579 // we make it a global object, but this would mean that we can
1580 // only call one thread function at a time :-(
1582 pthread_setspecific(gs_keySelf
, 0);
1587 m_internal
->SetState(STATE_EXITED
);
1591 // terminate the thread (pthread_exit() never returns)
1592 pthread_exit(status
);
1594 wxFAIL_MSG(_T("pthread_exit() failed"));
1597 // also test whether we were paused
1598 bool wxThread::TestDestroy()
1600 wxASSERT_MSG( This() == this,
1601 _T("wxThread::TestDestroy() can only be called in the context of the same thread") );
1605 if ( m_internal
->GetState() == STATE_PAUSED
)
1607 m_internal
->SetReallyPaused(true);
1609 // leave the crit section or the other threads will stop too if they
1610 // try to call any of (seemingly harmless) IsXXX() functions while we
1614 m_internal
->Pause();
1618 // thread wasn't requested to pause, nothing to do
1622 return m_internal
->WasCancelled();
1625 wxThread::~wxThread()
1630 // check that the thread either exited or couldn't be created
1631 if ( m_internal
->GetState() != STATE_EXITED
&&
1632 m_internal
->GetState() != STATE_NEW
)
1634 wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."),
1639 #endif // __WXDEBUG__
1643 // remove this thread from the global array
1645 wxMutexLocker
lock(*gs_mutexAllThreads
);
1647 gs_allThreads
.Remove(this);
1651 // -----------------------------------------------------------------------------
1653 // -----------------------------------------------------------------------------
1655 bool wxThread::IsRunning() const
1657 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1659 return m_internal
->GetState() == STATE_RUNNING
;
1662 bool wxThread::IsAlive() const
1664 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1666 switch ( m_internal
->GetState() )
1677 bool wxThread::IsPaused() const
1679 wxCriticalSectionLocker
lock((wxCriticalSection
&)m_critsect
);
1681 return (m_internal
->GetState() == STATE_PAUSED
);
1684 //--------------------------------------------------------------------
1686 //--------------------------------------------------------------------
1688 class wxThreadModule
: public wxModule
1691 virtual bool OnInit();
1692 virtual void OnExit();
1695 DECLARE_DYNAMIC_CLASS(wxThreadModule
)
1698 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule
, wxModule
)
1700 bool wxThreadModule::OnInit()
1702 int rc
= pthread_key_create(&gs_keySelf
, NULL
/* dtor function */);
1705 wxLogSysError(rc
, _("Thread module initialization failed: failed to create thread key"));
1710 gs_tidMain
= pthread_self();
1712 gs_mutexAllThreads
= new wxMutex();
1714 gs_mutexGui
= new wxMutex();
1715 gs_mutexGui
->Lock();
1717 gs_mutexDeleteThread
= new wxMutex();
1718 gs_condAllDeleted
= new wxCondition(*gs_mutexDeleteThread
);
1723 void wxThreadModule::OnExit()
1725 wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );
1727 // are there any threads left which are being deleted right now?
1728 size_t nThreadsBeingDeleted
;
1731 wxMutexLocker
lock( *gs_mutexDeleteThread
);
1732 nThreadsBeingDeleted
= gs_nThreadsBeingDeleted
;
1734 if ( nThreadsBeingDeleted
> 0 )
1736 wxLogTrace(TRACE_THREADS
,
1737 _T("Waiting for %lu threads to disappear"),
1738 (unsigned long)nThreadsBeingDeleted
);
1740 // have to wait until all of them disappear
1741 gs_condAllDeleted
->Wait();
1748 wxMutexLocker
lock(*gs_mutexAllThreads
);
1750 // terminate any threads left
1751 count
= gs_allThreads
.GetCount();
1754 wxLogDebug(wxT("%lu threads were not terminated by the application."),
1755 (unsigned long)count
);
1757 } // unlock mutex before deleting the threads as they lock it in their dtor
1759 for ( size_t n
= 0u; n
< count
; n
++ )
1761 // Delete calls the destructor which removes the current entry. We
1762 // should only delete the first one each time.
1763 gs_allThreads
[0]->Delete();
1766 delete gs_mutexAllThreads
;
1768 // destroy GUI mutex
1769 gs_mutexGui
->Unlock();
1772 // and free TLD slot
1773 (void)pthread_key_delete(gs_keySelf
);
1775 delete gs_condAllDeleted
;
1776 delete gs_mutexDeleteThread
;
1779 // ----------------------------------------------------------------------------
1781 // ----------------------------------------------------------------------------
1783 static void ScheduleThreadForDeletion()
1785 wxMutexLocker
lock( *gs_mutexDeleteThread
);
1787 gs_nThreadsBeingDeleted
++;
1789 wxLogTrace(TRACE_THREADS
, _T("%lu thread%s waiting to be deleted"),
1790 (unsigned long)gs_nThreadsBeingDeleted
,
1791 gs_nThreadsBeingDeleted
== 1 ? _T("") : _T("s"));
1794 static void DeleteThread(wxThread
*This
)
1796 // gs_mutexDeleteThread should be unlocked before signalling the condition
1797 // or wxThreadModule::OnExit() would deadlock
1798 wxMutexLocker
locker( *gs_mutexDeleteThread
);
1800 wxLogTrace(TRACE_THREADS
, _T("Thread %ld auto deletes."), This
->GetId());
1804 wxCHECK_RET( gs_nThreadsBeingDeleted
> 0,
1805 _T("no threads scheduled for deletion, yet we delete one?") );
1807 wxLogTrace(TRACE_THREADS
, _T("%lu scheduled for deletion threads left."),
1808 (unsigned long)gs_nThreadsBeingDeleted
- 1);
1810 if ( !--gs_nThreadsBeingDeleted
)
1812 // no more threads left, signal it
1813 gs_condAllDeleted
->Signal();
1817 void wxMutexGuiEnterImpl()
1819 gs_mutexGui
->Lock();
1822 void wxMutexGuiLeaveImpl()
1824 gs_mutexGui
->Unlock();
1827 // ----------------------------------------------------------------------------
1828 // include common implementation code
1829 // ----------------------------------------------------------------------------
1831 #include "wx/thrimpl.cpp"
1833 #endif // wxUSE_THREADS