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
 603                 // need to cancel the thread -- but we still need to resume it
 604                 // to let it 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 if ( m_state == STATE_EXITED )
 617         {
 618             return wxTHREAD_NOT_RUNNING;
 619         }
 620         else // running (but maybe paused or cancelled)
 621         {
 622             shouldResume = m_state == STATE_PAUSED;
 623         }
 624     }
 625
 626     // resume the thread if it is paused
 627     if ( shouldResume )
 628         Resume();
 629
 630     // is it still running?
 631     if ( isRunning || m_state == STATE_RUNNING )
 632     {
 633         if ( wxThread::IsMain() )
 634         {
 635             // set flag for wxIsWaitingForThread()
 636             gs_waitingForThread = TRUE;
 637         }
 638
 639         // ask the thread to terminate
 640         if ( shouldCancel )
 641         {
 642             wxCriticalSectionLocker lock(cs);
 643
 644             Cancel();
 645         }
 646
 647         // we can't just wait for the thread to terminate because it might be
 648         // calling some GUI functions and so it will never terminate before we
 649         // process the Windows messages that result from these functions
 650         // (note that even in console applications we might have to process
 651         // messages if we use wxExecute() or timers or ...)
 652         DWORD result = 0;       // suppress warnings from broken compilers
 653         do
 654         {
 655             if ( wxThread::IsMain() )
 656             {
 657                 // give the thread we're waiting for chance to do the GUI call
 658                 // it might be in
 659                 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
 660                 {
 661                     wxMutexGuiLeave();
 662                 }
 663             }
 664
 665             result = ::MsgWaitForMultipleObjects
 666                      (
 667                        1,              // number of objects to wait for
 668                        &m_hThread,     // the objects
 669                        FALSE,          // don't wait for all objects
 670                        INFINITE,       // no timeout
 671                        QS_ALLINPUT |   // return as soon as there are any events
 672                        QS_ALLPOSTMESSAGE
 673                      );
 674
 675             switch ( result )
 676             {
 677                 case 0xFFFFFFFF:
 678                     // error
 679                     wxLogSysError(_("Can not wait for thread termination"));
 680                     Kill();
 681                     return wxTHREAD_KILLED;
 682
 683                 case WAIT_OBJECT_0:
 684                     // thread we're waiting for terminated
 685                     break;
 686
 687                 case WAIT_OBJECT_0 + 1:
 688                     // new message arrived, process it -- but only if we're the
 689                     // main thread as we don't support processing messages in
 690                     // the other ones
 691                     //
 692                     // NB: we still must include QS_ALLINPUT even when waiting
 693                     //     in a secondary thread because if it had created some
 694                     //     window somehow (possible not even using wxWindows)
 695                     //     the system might dead lock then
 696                     if ( wxThread::IsMain() )
 697                     {
 698                         // it looks that sometimes WAIT_OBJECT_0 + 1 is
 699                         // returned but there are no messages in the thread
 700                         // queue -- prevent DoMessageFromThreadWait() from
 701                         // blocking inside ::GetMessage() forever in this case
 702                         ::PostMessage(NULL, WM_NULL, 0, 0);
 703
 704                         wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits()
 705                                                        : NULL;
 706
 707                         if ( traits && !traits->DoMessageFromThreadWait() )
 708                         {
 709                             // WM_QUIT received: kill the thread
 710                             Kill();
 711
 712                             return wxTHREAD_KILLED;
 713                         }
 714                     }
 715                     break;
 716
 717                 default:
 718                     wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
 719             }
 720         } while ( result != WAIT_OBJECT_0 );
 721
 722         if ( wxThread::IsMain() )
 723         {
 724             gs_waitingForThread = FALSE;
 725         }
 726     }
 727
 728     // although the thread might be already in the EXITED state it might not
 729     // have terminated yet and so we are not sure that it has actually
 730     // terminated if the "if" above hadn't been taken
 731     do
 732     {
 733         if ( !::GetExitCodeThread(m_hThread, (LPDWORD)&rc) )
 734         {
 735             wxLogLastError(wxT("GetExitCodeThread"));
 736
 737             rc = (wxThread::ExitCode)-1;
 738         }
 739     } while ( (DWORD)rc == STILL_ACTIVE );
 740
 741     if ( pRc )
 742         *pRc = rc;
 743
 744     // we don't need the thread handle any more
 745     Free();
 746
 747     wxCriticalSectionLocker lock(cs);
 748     SetState(STATE_EXITED);
 749
 750     return rc == (wxThread::ExitCode)-1 ? wxTHREAD_MISC_ERROR
 751                                         : wxTHREAD_NO_ERROR;
 752 }
 753
 754 bool wxThreadInternal::Suspend()
 755 {
 756     DWORD nSuspendCount = ::SuspendThread(m_hThread);
 757     if ( nSuspendCount == (DWORD)-1 )
 758     {
 759         wxLogSysError(_("Can not suspend thread %x"), m_hThread);
 760
 761         return FALSE;
 762     }
 763
 764     m_state = STATE_PAUSED;
 765
 766     return TRUE;
 767 }
 768
 769 bool wxThreadInternal::Resume()
 770 {
 771     DWORD nSuspendCount = ::ResumeThread(m_hThread);
 772     if ( nSuspendCount == (DWORD)-1 )
 773     {
 774         wxLogSysError(_("Can not resume thread %x"), m_hThread);
 775
 776         return FALSE;
 777     }
 778
 779     // don't change the state from STATE_EXITED because it's special and means
 780     // we are going to terminate without running any user code - if we did it,
 781     // the codei n Delete() wouldn't work
 782     if ( m_state != STATE_EXITED )
 783     {
 784         m_state = STATE_RUNNING;
 785     }
 786
 787     return TRUE;
 788 }
 789
 790 // static functions
 791 // ----------------
 792
 793 wxThread *wxThread::This()
 794 {
 795     wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
 796
 797     // be careful, 0 may be a valid return value as well
 798     if ( !thread && (::GetLastError() != NO_ERROR) )
 799     {
 800         wxLogSysError(_("Couldn't get the current thread pointer"));
 801
 802         // return NULL...
 803     }
 804
 805     return thread;
 806 }
 807
 808 bool wxThread::IsMain()
 809 {
 810     return ::GetCurrentThreadId() == gs_idMainThread;
 811 }
 812
 813 void wxThread::Yield()
 814 {
 815     // 0 argument to Sleep() is special and means to just give away the rest of
 816     // our timeslice
 817     ::Sleep(0);
 818 }
 819
 820 void wxThread::Sleep(unsigned long milliseconds)
 821 {
 822     ::Sleep(milliseconds);
 823 }
 824
 825 int wxThread::GetCPUCount()
 826 {
 827     SYSTEM_INFO si;
 828     GetSystemInfo(&si);
 829
 830     return si.dwNumberOfProcessors;
 831 }
 832
 833 unsigned long wxThread::GetCurrentId()
 834 {
 835     return (unsigned long)::GetCurrentThreadId();
 836 }
 837
 838 bool wxThread::SetConcurrency(size_t level)
 839 {
 840 #ifndef __WXWINCE__
 841     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
 842
 843     // ok only for the default one
 844     if ( level == 0 )
 845         return 0;
 846
 847     // get system affinity mask first
 848     HANDLE hProcess = ::GetCurrentProcess();
 849     DWORD dwProcMask, dwSysMask;
 850     if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
 851     {
 852         wxLogLastError(_T("GetProcessAffinityMask"));
 853
 854         return FALSE;
 855     }
 856
 857     // how many CPUs have we got?
 858     if ( dwSysMask == 1 )
 859     {
 860         // don't bother with all this complicated stuff - on a single
 861         // processor system it doesn't make much sense anyhow
 862         return level == 1;
 863     }
 864
 865     // calculate the process mask: it's a bit vector with one bit per
 866     // processor; we want to schedule the process to run on first level
 867     // CPUs
 868     DWORD bit = 1;
 869     while ( bit )
 870     {
 871         if ( dwSysMask & bit )
 872         {
 873             // ok, we can set this bit
 874             dwProcMask |= bit;
 875
 876             // another process added
 877             if ( !--level )
 878             {
 879                 // and that's enough
 880                 break;
 881             }
 882         }
 883
 884         // next bit
 885         bit <<= 1;
 886     }
 887
 888     // could we set all bits?
 889     if ( level != 0 )
 890     {
 891         wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level);
 892
 893         return FALSE;
 894     }
 895
 896     // set it: we can't link to SetProcessAffinityMask() because it doesn't
 897     // exist in Win9x, use RT binding instead
 898
 899     typedef BOOL (*SETPROCESSAFFINITYMASK)(HANDLE, DWORD);
 900
 901     // can use static var because we're always in the main thread here
 902     static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL;
 903
 904     if ( !pfnSetProcessAffinityMask )
 905     {
 906         HMODULE hModKernel = ::LoadLibrary(_T("kernel32"));
 907         if ( hModKernel )
 908         {
 909             pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
 910                 ::GetProcAddress(hModKernel, "SetProcessAffinityMask");
 911         }
 912
 913         // we've discovered a MT version of Win9x!
 914         wxASSERT_MSG( pfnSetProcessAffinityMask,
 915                       _T("this system has several CPUs but no SetProcessAffinityMask function?") );
 916     }
 917
 918     if ( !pfnSetProcessAffinityMask )
 919     {
 920         // msg given above - do it only once
 921         return FALSE;
 922     }
 923
 924     if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
 925     {
 926         wxLogLastError(_T("SetProcessAffinityMask"));
 927
 928         return FALSE;
 929     }
 930 #endif
 931     return TRUE;
 932 }
 933
 934 // ctor and dtor
 935 // -------------
 936
 937 wxThread::wxThread(wxThreadKind kind)
 938 {
 939     m_internal = new wxThreadInternal();
 940
 941     m_isDetached = kind == wxTHREAD_DETACHED;
 942 }
 943
 944 wxThread::~wxThread()
 945 {
 946     delete m_internal;
 947 }
 948
 949 // create/start thread
 950 // -------------------
 951
 952 wxThreadError wxThread::Create(unsigned int stackSize)
 953 {
 954     wxCriticalSectionLocker lock(m_critsect);
 955
 956     if ( !m_internal->Create(this, stackSize) )
 957         return wxTHREAD_NO_RESOURCE;
 958
 959     return wxTHREAD_NO_ERROR;
 960 }
 961
 962 wxThreadError wxThread::Run()
 963 {
 964     wxCriticalSectionLocker lock(m_critsect);
 965
 966     if ( m_internal->GetState() != STATE_NEW )
 967     {
 968         // actually, it may be almost any state at all, not only STATE_RUNNING
 969         return wxTHREAD_RUNNING;
 970     }
 971
 972     // the thread has just been created and is still suspended - let it run
 973     return Resume();
 974 }
 975
 976 // suspend/resume thread
 977 // ---------------------
 978
 979 wxThreadError wxThread::Pause()
 980 {
 981     wxCriticalSectionLocker lock(m_critsect);
 982
 983     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 984 }
 985
 986 wxThreadError wxThread::Resume()
 987 {
 988     wxCriticalSectionLocker lock(m_critsect);
 989
 990     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 991 }
 992
 993 // stopping thread
 994 // ---------------
 995
 996 wxThread::ExitCode wxThread::Wait()
 997 {
 998     // although under Windows we can wait for any thread, it's an error to
 999     // wait for a detached one in wxWin API
1000     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
1001                  _T("wxThread::Wait(): can't wait for detached thread") );
1002
1003     ExitCode rc = (ExitCode)-1;
1004
1005     (void)m_internal->WaitForTerminate(false, m_critsect, &rc);
1006
1007     return rc;
1008 }
1009
1010 wxThreadError wxThread::Delete(ExitCode *pRc)
1011 {
1012     return m_internal->WaitForTerminate(true, m_critsect, pRc);
1013 }
1014
1015 wxThreadError wxThread::Kill()
1016 {
1017     if ( !IsRunning() )
1018         return wxTHREAD_NOT_RUNNING;
1019
1020     wxThreadError rc = m_internal->Kill();
1021
1022     if ( IsDetached() )
1023     {
1024         delete this;
1025     }
1026     else // joinable
1027     {
1028         // update the status of the joinable thread
1029         wxCriticalSectionLocker lock(m_critsect);
1030         m_internal->SetState(STATE_EXITED);
1031     }
1032
1033     return rc;
1034 }
1035
1036 void wxThread::Exit(ExitCode status)
1037 {
1038     m_internal->Free();
1039
1040     if ( IsDetached() )
1041     {
1042         delete this;
1043     }
1044     else // joinable
1045     {
1046         // update the status of the joinable thread
1047         wxCriticalSectionLocker lock(m_critsect);
1048         m_internal->SetState(STATE_EXITED);
1049     }
1050
1051 #ifdef wxUSE_BEGIN_THREAD
1052     _endthreadex((unsigned)status);
1053 #else // !VC++
1054     ::ExitThread((DWORD)status);
1055 #endif // VC++/!VC++
1056
1057     wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
1058 }
1059
1060 // priority setting
1061 // ----------------
1062
1063 void wxThread::SetPriority(unsigned int prio)
1064 {
1065     wxCriticalSectionLocker lock(m_critsect);
1066
1067     m_internal->SetPriority(prio);
1068 }
1069
1070 unsigned int wxThread::GetPriority() const
1071 {
1072     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1073
1074     return m_internal->GetPriority();
1075 }
1076
1077 unsigned long wxThread::GetId() const
1078 {
1079     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1080
1081     return (unsigned long)m_internal->GetId();
1082 }
1083
1084 bool wxThread::IsRunning() const
1085 {
1086     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1087
1088     return m_internal->GetState() == STATE_RUNNING;
1089 }
1090
1091 bool wxThread::IsAlive() const
1092 {
1093     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1094
1095     return (m_internal->GetState() == STATE_RUNNING) ||
1096            (m_internal->GetState() == STATE_PAUSED);
1097 }
1098
1099 bool wxThread::IsPaused() const
1100 {
1101     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1102
1103     return m_internal->GetState() == STATE_PAUSED;
1104 }
1105
1106 bool wxThread::TestDestroy()
1107 {
1108     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1109
1110     return m_internal->GetState() == STATE_CANCELED;
1111 }
1112
1113 // ----------------------------------------------------------------------------
1114 // Automatic initialization for thread module
1115 // ----------------------------------------------------------------------------
1116
1117 class wxThreadModule : public wxModule
1118 {
1119 public:
1120     virtual bool OnInit();
1121     virtual void OnExit();
1122
1123 private:
1124     DECLARE_DYNAMIC_CLASS(wxThreadModule)
1125 };
1126
1127 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1128
1129 bool wxThreadModule::OnInit()
1130 {
1131     // allocate TLS index for storing the pointer to the current thread
1132     gs_tlsThisThread = ::TlsAlloc();
1133     if ( gs_tlsThisThread == 0xFFFFFFFF )
1134     {
1135         // in normal circumstances it will only happen if all other
1136         // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
1137         // words, this should never happen
1138         wxLogSysError(_("Thread module initialization failed: impossible to allocate index in thread local storage"));
1139
1140         return FALSE;
1141     }
1142
1143     // main thread doesn't have associated wxThread object, so store 0 in the
1144     // TLS instead
1145     if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
1146     {
1147         ::TlsFree(gs_tlsThisThread);
1148         gs_tlsThisThread = 0xFFFFFFFF;
1149
1150         wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage"));
1151
1152         return FALSE;
1153     }
1154
1155     gs_critsectWaitingForGui = new wxCriticalSection();
1156
1157     gs_critsectGui = new wxCriticalSection();
1158     gs_critsectGui->Enter();
1159
1160     // no error return for GetCurrentThreadId()
1161     gs_idMainThread = ::GetCurrentThreadId();
1162
1163     return TRUE;
1164 }
1165
1166 void wxThreadModule::OnExit()
1167 {
1168     if ( !::TlsFree(gs_tlsThisThread) )
1169     {
1170         wxLogLastError(wxT("TlsFree failed."));
1171     }
1172
1173     if ( gs_critsectGui )
1174     {
1175         gs_critsectGui->Leave();
1176         delete gs_critsectGui;
1177         gs_critsectGui = NULL;
1178     }
1179
1180     delete gs_critsectWaitingForGui;
1181     gs_critsectWaitingForGui = NULL;
1182 }
1183
1184 // ----------------------------------------------------------------------------
1185 // under Windows, these functions are implemented using a critical section and
1186 // not a mutex, so the names are a bit confusing
1187 // ----------------------------------------------------------------------------
1188
1189 void WXDLLIMPEXP_BASE wxMutexGuiEnter()
1190 {
1191     // this would dead lock everything...
1192     wxASSERT_MSG( !wxThread::IsMain(),
1193                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
1194
1195     // the order in which we enter the critical sections here is crucial!!
1196
1197     // set the flag telling to the main thread that we want to do some GUI
1198     {
1199         wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1200
1201         gs_nWaitingForGui++;
1202     }
1203
1204     wxWakeUpMainThread();
1205
1206     // now we may block here because the main thread will soon let us in
1207     // (during the next iteration of OnIdle())
1208     gs_critsectGui->Enter();
1209 }
1210
1211 void WXDLLIMPEXP_BASE wxMutexGuiLeave()
1212 {
1213     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1214
1215     if ( wxThread::IsMain() )
1216     {
1217         gs_bGuiOwnedByMainThread = FALSE;
1218     }
1219     else
1220     {
1221         // decrement the number of threads waiting for GUI access now
1222         wxASSERT_MSG( gs_nWaitingForGui > 0,
1223                       wxT("calling wxMutexGuiLeave() without entering it first?") );
1224
1225         gs_nWaitingForGui--;
1226
1227         wxWakeUpMainThread();
1228     }
1229
1230     gs_critsectGui->Leave();
1231 }
1232
1233 void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
1234 {
1235     wxASSERT_MSG( wxThread::IsMain(),
1236                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1237
1238     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1239
1240     if ( gs_nWaitingForGui == 0 )
1241     {
1242         // no threads are waiting for GUI - so we may acquire the lock without
1243         // any danger (but only if we don't already have it)
1244         if ( !wxGuiOwnedByMainThread() )
1245         {
1246             gs_critsectGui->Enter();
1247
1248             gs_bGuiOwnedByMainThread = TRUE;
1249         }
1250         //else: already have it, nothing to do
1251     }
1252     else
1253     {
1254         // some threads are waiting, release the GUI lock if we have it
1255         if ( wxGuiOwnedByMainThread() )
1256         {
1257             wxMutexGuiLeave();
1258         }
1259         //else: some other worker thread is doing GUI
1260     }
1261 }
1262
1263 bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
1264 {
1265     return gs_bGuiOwnedByMainThread;
1266 }
1267
1268 // wake up the main thread if it's in ::GetMessage()
1269 void WXDLLIMPEXP_BASE wxWakeUpMainThread()
1270 {
1271     // sending any message would do - hopefully WM_NULL is harmless enough
1272     if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
1273     {
1274         // should never happen
1275         wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
1276     }
1277 }
1278
1279 bool WXDLLIMPEXP_BASE wxIsWaitingForThread()
1280 {
1281     return gs_waitingForThread;
1282 }
1283
1284 // ----------------------------------------------------------------------------
1285 // include common implementation code
1286 // ----------------------------------------------------------------------------
1287
1288 #include "wx/thrimpl.cpp"
1289
1290 #endif // wxUSE_THREADS
1291