]> git.saurik.com Git - wxWidgets.git/blame - src/osx/carbon/thread.cpp
new file added
[wxWidgets.git] / src / osx / carbon / thread.cpp
CommitLineData
489468fe 1/////////////////////////////////////////////////////////////////////////////
524c47aa 2// Name: src/osx/carbon/thread.cpp
489468fe
SC
3// Purpose: wxThread Implementation
4// Author: Original from Wolfram Gloger/Guilhem Lavaux/Vadim Zeitlin
5// Modified by: Aj Lavin, Stefan Csomor
6// Created: 04/22/98
7// RCS-ID: $Id$
8// Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998),
9// Vadim Zeitlin (1999), Stefan Csomor (2000)
10// Licence: wxWindows licence
11/////////////////////////////////////////////////////////////////////////////
12
13#include "wx/wxprec.h"
14
15#if defined(__BORLANDC__)
16 #pragma hdrstop
17#endif
18
19#ifndef WX_PRECOMP
20 #include "wx/wx.h"
21 #include "wx/module.h"
22#endif
23
24#if wxUSE_THREADS
25
26#include "wx/thread.h"
27
b2680ced 28#if wxOSX_USE_COCOA_OR_CARBON
489468fe 29#include <CoreServices/CoreServices.h>
b2680ced
SC
30#else
31#include <Foundation/Foundation.h>
32#endif
33
1f0c8f31 34#include "wx/osx/uma.h"
489468fe
SC
35
36// the possible states of the thread:
37// ("=>" shows all possible transitions from this state)
38enum wxThreadState
39{
40 STATE_NEW, // didn't start execution yet (=> RUNNING)
41 STATE_RUNNING, // thread is running (=> PAUSED, CANCELED)
42 STATE_PAUSED, // thread is temporarily suspended (=> RUNNING)
43 STATE_CANCELED, // thread should terminate a.s.a.p. (=> EXITED)
44 STATE_EXITED // thread is terminating
45};
46
47// ----------------------------------------------------------------------------
48// globals
49// ----------------------------------------------------------------------------
50
51// the task ID of the main thread
f9226383 52wxThreadIdType wxThread::ms_idMainThread = kInvalidID;
489468fe
SC
53
54// this is the Per-Task Storage for the pointer to the appropriate wxThread
55TaskStorageIndex gs_tlsForWXThread = 0;
56
57// if it's false, some secondary thread is holding the GUI lock
58static bool gs_bGuiOwnedByMainThread = true;
59
60// critical section which controls access to all GUI functions: any secondary
61// thread (i.e. except the main one) must enter this crit section before doing
62// any GUI calls
63static wxCriticalSection *gs_critsectGui = NULL;
64
65// critical section which protects gs_nWaitingForGui variable
66static wxCriticalSection *gs_critsectWaitingForGui = NULL;
67
68// number of threads waiting for GUI in wxMutexGuiEnter()
69static size_t gs_nWaitingForGui = 0;
70
71// overall number of threads, needed for determining
72// the sleep value of the main event loop
73size_t g_numberOfThreads = 0;
74
75
76#if wxUSE_GUI
77MPCriticalRegionID gs_guiCritical = kInvalidID;
78#endif
79
80// ============================================================================
81// MacOS implementation of thread classes
82// ============================================================================
83
84/*
85 Notes :
86
87 The implementation is very close to the phtreads implementation, the reason for
88 using MPServices is the fact that these are also available under OS 9. Thus allowing
89 for one common API for all current builds.
90
91 As soon as wxThreads are on a 64 bit address space, the TLS must be extended
92 to use two indices one for each 32 bit part as the MP implementation is limited
93 to longs.
94
95 I have three implementations for mutexes :
96 version A based on a binary semaphore, problem - not reentrant, version B based
97 on a critical region, allows for reentrancy, performance implications not
98 yet tested, and third a plain pthreads implementation
99
100 The same for condition internal, one implementation by Aj Lavin and the other one
101 copied from the thrimpl.cpp which I assume has been more broadly tested, I've just
102 replaced the interlock increment with the appropriate PPC calls
103*/
104
105// ----------------------------------------------------------------------------
106// wxCriticalSection
107// ----------------------------------------------------------------------------
108
3ad41c28 109wxCriticalSection::wxCriticalSection( wxCriticalSectionType WXUNUSED(critSecType) )
489468fe
SC
110{
111 MPCreateCriticalRegion( (MPCriticalRegionID*) &m_critRegion );
112}
113
114wxCriticalSection::~wxCriticalSection()
115{
116 MPDeleteCriticalRegion( (MPCriticalRegionID) m_critRegion );
117}
118
119void wxCriticalSection::Enter()
120{
121 MPEnterCriticalRegion( (MPCriticalRegionID) m_critRegion, kDurationForever );
122}
123
b9697cb4
VZ
124bool wxCriticalSection::TryEnter()
125{
126 return MPEnterCriticalRegion( (MPCriticalRegionID) m_critRegion, kDurationImmediate ) == noErr;
127}
128
489468fe
SC
129void wxCriticalSection::Leave()
130{
131 MPExitCriticalRegion( (MPCriticalRegionID) m_critRegion );
132}
133
134// ----------------------------------------------------------------------------
135// wxMutex implementation
136// ----------------------------------------------------------------------------
137
138#define wxUSE_MAC_SEMAPHORE_MUTEX 0
139#define wxUSE_MAC_CRITICAL_REGION_MUTEX 1
140#define wxUSE_MAC_PTHREADS_MUTEX 0
141
489468fe
SC
142#if wxUSE_MAC_CRITICAL_REGION_MUTEX
143
144class wxMutexInternal
145{
146public:
147 wxMutexInternal( wxMutexType mutexType );
148 virtual ~wxMutexInternal();
149
150 bool IsOk() const { return m_isOk; }
151
152 wxMutexError Lock() { return Lock(kDurationForever); }
153 wxMutexError Lock(unsigned long ms);
154 wxMutexError TryLock();
155 wxMutexError Unlock();
156
157private:
158 MPCriticalRegionID m_critRegion;
159 bool m_isOk ;
160};
161
162wxMutexInternal::wxMutexInternal( wxMutexType WXUNUSED(mutexType) )
163{
164 m_isOk = false;
165 m_critRegion = kInvalidID;
166
167 verify_noerr( MPCreateCriticalRegion( &m_critRegion ) );
168 m_isOk = ( m_critRegion != kInvalidID );
169 if ( !IsOk() )
170 {
171 wxFAIL_MSG( wxT("Error when creating mutex") );
172 }
173}
174
175wxMutexInternal::~wxMutexInternal()
176{
177 if ( m_critRegion != kInvalidID )
178 MPDeleteCriticalRegion( m_critRegion );
179
180 MPYield();
181}
182
183wxMutexError wxMutexInternal::Lock(unsigned long ms)
184{
185 wxCHECK_MSG( m_isOk , wxMUTEX_MISC_ERROR , wxT("Invalid Mutex") );
186
187 OSStatus err = MPEnterCriticalRegion( m_critRegion, ms );
188 switch ( err )
189 {
190 case noErr:
191 break;
192
193 case kMPTimeoutErr:
194 wxASSERT_MSG( ms != kDurationForever, wxT("unexpected timeout") );
195 return wxMUTEX_TIMEOUT;
196
197 default:
198 wxLogSysError(wxT("Could not lock mutex"));
199 return wxMUTEX_MISC_ERROR;
200 }
201
202 return wxMUTEX_NO_ERROR;
203}
204
205wxMutexError wxMutexInternal::TryLock()
206{
207 wxCHECK_MSG( m_isOk , wxMUTEX_MISC_ERROR , wxT("Invalid Mutex") ) ;
208
209 OSStatus err = MPEnterCriticalRegion( m_critRegion, kDurationImmediate);
210 if (err != noErr)
211 {
212 if ( err == kMPTimeoutErr)
213 return wxMUTEX_BUSY;
214
215 wxLogSysError( wxT("Could not try lock mutex") );
216 return wxMUTEX_MISC_ERROR;
217 }
218
219 return wxMUTEX_NO_ERROR;
220}
221
222wxMutexError wxMutexInternal::Unlock()
223{
224 wxCHECK_MSG( m_isOk , wxMUTEX_MISC_ERROR , wxT("Invalid Mutex") ) ;
225
226 OSStatus err = MPExitCriticalRegion( m_critRegion );
227 MPYield() ;
228
229 if (err != noErr)
230 {
231 wxLogSysError( wxT("Could not unlock mutex") );
232
233 return wxMUTEX_MISC_ERROR;
234 }
235
236 return wxMUTEX_NO_ERROR;
237}
238
239#endif
240
241// --------------------------------------------------------------------------
242// wxSemaphore
243// --------------------------------------------------------------------------
244
245class wxSemaphoreInternal
246{
247public:
248 wxSemaphoreInternal( int initialcount, int maxcount );
249 virtual ~wxSemaphoreInternal();
250
251 bool IsOk() const
252 { return m_isOk; }
253
254 wxSemaError Post();
255 wxSemaError WaitTimeout( unsigned long milliseconds );
256
257 wxSemaError Wait()
258 { return WaitTimeout( kDurationForever); }
259
260 wxSemaError TryWait()
261 {
262 wxSemaError err = WaitTimeout( kDurationImmediate );
263 if (err == wxSEMA_TIMEOUT)
264 err = wxSEMA_BUSY;
265
266 return err;
267 }
268
269private:
270 MPSemaphoreID m_semaphore;
271 bool m_isOk;
272};
273
274wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount)
275{
276 m_isOk = false;
277 m_semaphore = kInvalidID;
278 if ( maxcount == 0 )
279 // make it practically infinite
280 maxcount = INT_MAX;
281
282 verify_noerr( MPCreateSemaphore( maxcount, initialcount, &m_semaphore ) );
283 m_isOk = ( m_semaphore != kInvalidID );
284
285 if ( !IsOk() )
286 {
287 wxFAIL_MSG( wxT("Error when creating semaphore") );
288 }
289}
290
291wxSemaphoreInternal::~wxSemaphoreInternal()
292{
293 if (m_semaphore != kInvalidID)
294 MPDeleteSemaphore( m_semaphore );
295
296 MPYield();
297}
298
299wxSemaError wxSemaphoreInternal::WaitTimeout( unsigned long milliseconds )
300{
301 OSStatus err = MPWaitOnSemaphore( m_semaphore, milliseconds );
302 if (err != noErr)
303 {
304 if (err == kMPTimeoutErr)
305 return wxSEMA_TIMEOUT;
306
307 return wxSEMA_MISC_ERROR;
308 }
309
310 return wxSEMA_NO_ERROR;
311}
312
313wxSemaError wxSemaphoreInternal::Post()
314{
315 OSStatus err = MPSignalSemaphore( m_semaphore );
316 MPYield();
317 if (err != noErr)
318 return wxSEMA_MISC_ERROR;
319
320 return wxSEMA_NO_ERROR;
321}
322
323// ----------------------------------------------------------------------------
324// wxCondition implementation
325// ----------------------------------------------------------------------------
326
489468fe
SC
327class wxConditionInternal
328{
329public:
330 wxConditionInternal( wxMutex& mutex );
331
332 bool IsOk() const
333 { return m_mutex.IsOk() && m_semaphore.IsOk(); }
334
335 wxCondError Wait();
336 wxCondError WaitTimeout( unsigned long milliseconds );
337
338 wxCondError Signal();
339 wxCondError Broadcast();
340
341private:
342 // the number of threads currently waiting for this condition
343 SInt32 m_numWaiters;
344
345 // the critical section protecting m_numWaiters
346 wxCriticalSection m_csWaiters;
347
348 wxMutex& m_mutex;
349 wxSemaphore m_semaphore;
350
c0c133e1 351 wxDECLARE_NO_COPY_CLASS(wxConditionInternal);
489468fe
SC
352};
353
354wxConditionInternal::wxConditionInternal( wxMutex& mutex )
355 : m_mutex(mutex)
356{
357 // another thread can't access it until we return from ctor, so no need to
358 // protect access to m_numWaiters here
359 m_numWaiters = 0;
360}
361
362wxCondError wxConditionInternal::Wait()
363{
364 // increment the number of waiters
365 IncrementAtomic( &m_numWaiters );
366
367 m_mutex.Unlock();
368
369 // a potential race condition can occur here
370 //
371 // after a thread increments nwaiters, and unlocks the mutex and before the
372 // semaphore.Wait() is called, if another thread can cause a signal to be
373 // generated
374 //
375 // this race condition is handled by using a semaphore and incrementing the
376 // semaphore only if 'nwaiters' is greater that zero since the semaphore,
377 // can 'remember' signals the race condition will not occur
378
379 // wait ( if necessary ) and decrement semaphore
380 wxSemaError err = m_semaphore.Wait();
381 m_mutex.Lock();
382
383 return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
384}
385
386wxCondError wxConditionInternal::WaitTimeout( unsigned long milliseconds )
387{
388 IncrementAtomic( &m_numWaiters );
389
390 m_mutex.Unlock();
391
392 // a race condition can occur at this point in the code
393 //
394 // please see the comments in Wait(), for details
395
396 wxSemaError err = m_semaphore.WaitTimeout(milliseconds);
397
398 if ( err == wxSEMA_TIMEOUT )
399 {
400 // another potential race condition exists here it is caused when a
401 // 'waiting' thread timesout, and returns from WaitForSingleObject, but
402 // has not yet decremented 'nwaiters'.
403 //
404 // at this point if another thread calls signal() then the semaphore
405 // will be incremented, but the waiting thread will miss it.
406 //
407 // to handle this particular case, the waiting thread calls
408 // WaitForSingleObject again with a timeout of 0, after locking
409 // 'nwaiters_mutex'. this call does not block because of the zero
410 // timeout, but will allow the waiting thread to catch the missed
411 // signals.
412 wxCriticalSectionLocker lock(m_csWaiters);
413
414 err = m_semaphore.WaitTimeout(0);
415
416 if ( err != wxSEMA_NO_ERROR )
417 {
418 m_numWaiters--;
419 }
420 }
421
422 m_mutex.Lock();
423
424 return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
425}
426
427wxCondError wxConditionInternal::Signal()
428{
429 wxCriticalSectionLocker lock(m_csWaiters);
430
431 if ( m_numWaiters > 0 )
432 {
433 // increment the semaphore by 1
434 if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
435 return wxCOND_MISC_ERROR;
436
437 m_numWaiters--;
438 }
439
440 return wxCOND_NO_ERROR;
441}
442
443wxCondError wxConditionInternal::Broadcast()
444{
445 wxCriticalSectionLocker lock(m_csWaiters);
446
447 while ( m_numWaiters > 0 )
448 {
449 if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
450 return wxCOND_MISC_ERROR;
451
452 m_numWaiters--;
453 }
454
455 return wxCOND_NO_ERROR;
456}
489468fe
SC
457
458// ----------------------------------------------------------------------------
459// wxCriticalSection implementation
460// ----------------------------------------------------------------------------
461
462// XXX currently implemented as mutex in headers. Change to critical section.
463
464// ----------------------------------------------------------------------------
465// wxThread implementation
466// ----------------------------------------------------------------------------
467
468// wxThreadInternal class
469// ----------------------
470
471class wxThreadInternal
472{
473public:
474 wxThreadInternal()
475 {
476 m_tid = kInvalidID;
477 m_state = STATE_NEW;
478 m_prio = WXTHREAD_DEFAULT_PRIORITY;
479 m_notifyQueueId = kInvalidID;
480 m_exitcode = 0;
481 m_cancelled = false ;
482
483 // set to true only when the thread starts waiting on m_semSuspend
484 m_isPaused = false;
485
486 // defaults for joinable threads
487 m_shouldBeJoined = true;
488 m_isDetached = false;
489 }
490
491 virtual ~wxThreadInternal()
492 {
493 if ( m_notifyQueueId)
494 {
495 MPDeleteQueue( m_notifyQueueId );
496 m_notifyQueueId = kInvalidID ;
497 }
498 }
499
500 // thread function
501 static OSStatus MacThreadStart(void* arg);
502
503 // create a new (suspended) thread (for the given thread object)
504 bool Create(wxThread *thread, unsigned int stackSize);
505
506 // thread actions
507
508 // start the thread
509 wxThreadError Run();
510
511 // unblock the thread allowing it to run
512 void SignalRun() { m_semRun.Post(); }
513
514 // ask the thread to terminate
515 void Wait();
516
517 // go to sleep until Resume() is called
518 void Pause();
519
520 // resume the thread
521 void Resume();
522
523 // accessors
524 // priority
525 int GetPriority() const
526 { return m_prio; }
527 void SetPriority(int prio);
528
529 // state
530 wxThreadState GetState() const
531 { return m_state; }
532 void SetState(wxThreadState state)
533 { m_state = state; }
534
535 // Get the ID of this thread's underlying MP Services task.
536 MPTaskID GetId() const
537 { return m_tid; }
538
539 void SetCancelFlag()
540 { m_cancelled = true; }
541
542 bool WasCancelled() const
543 { return m_cancelled; }
544
545 // exit code
546 void SetExitCode(wxThread::ExitCode exitcode)
547 { m_exitcode = exitcode; }
548 wxThread::ExitCode GetExitCode() const
549 { return m_exitcode; }
550
551 // the pause flag
552 void SetReallyPaused(bool paused)
553 { m_isPaused = paused; }
554 bool IsReallyPaused() const
555 { return m_isPaused; }
556
557 // tell the thread that it is a detached one
558 void Detach()
559 {
560 wxCriticalSectionLocker lock(m_csJoinFlag);
561
562 m_shouldBeJoined = false;
563 m_isDetached = true;
564 }
565
566private:
567 // the thread we're associated with
568 wxThread * m_thread;
569
570 MPTaskID m_tid; // thread id
571 MPQueueID m_notifyQueueId; // its notification queue
572
573 wxThreadState m_state; // see wxThreadState enum
574 int m_prio; // in wxWidgets units: from 0 to 100
575
576 // this flag is set when the thread should terminate
577 bool m_cancelled;
578
579 // this flag is set when the thread is blocking on m_semSuspend
580 bool m_isPaused;
581
582 // the thread exit code - only used for joinable (!detached) threads and
583 // is only valid after the thread termination
584 wxThread::ExitCode m_exitcode;
585
586 // many threads may call Wait(), but only one of them should call
587 // pthread_join(), so we have to keep track of this
588 wxCriticalSection m_csJoinFlag;
589 bool m_shouldBeJoined;
590 bool m_isDetached;
591
592 // this semaphore is posted by Run() and the threads Entry() is not
593 // called before it is done
594 wxSemaphore m_semRun;
595
596 // this one is signaled when the thread should resume after having been
597 // Pause()d
598 wxSemaphore m_semSuspend;
599};
600
601OSStatus wxThreadInternal::MacThreadStart(void *parameter)
602{
603 wxThread* thread = (wxThread*) parameter ;
604 wxThreadInternal *pthread = thread->m_internal;
605
606 // add to TLS so that This() will work
607 verify_noerr( MPSetTaskStorageValue( gs_tlsForWXThread , (TaskStorageValue) thread ) ) ;
608
609 // have to declare this before pthread_cleanup_push() which defines a
610 // block!
611 bool dontRunAtAll;
612
613 // wait for the semaphore to be posted from Run()
614 pthread->m_semRun.Wait();
615
616 // test whether we should run the run at all - may be it was deleted
617 // before it started to Run()?
618 {
619 wxCriticalSectionLocker lock(thread->m_critsect);
620
621 dontRunAtAll = pthread->GetState() == STATE_NEW &&
622 pthread->WasCancelled();
623 }
624
625 if ( !dontRunAtAll )
626 {
627 pthread->m_exitcode = thread->Entry();
628
629 {
630 wxCriticalSectionLocker lock(thread->m_critsect);
631 pthread->SetState( STATE_EXITED );
632 }
633 }
634
635 if ( dontRunAtAll )
636 {
637 if ( pthread->m_isDetached )
638 delete thread;
639
640 return -1;
641 }
642 else
643 {
644 // on Mac for the running code,
645 // the correct thread termination is to return
646
647 // terminate the thread
648 thread->Exit( pthread->m_exitcode );
649
650 return (OSStatus) NULL; // pthread->m_exitcode;
651 }
652}
653
654bool wxThreadInternal::Create( wxThread *thread, unsigned int stackSize )
655{
656 wxASSERT_MSG( m_state == STATE_NEW && !m_tid,
657 wxT("Create()ing thread twice?") );
658
659 OSStatus err = noErr;
660 m_thread = thread;
661
662 if ( m_notifyQueueId == kInvalidID )
663 {
664 OSStatus err = MPCreateQueue( &m_notifyQueueId );
665 if (err != noErr)
666 {
667 wxLogSysError( wxT("Cant create the thread event queue") );
668
669 return false;
670 }
671 }
672
673 m_state = STATE_NEW;
674
675 err = MPCreateTask(
676 MacThreadStart, (void*)m_thread, stackSize,
677 m_notifyQueueId, &m_exitcode, 0, 0, &m_tid );
678
679 if (err != noErr)
680 {
681 wxLogSysError( wxT("Can't create thread") );
682
683 return false;
684 }
685
686 if ( m_prio != WXTHREAD_DEFAULT_PRIORITY )
687 SetPriority( m_prio );
688
689 return true;
690}
691
692void wxThreadInternal::SetPriority( int priority )
693{
694 m_prio = priority;
695
696 if (m_tid)
697 {
698 // Mac priorities range from 1 to 10,000, with a default of 100.
699 // wxWidgets priorities range from 0 to 100 with a default of 50.
700 // We can map wxWidgets to Mac priorities easily by assuming
701 // the former uses a logarithmic scale.
702 const unsigned int macPriority = (int)( exp( priority / 25.0 * log( 10.0)) + 0.5);
703
704 MPSetTaskWeight( m_tid, macPriority );
705 }
706}
707
708wxThreadError wxThreadInternal::Run()
709{
710 wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
711 wxT("thread may only be started once after Create()") );
712
713 SetState( STATE_RUNNING );
714
715 // wake up threads waiting for our start
716 SignalRun();
717
718 return wxTHREAD_NO_ERROR;
719}
720
721void wxThreadInternal::Wait()
722{
723 wxCHECK_RET( !m_isDetached, wxT("can't wait for a detached thread") );
724
725 // if the thread we're waiting for is waiting for the GUI mutex, we will
726 // deadlock so make sure we release it temporarily
727 if ( wxThread::IsMain() )
728 {
729 // give the thread we're waiting for chance to do the GUI call
730 // it might be in, we don't do this conditionally as the to be waited on
731 // thread might have to acquire the mutex later but before terminating
732 if ( wxGuiOwnedByMainThread() )
733 wxMutexGuiLeave();
734 }
735
736 {
737 wxCriticalSectionLocker lock(m_csJoinFlag);
738
739 if ( m_shouldBeJoined )
740 {
741 void *param1, *param2, *rc;
742
743 OSStatus err = MPWaitOnQueue(
744 m_notifyQueueId,
745 &param1,
746 &param2,
747 &rc,
748 kDurationForever );
749 if (err != noErr)
750 {
751 wxLogSysError( wxT( "Cannot wait for thread termination."));
752 rc = (void*) -1;
753 }
754
755 // actually param1 would be the address of m_exitcode
756 // but we don't need this here
757 m_exitcode = rc;
758
759 m_shouldBeJoined = false;
760 }
761 }
762}
763
764void wxThreadInternal::Pause()
765{
766 // the state is set from the thread which pauses us first, this function
767 // is called later so the state should have been already set
768 wxCHECK_RET( m_state == STATE_PAUSED,
769 wxT("thread must first be paused with wxThread::Pause().") );
770
771 // wait until the semaphore is Post()ed from Resume()
772 m_semSuspend.Wait();
773}
774
775void wxThreadInternal::Resume()
776{
777 wxCHECK_RET( m_state == STATE_PAUSED,
778 wxT("can't resume thread which is not suspended.") );
779
780 // the thread might be not actually paused yet - if there were no call to
781 // TestDestroy() since the last call to Pause() for example
782 if ( IsReallyPaused() )
783 {
784 // wake up Pause()
785 m_semSuspend.Post();
786
787 // reset the flag
788 SetReallyPaused( false );
789 }
790
791 SetState( STATE_RUNNING );
792}
793
794// static functions
795// ----------------
796
797wxThread *wxThread::This()
798{
799 wxThread* thr = (wxThread*) MPGetTaskStorageValue( gs_tlsForWXThread ) ;
800
801 return thr;
802}
803
489468fe
SC
804#ifdef Yield
805#undef Yield
806#endif
807
808void wxThread::Yield()
809{
810 CFRunLoopRunInMode( kCFRunLoopDefaultMode , 0 , true ) ;
811
812 MPYield();
813}
814
815void wxThread::Sleep( unsigned long milliseconds )
816{
817 AbsoluteTime wakeup = AddDurationToAbsolute( milliseconds, UpTime() );
818 MPDelayUntil( &wakeup );
819}
820
821int wxThread::GetCPUCount()
822{
823 return MPProcessors();
824}
825
826unsigned long wxThread::GetCurrentId()
827{
828 return (unsigned long)MPCurrentTaskID();
829}
830
831bool wxThread::SetConcurrency( size_t WXUNUSED(level) )
832{
833 // Cannot be set in MacOS.
834 return false;
835}
836
837wxThread::wxThread( wxThreadKind kind )
838{
839 g_numberOfThreads++;
840 m_internal = new wxThreadInternal();
841
842 m_isDetached = (kind == wxTHREAD_DETACHED);
843}
844
845wxThread::~wxThread()
846{
847 wxASSERT_MSG( g_numberOfThreads>0 , wxT("More threads deleted than created.") ) ;
848
849 g_numberOfThreads--;
850
489468fe
SC
851 m_critsect.Enter();
852
853 // check that the thread either exited or couldn't be created
854 if ( m_internal->GetState() != STATE_EXITED &&
855 m_internal->GetState() != STATE_NEW )
856 {
857 wxLogDebug(
858 wxT("The thread %ld is being destroyed although it is still running! The application may crash."),
859 GetId() );
860 }
861
862 m_critsect.Leave();
489468fe
SC
863
864 wxDELETE( m_internal ) ;
865}
866
867wxThreadError wxThread::Create( unsigned int stackSize )
868{
869 wxCriticalSectionLocker lock(m_critsect);
870
871 if ( m_isDetached )
872 m_internal->Detach() ;
873
874 if ( !m_internal->Create(this, stackSize) )
875 {
876 m_internal->SetState( STATE_EXITED );
877
878 return wxTHREAD_NO_RESOURCE;
879 }
880
881 return wxTHREAD_NO_ERROR;
882}
883
884wxThreadError wxThread::Run()
885{
886 wxCriticalSectionLocker lock(m_critsect);
887
888 wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR,
889 wxT("must call wxThread::Create() first") );
890
891 return m_internal->Run();
892}
893
894// -----------------------------------------------------------------------------
895// pause/resume
896// -----------------------------------------------------------------------------
897
898wxThreadError wxThread::Pause()
899{
900 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
9a83f860 901 wxT("a thread can't pause itself") );
489468fe
SC
902
903 wxCriticalSectionLocker lock(m_critsect);
904
905 if ( m_internal->GetState() != STATE_RUNNING )
906 {
907 wxLogDebug( wxT("Can't pause thread which is not running.") );
908
909 return wxTHREAD_NOT_RUNNING;
910 }
911
912 // just set a flag, the thread will be really paused only during the next
913 // call to TestDestroy()
914 m_internal->SetState( STATE_PAUSED );
915
916 return wxTHREAD_NO_ERROR;
917}
918
919wxThreadError wxThread::Resume()
920{
921 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
922 wxT("a thread can't resume itself") );
923
924 wxCriticalSectionLocker lock(m_critsect);
925
926 wxThreadState state = m_internal->GetState();
927
928 switch ( state )
929 {
930 case STATE_PAUSED:
931 m_internal->Resume();
932 return wxTHREAD_NO_ERROR;
933
934 case STATE_EXITED:
935 return wxTHREAD_NO_ERROR;
936
937 default:
938 wxLogDebug( wxT("Attempt to resume a thread which is not paused.") );
939
940 return wxTHREAD_MISC_ERROR;
941 }
942}
943
944// -----------------------------------------------------------------------------
945// exiting thread
946// -----------------------------------------------------------------------------
947
b95a7c31 948wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode))
489468fe
SC
949{
950 wxCHECK_MSG( This() != this, (ExitCode)-1,
951 wxT("a thread can't wait for itself") );
952
953 wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
954 wxT("can't wait for detached thread") );
955
956 m_internal->Wait();
957
958 return m_internal->GetExitCode();
959}
960
b95a7c31 961wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode))
489468fe
SC
962{
963 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
964 wxT("a thread can't delete itself") );
965
966 bool isDetached = m_isDetached;
967
968 m_critsect.Enter();
969 wxThreadState state = m_internal->GetState();
970
971 // ask the thread to stop
972 m_internal->SetCancelFlag();
973
974 m_critsect.Leave();
975
976 switch ( state )
977 {
978 case STATE_NEW:
979 // we need to wake up the thread so that PthreadStart() will
980 // terminate - right now it's blocking on run semaphore in
981 // PthreadStart()
982 m_internal->SignalRun();
983
984 // fall through
985
986 case STATE_EXITED:
987 // nothing to do
988 break;
989
990 case STATE_PAUSED:
991 // resume the thread first
992 m_internal->Resume();
993
994 // fall through
995
996 default:
997 if ( !isDetached )
998 {
999 // wait until the thread stops
1000 m_internal->Wait();
1001
1002 if ( rc )
1003 {
1004 // return the exit code of the thread
1005 *rc = m_internal->GetExitCode();
1006 }
1007 }
1008 }
1009
1010 return wxTHREAD_NO_ERROR;
1011}
1012
1013wxThreadError wxThread::Kill()
1014{
1015 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1016 wxT("a thread can't kill itself") );
1017
1018 switch ( m_internal->GetState() )
1019 {
1020 case STATE_NEW:
1021 case STATE_EXITED:
1022 return wxTHREAD_NOT_RUNNING;
1023
1024 case STATE_PAUSED:
1025 // resume the thread first
1026 Resume();
1027
1028 // fall through
1029
1030 default:
1031 OSStatus err = MPTerminateTask( m_internal->GetId() , -1 ) ;
1032 if (err != noErr)
1033 {
1034 wxLogError( wxT("Failed to terminate a thread.") );
1035
1036 return wxTHREAD_MISC_ERROR;
1037 }
1038
1039 if ( m_isDetached )
1040 {
1041 delete this ;
1042 }
1043 else
1044 {
1045 // this should be retrieved by Wait actually
1046 m_internal->SetExitCode( (void*)-1 );
1047 }
1048
1049 return wxTHREAD_NO_ERROR;
1050 }
1051}
1052
1053void wxThread::Exit( ExitCode status )
1054{
1055 wxASSERT_MSG( This() == this,
1056 wxT("wxThread::Exit() can only be called in the context of the same thread") );
1057
1058 // don't enter m_critsect before calling OnExit() because the user code
1059 // might deadlock if, for example, it signals a condition in OnExit() (a
1060 // common case) while the main thread calls any of functions entering
1061 // m_critsect on us (almost all of them do)
1062 OnExit();
1063
1064 MPTaskID threadid = m_internal->GetId();
1065
1066 if ( IsDetached() )
1067 {
1068 delete this;
1069 }
1070 else // joinable
1071 {
1072 // update the status of the joinable thread
1073 wxCriticalSectionLocker lock( m_critsect );
1074 m_internal->SetState( STATE_EXITED );
1075 }
1076
1077 MPTerminateTask( threadid, (long)status );
1078}
1079
1080// also test whether we were paused
1081bool wxThread::TestDestroy()
1082{
1083 wxASSERT_MSG( This() == this,
1084 wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );
1085
1086 m_critsect.Enter();
1087
1088 if ( m_internal->GetState() == STATE_PAUSED )
1089 {
1090 m_internal->SetReallyPaused( true );
1091
1092 // leave the crit section or the other threads will stop too if they attempt
1093 // to call any of (seemingly harmless) IsXXX() functions while we sleep
1094 m_critsect.Leave();
1095
1096 m_internal->Pause();
1097 }
1098 else
1099 {
1100 // thread wasn't requested to pause, nothing to do
1101 m_critsect.Leave();
1102 }
1103
1104 return m_internal->WasCancelled();
1105}
1106
1107// -----------------------------------------------------------------------------
1108// priority setting
1109// -----------------------------------------------------------------------------
1110
1111void wxThread::SetPriority(unsigned int prio)
1112{
1113 wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
1114 ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
1115 wxT("invalid thread priority") );
1116
1117 wxCriticalSectionLocker lock(m_critsect);
1118
1119 switch ( m_internal->GetState() )
1120 {
1121 case STATE_RUNNING:
1122 case STATE_PAUSED:
1123 case STATE_NEW:
1124 // thread not yet started, priority will be set when it is
1125 m_internal->SetPriority( prio );
1126 break;
1127
1128 case STATE_EXITED:
1129 default:
1130 wxFAIL_MSG( wxT("impossible to set thread priority in this state") );
1131 }
1132}
1133
1134unsigned int wxThread::GetPriority() const
1135{
f48a1159 1136 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
489468fe
SC
1137
1138 return m_internal->GetPriority();
1139}
1140
1141unsigned long wxThread::GetId() const
1142{
f48a1159 1143 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
489468fe
SC
1144
1145 return (unsigned long)m_internal->GetId();
1146}
1147
1148// -----------------------------------------------------------------------------
1149// state tests
1150// -----------------------------------------------------------------------------
1151
1152bool wxThread::IsRunning() const
1153{
1154 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1155
1156 return m_internal->GetState() == STATE_RUNNING;
1157}
1158
1159bool wxThread::IsAlive() const
1160{
1161 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1162
1163 switch ( m_internal->GetState() )
1164 {
1165 case STATE_RUNNING:
1166 case STATE_PAUSED:
1167 return true;
1168
1169 default:
1170 return false;
1171 }
1172}
1173
1174bool wxThread::IsPaused() const
1175{
1176 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1177
1178 return (m_internal->GetState() == STATE_PAUSED);
1179}
1180
1181// ----------------------------------------------------------------------------
1182// Automatic initialization for thread module
1183// ----------------------------------------------------------------------------
1184
1185class wxThreadModule : public wxModule
1186{
1187public:
1188 virtual bool OnInit();
1189 virtual void OnExit();
1190
1191private:
1192 DECLARE_DYNAMIC_CLASS(wxThreadModule)
1193};
1194
1195IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1196
1197bool wxThreadModule::OnInit()
1198{
03647350
VZ
1199 bool hasThreadManager =
1200#ifdef __LP64__
489468fe
SC
1201 true ; // TODO VERIFY IN NEXT BUILD
1202#else
1203 MPLibraryIsLoaded();
1204#endif
1205
1206 if ( !hasThreadManager )
1207 {
1208 wxLogError( wxT("MP thread support is not available on this system" ) ) ;
1209
1210 return false;
1211 }
1212
1213 // main thread's This() is NULL
1214 verify_noerr( MPAllocateTaskStorageIndex( &gs_tlsForWXThread ) ) ;
1215 verify_noerr( MPSetTaskStorageValue( gs_tlsForWXThread, 0 ) ) ;
1216
f9226383 1217 wxThread::ms_idMainThread = wxThread::GetCurrentId();
489468fe
SC
1218 gs_critsectWaitingForGui = new wxCriticalSection();
1219
1220 gs_critsectGui = new wxCriticalSection();
1221 gs_critsectGui->Enter();
1222
1223 return true;
1224}
1225
1226void wxThreadModule::OnExit()
1227{
1228 if ( gs_critsectGui )
1229 {
1230 if ( !wxGuiOwnedByMainThread() )
1231 {
1232 gs_critsectGui->Enter();
1233 gs_bGuiOwnedByMainThread = true;
1234 }
1235
1236 gs_critsectGui->Leave();
5276b0a5 1237 wxDELETE(gs_critsectGui);
489468fe
SC
1238 }
1239
5276b0a5 1240 wxDELETE(gs_critsectWaitingForGui);
489468fe
SC
1241}
1242
1243// ----------------------------------------------------------------------------
1244// GUI Serialization copied from MSW implementation
1245// ----------------------------------------------------------------------------
1246
1247void wxMutexGuiEnterImpl()
1248{
1249 // this would dead lock everything...
1250 wxASSERT_MSG( !wxThread::IsMain(),
1251 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
1252
1253 // the order in which we enter the critical sections here is crucial!!
1254
1255 // set the flag telling to the main thread that we want to do some GUI
1256 {
1257 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1258
1259 gs_nWaitingForGui++;
1260 }
1261
1262 wxWakeUpMainThread();
1263
1264 // now we may block here because the main thread will soon let us in
1265 // (during the next iteration of OnIdle())
1266 gs_critsectGui->Enter();
1267}
1268
1269void wxMutexGuiLeaveImpl()
1270{
1271 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1272
1273 if ( wxThread::IsMain() )
1274 {
1275 gs_bGuiOwnedByMainThread = false;
1276 }
1277 else
1278 {
1279 // decrement the number of threads waiting for GUI access now
1280 wxASSERT_MSG( gs_nWaitingForGui > 0,
1281 wxT("calling wxMutexGuiLeave() without entering it first?") );
1282
1283 gs_nWaitingForGui--;
1284
1285 wxWakeUpMainThread();
1286 }
1287
1288 gs_critsectGui->Leave();
1289}
1290
1291void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
1292{
1293 wxASSERT_MSG( wxThread::IsMain(),
1294 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1295
1296 if ( !gs_critsectWaitingForGui )
1297 return;
1298
1299 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1300
1301 if ( gs_nWaitingForGui == 0 )
1302 {
1303 // no threads are waiting for GUI - so we may acquire the lock without
1304 // any danger (but only if we don't already have it)
1305 if ( !wxGuiOwnedByMainThread() )
1306 {
1307 gs_critsectGui->Enter();
1308
1309 gs_bGuiOwnedByMainThread = true;
1310 }
1311 //else: already have it, nothing to do
1312 }
1313 else
1314 {
1315 // some threads are waiting, release the GUI lock if we have it
1316 if ( wxGuiOwnedByMainThread() )
1317 wxMutexGuiLeave();
1318 //else: some other worker thread is doing GUI
1319 }
1320}
1321
1322bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
1323{
1324 return gs_bGuiOwnedByMainThread;
1325}
1326
1327// wake up the main thread
1328void WXDLLEXPORT wxWakeUpMainThread()
1329{
1330 wxMacWakeUp();
1331}
1332
1333// ----------------------------------------------------------------------------
1334// include common implementation code
1335// ----------------------------------------------------------------------------
1336
1337#include "wx/thrimpl.cpp"
1338
1339#endif // wxUSE_THREADS