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