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 // wxCondition
 365 // --------------------------------------------------------------------------
 366
 367 // Win32 doesn't have explicit support for the POSIX condition variables and
 368 // the Win32 events have quite different semantics, so we reimplement the
 369 // conditions from scratch using the mutexes and semaphores
 370 class wxConditionInternal
 371 {
 372 public:
 373     wxConditionInternal(wxMutex& mutex);
 374
 375     bool IsOk() const { return m_mutex.IsOk() && m_semaphore.IsOk(); }
 376
 377     wxCondError Wait();
 378     wxCondError WaitTimeout(unsigned long milliseconds);
 379
 380     wxCondError Signal();
 381     wxCondError Broadcast();
 382
 383 private:
 384     // the number of threads currently waiting for this condition
 385     LONG m_numWaiters;
 386
 387     // the critical section protecting m_numWaiters
 388     wxCriticalSection m_csWaiters;
 389
 390     wxMutex& m_mutex;
 391     wxSemaphore m_semaphore;
 392
 393     DECLARE_NO_COPY_CLASS(wxConditionInternal)
 394 };
 395
 396 wxConditionInternal::wxConditionInternal(wxMutex& mutex)
 397                    : m_mutex(mutex)
 398 {
 399     // another thread can't access it until we return from ctor, so no need to
 400     // protect access to m_numWaiters here
 401     m_numWaiters = 0;
 402 }
 403
 404 wxCondError wxConditionInternal::Wait()
 405 {
 406     // increment the number of waiters
 407     ::InterlockedIncrement(&m_numWaiters);
 408
 409     m_mutex.Unlock();
 410
 411     // a potential race condition can occur here
 412     //
 413     // after a thread increments nwaiters, and unlocks the mutex and before the
 414     // semaphore.Wait() is called, if another thread can cause a signal to be
 415     // generated
 416     //
 417     // this race condition is handled by using a semaphore and incrementing the
 418     // semaphore only if 'nwaiters' is greater that zero since the semaphore,
 419     // can 'remember' signals the race condition will not occur
 420
 421     // wait ( if necessary ) and decrement semaphore
 422     wxSemaError err = m_semaphore.Wait();
 423     m_mutex.Lock();
 424
 425     return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
 426 }
 427
 428 wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
 429 {
 430     ::InterlockedIncrement(&m_numWaiters);
 431
 432     m_mutex.Unlock();
 433
 434     // a race condition can occur at this point in the code
 435     //
 436     // please see the comments in Wait(), for details
 437
 438     wxSemaError err = m_semaphore.WaitTimeout(milliseconds);
 439
 440     if ( err == wxSEMA_BUSY )
 441     {
 442         // another potential race condition exists here it is caused when a
 443         // 'waiting' thread timesout, and returns from WaitForSingleObject, but
 444         // has not yet decremented 'nwaiters'.
 445         //
 446         // at this point if another thread calls signal() then the semaphore
 447         // will be incremented, but the waiting thread will miss it.
 448         //
 449         // to handle this particular case, the waiting thread calls
 450         // WaitForSingleObject again with a timeout of 0, after locking
 451         // 'nwaiters_mutex'. this call does not block because of the zero
 452         // timeout, but will allow the waiting thread to catch the missed
 453         // signals.
 454         wxCriticalSectionLocker lock(m_csWaiters);
 455
 456         err = m_semaphore.WaitTimeout(0);
 457
 458         if ( err != wxSEMA_NO_ERROR )
 459         {
 460             m_numWaiters--;
 461         }
 462     }
 463
 464     m_mutex.Lock();
 465
 466     return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
 467 }
 468
 469 wxCondError wxConditionInternal::Signal()
 470 {
 471     wxCriticalSectionLocker lock(m_csWaiters);
 472
 473     if ( m_numWaiters > 0 )
 474     {
 475         // increment the semaphore by 1
 476         if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
 477             return wxCOND_MISC_ERROR;
 478
 479         m_numWaiters--;
 480     }
 481
 482     return wxCOND_NO_ERROR;
 483 }
 484
 485 wxCondError wxConditionInternal::Broadcast()
 486 {
 487     wxCriticalSectionLocker lock(m_csWaiters);
 488
 489     while ( m_numWaiters > 0 )
 490     {
 491         if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
 492             return wxCOND_MISC_ERROR;
 493
 494         m_numWaiters--;
 495     }
 496
 497     return wxCOND_NO_ERROR;
 498 }
 499
 500 // ----------------------------------------------------------------------------
 501 // wxThread implementation
 502 // ----------------------------------------------------------------------------
 503
 504 // wxThreadInternal class
 505 // ----------------------
 506
 507 class wxThreadInternal
 508 {
 509 public:
 510     wxThreadInternal()
 511     {
 512         m_hThread = 0;
 513         m_state = STATE_NEW;
 514         m_priority = WXTHREAD_DEFAULT_PRIORITY;
 515     }
 516
 517     ~wxThreadInternal()
 518     {
 519         Free();
 520     }
 521
 522     void Free()
 523     {
 524         if ( m_hThread )
 525         {
 526             if ( !::CloseHandle(m_hThread) )
 527             {
 528                 wxLogLastError(wxT("CloseHandle(thread)"));
 529             }
 530
 531             m_hThread = 0;
 532         }
 533     }
 534
 535     // create a new (suspended) thread (for the given thread object)
 536     bool Create(wxThread *thread, unsigned int stackSize);
 537
 538     // wait for the thread to terminate, either by itself, or by asking it
 539     // (politely, this is not Kill()!) to do it
 540     wxThreadError WaitForTerminate(bool shouldCancel,
 541                                    wxCriticalSection& cs,
 542                                    wxThread::ExitCode *pRc);
 543
 544     // kill the thread unconditionally
 545     wxThreadError Kill();
 546
 547     // suspend/resume/terminate
 548     bool Suspend();
 549     bool Resume();
 550     void Cancel() { m_state = STATE_CANCELED; }
 551
 552     // thread state
 553     void SetState(wxThreadState state) { m_state = state; }
 554     wxThreadState GetState() const { return m_state; }
 555
 556     // thread priority
 557     void SetPriority(unsigned int priority);
 558     unsigned int GetPriority() const { return m_priority; }
 559
 560     // thread handle and id
 561     HANDLE GetHandle() const { return m_hThread; }
 562     DWORD  GetId() const { return m_tid; }
 563
 564     // thread function
 565     static THREAD_RETVAL THREAD_CALLCONV WinThreadStart(void *thread);
 566
 567 private:
 568     HANDLE        m_hThread;    // handle of the thread
 569     wxThreadState m_state;      // state, see wxThreadState enum
 570     unsigned int  m_priority;   // thread priority in "wx" units
 571     DWORD         m_tid;        // thread id
 572
 573     DECLARE_NO_COPY_CLASS(wxThreadInternal)
 574 };
 575
 576 THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param)
 577 {
 578     THREAD_RETVAL rc;
 579     bool wasCancelled;
 580
 581     // first of all, check whether we hadn't been cancelled already and don't
 582     // start the user code at all then
 583     wxThread *thread = (wxThread *)param;
 584     if ( thread->m_internal->GetState() == STATE_EXITED )
 585     {
 586         rc = (THREAD_RETVAL)-1;
 587         wasCancelled = TRUE;
 588     }
 589     else // do run thread
 590     {
 591         // store the thread object in the TLS
 592         if ( !::TlsSetValue(gs_tlsThisThread, thread) )
 593         {
 594             wxLogSysError(_("Can not start thread: error writing TLS."));
 595
 596             return (DWORD)-1;
 597         }
 598
 599         rc = (THREAD_RETVAL)thread->Entry();
 600
 601         // enter m_critsect before changing the thread state
 602         thread->m_critsect.Enter();
 603         wasCancelled = thread->m_internal->GetState() == STATE_CANCELED;
 604         thread->m_internal->SetState(STATE_EXITED);
 605         thread->m_critsect.Leave();
 606     }
 607
 608     thread->OnExit();
 609
 610     // if the thread was cancelled (from Delete()), then its handle is still
 611     // needed there
 612     if ( thread->IsDetached() && !wasCancelled )
 613     {
 614         // auto delete
 615         delete thread;
 616     }
 617     //else: the joinable threads handle will be closed when Wait() is done
 618
 619     return rc;
 620 }
 621
 622 void wxThreadInternal::SetPriority(unsigned int priority)
 623 {
 624     m_priority = priority;
 625
 626     // translate wxWindows priority to the Windows one
 627     int win_priority;
 628     if (m_priority <= 20)
 629         win_priority = THREAD_PRIORITY_LOWEST;
 630     else if (m_priority <= 40)
 631         win_priority = THREAD_PRIORITY_BELOW_NORMAL;
 632     else if (m_priority <= 60)
 633         win_priority = THREAD_PRIORITY_NORMAL;
 634     else if (m_priority <= 80)
 635         win_priority = THREAD_PRIORITY_ABOVE_NORMAL;
 636     else if (m_priority <= 100)
 637         win_priority = THREAD_PRIORITY_HIGHEST;
 638     else
 639     {
 640         wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
 641         win_priority = THREAD_PRIORITY_NORMAL;
 642     }
 643
 644     if ( !::SetThreadPriority(m_hThread, win_priority) )
 645     {
 646         wxLogSysError(_("Can't set thread priority"));
 647     }
 648 }
 649
 650 bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
 651 {
 652     wxASSERT_MSG( m_state == STATE_NEW && !m_hThread,
 653                     _T("Create()ing thread twice?") );
 654
 655     // for compilers which have it, we should use C RTL function for thread
 656     // creation instead of Win32 API one because otherwise we will have memory
 657     // leaks if the thread uses C RTL (and most threads do)
 658 #ifdef wxUSE_BEGIN_THREAD
 659
 660     // Watcom is reported to not like 0 stack size (which means "use default"
 661     // for the other compilers and is also the default value for stackSize)
 662 #ifdef __WATCOMC__
 663     if ( !stackSize )
 664         stackSize = 10240;
 665 #endif // __WATCOMC__
 666
 667     m_hThread = (HANDLE)_beginthreadex
 668                         (
 669                           NULL,                             // default security
 670                           stackSize,
 671                           wxThreadInternal::WinThreadStart, // entry point
 672                           thread,
 673                           CREATE_SUSPENDED,
 674                           (unsigned int *)&m_tid
 675                         );
 676 #else // compiler doesn't have _beginthreadex
 677     m_hThread = ::CreateThread
 678                   (
 679                     NULL,                               // default security
 680                     stackSize,                          // stack size
 681                     wxThreadInternal::WinThreadStart,   // thread entry point
 682                     (LPVOID)thread,                     // parameter
 683                     CREATE_SUSPENDED,                   // flags
 684                     &m_tid                              // [out] thread id
 685                   );
 686 #endif // _beginthreadex/CreateThread
 687
 688     if ( m_hThread == NULL )
 689     {
 690         wxLogSysError(_("Can't create thread"));
 691
 692         return FALSE;
 693     }
 694
 695     if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
 696     {
 697         SetPriority(m_priority);
 698     }
 699
 700     return TRUE;
 701 }
 702
 703 wxThreadError wxThreadInternal::Kill()
 704 {
 705     if ( !::TerminateThread(m_hThread, (DWORD)-1) )
 706     {
 707         wxLogSysError(_("Couldn't terminate thread"));
 708
 709         return wxTHREAD_MISC_ERROR;
 710     }
 711
 712     Free();
 713
 714     return wxTHREAD_NO_ERROR;
 715 }
 716
 717 wxThreadError
 718 wxThreadInternal::WaitForTerminate(bool shouldCancel,
 719                                    wxCriticalSection& cs,
 720                                    wxThread::ExitCode *pRc)
 721 {
 722     wxThread::ExitCode rc = 0;
 723
 724     // Delete() is always safe to call, so consider all possible states
 725
 726     // we might need to resume the thread, but we might also not need to cancel
 727     // it if it doesn't run yet
 728     bool shouldResume = FALSE,
 729          isRunning = FALSE;
 730
 731     // check if the thread already started to run
 732     {
 733         wxCriticalSectionLocker lock(cs);
 734
 735         if ( m_state == STATE_NEW )
 736         {
 737             if ( shouldCancel )
 738             {
 739                 // WinThreadStart() will see it and terminate immediately, no need
 740                 // to cancel the thread - but we still need to resume it to let it
 741                 // run
 742                 m_state = STATE_EXITED;
 743
 744                 Resume();   // it knows about STATE_EXITED special case
 745
 746                 shouldCancel = FALSE;
 747             }
 748
 749             isRunning = TRUE;
 750
 751             // shouldResume is correctly set to FALSE here
 752         }
 753         else
 754         {
 755             shouldResume = m_state == STATE_PAUSED;
 756         }
 757     }
 758
 759     // resume the thread if it is paused
 760     if ( shouldResume )
 761         Resume();
 762
 763     // does is still run?
 764     if ( isRunning || m_state == STATE_RUNNING )
 765     {
 766         if ( wxThread::IsMain() )
 767         {
 768             // set flag for wxIsWaitingForThread()
 769             gs_waitingForThread = TRUE;
 770         }
 771
 772         // ask the thread to terminate
 773         if ( shouldCancel )
 774         {
 775             wxCriticalSectionLocker lock(cs);
 776
 777             Cancel();
 778         }
 779
 780         // we can't just wait for the thread to terminate because it might be
 781         // calling some GUI functions and so it will never terminate before we
 782         // process the Windows messages that result from these functions
 783         // (note that even in console applications we might have to process
 784         // messages if we use wxExecute() or timers or ...)
 785         DWORD result = 0;       // suppress warnings from broken compilers
 786         do
 787         {
 788             if ( wxThread::IsMain() )
 789             {
 790                 // give the thread we're waiting for chance to do the GUI call
 791                 // it might be in
 792                 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
 793                 {
 794                     wxMutexGuiLeave();
 795                 }
 796             }
 797
 798             result = ::MsgWaitForMultipleObjects
 799                      (
 800                        1,              // number of objects to wait for
 801                        &m_hThread,     // the objects
 802                        FALSE,          // don't wait for all objects
 803                        INFINITE,       // no timeout
 804                        QS_ALLINPUT |   // return as soon as there are any events
 805                        QS_ALLPOSTMESSAGE
 806                      );
 807
 808             switch ( result )
 809             {
 810                 case 0xFFFFFFFF:
 811                     // error
 812                     wxLogSysError(_("Can not wait for thread termination"));
 813                     Kill();
 814                     return wxTHREAD_KILLED;
 815
 816                 case WAIT_OBJECT_0:
 817                     // thread we're waiting for terminated
 818                     break;
 819
 820                 case WAIT_OBJECT_0 + 1:
 821                     // new message arrived, process it -- but only if we're the
 822                     // main thread as we don't support processing messages in
 823                     // the other ones
 824                     //
 825                     // NB: we still must include QS_ALLINPUT even when waiting
 826                     //     in a secondary thread because if it had created some
 827                     //     window somehow (possible not even using wxWindows)
 828                     //     the system might dead lock then
 829                     if ( wxThread::IsMain() )
 830                     {
 831                         // it looks that sometimes WAIT_OBJECT_0 + 1 is
 832                         // returned but there are no messages in the thread
 833                         // queue -- prevent DoMessageFromThreadWait() from
 834                         // blocking inside ::GetMessage() forever in this case
 835                         ::PostMessage(NULL, WM_NULL, 0, 0);
 836
 837                         wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits()
 838                                                        : NULL;
 839
 840                         if ( traits && !traits->DoMessageFromThreadWait() )
 841                         {
 842                             // WM_QUIT received: kill the thread
 843                             Kill();
 844
 845                             return wxTHREAD_KILLED;
 846                         }
 847                     }
 848                     break;
 849
 850                 default:
 851                     wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
 852             }
 853         } while ( result != WAIT_OBJECT_0 );
 854
 855         if ( wxThread::IsMain() )
 856         {
 857             gs_waitingForThread = FALSE;
 858         }
 859     }
 860
 861     // although the thread might be already in the EXITED state it might not
 862     // have terminated yet and so we are not sure that it has actually
 863     // terminated if the "if" above hadn't been taken
 864     do
 865     {
 866         if ( !::GetExitCodeThread(m_hThread, (LPDWORD)&rc) )
 867         {
 868             wxLogLastError(wxT("GetExitCodeThread"));
 869
 870             rc = (wxThread::ExitCode)-1;
 871         }
 872     } while ( (DWORD)rc == STILL_ACTIVE );
 873
 874     if ( pRc )
 875         *pRc = rc;
 876
 877     return rc == (wxThread::ExitCode)-1 ? wxTHREAD_MISC_ERROR
 878                                         : wxTHREAD_NO_ERROR;
 879 }
 880
 881 bool wxThreadInternal::Suspend()
 882 {
 883     DWORD nSuspendCount = ::SuspendThread(m_hThread);
 884     if ( nSuspendCount == (DWORD)-1 )
 885     {
 886         wxLogSysError(_("Can not suspend thread %x"), m_hThread);
 887
 888         return FALSE;
 889     }
 890
 891     m_state = STATE_PAUSED;
 892
 893     return TRUE;
 894 }
 895
 896 bool wxThreadInternal::Resume()
 897 {
 898     DWORD nSuspendCount = ::ResumeThread(m_hThread);
 899     if ( nSuspendCount == (DWORD)-1 )
 900     {
 901         wxLogSysError(_("Can not resume thread %x"), m_hThread);
 902
 903         return FALSE;
 904     }
 905
 906     // don't change the state from STATE_EXITED because it's special and means
 907     // we are going to terminate without running any user code - if we did it,
 908     // the codei n Delete() wouldn't work
 909     if ( m_state != STATE_EXITED )
 910     {
 911         m_state = STATE_RUNNING;
 912     }
 913
 914     return TRUE;
 915 }
 916
 917 // static functions
 918 // ----------------
 919
 920 wxThread *wxThread::This()
 921 {
 922     wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
 923
 924     // be careful, 0 may be a valid return value as well
 925     if ( !thread && (::GetLastError() != NO_ERROR) )
 926     {
 927         wxLogSysError(_("Couldn't get the current thread pointer"));
 928
 929         // return NULL...
 930     }
 931
 932     return thread;
 933 }
 934
 935 bool wxThread::IsMain()
 936 {
 937     return ::GetCurrentThreadId() == gs_idMainThread;
 938 }
 939
 940 #ifdef Yield
 941 #undef Yield
 942 #endif
 943
 944 void wxThread::Yield()
 945 {
 946     // 0 argument to Sleep() is special and means to just give away the rest of
 947     // our timeslice
 948     ::Sleep(0);
 949 }
 950
 951 void wxThread::Sleep(unsigned long milliseconds)
 952 {
 953     ::Sleep(milliseconds);
 954 }
 955
 956 int wxThread::GetCPUCount()
 957 {
 958     SYSTEM_INFO si;
 959     GetSystemInfo(&si);
 960
 961     return si.dwNumberOfProcessors;
 962 }
 963
 964 unsigned long wxThread::GetCurrentId()
 965 {
 966     return (unsigned long)::GetCurrentThreadId();
 967 }
 968
 969 bool wxThread::SetConcurrency(size_t level)
 970 {
 971 #ifndef __WXWINCE__
 972     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
 973
 974     // ok only for the default one
 975     if ( level == 0 )
 976         return 0;
 977
 978     // get system affinity mask first
 979     HANDLE hProcess = ::GetCurrentProcess();
 980     DWORD dwProcMask, dwSysMask;
 981     if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
 982     {
 983         wxLogLastError(_T("GetProcessAffinityMask"));
 984
 985         return FALSE;
 986     }
 987
 988     // how many CPUs have we got?
 989     if ( dwSysMask == 1 )
 990     {
 991         // don't bother with all this complicated stuff - on a single
 992         // processor system it doesn't make much sense anyhow
 993         return level == 1;
 994     }
 995
 996     // calculate the process mask: it's a bit vector with one bit per
 997     // processor; we want to schedule the process to run on first level
 998     // CPUs
 999     DWORD bit = 1;
1000     while ( bit )
1001     {
1002         if ( dwSysMask & bit )
1003         {
1004             // ok, we can set this bit
1005             dwProcMask |= bit;
1006
1007             // another process added
1008             if ( !--level )
1009             {
1010                 // and that's enough
1011                 break;
1012             }
1013         }
1014
1015         // next bit
1016         bit <<= 1;
1017     }
1018
1019     // could we set all bits?
1020     if ( level != 0 )
1021     {
1022         wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level);
1023
1024         return FALSE;
1025     }
1026
1027     // set it: we can't link to SetProcessAffinityMask() because it doesn't
1028     // exist in Win9x, use RT binding instead
1029
1030     typedef BOOL (*SETPROCESSAFFINITYMASK)(HANDLE, DWORD);
1031
1032     // can use static var because we're always in the main thread here
1033     static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL;
1034
1035     if ( !pfnSetProcessAffinityMask )
1036     {
1037         HMODULE hModKernel = ::LoadLibrary(_T("kernel32"));
1038         if ( hModKernel )
1039         {
1040             pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
1041                 ::GetProcAddress(hModKernel, "SetProcessAffinityMask");
1042         }
1043
1044         // we've discovered a MT version of Win9x!
1045         wxASSERT_MSG( pfnSetProcessAffinityMask,
1046                       _T("this system has several CPUs but no SetProcessAffinityMask function?") );
1047     }
1048
1049     if ( !pfnSetProcessAffinityMask )
1050     {
1051         // msg given above - do it only once
1052         return FALSE;
1053     }
1054
1055     if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
1056     {
1057         wxLogLastError(_T("SetProcessAffinityMask"));
1058
1059         return FALSE;
1060     }
1061 #endif
1062     return TRUE;
1063 }
1064
1065 // ctor and dtor
1066 // -------------
1067
1068 wxThread::wxThread(wxThreadKind kind)
1069 {
1070     m_internal = new wxThreadInternal();
1071
1072     m_isDetached = kind == wxTHREAD_DETACHED;
1073 }
1074
1075 wxThread::~wxThread()
1076 {
1077     delete m_internal;
1078 }
1079
1080 // create/start thread
1081 // -------------------
1082
1083 wxThreadError wxThread::Create(unsigned int stackSize)
1084 {
1085     wxCriticalSectionLocker lock(m_critsect);
1086
1087     if ( !m_internal->Create(this, stackSize) )
1088         return wxTHREAD_NO_RESOURCE;
1089
1090     return wxTHREAD_NO_ERROR;
1091 }
1092
1093 wxThreadError wxThread::Run()
1094 {
1095     wxCriticalSectionLocker lock(m_critsect);
1096
1097     if ( m_internal->GetState() != STATE_NEW )
1098     {
1099         // actually, it may be almost any state at all, not only STATE_RUNNING
1100         return wxTHREAD_RUNNING;
1101     }
1102
1103     // the thread has just been created and is still suspended - let it run
1104     return Resume();
1105 }
1106
1107 // suspend/resume thread
1108 // ---------------------
1109
1110 wxThreadError wxThread::Pause()
1111 {
1112     wxCriticalSectionLocker lock(m_critsect);
1113
1114     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1115 }
1116
1117 wxThreadError wxThread::Resume()
1118 {
1119     wxCriticalSectionLocker lock(m_critsect);
1120
1121     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1122 }
1123
1124 // stopping thread
1125 // ---------------
1126
1127 wxThread::ExitCode wxThread::Wait()
1128 {
1129     // although under Windows we can wait for any thread, it's an error to
1130     // wait for a detached one in wxWin API
1131     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
1132                  _T("wxThread::Wait(): can't wait for detached thread") );
1133
1134     ExitCode rc = (ExitCode)-1;
1135
1136     (void)m_internal->WaitForTerminate(false, m_critsect, &rc);
1137
1138     m_internal->Free();
1139
1140     wxCriticalSectionLocker lock(m_critsect);
1141     m_internal->SetState(STATE_EXITED);
1142
1143     return rc;
1144 }
1145
1146 wxThreadError wxThread::Delete(ExitCode *pRc)
1147 {
1148     wxThreadError rc = m_internal->WaitForTerminate(true, m_critsect, pRc);
1149
1150     if ( IsDetached() )
1151     {
1152         delete this;
1153     }
1154     else // joinable
1155     {
1156         // update the status of the joinable thread
1157         wxCriticalSectionLocker lock(m_critsect);
1158         m_internal->SetState(STATE_EXITED);
1159     }
1160
1161     return rc;
1162 }
1163
1164 wxThreadError wxThread::Kill()
1165 {
1166     if ( !IsRunning() )
1167         return wxTHREAD_NOT_RUNNING;
1168
1169     wxThreadError rc = m_internal->Kill();
1170
1171     if ( IsDetached() )
1172     {
1173         delete this;
1174     }
1175     else // joinable
1176     {
1177         // update the status of the joinable thread
1178         wxCriticalSectionLocker lock(m_critsect);
1179         m_internal->SetState(STATE_EXITED);
1180     }
1181
1182     return rc;
1183 }
1184
1185 void wxThread::Exit(ExitCode status)
1186 {
1187     m_internal->Free();
1188
1189     if ( IsDetached() )
1190     {
1191         delete this;
1192     }
1193     else // joinable
1194     {
1195         // update the status of the joinable thread
1196         wxCriticalSectionLocker lock(m_critsect);
1197         m_internal->SetState(STATE_EXITED);
1198     }
1199
1200 #ifdef wxUSE_BEGIN_THREAD
1201     _endthreadex((unsigned)status);
1202 #else // !VC++
1203     ::ExitThread((DWORD)status);
1204 #endif // VC++/!VC++
1205
1206     wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
1207 }
1208
1209 // priority setting
1210 // ----------------
1211
1212 void wxThread::SetPriority(unsigned int prio)
1213 {
1214     wxCriticalSectionLocker lock(m_critsect);
1215
1216     m_internal->SetPriority(prio);
1217 }
1218
1219 unsigned int wxThread::GetPriority() const
1220 {
1221     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1222
1223     return m_internal->GetPriority();
1224 }
1225
1226 unsigned long wxThread::GetId() const
1227 {
1228     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1229
1230     return (unsigned long)m_internal->GetId();
1231 }
1232
1233 bool wxThread::IsRunning() const
1234 {
1235     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1236
1237     return m_internal->GetState() == STATE_RUNNING;
1238 }
1239
1240 bool wxThread::IsAlive() const
1241 {
1242     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1243
1244     return (m_internal->GetState() == STATE_RUNNING) ||
1245            (m_internal->GetState() == STATE_PAUSED);
1246 }
1247
1248 bool wxThread::IsPaused() const
1249 {
1250     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1251
1252     return m_internal->GetState() == STATE_PAUSED;
1253 }
1254
1255 bool wxThread::TestDestroy()
1256 {
1257     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1258
1259     return m_internal->GetState() == STATE_CANCELED;
1260 }
1261
1262 // ----------------------------------------------------------------------------
1263 // Automatic initialization for thread module
1264 // ----------------------------------------------------------------------------
1265
1266 class wxThreadModule : public wxModule
1267 {
1268 public:
1269     virtual bool OnInit();
1270     virtual void OnExit();
1271
1272 private:
1273     DECLARE_DYNAMIC_CLASS(wxThreadModule)
1274 };
1275
1276 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1277
1278 bool wxThreadModule::OnInit()
1279 {
1280     // allocate TLS index for storing the pointer to the current thread
1281     gs_tlsThisThread = ::TlsAlloc();
1282     if ( gs_tlsThisThread == 0xFFFFFFFF )
1283     {
1284         // in normal circumstances it will only happen if all other
1285         // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
1286         // words, this should never happen
1287         wxLogSysError(_("Thread module initialization failed: impossible to allocate index in thread local storage"));
1288
1289         return FALSE;
1290     }
1291
1292     // main thread doesn't have associated wxThread object, so store 0 in the
1293     // TLS instead
1294     if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
1295     {
1296         ::TlsFree(gs_tlsThisThread);
1297         gs_tlsThisThread = 0xFFFFFFFF;
1298
1299         wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage"));
1300
1301         return FALSE;
1302     }
1303
1304     gs_critsectWaitingForGui = new wxCriticalSection();
1305
1306     gs_critsectGui = new wxCriticalSection();
1307     gs_critsectGui->Enter();
1308
1309     // no error return for GetCurrentThreadId()
1310     gs_idMainThread = ::GetCurrentThreadId();
1311
1312     return TRUE;
1313 }
1314
1315 void wxThreadModule::OnExit()
1316 {
1317     if ( !::TlsFree(gs_tlsThisThread) )
1318     {
1319         wxLogLastError(wxT("TlsFree failed."));
1320     }
1321
1322     if ( gs_critsectGui )
1323     {
1324         gs_critsectGui->Leave();
1325         delete gs_critsectGui;
1326         gs_critsectGui = NULL;
1327     }
1328
1329     delete gs_critsectWaitingForGui;
1330     gs_critsectWaitingForGui = NULL;
1331 }
1332
1333 // ----------------------------------------------------------------------------
1334 // under Windows, these functions are implemented using a critical section and
1335 // not a mutex, so the names are a bit confusing
1336 // ----------------------------------------------------------------------------
1337
1338 void WXDLLIMPEXP_BASE wxMutexGuiEnter()
1339 {
1340     // this would dead lock everything...
1341     wxASSERT_MSG( !wxThread::IsMain(),
1342                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
1343
1344     // the order in which we enter the critical sections here is crucial!!
1345
1346     // set the flag telling to the main thread that we want to do some GUI
1347     {
1348         wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1349
1350         gs_nWaitingForGui++;
1351     }
1352
1353     wxWakeUpMainThread();
1354
1355     // now we may block here because the main thread will soon let us in
1356     // (during the next iteration of OnIdle())
1357     gs_critsectGui->Enter();
1358 }
1359
1360 void WXDLLIMPEXP_BASE wxMutexGuiLeave()
1361 {
1362     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1363
1364     if ( wxThread::IsMain() )
1365     {
1366         gs_bGuiOwnedByMainThread = FALSE;
1367     }
1368     else
1369     {
1370         // decrement the number of threads waiting for GUI access now
1371         wxASSERT_MSG( gs_nWaitingForGui > 0,
1372                       wxT("calling wxMutexGuiLeave() without entering it first?") );
1373
1374         gs_nWaitingForGui--;
1375
1376         wxWakeUpMainThread();
1377     }
1378
1379     gs_critsectGui->Leave();
1380 }
1381
1382 void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
1383 {
1384     wxASSERT_MSG( wxThread::IsMain(),
1385                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1386
1387     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1388
1389     if ( gs_nWaitingForGui == 0 )
1390     {
1391         // no threads are waiting for GUI - so we may acquire the lock without
1392         // any danger (but only if we don't already have it)
1393         if ( !wxGuiOwnedByMainThread() )
1394         {
1395             gs_critsectGui->Enter();
1396
1397             gs_bGuiOwnedByMainThread = TRUE;
1398         }
1399         //else: already have it, nothing to do
1400     }
1401     else
1402     {
1403         // some threads are waiting, release the GUI lock if we have it
1404         if ( wxGuiOwnedByMainThread() )
1405         {
1406             wxMutexGuiLeave();
1407         }
1408         //else: some other worker thread is doing GUI
1409     }
1410 }
1411
1412 bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
1413 {
1414     return gs_bGuiOwnedByMainThread;
1415 }
1416
1417 // wake up the main thread if it's in ::GetMessage()
1418 void WXDLLIMPEXP_BASE wxWakeUpMainThread()
1419 {
1420     // sending any message would do - hopefully WM_NULL is harmless enough
1421     if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
1422     {
1423         // should never happen
1424         wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
1425     }
1426 }
1427
1428 bool WXDLLIMPEXP_BASE wxIsWaitingForThread()
1429 {
1430     return gs_waitingForThread;
1431 }
1432
1433 // ----------------------------------------------------------------------------
1434 // include common implementation code
1435 // ----------------------------------------------------------------------------
1436
1437 #include "wx/thrimpl.cpp"
1438
1439 #endif // wxUSE_THREADS
1440