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