Add wxLoadUserResource() overload not copying the resource data.
[wxWidgets.git] / src / unix / threadpsx.cpp
0 / 1818 (  0%)
CommitLineData
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
6// Created: 04/22/98
7// RCS-ID: $Id$
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/////////////////////////////////////////////////////////////////////////////
15
16// ============================================================================
17// declaration
18// ============================================================================
19
20// ----------------------------------------------------------------------------
21// headers
22// ----------------------------------------------------------------------------
23
24// for compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#if wxUSE_THREADS
28
29#include "wx/thread.h"
30#include "wx/except.h"
31
32#ifndef WX_PRECOMP
33 #include "wx/app.h"
34 #include "wx/dynarray.h"
35 #include "wx/intl.h"
36 #include "wx/log.h"
37 #include "wx/utils.h"
38 #include "wx/timer.h"
39 #include "wx/stopwatch.h"
40 #include "wx/module.h"
41#endif
42
43#include <stdio.h>
44#include <unistd.h>
45#include <pthread.h>
46#include <errno.h>
47#include <time.h>
48#include <sys/time.h> // needed for at least __QNX__
49#ifdef HAVE_SCHED_H
50 #include <sched.h>
51#endif
52
53#ifdef HAVE_THR_SETCONCURRENCY
54 #include <thread.h>
55#endif
56
57// we use wxFFile under Linux in GetCPUCount()
58#ifdef __LINUX__
59 #include "wx/ffile.h"
60 #include <sys/resource.h> // for setpriority()
61#endif
62
63#ifdef __VMS
64 #define THR_ID(thr) ((long long)(thr)->GetId())
65#else
66 #define THR_ID(thr) ((long)(thr)->GetId())
67#endif
68
69// ----------------------------------------------------------------------------
70// constants
71// ----------------------------------------------------------------------------
72
73// the possible states of the thread and transitions from them
74enum wxThreadState
75{
76 STATE_NEW, // didn't start execution yet (=> RUNNING)
77 STATE_RUNNING, // running (=> PAUSED or EXITED)
78 STATE_PAUSED, // suspended (=> RUNNING or EXITED)
79 STATE_EXITED // thread doesn't exist any more
80};
81
82// the exit value of a thread which has been cancelled
83static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
84
85// trace mask for wxThread operations
86#define TRACE_THREADS wxT("thread")
87
88// you can get additional debugging messages for the semaphore operations
89#define TRACE_SEMA wxT("semaphore")
90
91// ----------------------------------------------------------------------------
92// private functions
93// ----------------------------------------------------------------------------
94
95static void ScheduleThreadForDeletion();
96static void DeleteThread(wxThread *This);
97
98// ----------------------------------------------------------------------------
99// private classes
100// ----------------------------------------------------------------------------
101
102// an (non owning) array of pointers to threads
103WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
104
105// an entry for a thread we can wait for
106
107// -----------------------------------------------------------------------------
108// global data
109// -----------------------------------------------------------------------------
110
111// we keep the list of all threads created by the application to be able to
112// terminate them on exit if there are some left - otherwise the process would
113// be left in memory
114static wxArrayThread gs_allThreads;
115
116// a mutex to protect gs_allThreads
117static wxMutex *gs_mutexAllThreads = NULL;
118
119// the id of the main thread
120//
121// we suppose that 0 is not a valid pthread_t value but in principle this might
122// be false (e.g. if it's a selector-like value), wxThread::IsMain() would need
123// to be updated in such case
124wxThreadIdType wxThread::ms_idMainThread = 0;
125
126// the key for the pointer to the associated wxThread object
127static pthread_key_t gs_keySelf;
128
129// the number of threads which are being deleted - the program won't exit
130// until there are any left
131static size_t gs_nThreadsBeingDeleted = 0;
132
133// a mutex to protect gs_nThreadsBeingDeleted
134static wxMutex *gs_mutexDeleteThread = NULL;
135
136// and a condition variable which will be signaled when all
137// gs_nThreadsBeingDeleted will have been deleted
138static wxCondition *gs_condAllDeleted = NULL;
139
140// this mutex must be acquired before any call to a GUI function
141// (it's not inside #if wxUSE_GUI because this file is compiled as part
142// of wxBase)
143static wxMutex *gs_mutexGui = NULL;
144
145// when we wait for a thread to exit, we're blocking on a condition which the
146// thread signals in its SignalExit() method -- but this condition can't be a
147// member of the thread itself as a detached thread may delete itself at any
148// moment and accessing the condition member of the thread after this would
149// result in a disaster
150//
151// so instead we maintain a global list of the structs below for the threads
152// we're interested in waiting on
153
154// ============================================================================
155// wxMutex implementation
156// ============================================================================
157
158// ----------------------------------------------------------------------------
159// wxMutexInternal
160// ----------------------------------------------------------------------------
161
162// this is a simple wrapper around pthread_mutex_t which provides error
163// checking
164class wxMutexInternal
165{
166public:
167 wxMutexInternal(wxMutexType mutexType);
168 ~wxMutexInternal();
169
170 wxMutexError Lock();
171 wxMutexError Lock(unsigned long ms);
172 wxMutexError TryLock();
173 wxMutexError Unlock();
174
175 bool IsOk() const { return m_isOk; }
176
177private:
178 // convert the result of pthread_mutex_[timed]lock() call to wx return code
179 wxMutexError HandleLockResult(int err);
180
181private:
182 pthread_mutex_t m_mutex;
183 bool m_isOk;
184 wxMutexType m_type;
185 unsigned long m_owningThread;
186
187 // wxConditionInternal uses our m_mutex
188 friend class wxConditionInternal;
189};
190
191#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
192 wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
193// on some systems pthread_mutexattr_settype() is not in the headers (but it is
194// in the library, otherwise we wouldn't compile this code at all)
195extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
196#endif
197
198wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
199{
200 m_type = mutexType;
201 m_owningThread = 0;
202
203 int err;
204 switch ( mutexType )
205 {
206 case wxMUTEX_RECURSIVE:
207 // support recursive locks like Win32, i.e. a thread can lock a
208 // mutex which it had itself already locked
209 //
210 // unfortunately initialization of recursive mutexes is non
211 // portable, so try several methods
212#ifdef HAVE_PTHREAD_MUTEXATTR_T
213 {
214 pthread_mutexattr_t attr;
215 pthread_mutexattr_init(&attr);
216 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
217
218 err = pthread_mutex_init(&m_mutex, &attr);
219 }
220#elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
221 // we can use this only as initializer so we have to assign it
222 // first to a temp var - assigning directly to m_mutex wouldn't
223 // even compile
224 {
225 pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
226 m_mutex = mutex;
227 }
228#else // no recursive mutexes
229 err = EINVAL;
230#endif // HAVE_PTHREAD_MUTEXATTR_T/...
231 break;
232
233 default:
234 wxFAIL_MSG( wxT("unknown mutex type") );
235 // fall through
236
237 case wxMUTEX_DEFAULT:
238 err = pthread_mutex_init(&m_mutex, NULL);
239 break;
240 }
241
242 m_isOk = err == 0;
243 if ( !m_isOk )
244 {
245 wxLogApiError( wxT("pthread_mutex_init()"), err);
246 }
247}
248
249wxMutexInternal::~wxMutexInternal()
250{
251 if ( m_isOk )
252 {
253 int err = pthread_mutex_destroy(&m_mutex);
254 if ( err != 0 )
255 {
256 wxLogApiError( wxT("pthread_mutex_destroy()"), err);
257 }
258 }
259}
260
261wxMutexError wxMutexInternal::Lock()
262{
263 if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0))
264 {
265 if (m_owningThread == wxThread::GetCurrentId())
266 return wxMUTEX_DEAD_LOCK;
267 }
268
269 return HandleLockResult(pthread_mutex_lock(&m_mutex));
270}
271
272wxMutexError wxMutexInternal::Lock(unsigned long ms)
273{
274#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
275 static const long MSEC_IN_SEC = 1000;
276 static const long NSEC_IN_MSEC = 1000000;
277 static const long NSEC_IN_USEC = 1000;
278 static const long NSEC_IN_SEC = MSEC_IN_SEC * NSEC_IN_MSEC;
279
280 time_t seconds = ms/MSEC_IN_SEC;
281 long nanoseconds = (ms % MSEC_IN_SEC) * NSEC_IN_MSEC;
282 timespec ts = { 0, 0 };
283
284 // normally we should use clock_gettime(CLOCK_REALTIME) here but this
285 // function is in librt and we don't link with it currently, so use
286 // gettimeofday() instead -- if it turns out that this is really too
287 // imprecise, we should modify configure to check if clock_gettime() is
288 // available and whether it requires -lrt and use it instead
289#if 0
290 if ( clock_gettime(CLOCK_REALTIME, &ts) == 0 )
291 {
292 }
293#else
294 struct timeval tv;
295 if ( wxGetTimeOfDay(&tv) != -1 )
296 {
297 ts.tv_sec = tv.tv_sec;
298 ts.tv_nsec = tv.tv_usec*NSEC_IN_USEC;
299 }
300#endif
301 else // fall back on system timer
302 {
303 ts.tv_sec = time(NULL);
304 }
305
306 ts.tv_sec += seconds;
307 ts.tv_nsec += nanoseconds;
308 if ( ts.tv_nsec > NSEC_IN_SEC )
309 {
310 ts.tv_sec += 1;
311 ts.tv_nsec -= NSEC_IN_SEC;
312 }
313
314 return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts));
315#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
316 wxUnusedVar(ms);
317
318 return wxMUTEX_MISC_ERROR;
319#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
320}
321
322wxMutexError wxMutexInternal::HandleLockResult(int err)
323{
324 // wxPrintf( "err %d\n", err );
325
326 switch ( err )
327 {
328 case EDEADLK:
329 // only error checking mutexes return this value and so it's an
330 // unexpected situation -- hence use assert, not wxLogDebug
331 wxFAIL_MSG( wxT("mutex deadlock prevented") );
332 return wxMUTEX_DEAD_LOCK;
333
334 case EINVAL:
335 wxLogDebug(wxT("pthread_mutex_[timed]lock(): mutex not initialized"));
336 break;
337
338 case ETIMEDOUT:
339 return wxMUTEX_TIMEOUT;
340
341 case 0:
342 if (m_type == wxMUTEX_DEFAULT)
343 m_owningThread = wxThread::GetCurrentId();
344 return wxMUTEX_NO_ERROR;
345
346 default:
347 wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err);
348 }
349
350 return wxMUTEX_MISC_ERROR;
351}
352
353
354wxMutexError wxMutexInternal::TryLock()
355{
356 int err = pthread_mutex_trylock(&m_mutex);
357 switch ( err )
358 {
359 case EBUSY:
360 // not an error: mutex is already locked, but we're prepared for
361 // this
362 return wxMUTEX_BUSY;
363
364 case EINVAL:
365 wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized."));
366 break;
367
368 case 0:
369 if (m_type == wxMUTEX_DEFAULT)
370 m_owningThread = wxThread::GetCurrentId();
371 return wxMUTEX_NO_ERROR;
372
373 default:
374 wxLogApiError(wxT("pthread_mutex_trylock()"), err);
375 }
376
377 return wxMUTEX_MISC_ERROR;
378}
379
380wxMutexError wxMutexInternal::Unlock()
381{
382 m_owningThread = 0;
383
384 int err = pthread_mutex_unlock(&m_mutex);
385 switch ( err )
386 {
387 case EPERM:
388 // we don't own the mutex
389 return wxMUTEX_UNLOCKED;
390
391 case EINVAL:
392 wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized."));
393 break;
394
395 case 0:
396 return wxMUTEX_NO_ERROR;
397
398 default:
399 wxLogApiError(wxT("pthread_mutex_unlock()"), err);
400 }
401
402 return wxMUTEX_MISC_ERROR;
403}
404
405// ===========================================================================
406// wxCondition implementation
407// ===========================================================================
408
409// ---------------------------------------------------------------------------
410// wxConditionInternal
411// ---------------------------------------------------------------------------
412
413// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
414// with a pthread_mutex_t)
415class wxConditionInternal
416{
417public:
418 wxConditionInternal(wxMutex& mutex);
419 ~wxConditionInternal();
420
421 bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
422
423 wxCondError Wait();
424 wxCondError WaitTimeout(unsigned long milliseconds);
425
426 wxCondError Signal();
427 wxCondError Broadcast();
428
429private:
430 // get the POSIX mutex associated with us
431 pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }
432
433 wxMutex& m_mutex;
434 pthread_cond_t m_cond;
435
436 bool m_isOk;
437};
438
439wxConditionInternal::wxConditionInternal(wxMutex& mutex)
440 : m_mutex(mutex)
441{
442 int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
443
444 m_isOk = err == 0;
445
446 if ( !m_isOk )
447 {
448 wxLogApiError(wxT("pthread_cond_init()"), err);
449 }
450}
451
452wxConditionInternal::~wxConditionInternal()
453{
454 if ( m_isOk )
455 {
456 int err = pthread_cond_destroy(&m_cond);
457 if ( err != 0 )
458 {
459 wxLogApiError(wxT("pthread_cond_destroy()"), err);
460 }
461 }
462}
463
464wxCondError wxConditionInternal::Wait()
465{
466 int err = pthread_cond_wait(&m_cond, GetPMutex());
467 if ( err != 0 )
468 {
469 wxLogApiError(wxT("pthread_cond_wait()"), err);
470
471 return wxCOND_MISC_ERROR;
472 }
473
474 return wxCOND_NO_ERROR;
475}
476
477wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
478{
479 wxLongLong curtime = wxGetLocalTimeMillis();
480 curtime += milliseconds;
481 wxLongLong temp = curtime / 1000;
482 int sec = temp.GetLo();
483 temp *= 1000;
484 temp = curtime - temp;
485 int millis = temp.GetLo();
486
487 timespec tspec;
488
489 tspec.tv_sec = sec;
490 tspec.tv_nsec = millis * 1000L * 1000L;
491
492 int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
493 switch ( err )
494 {
495 case ETIMEDOUT:
496 return wxCOND_TIMEOUT;
497
498 case 0:
499 return wxCOND_NO_ERROR;
500
501 default:
502 wxLogApiError(wxT("pthread_cond_timedwait()"), err);
503 }
504
505 return wxCOND_MISC_ERROR;
506}
507
508wxCondError wxConditionInternal::Signal()
509{
510 int err = pthread_cond_signal(&m_cond);
511 if ( err != 0 )
512 {
513 wxLogApiError(wxT("pthread_cond_signal()"), err);
514
515 return wxCOND_MISC_ERROR;
516 }
517
518 return wxCOND_NO_ERROR;
519}
520
521wxCondError wxConditionInternal::Broadcast()
522{
523 int err = pthread_cond_broadcast(&m_cond);
524 if ( err != 0 )
525 {
526 wxLogApiError(wxT("pthread_cond_broadcast()"), err);
527
528 return wxCOND_MISC_ERROR;
529 }
530
531 return wxCOND_NO_ERROR;
532}
533
534// ===========================================================================
535// wxSemaphore implementation
536// ===========================================================================
537
538// ---------------------------------------------------------------------------
539// wxSemaphoreInternal
540// ---------------------------------------------------------------------------
541
542// we implement the semaphores using mutexes and conditions instead of using
543// the sem_xxx() POSIX functions because they're not widely available and also
544// because it's impossible to implement WaitTimeout() using them
545class wxSemaphoreInternal
546{
547public:
548 wxSemaphoreInternal(int initialcount, int maxcount);
549
550 bool IsOk() const { return m_isOk; }
551
552 wxSemaError Wait();
553 wxSemaError TryWait();
554 wxSemaError WaitTimeout(unsigned long milliseconds);
555
556 wxSemaError Post();
557
558private:
559 wxMutex m_mutex;
560 wxCondition m_cond;
561
562 size_t m_count,
563 m_maxcount;
564
565 bool m_isOk;
566};
567
568wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
569 : m_cond(m_mutex)
570{
571
572 if ( (initialcount < 0 || maxcount < 0) ||
573 ((maxcount > 0) && (initialcount > maxcount)) )
574 {
575 wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") );
576
577 m_isOk = false;
578 }
579 else
580 {
581 m_maxcount = (size_t)maxcount;
582 m_count = (size_t)initialcount;
583 }
584
585 m_isOk = m_mutex.IsOk() && m_cond.IsOk();
586}
587
588wxSemaError wxSemaphoreInternal::Wait()
589{
590 wxMutexLocker locker(m_mutex);
591
592 while ( m_count == 0 )
593 {
594 wxLogTrace(TRACE_SEMA,
595 wxT("Thread %p waiting for semaphore to become signalled"),
596 wxThread::GetCurrentId());
597
598 if ( m_cond.Wait() != wxCOND_NO_ERROR )
599 return wxSEMA_MISC_ERROR;
600
601 wxLogTrace(TRACE_SEMA,
602 wxT("Thread %p finished waiting for semaphore, count = %lu"),
603 wxThread::GetCurrentId(), (unsigned long)m_count);
604 }
605
606 m_count--;
607
608 return wxSEMA_NO_ERROR;
609}
610
611wxSemaError wxSemaphoreInternal::TryWait()
612{
613 wxMutexLocker locker(m_mutex);
614
615 if ( m_count == 0 )
616 return wxSEMA_BUSY;
617
618 m_count--;
619
620 return wxSEMA_NO_ERROR;
621}
622
623wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
624{
625 wxMutexLocker locker(m_mutex);
626
627 wxLongLong startTime = wxGetLocalTimeMillis();
628
629 while ( m_count == 0 )
630 {
631 wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
632 long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
633 if ( remainingTime <= 0 )
634 {
635 // timeout
636 return wxSEMA_TIMEOUT;
637 }
638
639 switch ( m_cond.WaitTimeout(remainingTime) )
640 {
641 case wxCOND_TIMEOUT:
642 return wxSEMA_TIMEOUT;
643
644 default:
645 return wxSEMA_MISC_ERROR;
646
647 case wxCOND_NO_ERROR:
648 ;
649 }
650 }
651
652 m_count--;
653
654 return wxSEMA_NO_ERROR;
655}
656
657wxSemaError wxSemaphoreInternal::Post()
658{
659 wxMutexLocker locker(m_mutex);
660
661 if ( m_maxcount > 0 && m_count == m_maxcount )
662 {
663 return wxSEMA_OVERFLOW;
664 }
665
666 m_count++;
667
668 wxLogTrace(TRACE_SEMA,
669 wxT("Thread %p about to signal semaphore, count = %lu"),
670 wxThread::GetCurrentId(), (unsigned long)m_count);
671
672 return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
673 : wxSEMA_MISC_ERROR;
674}
675
676// ===========================================================================
677// wxThread implementation
678// ===========================================================================
679
680// the thread callback functions must have the C linkage
681extern "C"
682{
683
684#ifdef wxHAVE_PTHREAD_CLEANUP
685 // thread exit function
686 void wxPthreadCleanup(void *ptr);
687#endif // wxHAVE_PTHREAD_CLEANUP
688
689void *wxPthreadStart(void *ptr);
690
691} // extern "C"
692
693// ----------------------------------------------------------------------------
694// wxThreadInternal
695// ----------------------------------------------------------------------------
696
697class wxThreadInternal
698{
699public:
700 wxThreadInternal();
701 ~wxThreadInternal();
702
703 // thread entry function
704 static void *PthreadStart(wxThread *thread);
705
706 // thread actions
707 // start the thread
708 wxThreadError Run();
709 // unblock the thread allowing it to run
710 void SignalRun() { m_semRun.Post(); }
711 // ask the thread to terminate
712 void Wait();
713 // go to sleep until Resume() is called
714 void Pause();
715 // resume the thread
716 void Resume();
717
718 // accessors
719 // priority
720 int GetPriority() const { return m_prio; }
721 void SetPriority(int prio) { m_prio = prio; }
722 // state
723 wxThreadState GetState() const { return m_state; }
724 void SetState(wxThreadState state)
725 {
726#if wxUSE_LOG_TRACE
727 static const wxChar *const stateNames[] =
728 {
729 wxT("NEW"),
730 wxT("RUNNING"),
731 wxT("PAUSED"),
732 wxT("EXITED"),
733 };
734
735 wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."),
736 GetId(), stateNames[m_state], stateNames[state]);
737#endif // wxUSE_LOG_TRACE
738
739 m_state = state;
740 }
741 // id
742 pthread_t GetId() const { return m_threadId; }
743 pthread_t *GetIdPtr() { return &m_threadId; }
744 // "cancelled" flag
745 void SetCancelFlag() { m_cancelled = true; }
746 bool WasCancelled() const { return m_cancelled; }
747 // exit code
748 void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
749 wxThread::ExitCode GetExitCode() const { return m_exitcode; }
750
751 // the pause flag
752 void SetReallyPaused(bool paused) { m_isPaused = paused; }
753 bool IsReallyPaused() const { return m_isPaused; }
754
755 // tell the thread that it is a detached one
756 void Detach()
757 {
758 wxCriticalSectionLocker lock(m_csJoinFlag);
759
760 m_shouldBeJoined = false;
761 m_isDetached = true;
762 }
763
764#ifdef wxHAVE_PTHREAD_CLEANUP
765 // this is used by wxPthreadCleanup() only
766 static void Cleanup(wxThread *thread);
767#endif // wxHAVE_PTHREAD_CLEANUP
768
769private:
770 pthread_t m_threadId; // id of the thread
771 wxThreadState m_state; // see wxThreadState enum
772 int m_prio; // in wxWidgets units: from 0 to 100
773
774 // this flag is set when the thread should terminate
775 bool m_cancelled;
776
777 // this flag is set when the thread is blocking on m_semSuspend
778 bool m_isPaused;
779
780 // the thread exit code - only used for joinable (!detached) threads and
781 // is only valid after the thread termination
782 wxThread::ExitCode m_exitcode;
783
784 // many threads may call Wait(), but only one of them should call
785 // pthread_join(), so we have to keep track of this
786 wxCriticalSection m_csJoinFlag;
787 bool m_shouldBeJoined;
788 bool m_isDetached;
789
790 // this semaphore is posted by Run() and the threads Entry() is not
791 // called before it is done
792 wxSemaphore m_semRun;
793
794 // this one is signaled when the thread should resume after having been
795 // Pause()d
796 wxSemaphore m_semSuspend;
797};
798
799// ----------------------------------------------------------------------------
800// thread startup and exit functions
801// ----------------------------------------------------------------------------
802
803void *wxPthreadStart(void *ptr)
804{
805 return wxThreadInternal::PthreadStart((wxThread *)ptr);
806}
807
808void *wxThreadInternal::PthreadStart(wxThread *thread)
809{
810 wxThreadInternal *pthread = thread->m_internal;
811
812 wxLogTrace(TRACE_THREADS, wxT("Thread %p started."), THR_ID(pthread));
813
814 // associate the thread pointer with the newly created thread so that
815 // wxThread::This() will work
816 int rc = pthread_setspecific(gs_keySelf, thread);
817 if ( rc != 0 )
818 {
819 wxLogSysError(rc, _("Cannot start thread: error writing TLS"));
820
821 return (void *)-1;
822 }
823
824 // have to declare this before pthread_cleanup_push() which defines a
825 // block!
826 bool dontRunAtAll;
827
828#ifdef wxHAVE_PTHREAD_CLEANUP
829 // install the cleanup handler which will be called if the thread is
830 // cancelled
831 pthread_cleanup_push(wxPthreadCleanup, thread);
832#endif // wxHAVE_PTHREAD_CLEANUP
833
834 // wait for the semaphore to be posted from Run()
835 pthread->m_semRun.Wait();
836
837 // test whether we should run the run at all - may be it was deleted
838 // before it started to Run()?
839 {
840 wxCriticalSectionLocker lock(thread->m_critsect);
841
842 dontRunAtAll = pthread->GetState() == STATE_NEW &&
843 pthread->WasCancelled();
844 }
845
846 if ( !dontRunAtAll )
847 {
848 // call the main entry
849 wxLogTrace(TRACE_THREADS,
850 wxT("Thread %p about to enter its Entry()."),
851 THR_ID(pthread));
852
853 wxTRY
854 {
855 pthread->m_exitcode = thread->Entry();
856
857 wxLogTrace(TRACE_THREADS,
858 wxT("Thread %p Entry() returned %lu."),
859 THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
860 }
861 wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
862
863 {
864 wxCriticalSectionLocker lock(thread->m_critsect);
865
866 // change the state of the thread to "exited" so that
867 // wxPthreadCleanup handler won't do anything from now (if it's
868 // called before we do pthread_cleanup_pop below)
869 pthread->SetState(STATE_EXITED);
870 }
871 }
872
873 // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
874 // '}' for the '{' in push, so they must be used in the same block!
875#ifdef wxHAVE_PTHREAD_CLEANUP
876 #ifdef __DECCXX
877 // under Tru64 we get a warning from macro expansion
878 #pragma message save
879 #pragma message disable(declbutnotref)
880 #endif
881
882 // remove the cleanup handler without executing it
883 pthread_cleanup_pop(FALSE);
884
885 #ifdef __DECCXX
886 #pragma message restore
887 #endif
888#endif // wxHAVE_PTHREAD_CLEANUP
889
890 if ( dontRunAtAll )
891 {
892 // FIXME: deleting a possibly joinable thread here???
893 delete thread;
894
895 return EXITCODE_CANCELLED;
896 }
897 else
898 {
899 // terminate the thread
900 thread->Exit(pthread->m_exitcode);
901
902 wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
903
904 return NULL;
905 }
906}
907
908#ifdef wxHAVE_PTHREAD_CLEANUP
909
910// this handler is called when the thread is cancelled
911extern "C" void wxPthreadCleanup(void *ptr)
912{
913 wxThreadInternal::Cleanup((wxThread *)ptr);
914}
915
916void wxThreadInternal::Cleanup(wxThread *thread)
917{
918 if (pthread_getspecific(gs_keySelf) == 0) return;
919 {
920 wxCriticalSectionLocker lock(thread->m_critsect);
921 if ( thread->m_internal->GetState() == STATE_EXITED )
922 {
923 // thread is already considered as finished.
924 return;
925 }
926 }
927
928 // exit the thread gracefully
929 thread->Exit(EXITCODE_CANCELLED);
930}
931
932#endif // wxHAVE_PTHREAD_CLEANUP
933
934// ----------------------------------------------------------------------------
935// wxThreadInternal
936// ----------------------------------------------------------------------------
937
938wxThreadInternal::wxThreadInternal()
939{
940 m_state = STATE_NEW;
941 m_cancelled = false;
942 m_prio = WXTHREAD_DEFAULT_PRIORITY;
943 m_threadId = 0;
944 m_exitcode = 0;
945
946 // set to true only when the thread starts waiting on m_semSuspend
947 m_isPaused = false;
948
949 // defaults for joinable threads
950 m_shouldBeJoined = true;
951 m_isDetached = false;
952}
953
954wxThreadInternal::~wxThreadInternal()
955{
956}
957
958wxThreadError wxThreadInternal::Run()
959{
960 wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
961 wxT("thread may only be started once after Create()") );
962
963 SetState(STATE_RUNNING);
964
965 // wake up threads waiting for our start
966 SignalRun();
967
968 return wxTHREAD_NO_ERROR;
969}
970
971void wxThreadInternal::Wait()
972{
973 wxCHECK_RET( !m_isDetached, wxT("can't wait for a detached thread") );
974
975 // if the thread we're waiting for is waiting for the GUI mutex, we will
976 // deadlock so make sure we release it temporarily
977 if ( wxThread::IsMain() )
978 wxMutexGuiLeave();
979
980 wxLogTrace(TRACE_THREADS,
981 wxT("Starting to wait for thread %p to exit."),
982 THR_ID(this));
983
984 // to avoid memory leaks we should call pthread_join(), but it must only be
985 // done once so use a critical section to serialize the code below
986 {
987 wxCriticalSectionLocker lock(m_csJoinFlag);
988
989 if ( m_shouldBeJoined )
990 {
991 // FIXME shouldn't we set cancellation type to DISABLED here? If
992 // we're cancelled inside pthread_join(), things will almost
993 // certainly break - but if we disable the cancellation, we
994 // might deadlock
995 if ( pthread_join(GetId(), &m_exitcode) != 0 )
996 {
997 // this is a serious problem, so use wxLogError and not
998 // wxLogDebug: it is possible to bring the system to its knees
999 // by creating too many threads and not joining them quite
1000 // easily
1001 wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
1002 }
1003
1004 m_shouldBeJoined = false;
1005 }
1006 }
1007
1008 // reacquire GUI mutex
1009 if ( wxThread::IsMain() )
1010 wxMutexGuiEnter();
1011}
1012
1013void wxThreadInternal::Pause()
1014{
1015 // the state is set from the thread which pauses us first, this function
1016 // is called later so the state should have been already set
1017 wxCHECK_RET( m_state == STATE_PAUSED,
1018 wxT("thread must first be paused with wxThread::Pause().") );
1019
1020 wxLogTrace(TRACE_THREADS,
1021 wxT("Thread %p goes to sleep."), THR_ID(this));
1022
1023 // wait until the semaphore is Post()ed from Resume()
1024 m_semSuspend.Wait();
1025}
1026
1027void wxThreadInternal::Resume()
1028{
1029 wxCHECK_RET( m_state == STATE_PAUSED,
1030 wxT("can't resume thread which is not suspended.") );
1031
1032 // the thread might be not actually paused yet - if there were no call to
1033 // TestDestroy() since the last call to Pause() for example
1034 if ( IsReallyPaused() )
1035 {
1036 wxLogTrace(TRACE_THREADS,
1037 wxT("Waking up thread %p"), THR_ID(this));
1038
1039 // wake up Pause()
1040 m_semSuspend.Post();
1041
1042 // reset the flag
1043 SetReallyPaused(false);
1044 }
1045 else
1046 {
1047 wxLogTrace(TRACE_THREADS,
1048 wxT("Thread %p is not yet really paused"), THR_ID(this));
1049 }
1050
1051 SetState(STATE_RUNNING);
1052}
1053
1054// -----------------------------------------------------------------------------
1055// wxThread static functions
1056// -----------------------------------------------------------------------------
1057
1058wxThread *wxThread::This()
1059{
1060 return (wxThread *)pthread_getspecific(gs_keySelf);
1061}
1062
1063void wxThread::Yield()
1064{
1065#ifdef HAVE_SCHED_YIELD
1066 sched_yield();
1067#endif
1068}
1069
1070int wxThread::GetCPUCount()
1071{
1072#if defined(_SC_NPROCESSORS_ONLN)
1073 // this works for Solaris and Linux 2.6
1074 int rc = sysconf(_SC_NPROCESSORS_ONLN);
1075 if ( rc != -1 )
1076 {
1077 return rc;
1078 }
1079#elif defined(__LINUX__) && wxUSE_FFILE
1080 // read from proc (can't use wxTextFile here because it's a special file:
1081 // it has 0 size but still can be read from)
1082 wxLogNull nolog;
1083
1084 wxFFile file(wxT("/proc/cpuinfo"));
1085 if ( file.IsOpened() )
1086 {
1087 // slurp the whole file
1088 wxString s;
1089 if ( file.ReadAll(&s) )
1090 {
1091 // (ab)use Replace() to find the number of "processor: num" strings
1092 size_t count = s.Replace(wxT("processor\t:"), wxT(""));
1093 if ( count > 0 )
1094 {
1095 return count;
1096 }
1097
1098 wxLogDebug(wxT("failed to parse /proc/cpuinfo"));
1099 }
1100 else
1101 {
1102 wxLogDebug(wxT("failed to read /proc/cpuinfo"));
1103 }
1104 }
1105#endif // different ways to get number of CPUs
1106
1107 // unknown
1108 return -1;
1109}
1110
1111wxThreadIdType wxThread::GetCurrentId()
1112{
1113 return (wxThreadIdType)pthread_self();
1114}
1115
1116
1117bool wxThread::SetConcurrency(size_t level)
1118{
1119#ifdef HAVE_THR_SETCONCURRENCY
1120 int rc = thr_setconcurrency(level);
1121 if ( rc != 0 )
1122 {
1123 wxLogSysError(rc, wxT("thr_setconcurrency() failed"));
1124 }
1125
1126 return rc == 0;
1127#else // !HAVE_THR_SETCONCURRENCY
1128 // ok only for the default value
1129 return level == 0;
1130#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
1131}
1132
1133// -----------------------------------------------------------------------------
1134// creating thread
1135// -----------------------------------------------------------------------------
1136
1137wxThread::wxThread(wxThreadKind kind)
1138{
1139 // add this thread to the global list of all threads
1140 {
1141 wxMutexLocker lock(*gs_mutexAllThreads);
1142
1143 gs_allThreads.Add(this);
1144 }
1145
1146 m_internal = new wxThreadInternal();
1147
1148 m_isDetached = kind == wxTHREAD_DETACHED;
1149}
1150
1151#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1152 #define WXUNUSED_STACKSIZE(identifier) identifier
1153#else
1154 #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier)
1155#endif
1156
1157wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))
1158{
1159 if ( m_internal->GetState() != STATE_NEW )
1160 {
1161 // don't recreate thread
1162 return wxTHREAD_RUNNING;
1163 }
1164
1165 // set up the thread attribute: right now, we only set thread priority
1166 pthread_attr_t attr;
1167 pthread_attr_init(&attr);
1168
1169#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1170 if (stackSize)
1171 pthread_attr_setstacksize(&attr, stackSize);
1172#endif
1173
1174#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1175 int policy;
1176 if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
1177 {
1178 wxLogError(_("Cannot retrieve thread scheduling policy."));
1179 }
1180
1181#ifdef __VMS__
1182 /* the pthread.h contains too many spaces. This is a work-around */
1183# undef sched_get_priority_max
1184#undef sched_get_priority_min
1185#define sched_get_priority_max(_pol_) \
1186 (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
1187#define sched_get_priority_min(_pol_) \
1188 (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
1189#endif
1190
1191 int max_prio = sched_get_priority_max(policy),
1192 min_prio = sched_get_priority_min(policy),
1193 prio = m_internal->GetPriority();
1194
1195 if ( min_prio == -1 || max_prio == -1 )
1196 {
1197 wxLogError(_("Cannot get priority range for scheduling policy %d."),
1198 policy);
1199 }
1200 else if ( max_prio == min_prio )
1201 {
1202 if ( prio != WXTHREAD_DEFAULT_PRIORITY )
1203 {
1204 // notify the programmer that this doesn't work here
1205 wxLogWarning(_("Thread priority setting is ignored."));
1206 }
1207 //else: we have default priority, so don't complain
1208
1209 // anyhow, don't do anything because priority is just ignored
1210 }
1211 else
1212 {
1213 struct sched_param sp;
1214 if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
1215 {
1216 wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed"));
1217 }
1218
1219 sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
1220
1221 if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
1222 {
1223 wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));
1224 }
1225 }
1226#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1227
1228#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
1229 // this will make the threads created by this process really concurrent
1230 if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
1231 {
1232 wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
1233 }
1234#endif // HAVE_PTHREAD_ATTR_SETSCOPE
1235
1236 // VZ: assume that this one is always available (it's rather fundamental),
1237 // if this function is ever missing we should try to use
1238 // pthread_detach() instead (after thread creation)
1239 if ( m_isDetached )
1240 {
1241 if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
1242 {
1243 wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
1244 }
1245
1246 // never try to join detached threads
1247 m_internal->Detach();
1248 }
1249 //else: threads are created joinable by default, it's ok
1250
1251 // create the new OS thread object
1252 int rc = pthread_create
1253 (
1254 m_internal->GetIdPtr(),
1255 &attr,
1256 wxPthreadStart,
1257 (void *)this
1258 );
1259
1260 if ( pthread_attr_destroy(&attr) != 0 )
1261 {
1262 wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
1263 }
1264
1265 if ( rc != 0 )
1266 {
1267 m_internal->SetState(STATE_EXITED);
1268
1269 return wxTHREAD_NO_RESOURCE;
1270 }
1271
1272 return wxTHREAD_NO_ERROR;
1273}
1274
1275wxThreadError wxThread::Run()
1276{
1277 wxCriticalSectionLocker lock(m_critsect);
1278
1279 wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR,
1280 wxT("must call wxThread::Create() first") );
1281
1282 return m_internal->Run();
1283}
1284
1285// -----------------------------------------------------------------------------
1286// misc accessors
1287// -----------------------------------------------------------------------------
1288
1289void wxThread::SetPriority(unsigned int prio)
1290{
1291 wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
1292 ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
1293 wxT("invalid thread priority") );
1294
1295 wxCriticalSectionLocker lock(m_critsect);
1296
1297 switch ( m_internal->GetState() )
1298 {
1299 case STATE_NEW:
1300 // thread not yet started, priority will be set when it is
1301 m_internal->SetPriority(prio);
1302 break;
1303
1304 case STATE_RUNNING:
1305 case STATE_PAUSED:
1306#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1307#if defined(__LINUX__)
1308 // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
1309 // a priority other than 0. Instead, we use the BSD setpriority
1310 // which alllows us to set a 'nice' value between 20 to -20. Only
1311 // super user can set a value less than zero (more negative yields
1312 // higher priority). setpriority set the static priority of a
1313 // process, but this is OK since Linux is configured as a thread
1314 // per process.
1315 //
1316 // FIXME this is not true for 2.6!!
1317
1318 // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
1319 // to Unix priorities 20..-20
1320 if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
1321 {
1322 wxLogError(_("Failed to set thread priority %d."), prio);
1323 }
1324#else // __LINUX__
1325 {
1326 struct sched_param sparam;
1327 sparam.sched_priority = prio;
1328
1329 if ( pthread_setschedparam(m_internal->GetId(),
1330 SCHED_OTHER, &sparam) != 0 )
1331 {
1332 wxLogError(_("Failed to set thread priority %d."), prio);
1333 }
1334 }
1335#endif // __LINUX__
1336#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1337 break;
1338
1339 case STATE_EXITED:
1340 default:
1341 wxFAIL_MSG(wxT("impossible to set thread priority in this state"));
1342 }
1343}
1344
1345unsigned int wxThread::GetPriority() const
1346{
1347 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1348
1349 return m_internal->GetPriority();
1350}
1351
1352wxThreadIdType wxThread::GetId() const
1353{
1354 return (wxThreadIdType) m_internal->GetId();
1355}
1356
1357// -----------------------------------------------------------------------------
1358// pause/resume
1359// -----------------------------------------------------------------------------
1360
1361wxThreadError wxThread::Pause()
1362{
1363 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1364 wxT("a thread can't pause itself") );
1365
1366 wxCriticalSectionLocker lock(m_critsect);
1367
1368 if ( m_internal->GetState() != STATE_RUNNING )
1369 {
1370 wxLogDebug(wxT("Can't pause thread which is not running."));
1371
1372 return wxTHREAD_NOT_RUNNING;
1373 }
1374
1375 // just set a flag, the thread will be really paused only during the next
1376 // call to TestDestroy()
1377 m_internal->SetState(STATE_PAUSED);
1378
1379 return wxTHREAD_NO_ERROR;
1380}
1381
1382wxThreadError wxThread::Resume()
1383{
1384 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1385 wxT("a thread can't resume itself") );
1386
1387 wxCriticalSectionLocker lock(m_critsect);
1388
1389 wxThreadState state = m_internal->GetState();
1390
1391 switch ( state )
1392 {
1393 case STATE_PAUSED:
1394 wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."),
1395 GetId());
1396
1397 m_internal->Resume();
1398
1399 return wxTHREAD_NO_ERROR;
1400
1401 case STATE_EXITED:
1402 wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."),
1403 GetId());
1404 return wxTHREAD_NO_ERROR;
1405
1406 default:
1407 wxLogDebug(wxT("Attempt to resume a thread which is not paused."));
1408
1409 return wxTHREAD_MISC_ERROR;
1410 }
1411}
1412
1413// -----------------------------------------------------------------------------
1414// exiting thread
1415// -----------------------------------------------------------------------------
1416
1417wxThread::ExitCode wxThread::Wait()
1418{
1419 wxCHECK_MSG( This() != this, (ExitCode)-1,
1420 wxT("a thread can't wait for itself") );
1421
1422 wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
1423 wxT("can't wait for detached thread") );
1424
1425 m_internal->Wait();
1426
1427 return m_internal->GetExitCode();
1428}
1429
1430wxThreadError wxThread::Delete(ExitCode *rc)
1431{
1432 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1433 wxT("a thread can't delete itself") );
1434
1435 bool isDetached = m_isDetached;
1436
1437 m_critsect.Enter();
1438 wxThreadState state = m_internal->GetState();
1439
1440 // ask the thread to stop
1441 m_internal->SetCancelFlag();
1442
1443 m_critsect.Leave();
1444
1445 switch ( state )
1446 {
1447 case STATE_NEW:
1448 // we need to wake up the thread so that PthreadStart() will
1449 // terminate - right now it's blocking on run semaphore in
1450 // PthreadStart()
1451 m_internal->SignalRun();
1452
1453 // fall through
1454
1455 case STATE_EXITED:
1456 // nothing to do
1457 break;
1458
1459 case STATE_PAUSED:
1460 // resume the thread first
1461 m_internal->Resume();
1462
1463 // fall through
1464
1465 default:
1466 if ( !isDetached )
1467 {
1468 // wait until the thread stops
1469 m_internal->Wait();
1470
1471 if ( rc )
1472 {
1473 // return the exit code of the thread
1474 *rc = m_internal->GetExitCode();
1475 }
1476 }
1477 //else: can't wait for detached threads
1478 }
1479
1480 return wxTHREAD_NO_ERROR;
1481}
1482
1483wxThreadError wxThread::Kill()
1484{
1485 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1486 wxT("a thread can't kill itself") );
1487
1488 switch ( m_internal->GetState() )
1489 {
1490 case STATE_NEW:
1491 case STATE_EXITED:
1492 return wxTHREAD_NOT_RUNNING;
1493
1494 case STATE_PAUSED:
1495 // resume the thread first
1496 Resume();
1497
1498 // fall through
1499
1500 default:
1501#ifdef HAVE_PTHREAD_CANCEL
1502 if ( pthread_cancel(m_internal->GetId()) != 0 )
1503#endif // HAVE_PTHREAD_CANCEL
1504 {
1505 wxLogError(_("Failed to terminate a thread."));
1506
1507 return wxTHREAD_MISC_ERROR;
1508 }
1509
1510#ifdef HAVE_PTHREAD_CANCEL
1511 if ( m_isDetached )
1512 {
1513 // if we use cleanup function, this will be done from
1514 // wxPthreadCleanup()
1515#ifndef wxHAVE_PTHREAD_CLEANUP
1516 ScheduleThreadForDeletion();
1517
1518 // don't call OnExit() here, it can only be called in the
1519 // threads context and we're in the context of another thread
1520
1521 DeleteThread(this);
1522#endif // wxHAVE_PTHREAD_CLEANUP
1523 }
1524 else
1525 {
1526 m_internal->SetExitCode(EXITCODE_CANCELLED);
1527 }
1528
1529 return wxTHREAD_NO_ERROR;
1530#endif // HAVE_PTHREAD_CANCEL
1531 }
1532}
1533
1534void wxThread::Exit(ExitCode status)
1535{
1536 wxASSERT_MSG( This() == this,
1537 wxT("wxThread::Exit() can only be called in the context of the same thread") );
1538
1539 if ( m_isDetached )
1540 {
1541 // from the moment we call OnExit(), the main program may terminate at
1542 // any moment, so mark this thread as being already in process of being
1543 // deleted or wxThreadModule::OnExit() will try to delete it again
1544 ScheduleThreadForDeletion();
1545 }
1546
1547 // don't enter m_critsect before calling OnExit() because the user code
1548 // might deadlock if, for example, it signals a condition in OnExit() (a
1549 // common case) while the main thread calls any of functions entering
1550 // m_critsect on us (almost all of them do)
1551 wxTRY
1552 {
1553 OnExit();
1554 }
1555 wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
1556
1557 // delete C++ thread object if this is a detached thread - user is
1558 // responsible for doing this for joinable ones
1559 if ( m_isDetached )
1560 {
1561 // FIXME I'm feeling bad about it - what if another thread function is
1562 // called (in another thread context) now? It will try to access
1563 // half destroyed object which will probably result in something
1564 // very bad - but we can't protect this by a crit section unless
1565 // we make it a global object, but this would mean that we can
1566 // only call one thread function at a time :-(
1567 DeleteThread(this);
1568 pthread_setspecific(gs_keySelf, 0);
1569 }
1570 else
1571 {
1572 m_critsect.Enter();
1573 m_internal->SetState(STATE_EXITED);
1574 m_critsect.Leave();
1575 }
1576
1577 // terminate the thread (pthread_exit() never returns)
1578 pthread_exit(status);
1579
1580 wxFAIL_MSG(wxT("pthread_exit() failed"));
1581}
1582
1583// also test whether we were paused
1584bool wxThread::TestDestroy()
1585{
1586 wxASSERT_MSG( This() == this,
1587 wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );
1588
1589 m_critsect.Enter();
1590
1591 if ( m_internal->GetState() == STATE_PAUSED )
1592 {
1593 m_internal->SetReallyPaused(true);
1594
1595 // leave the crit section or the other threads will stop too if they
1596 // try to call any of (seemingly harmless) IsXXX() functions while we
1597 // sleep
1598 m_critsect.Leave();
1599
1600 m_internal->Pause();
1601 }
1602 else
1603 {
1604 // thread wasn't requested to pause, nothing to do
1605 m_critsect.Leave();
1606 }
1607
1608 return m_internal->WasCancelled();
1609}
1610
1611wxThread::~wxThread()
1612{
1613 m_critsect.Enter();
1614
1615 // check that the thread either exited or couldn't be created
1616 if ( m_internal->GetState() != STATE_EXITED &&
1617 m_internal->GetState() != STATE_NEW )
1618 {
1619 wxLogDebug(wxT("The thread %ld is being destroyed although it is still running! The application may crash."),
1620 (long)GetId());
1621 }
1622
1623 m_critsect.Leave();
1624
1625 delete m_internal;
1626
1627 // remove this thread from the global array
1628 {
1629 wxMutexLocker lock(*gs_mutexAllThreads);
1630
1631 gs_allThreads.Remove(this);
1632 }
1633}
1634
1635// -----------------------------------------------------------------------------
1636// state tests
1637// -----------------------------------------------------------------------------
1638
1639bool wxThread::IsRunning() const
1640{
1641 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1642
1643 return m_internal->GetState() == STATE_RUNNING;
1644}
1645
1646bool wxThread::IsAlive() const
1647{
1648 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1649
1650 switch ( m_internal->GetState() )
1651 {
1652 case STATE_RUNNING:
1653 case STATE_PAUSED:
1654 return true;
1655
1656 default:
1657 return false;
1658 }
1659}
1660
1661bool wxThread::IsPaused() const
1662{
1663 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1664
1665 return (m_internal->GetState() == STATE_PAUSED);
1666}
1667
1668//--------------------------------------------------------------------
1669// wxThreadModule
1670//--------------------------------------------------------------------
1671
1672class wxThreadModule : public wxModule
1673{
1674public:
1675 virtual bool OnInit();
1676 virtual void OnExit();
1677
1678private:
1679 DECLARE_DYNAMIC_CLASS(wxThreadModule)
1680};
1681
1682IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1683
1684bool wxThreadModule::OnInit()
1685{
1686 int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
1687 if ( rc != 0 )
1688 {
1689 wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
1690
1691 return false;
1692 }
1693
1694 wxThread::ms_idMainThread = wxThread::GetCurrentId();
1695
1696 gs_mutexAllThreads = new wxMutex();
1697
1698 gs_mutexGui = new wxMutex();
1699 gs_mutexGui->Lock();
1700
1701 gs_mutexDeleteThread = new wxMutex();
1702 gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);
1703
1704 return true;
1705}
1706
1707void wxThreadModule::OnExit()
1708{
1709 wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );
1710
1711 // are there any threads left which are being deleted right now?
1712 size_t nThreadsBeingDeleted;
1713
1714 {
1715 wxMutexLocker lock( *gs_mutexDeleteThread );
1716 nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
1717
1718 if ( nThreadsBeingDeleted > 0 )
1719 {
1720 wxLogTrace(TRACE_THREADS,
1721 wxT("Waiting for %lu threads to disappear"),
1722 (unsigned long)nThreadsBeingDeleted);
1723
1724 // have to wait until all of them disappear
1725 gs_condAllDeleted->Wait();
1726 }
1727 }
1728
1729 size_t count;
1730
1731 {
1732 wxMutexLocker lock(*gs_mutexAllThreads);
1733
1734 // terminate any threads left
1735 count = gs_allThreads.GetCount();
1736 if ( count != 0u )
1737 {
1738 wxLogDebug(wxT("%lu threads were not terminated by the application."),
1739 (unsigned long)count);
1740 }
1741 } // unlock mutex before deleting the threads as they lock it in their dtor
1742
1743 for ( size_t n = 0u; n < count; n++ )
1744 {
1745 // Delete calls the destructor which removes the current entry. We
1746 // should only delete the first one each time.
1747 gs_allThreads[0]->Delete();
1748 }
1749
1750 delete gs_mutexAllThreads;
1751
1752 // destroy GUI mutex
1753 gs_mutexGui->Unlock();
1754 delete gs_mutexGui;
1755
1756 // and free TLD slot
1757 (void)pthread_key_delete(gs_keySelf);
1758
1759 delete gs_condAllDeleted;
1760 delete gs_mutexDeleteThread;
1761}
1762
1763// ----------------------------------------------------------------------------
1764// global functions
1765// ----------------------------------------------------------------------------
1766
1767static void ScheduleThreadForDeletion()
1768{
1769 wxMutexLocker lock( *gs_mutexDeleteThread );
1770
1771 gs_nThreadsBeingDeleted++;
1772
1773 wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"),
1774 (unsigned long)gs_nThreadsBeingDeleted,
1775 gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s"));
1776}
1777
1778static void DeleteThread(wxThread *This)
1779{
1780 wxLogTrace(TRACE_THREADS, wxT("Thread %p auto deletes."), This->GetId());
1781
1782 delete This;
1783
1784 // only lock gs_mutexDeleteThread after deleting the thread to avoid
1785 // calling out into user code with it locked as this may result in
1786 // deadlocks if the thread dtor deletes another thread (see #11501)
1787 wxMutexLocker locker( *gs_mutexDeleteThread );
1788
1789 wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
1790 wxT("no threads scheduled for deletion, yet we delete one?") );
1791
1792 wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."),
1793 (unsigned long)gs_nThreadsBeingDeleted - 1);
1794
1795 if ( !--gs_nThreadsBeingDeleted )
1796 {
1797 // no more threads left, signal it
1798 gs_condAllDeleted->Signal();
1799 }
1800}
1801
1802void wxMutexGuiEnterImpl()
1803{
1804 gs_mutexGui->Lock();
1805}
1806
1807void wxMutexGuiLeaveImpl()
1808{
1809 gs_mutexGui->Unlock();
1810}
1811
1812// ----------------------------------------------------------------------------
1813// include common implementation code
1814// ----------------------------------------------------------------------------
1815
1816#include "wx/thrimpl.cpp"
1817
1818#endif // wxUSE_THREADS