src/msw/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/thread.cpp
   3 // Purpose:     wxThread Implementation
   4 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
   5 // Modified by: Vadim Zeitlin to make it work :-)
   6 // Created:     04/22/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Wolfram Gloger (1996, 1997), Guilhem Lavaux (1998);
   9 //                  Vadim Zeitlin (1999-2002)
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  14     #pragma implementation "thread.h"
  15 #endif
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 // For compilers that support precompilation, includes "wx.h".
  22 #include "wx/wxprec.h"
  23
  24 #if defined(__BORLANDC__)
  25     #pragma hdrstop
  26 #endif
  27
  28 #ifndef WX_PRECOMP
  29     #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
 822                     {
 823                         // it looks that sometimes WAIT_OBJECT_0 + 1 is
 824                         // returned but there are no messages in the thread
 825                         // queue -- prevent DoMessageFromThreadWait() from
 826                         // blocking inside ::GetMessage() forever in this case
 827                         ::PostMessage(NULL, WM_NULL, 0, 0);
 828
 829                         wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits()
 830                                                        : NULL;
 831
 832                         if ( traits && !traits->DoMessageFromThreadWait() )
 833                         {
 834                             // WM_QUIT received: kill the thread
 835                             Kill();
 836
 837                             return wxTHREAD_KILLED;
 838                         }
 839                     }
 840                     break;
 841
 842                 default:
 843                     wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
 844             }
 845         } while ( result != WAIT_OBJECT_0 );
 846
 847         if ( wxThread::IsMain() )
 848         {
 849             gs_waitingForThread = FALSE;
 850         }
 851     }
 852
 853     // although the thread might be already in the EXITED state it might not
 854     // have terminated yet and so we are not sure that it has actually
 855     // terminated if the "if" above hadn't been taken
 856     do
 857     {
 858         if ( !::GetExitCodeThread(m_hThread, (LPDWORD)&rc) )
 859         {
 860             wxLogLastError(wxT("GetExitCodeThread"));
 861
 862             rc = (wxThread::ExitCode)-1;
 863         }
 864     } while ( (DWORD)rc == STILL_ACTIVE );
 865
 866     if ( pRc )
 867         *pRc = rc;
 868
 869     return rc == (wxThread::ExitCode)-1 ? wxTHREAD_MISC_ERROR
 870                                         : wxTHREAD_NO_ERROR;
 871 }
 872
 873 bool wxThreadInternal::Suspend()
 874 {
 875     DWORD nSuspendCount = ::SuspendThread(m_hThread);
 876     if ( nSuspendCount == (DWORD)-1 )
 877     {
 878         wxLogSysError(_("Can not suspend thread %x"), m_hThread);
 879
 880         return FALSE;
 881     }
 882
 883     m_state = STATE_PAUSED;
 884
 885     return TRUE;
 886 }
 887
 888 bool wxThreadInternal::Resume()
 889 {
 890     DWORD nSuspendCount = ::ResumeThread(m_hThread);
 891     if ( nSuspendCount == (DWORD)-1 )
 892     {
 893         wxLogSysError(_("Can not resume thread %x"), m_hThread);
 894
 895         return FALSE;
 896     }
 897
 898     // don't change the state from STATE_EXITED because it's special and means
 899     // we are going to terminate without running any user code - if we did it,
 900     // the codei n Delete() wouldn't work
 901     if ( m_state != STATE_EXITED )
 902     {
 903         m_state = STATE_RUNNING;
 904     }
 905
 906     return TRUE;
 907 }
 908
 909 // static functions
 910 // ----------------
 911
 912 wxThread *wxThread::This()
 913 {
 914     wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
 915
 916     // be careful, 0 may be a valid return value as well
 917     if ( !thread && (::GetLastError() != NO_ERROR) )
 918     {
 919         wxLogSysError(_("Couldn't get the current thread pointer"));
 920
 921         // return NULL...
 922     }
 923
 924     return thread;
 925 }
 926
 927 bool wxThread::IsMain()
 928 {
 929     return ::GetCurrentThreadId() == gs_idMainThread;
 930 }
 931
 932 #ifdef Yield
 933 #undef Yield
 934 #endif
 935
 936 void wxThread::Yield()
 937 {
 938     // 0 argument to Sleep() is special and means to just give away the rest of
 939     // our timeslice
 940     ::Sleep(0);
 941 }
 942
 943 void wxThread::Sleep(unsigned long milliseconds)
 944 {
 945     ::Sleep(milliseconds);
 946 }
 947
 948 int wxThread::GetCPUCount()
 949 {
 950     SYSTEM_INFO si;
 951     GetSystemInfo(&si);
 952
 953     return si.dwNumberOfProcessors;
 954 }
 955
 956 unsigned long wxThread::GetCurrentId()
 957 {
 958     return (unsigned long)::GetCurrentThreadId();
 959 }
 960
 961 bool wxThread::SetConcurrency(size_t level)
 962 {
 963 #ifndef __WXWINCE__
 964     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
 965
 966     // ok only for the default one
 967     if ( level == 0 )
 968         return 0;
 969
 970     // get system affinity mask first
 971     HANDLE hProcess = ::GetCurrentProcess();
 972     DWORD dwProcMask, dwSysMask;
 973     if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
 974     {
 975         wxLogLastError(_T("GetProcessAffinityMask"));
 976
 977         return FALSE;
 978     }
 979
 980     // how many CPUs have we got?
 981     if ( dwSysMask == 1 )
 982     {
 983         // don't bother with all this complicated stuff - on a single
 984         // processor system it doesn't make much sense anyhow
 985         return level == 1;
 986     }
 987
 988     // calculate the process mask: it's a bit vector with one bit per
 989     // processor; we want to schedule the process to run on first level
 990     // CPUs
 991     DWORD bit = 1;
 992     while ( bit )
 993     {
 994         if ( dwSysMask & bit )
 995         {
 996             // ok, we can set this bit
 997             dwProcMask |= bit;
 998
 999             // another process added
1000             if ( !--level )
1001             {
1002                 // and that's enough
1003                 break;
1004             }
1005         }
1006
1007         // next bit
1008         bit <<= 1;
1009     }
1010
1011     // could we set all bits?
1012     if ( level != 0 )
1013     {
1014         wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level);
1015
1016         return FALSE;
1017     }
1018
1019     // set it: we can't link to SetProcessAffinityMask() because it doesn't
1020     // exist in Win9x, use RT binding instead
1021
1022     typedef BOOL (*SETPROCESSAFFINITYMASK)(HANDLE, DWORD);
1023
1024     // can use static var because we're always in the main thread here
1025     static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL;
1026
1027     if ( !pfnSetProcessAffinityMask )
1028     {
1029         HMODULE hModKernel = ::LoadLibrary(_T("kernel32"));
1030         if ( hModKernel )
1031         {
1032             pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
1033                 ::GetProcAddress(hModKernel, "SetProcessAffinityMask");
1034         }
1035
1036         // we've discovered a MT version of Win9x!
1037         wxASSERT_MSG( pfnSetProcessAffinityMask,
1038                       _T("this system has several CPUs but no SetProcessAffinityMask function?") );
1039     }
1040
1041     if ( !pfnSetProcessAffinityMask )
1042     {
1043         // msg given above - do it only once
1044         return FALSE;
1045     }
1046
1047     if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
1048     {
1049         wxLogLastError(_T("SetProcessAffinityMask"));
1050
1051         return FALSE;
1052     }
1053 #endif
1054     return TRUE;
1055 }
1056
1057 // ctor and dtor
1058 // -------------
1059
1060 wxThread::wxThread(wxThreadKind kind)
1061 {
1062     m_internal = new wxThreadInternal();
1063
1064     m_isDetached = kind == wxTHREAD_DETACHED;
1065 }
1066
1067 wxThread::~wxThread()
1068 {
1069     delete m_internal;
1070 }
1071
1072 // create/start thread
1073 // -------------------
1074
1075 wxThreadError wxThread::Create(unsigned int stackSize)
1076 {
1077     wxCriticalSectionLocker lock(m_critsect);
1078
1079     if ( !m_internal->Create(this, stackSize) )
1080         return wxTHREAD_NO_RESOURCE;
1081
1082     return wxTHREAD_NO_ERROR;
1083 }
1084
1085 wxThreadError wxThread::Run()
1086 {
1087     wxCriticalSectionLocker lock(m_critsect);
1088
1089     if ( m_internal->GetState() != STATE_NEW )
1090     {
1091         // actually, it may be almost any state at all, not only STATE_RUNNING
1092         return wxTHREAD_RUNNING;
1093     }
1094
1095     // the thread has just been created and is still suspended - let it run
1096     return Resume();
1097 }
1098
1099 // suspend/resume thread
1100 // ---------------------
1101
1102 wxThreadError wxThread::Pause()
1103 {
1104     wxCriticalSectionLocker lock(m_critsect);
1105
1106     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1107 }
1108
1109 wxThreadError wxThread::Resume()
1110 {
1111     wxCriticalSectionLocker lock(m_critsect);
1112
1113     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
1114 }
1115
1116 // stopping thread
1117 // ---------------
1118
1119 wxThread::ExitCode wxThread::Wait()
1120 {
1121     // although under Windows we can wait for any thread, it's an error to
1122     // wait for a detached one in wxWin API
1123     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
1124                  _T("wxThread::Wait(): can't wait for detached thread") );
1125
1126     ExitCode rc = (ExitCode)-1;
1127
1128     (void)m_internal->WaitForTerminate(false, m_critsect, &rc);
1129
1130     m_internal->Free();
1131
1132     wxCriticalSectionLocker lock(m_critsect);
1133     m_internal->SetState(STATE_EXITED);
1134
1135     return rc;
1136 }
1137
1138 wxThreadError wxThread::Delete(ExitCode *pRc)
1139 {
1140     wxThreadError rc = m_internal->WaitForTerminate(true, m_critsect, pRc);
1141
1142     if ( IsDetached() )
1143     {
1144         delete this;
1145     }
1146     else // joinable
1147     {
1148         // update the status of the joinable thread
1149         wxCriticalSectionLocker lock(m_critsect);
1150         m_internal->SetState(STATE_EXITED);
1151     }
1152
1153     return rc;
1154 }
1155
1156 wxThreadError wxThread::Kill()
1157 {
1158     if ( !IsRunning() )
1159         return wxTHREAD_NOT_RUNNING;
1160
1161     wxThreadError rc = m_internal->Kill();
1162
1163     if ( IsDetached() )
1164     {
1165         delete this;
1166     }
1167     else // joinable
1168     {
1169         // update the status of the joinable thread
1170         wxCriticalSectionLocker lock(m_critsect);
1171         m_internal->SetState(STATE_EXITED);
1172     }
1173
1174     return rc;
1175 }
1176
1177 void wxThread::Exit(ExitCode status)
1178 {
1179     m_internal->Free();
1180
1181     if ( IsDetached() )
1182     {
1183         delete this;
1184     }
1185     else // joinable
1186     {
1187         // update the status of the joinable thread
1188         wxCriticalSectionLocker lock(m_critsect);
1189         m_internal->SetState(STATE_EXITED);
1190     }
1191
1192 #ifdef wxUSE_BEGIN_THREAD
1193     _endthreadex((unsigned)status);
1194 #else // !VC++
1195     ::ExitThread((DWORD)status);
1196 #endif // VC++/!VC++
1197
1198     wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
1199 }
1200
1201 // priority setting
1202 // ----------------
1203
1204 void wxThread::SetPriority(unsigned int prio)
1205 {
1206     wxCriticalSectionLocker lock(m_critsect);
1207
1208     m_internal->SetPriority(prio);
1209 }
1210
1211 unsigned int wxThread::GetPriority() const
1212 {
1213     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1214
1215     return m_internal->GetPriority();
1216 }
1217
1218 unsigned long wxThread::GetId() const
1219 {
1220     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1221
1222     return (unsigned long)m_internal->GetId();
1223 }
1224
1225 bool wxThread::IsRunning() const
1226 {
1227     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1228
1229     return m_internal->GetState() == STATE_RUNNING;
1230 }
1231
1232 bool wxThread::IsAlive() const
1233 {
1234     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1235
1236     return (m_internal->GetState() == STATE_RUNNING) ||
1237            (m_internal->GetState() == STATE_PAUSED);
1238 }
1239
1240 bool wxThread::IsPaused() const
1241 {
1242     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1243
1244     return m_internal->GetState() == STATE_PAUSED;
1245 }
1246
1247 bool wxThread::TestDestroy()
1248 {
1249     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
1250
1251     return m_internal->GetState() == STATE_CANCELED;
1252 }
1253
1254 // ----------------------------------------------------------------------------
1255 // Automatic initialization for thread module
1256 // ----------------------------------------------------------------------------
1257
1258 class wxThreadModule : public wxModule
1259 {
1260 public:
1261     virtual bool OnInit();
1262     virtual void OnExit();
1263
1264 private:
1265     DECLARE_DYNAMIC_CLASS(wxThreadModule)
1266 };
1267
1268 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1269
1270 bool wxThreadModule::OnInit()
1271 {
1272     // allocate TLS index for storing the pointer to the current thread
1273     gs_tlsThisThread = ::TlsAlloc();
1274     if ( gs_tlsThisThread == 0xFFFFFFFF )
1275     {
1276         // in normal circumstances it will only happen if all other
1277         // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
1278         // words, this should never happen
1279         wxLogSysError(_("Thread module initialization failed: impossible to allocate index in thread local storage"));
1280
1281         return FALSE;
1282     }
1283
1284     // main thread doesn't have associated wxThread object, so store 0 in the
1285     // TLS instead
1286     if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
1287     {
1288         ::TlsFree(gs_tlsThisThread);
1289         gs_tlsThisThread = 0xFFFFFFFF;
1290
1291         wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage"));
1292
1293         return FALSE;
1294     }
1295
1296     gs_critsectWaitingForGui = new wxCriticalSection();
1297
1298     gs_critsectGui = new wxCriticalSection();
1299     gs_critsectGui->Enter();
1300
1301     // no error return for GetCurrentThreadId()
1302     gs_idMainThread = ::GetCurrentThreadId();
1303
1304     return TRUE;
1305 }
1306
1307 void wxThreadModule::OnExit()
1308 {
1309     if ( !::TlsFree(gs_tlsThisThread) )
1310     {
1311         wxLogLastError(wxT("TlsFree failed."));
1312     }
1313
1314     if ( gs_critsectGui )
1315     {
1316         gs_critsectGui->Leave();
1317         delete gs_critsectGui;
1318         gs_critsectGui = NULL;
1319     }
1320
1321     delete gs_critsectWaitingForGui;
1322     gs_critsectWaitingForGui = NULL;
1323 }
1324
1325 // ----------------------------------------------------------------------------
1326 // under Windows, these functions are implemented using a critical section and
1327 // not a mutex, so the names are a bit confusing
1328 // ----------------------------------------------------------------------------
1329
1330 void WXDLLIMPEXP_BASE wxMutexGuiEnter()
1331 {
1332     // this would dead lock everything...
1333     wxASSERT_MSG( !wxThread::IsMain(),
1334                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
1335
1336     // the order in which we enter the critical sections here is crucial!!
1337
1338     // set the flag telling to the main thread that we want to do some GUI
1339     {
1340         wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1341
1342         gs_nWaitingForGui++;
1343     }
1344
1345     wxWakeUpMainThread();
1346
1347     // now we may block here because the main thread will soon let us in
1348     // (during the next iteration of OnIdle())
1349     gs_critsectGui->Enter();
1350 }
1351
1352 void WXDLLIMPEXP_BASE wxMutexGuiLeave()
1353 {
1354     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1355
1356     if ( wxThread::IsMain() )
1357     {
1358         gs_bGuiOwnedByMainThread = FALSE;
1359     }
1360     else
1361     {
1362         // decrement the number of threads waiting for GUI access now
1363         wxASSERT_MSG( gs_nWaitingForGui > 0,
1364                       wxT("calling wxMutexGuiLeave() without entering it first?") );
1365
1366         gs_nWaitingForGui--;
1367
1368         wxWakeUpMainThread();
1369     }
1370
1371     gs_critsectGui->Leave();
1372 }
1373
1374 void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
1375 {
1376     wxASSERT_MSG( wxThread::IsMain(),
1377                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1378
1379     wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
1380
1381     if ( gs_nWaitingForGui == 0 )
1382     {
1383         // no threads are waiting for GUI - so we may acquire the lock without
1384         // any danger (but only if we don't already have it)
1385         if ( !wxGuiOwnedByMainThread() )
1386         {
1387             gs_critsectGui->Enter();
1388
1389             gs_bGuiOwnedByMainThread = TRUE;
1390         }
1391         //else: already have it, nothing to do
1392     }
1393     else
1394     {
1395         // some threads are waiting, release the GUI lock if we have it
1396         if ( wxGuiOwnedByMainThread() )
1397         {
1398             wxMutexGuiLeave();
1399         }
1400         //else: some other worker thread is doing GUI
1401     }
1402 }
1403
1404 bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
1405 {
1406     return gs_bGuiOwnedByMainThread;
1407 }
1408
1409 // wake up the main thread if it's in ::GetMessage()
1410 void WXDLLIMPEXP_BASE wxWakeUpMainThread()
1411 {
1412     // sending any message would do - hopefully WM_NULL is harmless enough
1413     if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
1414     {
1415         // should never happen
1416         wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
1417     }
1418 }
1419
1420 bool WXDLLIMPEXP_BASE wxIsWaitingForThread()
1421 {
1422     return gs_waitingForThread;
1423 }
1424
1425 // ----------------------------------------------------------------------------
1426 // include common implementation code
1427 // ----------------------------------------------------------------------------
1428
1429 #include "wx/thrimpl.cpp"
1430
1431 #endif // wxUSE_THREADS
1432