]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/thread.cpp
Corrected some wxAccessible mistakes
[wxWidgets.git] / src / msw / thread.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/msw/thread.cpp
3// Purpose: wxThread Implementation
4// Author: Original from Wolfram Gloger/Guilhem Lavaux
5// Modified by: Vadim Zeitlin to make it work :-)
6// Created: 04/22/98
7// RCS-ID: $Id$
8// Copyright: (c) Wolfram Gloger (1996, 1997), Guilhem Lavaux (1998);
9// Vadim Zeitlin (1999-2002)
10// Licence: wxWindows licence
11/////////////////////////////////////////////////////////////////////////////
12
13#ifdef __GNUG__
14 #pragma implementation "thread.h"
15#endif
16
17// ----------------------------------------------------------------------------
18// headers
19// ----------------------------------------------------------------------------
20
21// For compilers that support precompilation, includes "wx.h".
22#include "wx/wxprec.h"
23
24#if defined(__BORLANDC__)
25 #pragma hdrstop
26#endif
27
28#ifndef WX_PRECOMP
29# include "wx/wx.h"
30#endif
31
32#if wxUSE_THREADS
33
34#include "wx/msw/private.h"
35#include "wx/msw/missing.h"
36
37#include "wx/module.h"
38#include "wx/thread.h"
39
40// must have this symbol defined to get _beginthread/_endthread declarations
41#ifndef _MT
42 #define _MT
43#endif
44
45#if defined(__BORLANDC__)
46 #if !defined(__MT__)
47 // I can't set -tWM in the IDE (anyone?) so have to do this
48 #define __MT__
49 #endif
50
51 #if !defined(__MFC_COMPAT__)
52 // Needed to know about _beginthreadex etc..
53 #define __MFC_COMPAT__
54 #endif
55#endif // BC++
56
57// define wxUSE_BEGIN_THREAD if the compiler has _beginthreadex() function
58// which should be used instead of Win32 ::CreateThread() if possible
59#if defined(__VISUALC__) || \
60 (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \
61 (defined(__GNUG__) && defined(__MSVCRT__)) || \
62 defined(__WATCOMC__) || defined(__MWERKS__)
63
64 #undef wxUSE_BEGIN_THREAD
65 #define wxUSE_BEGIN_THREAD
66#endif
67
68#ifdef wxUSE_BEGIN_THREAD
69 // this is where _beginthreadex() is declared
70 #include <process.h>
71
72 // the return type of the thread function entry point
73 typedef unsigned THREAD_RETVAL;
74
75 // the calling convention of the thread function entry point
76 #define THREAD_CALLCONV __stdcall
77#else
78 // the settings for CreateThread()
79 typedef DWORD THREAD_RETVAL;
80 #define THREAD_CALLCONV WINAPI
81#endif
82
83// ----------------------------------------------------------------------------
84// constants
85// ----------------------------------------------------------------------------
86
87// the possible states of the thread ("=>" shows all possible transitions from
88// this state)
89enum wxThreadState
90{
91 STATE_NEW, // didn't start execution yet (=> RUNNING)
92 STATE_RUNNING, // thread is running (=> PAUSED, CANCELED)
93 STATE_PAUSED, // thread is temporarily suspended (=> RUNNING)
94 STATE_CANCELED, // thread should terminate a.s.a.p. (=> EXITED)
95 STATE_EXITED // thread is terminating
96};
97
98// ----------------------------------------------------------------------------
99// this module globals
100// ----------------------------------------------------------------------------
101
102// TLS index of the slot where we store the pointer to the current thread
103static DWORD gs_tlsThisThread = 0xFFFFFFFF;
104
105// id of the main thread - the one which can call GUI functions without first
106// calling wxMutexGuiEnter()
107static DWORD gs_idMainThread = 0;
108
109// if it's FALSE, some secondary thread is holding the GUI lock
110static bool gs_bGuiOwnedByMainThread = TRUE;
111
112// critical section which controls access to all GUI functions: any secondary
113// thread (i.e. except the main one) must enter this crit section before doing
114// any GUI calls
115static wxCriticalSection *gs_critsectGui = NULL;
116
117// critical section which protects gs_nWaitingForGui variable
118static wxCriticalSection *gs_critsectWaitingForGui = NULL;
119
120// number of threads waiting for GUI in wxMutexGuiEnter()
121static size_t gs_nWaitingForGui = 0;
122
123// are we waiting for a thread termination?
124static bool gs_waitingForThread = FALSE;
125
126// ============================================================================
127// Windows implementation of thread and related classes
128// ============================================================================
129
130// ----------------------------------------------------------------------------
131// wxCriticalSection
132// ----------------------------------------------------------------------------
133
134wxCriticalSection::wxCriticalSection()
135{
136 wxCOMPILE_TIME_ASSERT( sizeof(CRITICAL_SECTION) <= sizeof(wxCritSectBuffer),
137 wxCriticalSectionBufferTooSmall );
138
139 ::InitializeCriticalSection((CRITICAL_SECTION *)m_buffer);
140}
141
142wxCriticalSection::~wxCriticalSection()
143{
144 ::DeleteCriticalSection((CRITICAL_SECTION *)m_buffer);
145}
146
147void wxCriticalSection::Enter()
148{
149 ::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
150}
151
152void wxCriticalSection::Leave()
153{
154 ::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
155}
156
157// ----------------------------------------------------------------------------
158// wxMutex
159// ----------------------------------------------------------------------------
160
161class wxMutexInternal
162{
163public:
164 wxMutexInternal(wxMutexType mutexType);
165 ~wxMutexInternal();
166
167 bool IsOk() const { return m_mutex != NULL; }
168
169 wxMutexError Lock() { return LockTimeout(INFINITE); }
170 wxMutexError TryLock() { return LockTimeout(0); }
171 wxMutexError Unlock();
172
173private:
174 wxMutexError LockTimeout(DWORD milliseconds);
175
176 HANDLE m_mutex;
177
178 DECLARE_NO_COPY_CLASS(wxMutexInternal)
179};
180
181// all mutexes are recursive under Win32 so we don't use mutexType
182wxMutexInternal::wxMutexInternal(wxMutexType WXUNUSED(mutexType))
183{
184 // create a nameless (hence intra process and always private) mutex
185 m_mutex = ::CreateMutex
186 (
187 NULL, // default secutiry attributes
188 FALSE, // not initially locked
189 NULL // no name
190 );
191
192 if ( !m_mutex )
193 {
194 wxLogLastError(_T("CreateMutex()"));
195 }
196}
197
198wxMutexInternal::~wxMutexInternal()
199{
200 if ( m_mutex )
201 {
202 if ( !::CloseHandle(m_mutex) )
203 {
204 wxLogLastError(_T("CloseHandle(mutex)"));
205 }
206 }
207}
208
209wxMutexError wxMutexInternal::LockTimeout(DWORD milliseconds)
210{
211 DWORD rc = ::WaitForSingleObject(m_mutex, milliseconds);
212 if ( rc == WAIT_ABANDONED )
213 {
214 // the previous caller died without releasing the mutex, but now we can
215 // really lock it
216 wxLogDebug(_T("WaitForSingleObject() returned WAIT_ABANDONED"));
217
218 // use 0 timeout, normally we should always get it
219 rc = ::WaitForSingleObject(m_mutex, 0);
220 }
221
222 switch ( rc )
223 {
224 case WAIT_OBJECT_0:
225 // ok
226 break;
227
228 case WAIT_TIMEOUT:
229 return wxMUTEX_BUSY;
230
231 case WAIT_ABANDONED: // checked for above
232 default:
233 wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
234 // fall through
235
236 case WAIT_FAILED:
237 wxLogLastError(_T("WaitForSingleObject(mutex)"));
238 return wxMUTEX_MISC_ERROR;
239 }
240
241 return wxMUTEX_NO_ERROR;
242}
243
244wxMutexError wxMutexInternal::Unlock()
245{
246 if ( !::ReleaseMutex(m_mutex) )
247 {
248 wxLogLastError(_T("ReleaseMutex()"));
249
250 return wxMUTEX_MISC_ERROR;
251 }
252
253 return wxMUTEX_NO_ERROR;
254}
255
256// --------------------------------------------------------------------------
257// wxSemaphore
258// --------------------------------------------------------------------------
259
260// a trivial wrapper around Win32 semaphore
261class wxSemaphoreInternal
262{
263public:
264 wxSemaphoreInternal(int initialcount, int maxcount);
265 ~wxSemaphoreInternal();
266
267 bool IsOk() const { return m_semaphore != NULL; }
268
269 wxSemaError Wait() { return WaitTimeout(INFINITE); }
270
271 wxSemaError TryWait()
272 {
273 wxSemaError rc = WaitTimeout(0);
274 if ( rc == wxSEMA_TIMEOUT )
275 rc = wxSEMA_BUSY;
276
277 return rc;
278 }
279
280 wxSemaError WaitTimeout(unsigned long milliseconds);
281
282 wxSemaError Post();
283
284private:
285 HANDLE m_semaphore;
286
287 DECLARE_NO_COPY_CLASS(wxSemaphoreInternal)
288};
289
290wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
291{
292 if ( maxcount == 0 )
293 {
294 // make it practically infinite
295 maxcount = INT_MAX;
296 }
297
298 m_semaphore = ::CreateSemaphore
299 (
300 NULL, // default security attributes
301 initialcount,
302 maxcount,
303 NULL // no name
304 );
305
306 if ( !m_semaphore )
307 {
308 wxLogLastError(_T("CreateSemaphore()"));
309 }
310}
311
312wxSemaphoreInternal::~wxSemaphoreInternal()
313{
314 if ( m_semaphore )
315 {
316 if ( !::CloseHandle(m_semaphore) )
317 {
318 wxLogLastError(_T("CloseHandle(semaphore)"));
319 }
320 }
321}
322
323wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
324{
325 DWORD rc = ::WaitForSingleObject( m_semaphore, milliseconds );
326
327 switch ( rc )
328 {
329 case WAIT_OBJECT_0:
330 return wxSEMA_NO_ERROR;
331
332 case WAIT_TIMEOUT:
333 return wxSEMA_TIMEOUT;
334
335 default:
336 wxLogLastError(_T("WaitForSingleObject(semaphore)"));
337 }
338
339 return wxSEMA_MISC_ERROR;
340}
341
342wxSemaError wxSemaphoreInternal::Post()
343{
344 if ( !::ReleaseSemaphore(m_semaphore, 1, NULL /* ptr to previous count */) )
345 {
346 wxLogLastError(_T("ReleaseSemaphore"));
347
348 return wxSEMA_MISC_ERROR;
349 }
350
351 return wxSEMA_NO_ERROR;
352}
353
354// --------------------------------------------------------------------------
355// wxCondition
356// --------------------------------------------------------------------------
357
358// Win32 doesn't have explicit support for the POSIX condition variables and
359// the Win32 events have quite different semantics, so we reimplement the
360// conditions from scratch using the mutexes and semaphores
361class wxConditionInternal
362{
363public:
364 wxConditionInternal(wxMutex& mutex);
365
366 bool IsOk() const { return m_mutex.IsOk() && m_semaphore.IsOk(); }
367
368 wxCondError Wait();
369 wxCondError WaitTimeout(unsigned long milliseconds);
370
371 wxCondError Signal();
372 wxCondError Broadcast();
373
374private:
375 // the number of threads currently waiting for this condition
376 LONG m_numWaiters;
377
378 // the critical section protecting m_numWaiters
379 wxCriticalSection m_csWaiters;
380
381 wxMutex& m_mutex;
382 wxSemaphore m_semaphore;
383};
384
385wxConditionInternal::wxConditionInternal(wxMutex& mutex)
386 : m_mutex(mutex)
387{
388 // another thread can't access it until we return from ctor, so no need to
389 // protect access to m_numWaiters here
390 m_numWaiters = 0;
391}
392
393wxCondError wxConditionInternal::Wait()
394{
395 // increment the number of waiters
396 ::InterlockedIncrement(&m_numWaiters);
397
398 m_mutex.Unlock();
399
400 // a potential race condition can occur here
401 //
402 // after a thread increments nwaiters, and unlocks the mutex and before the
403 // semaphore.Wait() is called, if another thread can cause a signal to be
404 // generated
405 //
406 // this race condition is handled by using a semaphore and incrementing the
407 // semaphore only if 'nwaiters' is greater that zero since the semaphore,
408 // can 'remember' signals the race condition will not occur
409
410 // wait ( if necessary ) and decrement semaphore
411 wxSemaError err = m_semaphore.Wait();
412 m_mutex.Lock();
413
414 return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
415}
416
417wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
418{
419 ::InterlockedIncrement(&m_numWaiters);
420
421 m_mutex.Unlock();
422
423 // a race condition can occur at this point in the code
424 //
425 // please see the comments in Wait(), for details
426
427 wxSemaError err = m_semaphore.WaitTimeout(milliseconds);
428
429 if ( err == wxSEMA_BUSY )
430 {
431 // another potential race condition exists here it is caused when a
432 // 'waiting' thread timesout, and returns from WaitForSingleObject, but
433 // has not yet decremented 'nwaiters'.
434 //
435 // at this point if another thread calls signal() then the semaphore
436 // will be incremented, but the waiting thread will miss it.
437 //
438 // to handle this particular case, the waiting thread calls
439 // WaitForSingleObject again with a timeout of 0, after locking
440 // 'nwaiters_mutex'. this call does not block because of the zero
441 // timeout, but will allow the waiting thread to catch the missed
442 // signals.
443 wxCriticalSectionLocker lock(m_csWaiters);
444
445 err = m_semaphore.WaitTimeout(0);
446
447 if ( err != wxSEMA_NO_ERROR )
448 {
449 m_numWaiters--;
450 }
451 }
452
453 m_mutex.Lock();
454
455 return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
456}
457
458wxCondError wxConditionInternal::Signal()
459{
460 wxCriticalSectionLocker lock(m_csWaiters);
461
462 if ( m_numWaiters > 0 )
463 {
464 // increment the semaphore by 1
465 if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
466 return wxCOND_MISC_ERROR;
467
468 m_numWaiters--;
469 }
470
471 return wxCOND_NO_ERROR;
472}
473
474wxCondError wxConditionInternal::Broadcast()
475{
476 wxCriticalSectionLocker lock(m_csWaiters);
477
478 while ( m_numWaiters > 0 )
479 {
480 if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
481 return wxCOND_MISC_ERROR;
482
483 m_numWaiters--;
484 }
485
486 return wxCOND_NO_ERROR;
487}
488
489// ----------------------------------------------------------------------------
490// wxThread implementation
491// ----------------------------------------------------------------------------
492
493// wxThreadInternal class
494// ----------------------
495
496class wxThreadInternal
497{
498public:
499 wxThreadInternal()
500 {
501 m_hThread = 0;
502 m_state = STATE_NEW;
503 m_priority = WXTHREAD_DEFAULT_PRIORITY;
504 }
505
506 ~wxThreadInternal()
507 {
508 Free();
509 }
510
511 void Free()
512 {
513 if ( m_hThread )
514 {
515 if ( !::CloseHandle(m_hThread) )
516 {
517 wxLogLastError(wxT("CloseHandle(thread)"));
518 }
519
520 m_hThread = 0;
521 }
522 }
523
524 // create a new (suspended) thread (for the given thread object)
525 bool Create(wxThread *thread, unsigned int stackSize);
526
527 // suspend/resume/terminate
528 bool Suspend();
529 bool Resume();
530 void Cancel() { m_state = STATE_CANCELED; }
531
532 // thread state
533 void SetState(wxThreadState state) { m_state = state; }
534 wxThreadState GetState() const { return m_state; }
535
536 // thread priority
537 void SetPriority(unsigned int priority);
538 unsigned int GetPriority() const { return m_priority; }
539
540 // thread handle and id
541 HANDLE GetHandle() const { return m_hThread; }
542 DWORD GetId() const { return m_tid; }
543
544 // thread function
545 static THREAD_RETVAL THREAD_CALLCONV WinThreadStart(void *thread);
546
547private:
548 HANDLE m_hThread; // handle of the thread
549 wxThreadState m_state; // state, see wxThreadState enum
550 unsigned int m_priority; // thread priority in "wx" units
551 DWORD m_tid; // thread id
552
553 DECLARE_NO_COPY_CLASS(wxThreadInternal)
554};
555
556THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param)
557{
558 THREAD_RETVAL rc;
559 bool wasCancelled;
560
561 // first of all, check whether we hadn't been cancelled already and don't
562 // start the user code at all then
563 wxThread *thread = (wxThread *)param;
564 if ( thread->m_internal->GetState() == STATE_EXITED )
565 {
566 rc = (THREAD_RETVAL)-1;
567 wasCancelled = TRUE;
568 }
569 else // do run thread
570 {
571 // store the thread object in the TLS
572 if ( !::TlsSetValue(gs_tlsThisThread, thread) )
573 {
574 wxLogSysError(_("Can not start thread: error writing TLS."));
575
576 return (DWORD)-1;
577 }
578
579 rc = (THREAD_RETVAL)thread->Entry();
580
581 // enter m_critsect before changing the thread state
582 thread->m_critsect.Enter();
583 wasCancelled = thread->m_internal->GetState() == STATE_CANCELED;
584 thread->m_internal->SetState(STATE_EXITED);
585 thread->m_critsect.Leave();
586 }
587
588 thread->OnExit();
589
590 // if the thread was cancelled (from Delete()), then its handle is still
591 // needed there
592 if ( thread->IsDetached() && !wasCancelled )
593 {
594 // auto delete
595 delete thread;
596 }
597 //else: the joinable threads handle will be closed when Wait() is done
598
599 return rc;
600}
601
602void wxThreadInternal::SetPriority(unsigned int priority)
603{
604 m_priority = priority;
605
606 // translate wxWindows priority to the Windows one
607 int win_priority;
608 if (m_priority <= 20)
609 win_priority = THREAD_PRIORITY_LOWEST;
610 else if (m_priority <= 40)
611 win_priority = THREAD_PRIORITY_BELOW_NORMAL;
612 else if (m_priority <= 60)
613 win_priority = THREAD_PRIORITY_NORMAL;
614 else if (m_priority <= 80)
615 win_priority = THREAD_PRIORITY_ABOVE_NORMAL;
616 else if (m_priority <= 100)
617 win_priority = THREAD_PRIORITY_HIGHEST;
618 else
619 {
620 wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
621 win_priority = THREAD_PRIORITY_NORMAL;
622 }
623
624 if ( !::SetThreadPriority(m_hThread, win_priority) )
625 {
626 wxLogSysError(_("Can't set thread priority"));
627 }
628}
629
630bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
631{
632 wxASSERT_MSG( m_state == STATE_NEW && !m_hThread,
633 _T("Create()ing thread twice?") );
634
635 // for compilers which have it, we should use C RTL function for thread
636 // creation instead of Win32 API one because otherwise we will have memory
637 // leaks if the thread uses C RTL (and most threads do)
638#ifdef wxUSE_BEGIN_THREAD
639
640 // Watcom is reported to not like 0 stack size (which means "use default"
641 // for the other compilers and is also the default value for stackSize)
642#ifdef __WATCOMC__
643 if ( !stackSize )
644 stackSize = 10240;
645#endif // __WATCOMC__
646
647 m_hThread = (HANDLE)_beginthreadex
648 (
649 NULL, // default security
650 stackSize,
651 wxThreadInternal::WinThreadStart, // entry point
652 thread,
653 CREATE_SUSPENDED,
654 (unsigned int *)&m_tid
655 );
656#else // compiler doesn't have _beginthreadex
657 m_hThread = ::CreateThread
658 (
659 NULL, // default security
660 stackSize, // stack size
661 wxThreadInternal::WinThreadStart, // thread entry point
662 (LPVOID)thread, // parameter
663 CREATE_SUSPENDED, // flags
664 &m_tid // [out] thread id
665 );
666#endif // _beginthreadex/CreateThread
667
668 if ( m_hThread == NULL )
669 {
670 wxLogSysError(_("Can't create thread"));
671
672 return FALSE;
673 }
674
675 if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
676 {
677 SetPriority(m_priority);
678 }
679
680 return TRUE;
681}
682
683bool wxThreadInternal::Suspend()
684{
685 DWORD nSuspendCount = ::SuspendThread(m_hThread);
686 if ( nSuspendCount == (DWORD)-1 )
687 {
688 wxLogSysError(_("Can not suspend thread %x"), m_hThread);
689
690 return FALSE;
691 }
692
693 m_state = STATE_PAUSED;
694
695 return TRUE;
696}
697
698bool wxThreadInternal::Resume()
699{
700 DWORD nSuspendCount = ::ResumeThread(m_hThread);
701 if ( nSuspendCount == (DWORD)-1 )
702 {
703 wxLogSysError(_("Can not resume thread %x"), m_hThread);
704
705 return FALSE;
706 }
707
708 // don't change the state from STATE_EXITED because it's special and means
709 // we are going to terminate without running any user code - if we did it,
710 // the codei n Delete() wouldn't work
711 if ( m_state != STATE_EXITED )
712 {
713 m_state = STATE_RUNNING;
714 }
715
716 return TRUE;
717}
718
719// static functions
720// ----------------
721
722wxThread *wxThread::This()
723{
724 wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
725
726 // be careful, 0 may be a valid return value as well
727 if ( !thread && (::GetLastError() != NO_ERROR) )
728 {
729 wxLogSysError(_("Couldn't get the current thread pointer"));
730
731 // return NULL...
732 }
733
734 return thread;
735}
736
737bool wxThread::IsMain()
738{
739 return ::GetCurrentThreadId() == gs_idMainThread;
740}
741
742#ifdef Yield
743#undef Yield
744#endif
745
746void wxThread::Yield()
747{
748 // 0 argument to Sleep() is special and means to just give away the rest of
749 // our timeslice
750 ::Sleep(0);
751}
752
753void wxThread::Sleep(unsigned long milliseconds)
754{
755 ::Sleep(milliseconds);
756}
757
758int wxThread::GetCPUCount()
759{
760 SYSTEM_INFO si;
761 GetSystemInfo(&si);
762
763 return si.dwNumberOfProcessors;
764}
765
766unsigned long wxThread::GetCurrentId()
767{
768 return (unsigned long)::GetCurrentThreadId();
769}
770
771bool wxThread::SetConcurrency(size_t level)
772{
773 wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
774
775 // ok only for the default one
776 if ( level == 0 )
777 return 0;
778
779 // get system affinity mask first
780 HANDLE hProcess = ::GetCurrentProcess();
781 DWORD dwProcMask, dwSysMask;
782 if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
783 {
784 wxLogLastError(_T("GetProcessAffinityMask"));
785
786 return FALSE;
787 }
788
789 // how many CPUs have we got?
790 if ( dwSysMask == 1 )
791 {
792 // don't bother with all this complicated stuff - on a single
793 // processor system it doesn't make much sense anyhow
794 return level == 1;
795 }
796
797 // calculate the process mask: it's a bit vector with one bit per
798 // processor; we want to schedule the process to run on first level
799 // CPUs
800 DWORD bit = 1;
801 while ( bit )
802 {
803 if ( dwSysMask & bit )
804 {
805 // ok, we can set this bit
806 dwProcMask |= bit;
807
808 // another process added
809 if ( !--level )
810 {
811 // and that's enough
812 break;
813 }
814 }
815
816 // next bit
817 bit <<= 1;
818 }
819
820 // could we set all bits?
821 if ( level != 0 )
822 {
823 wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level);
824
825 return FALSE;
826 }
827
828 // set it: we can't link to SetProcessAffinityMask() because it doesn't
829 // exist in Win9x, use RT binding instead
830
831 typedef BOOL (*SETPROCESSAFFINITYMASK)(HANDLE, DWORD);
832
833 // can use static var because we're always in the main thread here
834 static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL;
835
836 if ( !pfnSetProcessAffinityMask )
837 {
838 HMODULE hModKernel = ::LoadLibrary(_T("kernel32"));
839 if ( hModKernel )
840 {
841 pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
842 ::GetProcAddress(hModKernel, "SetProcessAffinityMask");
843 }
844
845 // we've discovered a MT version of Win9x!
846 wxASSERT_MSG( pfnSetProcessAffinityMask,
847 _T("this system has several CPUs but no SetProcessAffinityMask function?") );
848 }
849
850 if ( !pfnSetProcessAffinityMask )
851 {
852 // msg given above - do it only once
853 return FALSE;
854 }
855
856 if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
857 {
858 wxLogLastError(_T("SetProcessAffinityMask"));
859
860 return FALSE;
861 }
862
863 return TRUE;
864}
865
866// ctor and dtor
867// -------------
868
869wxThread::wxThread(wxThreadKind kind)
870{
871 m_internal = new wxThreadInternal();
872
873 m_isDetached = kind == wxTHREAD_DETACHED;
874}
875
876wxThread::~wxThread()
877{
878 delete m_internal;
879}
880
881// create/start thread
882// -------------------
883
884wxThreadError wxThread::Create(unsigned int stackSize)
885{
886 wxCriticalSectionLocker lock(m_critsect);
887
888 if ( !m_internal->Create(this, stackSize) )
889 return wxTHREAD_NO_RESOURCE;
890
891 return wxTHREAD_NO_ERROR;
892}
893
894wxThreadError wxThread::Run()
895{
896 wxCriticalSectionLocker lock(m_critsect);
897
898 if ( m_internal->GetState() != STATE_NEW )
899 {
900 // actually, it may be almost any state at all, not only STATE_RUNNING
901 return wxTHREAD_RUNNING;
902 }
903
904 // the thread has just been created and is still suspended - let it run
905 return Resume();
906}
907
908// suspend/resume thread
909// ---------------------
910
911wxThreadError wxThread::Pause()
912{
913 wxCriticalSectionLocker lock(m_critsect);
914
915 return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
916}
917
918wxThreadError wxThread::Resume()
919{
920 wxCriticalSectionLocker lock(m_critsect);
921
922 return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
923}
924
925// stopping thread
926// ---------------
927
928wxThread::ExitCode wxThread::Wait()
929{
930 // although under Windows we can wait for any thread, it's an error to
931 // wait for a detached one in wxWin API
932 wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
933 _T("can't wait for detached thread") );
934
935 ExitCode rc = (ExitCode)-1;
936
937 (void)Delete(&rc);
938
939 m_internal->Free();
940
941 return rc;
942}
943
944wxThreadError wxThread::Delete(ExitCode *pRc)
945{
946 ExitCode rc = 0;
947
948 // Delete() is always safe to call, so consider all possible states
949
950 // we might need to resume the thread, but we might also not need to cancel
951 // it if it doesn't run yet
952 bool shouldResume = FALSE,
953 shouldCancel = TRUE,
954 isRunning = FALSE;
955
956 // check if the thread already started to run
957 {
958 wxCriticalSectionLocker lock(m_critsect);
959
960 if ( m_internal->GetState() == STATE_NEW )
961 {
962 // WinThreadStart() will see it and terminate immediately, no need
963 // to cancel the thread - but we still need to resume it to let it
964 // run
965 m_internal->SetState(STATE_EXITED);
966
967 Resume(); // it knows about STATE_EXITED special case
968
969 shouldCancel = FALSE;
970 isRunning = TRUE;
971
972 // shouldResume is correctly set to FALSE here
973 }
974 else
975 {
976 shouldResume = IsPaused();
977 }
978 }
979
980 // resume the thread if it is paused
981 if ( shouldResume )
982 Resume();
983
984 HANDLE hThread = m_internal->GetHandle();
985
986 // does is still run?
987 if ( isRunning || IsRunning() )
988 {
989 if ( IsMain() )
990 {
991 // set flag for wxIsWaitingForThread()
992 gs_waitingForThread = TRUE;
993 }
994
995 // ask the thread to terminate
996 if ( shouldCancel )
997 {
998 wxCriticalSectionLocker lock(m_critsect);
999
1000 m_internal->Cancel();
1001 }
1002
1003#if wxUSE_GUI
1004 // we can't just wait for the thread to terminate because it might be
1005 // calling some GUI functions and so it will never terminate before we
1006 // process the Windows messages that result from these functions
1007 DWORD result = 0; // suppress warnings from broken compilers
1008 do
1009 {
1010 if ( IsMain() )
1011 {
1012 // give the thread we're waiting for chance to do the GUI call
1013 // it might be in
1014 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
1015 {
1016 wxMutexGuiLeave();
1017 }
1018 }
1019
1020 result = ::MsgWaitForMultipleObjects
1021 (
1022 1, // number of objects to wait for
1023 &hThread, // the objects
1024 FALSE, // don't wait for all objects
1025 INFINITE, // no timeout
1026 QS_ALLINPUT | // return as soon as there are any events
1027 QS_ALLPOSTMESSAGE
1028 );
1029
1030 switch ( result )
1031 {
1032 case 0xFFFFFFFF:
1033 // error
1034 wxLogSysError(_("Can not wait for thread termination"));
1035 Kill();
1036 return wxTHREAD_KILLED;
1037
1038 case WAIT_OBJECT_0:
1039 // thread we're waiting for terminated
1040 break;
1041
1042 case WAIT_OBJECT_0 + 1:
1043 // new message arrived, process it
1044 if ( !wxTheApp->DoMessage() )
1045 {
1046 // WM_QUIT received: kill the thread
1047 Kill();
1048
1049 return wxTHREAD_KILLED;
1050 }
1051 break;
1052
1053 default:
1054 wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
1055 }
1056 } while ( result != WAIT_OBJECT_0 );
1057#else // !wxUSE_GUI
1058 // simply wait for the thread to terminate
1059 //
1060 // OTOH, even console apps create windows (in wxExecute, for WinSock
1061 // &c), so may be use MsgWaitForMultipleObject() too here?
1062 if ( WaitForSingleObject(hThread, INFINITE) != WAIT_OBJECT_0 )
1063 {
1064 wxFAIL_MSG(wxT("unexpected result of WaitForSingleObject"));
1065 }
1066#endif // wxUSE_GUI/!wxUSE_GUI
1067
1068 if ( IsMain() )
1069 {
1070 gs_waitingForThread = FALSE;
1071 }
1072 }
1073
1074 // although the thread might be already in the EXITED state it might not
1075 // have terminated yet and so we are not sure that it has actually
1076 // terminated if the "if" above hadn't been taken
1077 do
1078 {
1079 if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
1080 {
1081 wxLogLastError(wxT("GetExitCodeThread"));
1082
1083 rc = (ExitCode)-1;
1084 }
1085 } while ( (DWORD)rc == STILL_ACTIVE );
1086
1087 if ( IsDetached() )
1088 {
1089 // if the thread exits normally, this is done in WinThreadStart, but in
1090 // this case it would have been too early because
1091 // MsgWaitForMultipleObject() would fail if the thread handle was
1092 // closed while we were waiting on it, so we must do it here
1093 delete this;
1094 }
1095
1096 if ( pRc )
1097 *pRc = rc;
1098
1099 return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
1100}
1101
1102wxThreadError wxThread::Kill()
1103{
1104 if ( !IsRunning() )
1105 return wxTHREAD_NOT_RUNNING;
1106
1107 if ( !::TerminateThread(m_internal->GetHandle(), (DWORD)-1) )
1108 {
1109 wxLogSysError(_("Couldn't terminate thread"));
1110
1111 return wxTHREAD_MISC_ERROR;
1112 }
1113
1114 m_internal->Free();
1115
1116 if ( IsDetached() )
1117 {
1118 delete this;
1119 }
1120
1121 return wxTHREAD_NO_ERROR;
1122}
1123
1124void wxThread::Exit(ExitCode status)
1125{
1126 m_internal->Free();
1127
1128 if ( IsDetached() )
1129 {
1130 delete this;
1131 }
1132
1133#ifdef wxUSE_BEGIN_THREAD
1134 _endthreadex((unsigned)status);
1135#else // !VC++
1136 ::ExitThread((DWORD)status);
1137#endif // VC++/!VC++
1138
1139 wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
1140}
1141
1142// priority setting
1143// ----------------
1144
1145void wxThread::SetPriority(unsigned int prio)
1146{
1147 wxCriticalSectionLocker lock(m_critsect);
1148
1149 m_internal->SetPriority(prio);
1150}
1151
1152unsigned int wxThread::GetPriority() const
1153{
1154 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1155
1156 return m_internal->GetPriority();
1157}
1158
1159unsigned long wxThread::GetId() const
1160{
1161 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1162
1163 return (unsigned long)m_internal->GetId();
1164}
1165
1166bool wxThread::IsRunning() const
1167{
1168 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1169
1170 return m_internal->GetState() == STATE_RUNNING;
1171}
1172
1173bool wxThread::IsAlive() const
1174{
1175 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1176
1177 return (m_internal->GetState() == STATE_RUNNING) ||
1178 (m_internal->GetState() == STATE_PAUSED);
1179}
1180
1181bool wxThread::IsPaused() const
1182{
1183 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1184
1185 return m_internal->GetState() == STATE_PAUSED;
1186}
1187
1188bool wxThread::TestDestroy()
1189{
1190 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1191
1192 return m_internal->GetState() == STATE_CANCELED;
1193}
1194
1195// ----------------------------------------------------------------------------
1196// Automatic initialization for thread module
1197// ----------------------------------------------------------------------------
1198
1199class wxThreadModule : public wxModule
1200{
1201public:
1202 virtual bool OnInit();
1203 virtual void OnExit();
1204
1205private:
1206 DECLARE_DYNAMIC_CLASS(wxThreadModule)
1207};
1208
1209IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1210
1211bool wxThreadModule::OnInit()
1212{
1213 // allocate TLS index for storing the pointer to the current thread
1214 gs_tlsThisThread = ::TlsAlloc();
1215 if ( gs_tlsThisThread == 0xFFFFFFFF )
1216 {
1217 // in normal circumstances it will only happen if all other
1218 // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
1219 // words, this should never happen
1220 wxLogSysError(_("Thread module initialization failed: impossible to allocate index in thread local storage"));
1221
1222 return FALSE;
1223 }
1224
1225 // main thread doesn't have associated wxThread object, so store 0 in the
1226 // TLS instead
1227 if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
1228 {
1229 ::TlsFree(gs_tlsThisThread);
1230 gs_tlsThisThread = 0xFFFFFFFF;
1231
1232 wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage"));
1233
1234 return FALSE;
1235 }
1236
1237 gs_critsectWaitingForGui = new wxCriticalSection();
1238
1239 gs_critsectGui = new wxCriticalSection();
1240 gs_critsectGui->Enter();
1241
1242 // no error return for GetCurrentThreadId()
1243 gs_idMainThread = ::GetCurrentThreadId();
1244
1245 return TRUE;
1246}
1247
1248void wxThreadModule::OnExit()
1249{
1250 if ( !::TlsFree(gs_tlsThisThread) )
1251 {
1252 wxLogLastError(wxT("TlsFree failed."));
1253 }
1254
1255 if ( gs_critsectGui )
1256 {
1257 gs_critsectGui->Leave();
1258 delete gs_critsectGui;
1259 gs_critsectGui = NULL;
1260 }
1261
1262 delete gs_critsectWaitingForGui;
1263 gs_critsectWaitingForGui = NULL;
1264}
1265
1266// ----------------------------------------------------------------------------
1267// under Windows, these functions are implemented using a critical section and
1268// not a mutex, so the names are a bit confusing
1269// ----------------------------------------------------------------------------
1270
1271void WXDLLEXPORT wxMutexGuiEnter()
1272{
1273 // this would dead lock everything...
1274 wxASSERT_MSG( !wxThread::IsMain(),
1275 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
1276
1277 // the order in which we enter the critical sections here is crucial!!
1278
1279 // set the flag telling to the main thread that we want to do some GUI
1280 {
1281 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1282
1283 gs_nWaitingForGui++;
1284 }
1285
1286 wxWakeUpMainThread();
1287
1288 // now we may block here because the main thread will soon let us in
1289 // (during the next iteration of OnIdle())
1290 gs_critsectGui->Enter();
1291}
1292
1293void WXDLLEXPORT wxMutexGuiLeave()
1294{
1295 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1296
1297 if ( wxThread::IsMain() )
1298 {
1299 gs_bGuiOwnedByMainThread = FALSE;
1300 }
1301 else
1302 {
1303 // decrement the number of threads waiting for GUI access now
1304 wxASSERT_MSG( gs_nWaitingForGui > 0,
1305 wxT("calling wxMutexGuiLeave() without entering it first?") );
1306
1307 gs_nWaitingForGui--;
1308
1309 wxWakeUpMainThread();
1310 }
1311
1312 gs_critsectGui->Leave();
1313}
1314
1315void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
1316{
1317 wxASSERT_MSG( wxThread::IsMain(),
1318 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1319
1320 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1321
1322 if ( gs_nWaitingForGui == 0 )
1323 {
1324 // no threads are waiting for GUI - so we may acquire the lock without
1325 // any danger (but only if we don't already have it)
1326 if ( !wxGuiOwnedByMainThread() )
1327 {
1328 gs_critsectGui->Enter();
1329
1330 gs_bGuiOwnedByMainThread = TRUE;
1331 }
1332 //else: already have it, nothing to do
1333 }
1334 else
1335 {
1336 // some threads are waiting, release the GUI lock if we have it
1337 if ( wxGuiOwnedByMainThread() )
1338 {
1339 wxMutexGuiLeave();
1340 }
1341 //else: some other worker thread is doing GUI
1342 }
1343}
1344
1345bool WXDLLEXPORT wxGuiOwnedByMainThread()
1346{
1347 return gs_bGuiOwnedByMainThread;
1348}
1349
1350// wake up the main thread if it's in ::GetMessage()
1351void WXDLLEXPORT wxWakeUpMainThread()
1352{
1353 // sending any message would do - hopefully WM_NULL is harmless enough
1354 if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
1355 {
1356 // should never happen
1357 wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
1358 }
1359}
1360
1361bool WXDLLEXPORT wxIsWaitingForThread()
1362{
1363 return gs_waitingForThread;
1364}
1365
1366// ----------------------------------------------------------------------------
1367// include common implementation code
1368// ----------------------------------------------------------------------------
1369
1370#include "wx/thrimpl.cpp"
1371
1372#endif // wxUSE_THREADS
1373