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