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