src/msw/thread.cpp

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