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