src/unix/threadpsx.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        threadpsx.cpp
   3 // Purpose:     wxThread (Posix) Implementation
   4 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
   5 // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
   6 // Created:     04/22/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Wolfram Gloger (1996, 1997)
   9 //                  Guilhem Lavaux (1998)
  10 //                  Vadim Zeitlin (1999-2002)
  11 //                  Robert Roebling (1999)
  12 //                  K. S. Sreeram (2002)
  13 // Licence:     wxWindows licence
  14 /////////////////////////////////////////////////////////////////////////////
  15
  16 // ============================================================================
  17 // declaration
  18 // ============================================================================
  19
  20 // ----------------------------------------------------------------------------
  21 // headers
  22 // ----------------------------------------------------------------------------
  23
  24 // for compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #if wxUSE_THREADS
  28
  29 #include "wx/thread.h"
  30 #include "wx/module.h"
  31 #include "wx/utils.h"
  32 #include "wx/log.h"
  33 #include "wx/intl.h"
  34 #include "wx/dynarray.h"
  35 #include "wx/timer.h"
  36 #include "wx/stopwatch.h"
  37
  38 #include <stdio.h>
  39 #include <unistd.h>
  40 #include <pthread.h>
  41 #include <errno.h>
  42 #include <time.h>
  43 #ifdef HAVE_SCHED_H
  44     #include <sched.h>
  45 #endif
  46
  47 #ifdef HAVE_THR_SETCONCURRENCY
  48     #include <thread.h>
  49 #endif
  50
  51 // we use wxFFile under Linux in GetCPUCount()
  52 #ifdef __LINUX__
  53     #include "wx/ffile.h"
  54     // For setpriority.
  55     #include <sys/time.h>
  56     #include <sys/resource.h>
  57 #endif
  58
  59 #ifdef __VMS
  60     #define THR_ID(thr) ((long long)(thr)->GetId())
  61 #else
  62     #define THR_ID(thr) ((long)(thr)->GetId())
  63 #endif
  64
  65 // ----------------------------------------------------------------------------
  66 // constants
  67 // ----------------------------------------------------------------------------
  68
  69 // the possible states of the thread and transitions from them
  70 enum wxThreadState
  71 {
  72     STATE_NEW,          // didn't start execution yet (=> RUNNING)
  73     STATE_RUNNING,      // running (=> PAUSED or EXITED)
  74     STATE_PAUSED,       // suspended (=> RUNNING or EXITED)
  75     STATE_EXITED        // thread doesn't exist any more
  76 };
  77
  78 // the exit value of a thread which has been cancelled
  79 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
  80
  81 // trace mask for wxThread operations
  82 #define TRACE_THREADS   _T("thread")
  83
  84 // you can get additional debugging messages for the semaphore operations
  85 #define TRACE_SEMA      _T("semaphore")
  86
  87 // ----------------------------------------------------------------------------
  88 // private functions
  89 // ----------------------------------------------------------------------------
  90
  91 static void ScheduleThreadForDeletion();
  92 static void DeleteThread(wxThread *This);
  93
  94 // ----------------------------------------------------------------------------
  95 // private classes
  96 // ----------------------------------------------------------------------------
  97
  98 // an (non owning) array of pointers to threads
  99 WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
 100
 101 // an entry for a thread we can wait for
 102
 103 // -----------------------------------------------------------------------------
 104 // global data
 105 // -----------------------------------------------------------------------------
 106
 107 // we keep the list of all threads created by the application to be able to
 108 // terminate them on exit if there are some left - otherwise the process would
 109 // be left in memory
 110 static wxArrayThread gs_allThreads;
 111
 112 // the id of the main thread
 113 static pthread_t gs_tidMain = (pthread_t)-1;
 114
 115 // the key for the pointer to the associated wxThread object
 116 static pthread_key_t gs_keySelf;
 117
 118 // the number of threads which are being deleted - the program won't exit
 119 // until there are any left
 120 static size_t gs_nThreadsBeingDeleted = 0;
 121
 122 // a mutex to protect gs_nThreadsBeingDeleted
 123 static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
 124
 125 // and a condition variable which will be signaled when all
 126 // gs_nThreadsBeingDeleted will have been deleted
 127 static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 128
 129 // this mutex must be acquired before any call to a GUI function
 130 // (it's not inside #if wxUSE_GUI because this file is compiled as part
 131 // of wxBase)
 132 static wxMutex *gs_mutexGui = NULL;
 133
 134 // when we wait for a thread to exit, we're blocking on a condition which the
 135 // thread signals in its SignalExit() method -- but this condition can't be a
 136 // member of the thread itself as a detached thread may delete itself at any
 137 // moment and accessing the condition member of the thread after this would
 138 // result in a disaster
 139 //
 140 // so instead we maintain a global list of the structs below for the threads
 141 // we're interested in waiting on
 142
 143 // ============================================================================
 144 // wxMutex implementation
 145 // ============================================================================
 146
 147 // ----------------------------------------------------------------------------
 148 // wxMutexInternal
 149 // ----------------------------------------------------------------------------
 150
 151 // this is a simple wrapper around pthread_mutex_t which provides error
 152 // checking
 153 class wxMutexInternal
 154 {
 155 public:
 156     wxMutexInternal(wxMutexType mutexType);
 157     ~wxMutexInternal();
 158
 159     wxMutexError Lock();
 160     wxMutexError TryLock();
 161     wxMutexError Unlock();
 162
 163     bool IsOk() const { return m_isOk; }
 164
 165 private:
 166     pthread_mutex_t m_mutex;
 167     bool m_isOk;
 168
 169     // wxConditionInternal uses our m_mutex
 170     friend class wxConditionInternal;
 171 };
 172
 173 #if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
 174         wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
 175 // on some systems pthread_mutexattr_settype() is not in the headers (but it is
 176 // in the library, otherwise we wouldn't compile this code at all)
 177 extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
 178 #endif
 179
 180 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 181 {
 182     int err;
 183     switch ( mutexType )
 184     {
 185         case wxMUTEX_RECURSIVE:
 186             // support recursive locks like Win32, i.e. a thread can lock a
 187             // mutex which it had itself already locked
 188             //
 189             // unfortunately initialization of recursive mutexes is non
 190             // portable, so try several methods
 191 #ifdef HAVE_PTHREAD_MUTEXATTR_T
 192             {
 193                 pthread_mutexattr_t attr;
 194                 pthread_mutexattr_init(&attr);
 195                 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 196
 197                 err = pthread_mutex_init(&m_mutex, &attr);
 198             }
 199 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
 200             // we can use this only as initializer so we have to assign it
 201             // first to a temp var - assigning directly to m_mutex wouldn't
 202             // even compile
 203             {
 204                 pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 205                 m_mutex = mutex;
 206             }
 207 #else // no recursive mutexes
 208             err = EINVAL;
 209 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
 210             break;
 211
 212         default:
 213             wxFAIL_MSG( _T("unknown mutex type") );
 214             // fall through
 215
 216         case wxMUTEX_DEFAULT:
 217             err = pthread_mutex_init(&m_mutex, NULL);
 218             break;
 219     }
 220
 221     m_isOk = err == 0;
 222     if ( !m_isOk )
 223     {
 224         wxLogApiError( wxT("pthread_mutex_init()"), err);
 225     }
 226 }
 227
 228 wxMutexInternal::~wxMutexInternal()
 229 {
 230     if ( m_isOk )
 231     {
 232         int err = pthread_mutex_destroy(&m_mutex);
 233         if ( err != 0 )
 234         {
 235             wxLogApiError( wxT("pthread_mutex_destroy()"), err);
 236         }
 237     }
 238 }
 239
 240 wxMutexError wxMutexInternal::Lock()
 241 {
 242     int err = pthread_mutex_lock(&m_mutex);
 243     switch ( err )
 244     {
 245         case EDEADLK:
 246             // only error checking mutexes return this value and so it's an
 247             // unexpected situation -- hence use assert, not wxLogDebug
 248             wxFAIL_MSG( _T("mutex deadlock prevented") );
 249             return wxMUTEX_DEAD_LOCK;
 250
 251         case EINVAL:
 252             wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
 253             break;
 254
 255         case 0:
 256             return wxMUTEX_NO_ERROR;
 257
 258         default:
 259             wxLogApiError(_T("pthread_mutex_lock()"), err);
 260     }
 261
 262     return wxMUTEX_MISC_ERROR;
 263 }
 264
 265 wxMutexError wxMutexInternal::TryLock()
 266 {
 267     int err = pthread_mutex_trylock(&m_mutex);
 268     switch ( err )
 269     {
 270         case EBUSY:
 271             // not an error: mutex is already locked, but we're prepared for
 272             // this
 273             return wxMUTEX_BUSY;
 274
 275         case EINVAL:
 276             wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
 277             break;
 278
 279         case 0:
 280             return wxMUTEX_NO_ERROR;
 281
 282         default:
 283             wxLogApiError(_T("pthread_mutex_trylock()"), err);
 284     }
 285
 286     return wxMUTEX_MISC_ERROR;
 287 }
 288
 289 wxMutexError wxMutexInternal::Unlock()
 290 {
 291     int err = pthread_mutex_unlock(&m_mutex);
 292     switch ( err )
 293     {
 294         case EPERM:
 295             // we don't own the mutex
 296             return wxMUTEX_UNLOCKED;
 297
 298         case EINVAL:
 299             wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
 300             break;
 301
 302         case 0:
 303             return wxMUTEX_NO_ERROR;
 304
 305         default:
 306             wxLogApiError(_T("pthread_mutex_unlock()"), err);
 307     }
 308
 309     return wxMUTEX_MISC_ERROR;
 310 }
 311
 312 // ===========================================================================
 313 // wxCondition implementation
 314 // ===========================================================================
 315
 316 // ---------------------------------------------------------------------------
 317 // wxConditionInternal
 318 // ---------------------------------------------------------------------------
 319
 320 // this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
 321 // with a pthread_mutex_t)
 322 class wxConditionInternal
 323 {
 324 public:
 325     wxConditionInternal(wxMutex& mutex);
 326     ~wxConditionInternal();
 327
 328     bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
 329
 330     wxCondError Wait();
 331     wxCondError WaitTimeout(unsigned long milliseconds);
 332
 333     wxCondError Signal();
 334     wxCondError Broadcast();
 335
 336 private:
 337     // get the POSIX mutex associated with us
 338     pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }
 339
 340     wxMutex& m_mutex;
 341     pthread_cond_t m_cond;
 342
 343     bool m_isOk;
 344 };
 345
 346 wxConditionInternal::wxConditionInternal(wxMutex& mutex)
 347                    : m_mutex(mutex)
 348 {
 349     int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
 350
 351     m_isOk = err == 0;
 352
 353     if ( !m_isOk )
 354     {
 355         wxLogApiError(_T("pthread_cond_init()"), err);
 356     }
 357 }
 358
 359 wxConditionInternal::~wxConditionInternal()
 360 {
 361     if ( m_isOk )
 362     {
 363         int err = pthread_cond_destroy(&m_cond);
 364         if ( err != 0 )
 365         {
 366             wxLogApiError(_T("pthread_cond_destroy()"), err);
 367         }
 368     }
 369 }
 370
 371 wxCondError wxConditionInternal::Wait()
 372 {
 373     int err = pthread_cond_wait(&m_cond, GetPMutex());
 374     if ( err != 0 )
 375     {
 376         wxLogApiError(_T("pthread_cond_wait()"), err);
 377
 378         return wxCOND_MISC_ERROR;
 379     }
 380
 381     return wxCOND_NO_ERROR;
 382 }
 383
 384 wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
 385 {
 386     wxLongLong curtime = wxGetLocalTimeMillis();
 387     curtime += milliseconds;
 388     wxLongLong temp = curtime / 1000;
 389     int sec = temp.GetLo();
 390     temp *= 1000;
 391     temp = curtime - temp;
 392     int millis = temp.GetLo();
 393
 394     timespec tspec;
 395
 396     tspec.tv_sec = sec;
 397     tspec.tv_nsec = millis * 1000L * 1000L;
 398
 399     int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
 400     switch ( err )
 401     {
 402         case ETIMEDOUT:
 403             return wxCOND_TIMEOUT;
 404
 405         case 0:
 406             return wxCOND_NO_ERROR;
 407
 408         default:
 409             wxLogApiError(_T("pthread_cond_timedwait()"), err);
 410     }
 411
 412     return wxCOND_MISC_ERROR;
 413 }
 414
 415 wxCondError wxConditionInternal::Signal()
 416 {
 417     int err = pthread_cond_signal(&m_cond);
 418     if ( err != 0 )
 419     {
 420         wxLogApiError(_T("pthread_cond_signal()"), err);
 421
 422         return wxCOND_MISC_ERROR;
 423     }
 424
 425     return wxCOND_NO_ERROR;
 426 }
 427
 428 wxCondError wxConditionInternal::Broadcast()
 429 {
 430     int err = pthread_cond_broadcast(&m_cond);
 431     if ( err != 0 )
 432     {
 433         wxLogApiError(_T("pthread_cond_broadcast()"), err);
 434
 435         return wxCOND_MISC_ERROR;
 436     }
 437
 438     return wxCOND_NO_ERROR;
 439 }
 440
 441 // ===========================================================================
 442 // wxSemaphore implementation
 443 // ===========================================================================
 444
 445 // ---------------------------------------------------------------------------
 446 // wxSemaphoreInternal
 447 // ---------------------------------------------------------------------------
 448
 449 // we implement the semaphores using mutexes and conditions instead of using
 450 // the sem_xxx() POSIX functions because they're not widely available and also
 451 // because it's impossible to implement WaitTimeout() using them
 452 class wxSemaphoreInternal
 453 {
 454 public:
 455     wxSemaphoreInternal(int initialcount, int maxcount);
 456
 457     bool IsOk() const { return m_isOk; }
 458
 459     wxSemaError Wait();
 460     wxSemaError TryWait();
 461     wxSemaError WaitTimeout(unsigned long milliseconds);
 462
 463     wxSemaError Post();
 464
 465 private:
 466     wxMutex m_mutex;
 467     wxCondition m_cond;
 468
 469     size_t m_count,
 470            m_maxcount;
 471
 472     bool m_isOk;
 473 };
 474
 475 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
 476                    : m_cond(m_mutex)
 477 {
 478
 479     if ( (initialcount < 0 || maxcount < 0) ||
 480             ((maxcount > 0) && (initialcount > maxcount)) )
 481     {
 482         wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
 483
 484         m_isOk = FALSE;
 485     }
 486     else
 487     {
 488         m_maxcount = (size_t)maxcount;
 489         m_count = (size_t)initialcount;
 490     }
 491
 492     m_isOk = m_mutex.IsOk() && m_cond.IsOk();
 493 }
 494
 495 wxSemaError wxSemaphoreInternal::Wait()
 496 {
 497     wxMutexLocker locker(m_mutex);
 498
 499     while ( m_count == 0 )
 500     {
 501         wxLogTrace(TRACE_SEMA,
 502                    _T("Thread %ld waiting for semaphore to become signalled"),
 503                    wxThread::GetCurrentId());
 504
 505         if ( m_cond.Wait() != wxCOND_NO_ERROR )
 506             return wxSEMA_MISC_ERROR;
 507
 508         wxLogTrace(TRACE_SEMA,
 509                    _T("Thread %ld finished waiting for semaphore, count = %lu"),
 510                    wxThread::GetCurrentId(), (unsigned long)m_count);
 511     }
 512
 513     m_count--;
 514
 515     return wxSEMA_NO_ERROR;
 516 }
 517
 518 wxSemaError wxSemaphoreInternal::TryWait()
 519 {
 520     wxMutexLocker locker(m_mutex);
 521
 522     if ( m_count == 0 )
 523         return wxSEMA_BUSY;
 524
 525     m_count--;
 526
 527     return wxSEMA_NO_ERROR;
 528 }
 529
 530 wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
 531 {
 532     wxMutexLocker locker(m_mutex);
 533
 534     wxLongLong startTime = wxGetLocalTimeMillis();
 535
 536     while ( m_count == 0 )
 537     {
 538         wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
 539         long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
 540         if ( remainingTime <= 0 )
 541         {
 542             // timeout
 543             return wxSEMA_TIMEOUT;
 544         }
 545
 546         switch ( m_cond.WaitTimeout(remainingTime) )
 547         {
 548             case wxCOND_TIMEOUT:
 549                 return wxSEMA_TIMEOUT;
 550
 551             default:
 552                 return wxSEMA_MISC_ERROR;
 553
 554             case wxCOND_NO_ERROR:
 555                 ;
 556         }
 557     }
 558
 559     m_count--;
 560
 561     return wxSEMA_NO_ERROR;
 562 }
 563
 564 wxSemaError wxSemaphoreInternal::Post()
 565 {
 566     wxMutexLocker locker(m_mutex);
 567
 568     if ( m_maxcount > 0 && m_count == m_maxcount )
 569     {
 570         return wxSEMA_OVERFLOW;
 571     }
 572
 573     m_count++;
 574
 575     wxLogTrace(TRACE_SEMA,
 576                _T("Thread %ld about to signal semaphore, count = %lu"),
 577                wxThread::GetCurrentId(), (unsigned long)m_count);
 578
 579     return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
 580                                               : wxSEMA_MISC_ERROR;
 581 }
 582
 583 // ===========================================================================
 584 // wxThread implementation
 585 // ===========================================================================
 586
 587 // the thread callback functions must have the C linkage
 588 extern "C"
 589 {
 590
 591 #ifdef wxHAVE_PTHREAD_CLEANUP
 592     // thread exit function
 593     void wxPthreadCleanup(void *ptr);
 594 #endif // wxHAVE_PTHREAD_CLEANUP
 595
 596 void *wxPthreadStart(void *ptr);
 597
 598 } // extern "C"
 599
 600 // ----------------------------------------------------------------------------
 601 // wxThreadInternal
 602 // ----------------------------------------------------------------------------
 603
 604 class wxThreadInternal
 605 {
 606 public:
 607     wxThreadInternal();
 608     ~wxThreadInternal();
 609
 610     // thread entry function
 611     static void *PthreadStart(wxThread *thread);
 612
 613     // thread actions
 614         // start the thread
 615     wxThreadError Run();
 616         // unblock the thread allowing it to run
 617     void SignalRun() { m_semRun.Post(); }
 618         // ask the thread to terminate
 619     void Wait();
 620         // go to sleep until Resume() is called
 621     void Pause();
 622         // resume the thread
 623     void Resume();
 624
 625     // accessors
 626         // priority
 627     int GetPriority() const { return m_prio; }
 628     void SetPriority(int prio) { m_prio = prio; }
 629         // state
 630     wxThreadState GetState() const { return m_state; }
 631     void SetState(wxThreadState state)
 632     {
 633 #ifdef __WXDEBUG__
 634         static const wxChar *stateNames[] =
 635         {
 636             _T("NEW"),
 637             _T("RUNNING"),
 638             _T("PAUSED"),
 639             _T("EXITED"),
 640         };
 641
 642         wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
 643                    (long)GetId(), stateNames[m_state], stateNames[state]);
 644 #endif // __WXDEBUG__
 645
 646         m_state = state;
 647     }
 648         // id
 649     pthread_t GetId() const { return m_threadId; }
 650     pthread_t *GetIdPtr() { return &m_threadId; }
 651         // "cancelled" flag
 652     void SetCancelFlag() { m_cancelled = TRUE; }
 653     bool WasCancelled() const { return m_cancelled; }
 654         // exit code
 655     void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
 656     wxThread::ExitCode GetExitCode() const { return m_exitcode; }
 657
 658         // the pause flag
 659     void SetReallyPaused(bool paused) { m_isPaused = paused; }
 660     bool IsReallyPaused() const { return m_isPaused; }
 661
 662         // tell the thread that it is a detached one
 663     void Detach()
 664     {
 665         wxCriticalSectionLocker lock(m_csJoinFlag);
 666
 667         m_shouldBeJoined = FALSE;
 668         m_isDetached = TRUE;
 669     }
 670
 671 #ifdef wxHAVE_PTHREAD_CLEANUP
 672     // this is used by wxPthreadCleanup() only
 673     static void Cleanup(wxThread *thread);
 674 #endif // wxHAVE_PTHREAD_CLEANUP
 675
 676 private:
 677     pthread_t     m_threadId;   // id of the thread
 678     wxThreadState m_state;      // see wxThreadState enum
 679     int           m_prio;       // in wxWidgets units: from 0 to 100
 680
 681     // this flag is set when the thread should terminate
 682     bool m_cancelled;
 683
 684     // this flag is set when the thread is blocking on m_semSuspend
 685     bool m_isPaused;
 686
 687     // the thread exit code - only used for joinable (!detached) threads and
 688     // is only valid after the thread termination
 689     wxThread::ExitCode m_exitcode;
 690
 691     // many threads may call Wait(), but only one of them should call
 692     // pthread_join(), so we have to keep track of this
 693     wxCriticalSection m_csJoinFlag;
 694     bool m_shouldBeJoined;
 695     bool m_isDetached;
 696
 697     // this semaphore is posted by Run() and the threads Entry() is not
 698     // called before it is done
 699     wxSemaphore m_semRun;
 700
 701     // this one is signaled when the thread should resume after having been
 702     // Pause()d
 703     wxSemaphore m_semSuspend;
 704 };
 705
 706 // ----------------------------------------------------------------------------
 707 // thread startup and exit functions
 708 // ----------------------------------------------------------------------------
 709
 710 void *wxPthreadStart(void *ptr)
 711 {
 712     return wxThreadInternal::PthreadStart((wxThread *)ptr);
 713 }
 714
 715 void *wxThreadInternal::PthreadStart(wxThread *thread)
 716 {
 717     wxThreadInternal *pthread = thread->m_internal;
 718
 719     wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread));
 720
 721     // associate the thread pointer with the newly created thread so that
 722     // wxThread::This() will work
 723     int rc = pthread_setspecific(gs_keySelf, thread);
 724     if ( rc != 0 )
 725     {
 726         wxLogSysError(rc, _("Cannot start thread: error writing TLS"));
 727
 728         return (void *)-1;
 729     }
 730
 731     // have to declare this before pthread_cleanup_push() which defines a
 732     // block!
 733     bool dontRunAtAll;
 734
 735 #ifdef wxHAVE_PTHREAD_CLEANUP
 736     // install the cleanup handler which will be called if the thread is
 737     // cancelled
 738     pthread_cleanup_push(wxPthreadCleanup, thread);
 739 #endif // wxHAVE_PTHREAD_CLEANUP
 740
 741     // wait for the semaphore to be posted from Run()
 742     pthread->m_semRun.Wait();
 743
 744     // test whether we should run the run at all - may be it was deleted
 745     // before it started to Run()?
 746     {
 747         wxCriticalSectionLocker lock(thread->m_critsect);
 748
 749         dontRunAtAll = pthread->GetState() == STATE_NEW &&
 750                        pthread->WasCancelled();
 751     }
 752
 753     if ( !dontRunAtAll )
 754     {
 755         // call the main entry
 756         wxLogTrace(TRACE_THREADS,
 757                    _T("Thread %ld about to enter its Entry()."),
 758                    THR_ID(pthread));
 759
 760         pthread->m_exitcode = thread->Entry();
 761
 762         wxLogTrace(TRACE_THREADS,
 763                    _T("Thread %ld Entry() returned %lu."),
 764                    THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
 765
 766         {
 767             wxCriticalSectionLocker lock(thread->m_critsect);
 768
 769             // change the state of the thread to "exited" so that
 770             // wxPthreadCleanup handler won't do anything from now (if it's
 771             // called before we do pthread_cleanup_pop below)
 772             pthread->SetState(STATE_EXITED);
 773         }
 774     }
 775
 776     // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
 777     //     '}' for the '{' in push, so they must be used in the same block!
 778 #ifdef wxHAVE_PTHREAD_CLEANUP
 779     #ifdef __DECCXX
 780         // under Tru64 we get a warning from macro expansion
 781         #pragma message save
 782         #pragma message disable(declbutnotref)
 783     #endif
 784
 785     // remove the cleanup handler without executing it
 786     pthread_cleanup_pop(FALSE);
 787
 788     #ifdef __DECCXX
 789         #pragma message restore
 790     #endif
 791 #endif // wxHAVE_PTHREAD_CLEANUP
 792
 793     if ( dontRunAtAll )
 794     {
 795         // FIXME: deleting a possibly joinable thread here???
 796         delete thread;
 797
 798         return EXITCODE_CANCELLED;
 799     }
 800     else
 801     {
 802         // terminate the thread
 803         thread->Exit(pthread->m_exitcode);
 804
 805         wxFAIL_MSG(wxT("wxThread::Exit() can't return."));
 806
 807         return NULL;
 808     }
 809 }
 810
 811 #ifdef wxHAVE_PTHREAD_CLEANUP
 812
 813 // this handler is called when the thread is cancelled
 814 extern "C" void wxPthreadCleanup(void *ptr)
 815 {
 816     wxThreadInternal::Cleanup((wxThread *)ptr);
 817 }
 818
 819 void wxThreadInternal::Cleanup(wxThread *thread)
 820 {
 821     {
 822         wxCriticalSectionLocker lock(thread->m_critsect);
 823         if ( thread->m_internal->GetState() == STATE_EXITED )
 824         {
 825             // thread is already considered as finished.
 826             return;
 827         }
 828     }
 829
 830     // exit the thread gracefully
 831     thread->Exit(EXITCODE_CANCELLED);
 832 }
 833
 834 #endif // wxHAVE_PTHREAD_CLEANUP
 835
 836 // ----------------------------------------------------------------------------
 837 // wxThreadInternal
 838 // ----------------------------------------------------------------------------
 839
 840 wxThreadInternal::wxThreadInternal()
 841 {
 842     m_state = STATE_NEW;
 843     m_cancelled = FALSE;
 844     m_prio = WXTHREAD_DEFAULT_PRIORITY;
 845     m_threadId = 0;
 846     m_exitcode = 0;
 847
 848     // set to TRUE only when the thread starts waiting on m_semSuspend
 849     m_isPaused = FALSE;
 850
 851     // defaults for joinable threads
 852     m_shouldBeJoined = TRUE;
 853     m_isDetached = FALSE;
 854 }
 855
 856 wxThreadInternal::~wxThreadInternal()
 857 {
 858 }
 859
 860 wxThreadError wxThreadInternal::Run()
 861 {
 862     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
 863                  wxT("thread may only be started once after Create()") );
 864
 865     SetState(STATE_RUNNING);
 866
 867     // wake up threads waiting for our start
 868     SignalRun();
 869
 870     return wxTHREAD_NO_ERROR;
 871 }
 872
 873 void wxThreadInternal::Wait()
 874 {
 875     wxCHECK_RET( !m_isDetached, _T("can't wait for a detached thread") );
 876
 877     // if the thread we're waiting for is waiting for the GUI mutex, we will
 878     // deadlock so make sure we release it temporarily
 879     if ( wxThread::IsMain() )
 880         wxMutexGuiLeave();
 881
 882     wxLogTrace(TRACE_THREADS,
 883                _T("Starting to wait for thread %ld to exit."),
 884                THR_ID(this));
 885
 886     // to avoid memory leaks we should call pthread_join(), but it must only be
 887     // done once so use a critical section to serialize the code below
 888     {
 889         wxCriticalSectionLocker lock(m_csJoinFlag);
 890
 891         if ( m_shouldBeJoined )
 892         {
 893             // FIXME shouldn't we set cancellation type to DISABLED here? If
 894             //       we're cancelled inside pthread_join(), things will almost
 895             //       certainly break - but if we disable the cancellation, we
 896             //       might deadlock
 897             if ( pthread_join(GetId(), &m_exitcode) != 0 )
 898             {
 899                 // this is a serious problem, so use wxLogError and not
 900                 // wxLogDebug: it is possible to bring the system to its knees
 901                 // by creating too many threads and not joining them quite
 902                 // easily
 903                 wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
 904             }
 905
 906             m_shouldBeJoined = FALSE;
 907         }
 908     }
 909
 910     // reacquire GUI mutex
 911     if ( wxThread::IsMain() )
 912         wxMutexGuiEnter();
 913 }
 914
 915 void wxThreadInternal::Pause()
 916 {
 917     // the state is set from the thread which pauses us first, this function
 918     // is called later so the state should have been already set
 919     wxCHECK_RET( m_state == STATE_PAUSED,
 920                  wxT("thread must first be paused with wxThread::Pause().") );
 921
 922    wxLogTrace(TRACE_THREADS,
 923               _T("Thread %ld goes to sleep."), THR_ID(this));
 924
 925     // wait until the semaphore is Post()ed from Resume()
 926     m_semSuspend.Wait();
 927 }
 928
 929 void wxThreadInternal::Resume()
 930 {
 931     wxCHECK_RET( m_state == STATE_PAUSED,
 932                  wxT("can't resume thread which is not suspended.") );
 933
 934     // the thread might be not actually paused yet - if there were no call to
 935     // TestDestroy() since the last call to Pause() for example
 936     if ( IsReallyPaused() )
 937     {
 938        wxLogTrace(TRACE_THREADS,
 939                   _T("Waking up thread %ld"), THR_ID(this));
 940
 941         // wake up Pause()
 942         m_semSuspend.Post();
 943
 944         // reset the flag
 945         SetReallyPaused(FALSE);
 946     }
 947     else
 948     {
 949         wxLogTrace(TRACE_THREADS,
 950                    _T("Thread %ld is not yet really paused"), THR_ID(this));
 951     }
 952
 953     SetState(STATE_RUNNING);
 954 }
 955
 956 // -----------------------------------------------------------------------------
 957 // wxThread static functions
 958 // -----------------------------------------------------------------------------
 959
 960 wxThread *wxThread::This()
 961 {
 962     return (wxThread *)pthread_getspecific(gs_keySelf);
 963 }
 964
 965 bool wxThread::IsMain()
 966 {
 967     return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1;
 968 }
 969
 970 void wxThread::Yield()
 971 {
 972 #ifdef HAVE_SCHED_YIELD
 973     sched_yield();
 974 #endif
 975 }
 976
 977 void wxThread::Sleep(unsigned long milliseconds)
 978 {
 979     wxMilliSleep(milliseconds);
 980 }
 981
 982 int wxThread::GetCPUCount()
 983 {
 984 #if defined(__LINUX__) && wxUSE_FFILE
 985     // read from proc (can't use wxTextFile here because it's a special file:
 986     // it has 0 size but still can be read from)
 987     wxLogNull nolog;
 988
 989     wxFFile file(_T("/proc/cpuinfo"));
 990     if ( file.IsOpened() )
 991     {
 992         // slurp the whole file
 993         wxString s;
 994         if ( file.ReadAll(&s) )
 995         {
 996             // (ab)use Replace() to find the number of "processor: num" strings
 997             size_t count = s.Replace(_T("processor\t:"), _T(""));
 998             if ( count > 0 )
 999             {
1000                 return count;
1001             }
1002
1003             wxLogDebug(_T("failed to parse /proc/cpuinfo"));
1004         }
1005         else
1006         {
1007             wxLogDebug(_T("failed to read /proc/cpuinfo"));
1008         }
1009     }
1010 #elif defined(_SC_NPROCESSORS_ONLN)
1011     // this works for Solaris
1012     int rc = sysconf(_SC_NPROCESSORS_ONLN);
1013     if ( rc != -1 )
1014     {
1015         return rc;
1016     }
1017 #endif // different ways to get number of CPUs
1018
1019     // unknown
1020     return -1;
1021 }
1022
1023 // VMS is a 64 bit system and threads have 64 bit pointers.
1024 // FIXME: also needed for other systems????
1025 #ifdef __VMS
1026 unsigned long long wxThread::GetCurrentId()
1027 {
1028     return (unsigned long long)pthread_self();
1029 }
1030
1031 #else // !__VMS
1032
1033 unsigned long wxThread::GetCurrentId()
1034 {
1035     return (unsigned long)pthread_self();
1036 }
1037
1038 #endif // __VMS/!__VMS
1039
1040
1041 bool wxThread::SetConcurrency(size_t level)
1042 {
1043 #ifdef HAVE_THR_SETCONCURRENCY
1044     int rc = thr_setconcurrency(level);
1045     if ( rc != 0 )
1046     {
1047         wxLogSysError(rc, _T("thr_setconcurrency() failed"));
1048     }
1049
1050     return rc == 0;
1051 #else // !HAVE_THR_SETCONCURRENCY
1052     // ok only for the default value
1053     return level == 0;
1054 #endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
1055 }
1056
1057 // -----------------------------------------------------------------------------
1058 // creating thread
1059 // -----------------------------------------------------------------------------
1060
1061 wxThread::wxThread(wxThreadKind kind)
1062 {
1063     // add this thread to the global list of all threads
1064     gs_allThreads.Add(this);
1065
1066     m_internal = new wxThreadInternal();
1067
1068     m_isDetached = kind == wxTHREAD_DETACHED;
1069 }
1070
1071 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1072     #define WXUNUSED_STACKSIZE(identifier)  identifier
1073 #else
1074     #define WXUNUSED_STACKSIZE(identifier)  WXUNUSED(identifier)
1075 #endif
1076
1077 wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))
1078 {
1079     if ( m_internal->GetState() != STATE_NEW )
1080     {
1081         // don't recreate thread
1082         return wxTHREAD_RUNNING;
1083     }
1084
1085     // set up the thread attribute: right now, we only set thread priority
1086     pthread_attr_t attr;
1087     pthread_attr_init(&attr);
1088
1089 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1090     if (stackSize)
1091       pthread_attr_setstacksize(&attr, stackSize);
1092 #endif
1093
1094 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1095     int policy;
1096     if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
1097     {
1098         wxLogError(_("Cannot retrieve thread scheduling policy."));
1099     }
1100
1101 #ifdef __VMS__
1102    /* the pthread.h contains too many spaces. This is a work-around */
1103 # undef sched_get_priority_max
1104 #undef sched_get_priority_min
1105 #define sched_get_priority_max(_pol_) \
1106      (_pol_ == SCHED_OTHER ? PRI_FG_MAX_NP : PRI_FIFO_MAX)
1107 #define sched_get_priority_min(_pol_) \
1108      (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
1109 #endif
1110
1111     int max_prio = sched_get_priority_max(policy),
1112         min_prio = sched_get_priority_min(policy),
1113         prio = m_internal->GetPriority();
1114
1115     if ( min_prio == -1 || max_prio == -1 )
1116     {
1117         wxLogError(_("Cannot get priority range for scheduling policy %d."),
1118                    policy);
1119     }
1120     else if ( max_prio == min_prio )
1121     {
1122         if ( prio != WXTHREAD_DEFAULT_PRIORITY )
1123         {
1124             // notify the programmer that this doesn't work here
1125             wxLogWarning(_("Thread priority setting is ignored."));
1126         }
1127         //else: we have default priority, so don't complain
1128
1129         // anyhow, don't do anything because priority is just ignored
1130     }
1131     else
1132     {
1133         struct sched_param sp;
1134         if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
1135         {
1136             wxFAIL_MSG(_T("pthread_attr_getschedparam() failed"));
1137         }
1138
1139         sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
1140
1141         if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
1142         {
1143             wxFAIL_MSG(_T("pthread_attr_setschedparam(priority) failed"));
1144         }
1145     }
1146 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1147
1148 #ifdef HAVE_PTHREAD_ATTR_SETSCOPE
1149     // this will make the threads created by this process really concurrent
1150     if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
1151     {
1152         wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
1153     }
1154 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
1155
1156     // VZ: assume that this one is always available (it's rather fundamental),
1157     //     if this function is ever missing we should try to use
1158     //     pthread_detach() instead (after thread creation)
1159     if ( m_isDetached )
1160     {
1161         if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
1162         {
1163             wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed"));
1164         }
1165
1166         // never try to join detached threads
1167         m_internal->Detach();
1168     }
1169     //else: threads are created joinable by default, it's ok
1170
1171     // create the new OS thread object
1172     int rc = pthread_create
1173              (
1174                 m_internal->GetIdPtr(),
1175                 &attr,
1176                 wxPthreadStart,
1177                 (void *)this
1178              );
1179
1180     if ( pthread_attr_destroy(&attr) != 0 )
1181     {
1182         wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
1183     }
1184
1185     if ( rc != 0 )
1186     {
1187         m_internal->SetState(STATE_EXITED);
1188
1189         return wxTHREAD_NO_RESOURCE;
1190     }
1191
1192     return wxTHREAD_NO_ERROR;
1193 }
1194
1195 wxThreadError wxThread::Run()
1196 {
1197     wxCriticalSectionLocker lock(m_critsect);
1198
1199     wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR,
1200                  wxT("must call wxThread::Create() first") );
1201
1202     return m_internal->Run();
1203 }
1204
1205 // -----------------------------------------------------------------------------
1206 // misc accessors
1207 // -----------------------------------------------------------------------------
1208
1209 void wxThread::SetPriority(unsigned int prio)
1210 {
1211     wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
1212                  ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
1213                  wxT("invalid thread priority") );
1214
1215     wxCriticalSectionLocker lock(m_critsect);
1216
1217     switch ( m_internal->GetState() )
1218     {
1219         case STATE_NEW:
1220             // thread not yet started, priority will be set when it is
1221             m_internal->SetPriority(prio);
1222             break;
1223
1224         case STATE_RUNNING:
1225         case STATE_PAUSED:
1226 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
1227 #if defined(__LINUX__)
1228             // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
1229             // a priority other than 0.  Instead, we use the BSD setpriority
1230             // which alllows us to set a 'nice' value between 20 to -20.  Only
1231             // super user can set a value less than zero (more negative yields
1232             // higher priority).  setpriority set the static priority of a
1233             // process, but this is OK since Linux is configured as a thread
1234             // per process.
1235             //
1236             // FIXME this is not true for 2.6!!
1237
1238             // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
1239             // to Unix priorities 20..-20
1240             if ( setpriority(PRIO_PROCESS, 0, -(2*prio)/5 + 20) == -1 )
1241             {
1242                 wxLogError(_("Failed to set thread priority %d."), prio);
1243             }
1244 #else // __LINUX__
1245             {
1246                 struct sched_param sparam;
1247                 sparam.sched_priority = prio;
1248
1249                 if ( pthread_setschedparam(m_internal->GetId(),
1250                                            SCHED_OTHER, &sparam) != 0 )
1251                 {
1252                     wxLogError(_("Failed to set thread priority %d."), prio);
1253                 }
1254             }
1255 #endif // __LINUX__
1256 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
1257             break;
1258
1259         case STATE_EXITED:
1260         default:
1261             wxFAIL_MSG(wxT("impossible to set thread priority in this state"));
1262     }
1263 }
1264
1265 unsigned int wxThread::GetPriority() const
1266 {
1267     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1268
1269     return m_internal->GetPriority();
1270 }
1271
1272 wxThreadIdType wxThread::GetId() const
1273 {
1274     return (wxThreadIdType) m_internal->GetId();
1275 }
1276
1277 // -----------------------------------------------------------------------------
1278 // pause/resume
1279 // -----------------------------------------------------------------------------
1280
1281 wxThreadError wxThread::Pause()
1282 {
1283     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1284                  _T("a thread can't pause itself") );
1285
1286     wxCriticalSectionLocker lock(m_critsect);
1287
1288     if ( m_internal->GetState() != STATE_RUNNING )
1289     {
1290         wxLogDebug(wxT("Can't pause thread which is not running."));
1291
1292         return wxTHREAD_NOT_RUNNING;
1293     }
1294
1295     // just set a flag, the thread will be really paused only during the next
1296     // call to TestDestroy()
1297     m_internal->SetState(STATE_PAUSED);
1298
1299     return wxTHREAD_NO_ERROR;
1300 }
1301
1302 wxThreadError wxThread::Resume()
1303 {
1304     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1305                  _T("a thread can't resume itself") );
1306
1307     wxCriticalSectionLocker lock(m_critsect);
1308
1309     wxThreadState state = m_internal->GetState();
1310
1311     switch ( state )
1312     {
1313         case STATE_PAUSED:
1314             wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
1315                        GetId());
1316
1317             m_internal->Resume();
1318
1319             return wxTHREAD_NO_ERROR;
1320
1321         case STATE_EXITED:
1322             wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."),
1323                        GetId());
1324             return wxTHREAD_NO_ERROR;
1325
1326         default:
1327             wxLogDebug(_T("Attempt to resume a thread which is not paused."));
1328
1329             return wxTHREAD_MISC_ERROR;
1330     }
1331 }
1332
1333 // -----------------------------------------------------------------------------
1334 // exiting thread
1335 // -----------------------------------------------------------------------------
1336
1337 wxThread::ExitCode wxThread::Wait()
1338 {
1339     wxCHECK_MSG( This() != this, (ExitCode)-1,
1340                  _T("a thread can't wait for itself") );
1341
1342     wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
1343                  _T("can't wait for detached thread") );
1344
1345     m_internal->Wait();
1346
1347     return m_internal->GetExitCode();
1348 }
1349
1350 wxThreadError wxThread::Delete(ExitCode *rc)
1351 {
1352     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1353                  _T("a thread can't delete itself") );
1354
1355     bool isDetached = m_isDetached;
1356
1357     m_critsect.Enter();
1358     wxThreadState state = m_internal->GetState();
1359
1360     // ask the thread to stop
1361     m_internal->SetCancelFlag();
1362
1363     m_critsect.Leave();
1364
1365     switch ( state )
1366     {
1367         case STATE_NEW:
1368             // we need to wake up the thread so that PthreadStart() will
1369             // terminate - right now it's blocking on run semaphore in
1370             // PthreadStart()
1371             m_internal->SignalRun();
1372
1373             // fall through
1374
1375         case STATE_EXITED:
1376             // nothing to do
1377             break;
1378
1379         case STATE_PAUSED:
1380             // resume the thread first
1381             m_internal->Resume();
1382
1383             // fall through
1384
1385         default:
1386             if ( !isDetached )
1387             {
1388                 // wait until the thread stops
1389                 m_internal->Wait();
1390
1391                 if ( rc )
1392                 {
1393                     // return the exit code of the thread
1394                     *rc = m_internal->GetExitCode();
1395                 }
1396             }
1397             //else: can't wait for detached threads
1398     }
1399
1400     return wxTHREAD_NO_ERROR;
1401 }
1402
1403 wxThreadError wxThread::Kill()
1404 {
1405     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1406                  _T("a thread can't kill itself") );
1407
1408     switch ( m_internal->GetState() )
1409     {
1410         case STATE_NEW:
1411         case STATE_EXITED:
1412             return wxTHREAD_NOT_RUNNING;
1413
1414         case STATE_PAUSED:
1415             // resume the thread first
1416             Resume();
1417
1418             // fall through
1419
1420         default:
1421 #ifdef HAVE_PTHREAD_CANCEL
1422             if ( pthread_cancel(m_internal->GetId()) != 0 )
1423 #endif // HAVE_PTHREAD_CANCEL
1424             {
1425                 wxLogError(_("Failed to terminate a thread."));
1426
1427                 return wxTHREAD_MISC_ERROR;
1428             }
1429
1430 #ifdef HAVE_PTHREAD_CANCEL
1431             if ( m_isDetached )
1432             {
1433                 // if we use cleanup function, this will be done from
1434                 // wxPthreadCleanup()
1435 #ifndef wxHAVE_PTHREAD_CLEANUP
1436                 ScheduleThreadForDeletion();
1437
1438                 // don't call OnExit() here, it can only be called in the
1439                 // threads context and we're in the context of another thread
1440
1441                 DeleteThread(this);
1442 #endif // wxHAVE_PTHREAD_CLEANUP
1443             }
1444             else
1445             {
1446                 m_internal->SetExitCode(EXITCODE_CANCELLED);
1447             }
1448
1449             return wxTHREAD_NO_ERROR;
1450 #endif // HAVE_PTHREAD_CANCEL
1451     }
1452 }
1453
1454 void wxThread::Exit(ExitCode status)
1455 {
1456     wxASSERT_MSG( This() == this,
1457                   _T("wxThread::Exit() can only be called in the context of the same thread") );
1458
1459     if ( m_isDetached )
1460     {
1461         // from the moment we call OnExit(), the main program may terminate at
1462         // any moment, so mark this thread as being already in process of being
1463         // deleted or wxThreadModule::OnExit() will try to delete it again
1464         ScheduleThreadForDeletion();
1465     }
1466
1467     // don't enter m_critsect before calling OnExit() because the user code
1468     // might deadlock if, for example, it signals a condition in OnExit() (a
1469     // common case) while the main thread calls any of functions entering
1470     // m_critsect on us (almost all of them do)
1471     OnExit();
1472
1473     // delete C++ thread object if this is a detached thread - user is
1474     // responsible for doing this for joinable ones
1475     if ( m_isDetached )
1476     {
1477         // FIXME I'm feeling bad about it - what if another thread function is
1478         //       called (in another thread context) now? It will try to access
1479         //       half destroyed object which will probably result in something
1480         //       very bad - but we can't protect this by a crit section unless
1481         //       we make it a global object, but this would mean that we can
1482         //       only call one thread function at a time :-(
1483         DeleteThread(this);
1484     }
1485     else
1486     {
1487         m_critsect.Enter();
1488         m_internal->SetState(STATE_EXITED);
1489         m_critsect.Leave();
1490     }
1491
1492     // terminate the thread (pthread_exit() never returns)
1493     pthread_exit(status);
1494
1495     wxFAIL_MSG(_T("pthread_exit() failed"));
1496 }
1497
1498 // also test whether we were paused
1499 bool wxThread::TestDestroy()
1500 {
1501     wxASSERT_MSG( This() == this,
1502                   _T("wxThread::TestDestroy() can only be called in the context of the same thread") );
1503
1504     m_critsect.Enter();
1505
1506     if ( m_internal->GetState() == STATE_PAUSED )
1507     {
1508         m_internal->SetReallyPaused(TRUE);
1509
1510         // leave the crit section or the other threads will stop too if they
1511         // try to call any of (seemingly harmless) IsXXX() functions while we
1512         // sleep
1513         m_critsect.Leave();
1514
1515         m_internal->Pause();
1516     }
1517     else
1518     {
1519         // thread wasn't requested to pause, nothing to do
1520         m_critsect.Leave();
1521     }
1522
1523     return m_internal->WasCancelled();
1524 }
1525
1526 wxThread::~wxThread()
1527 {
1528 #ifdef __WXDEBUG__
1529     m_critsect.Enter();
1530
1531     // check that the thread either exited or couldn't be created
1532     if ( m_internal->GetState() != STATE_EXITED &&
1533          m_internal->GetState() != STATE_NEW )
1534     {
1535         wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."),
1536                    (long)GetId());
1537     }
1538
1539     m_critsect.Leave();
1540 #endif // __WXDEBUG__
1541
1542     delete m_internal;
1543
1544     // remove this thread from the global array
1545     gs_allThreads.Remove(this);
1546 }
1547
1548 // -----------------------------------------------------------------------------
1549 // state tests
1550 // -----------------------------------------------------------------------------
1551
1552 bool wxThread::IsRunning() const
1553 {
1554     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1555
1556     return m_internal->GetState() == STATE_RUNNING;
1557 }
1558
1559 bool wxThread::IsAlive() const
1560 {
1561     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1562
1563     switch ( m_internal->GetState() )
1564     {
1565         case STATE_RUNNING:
1566         case STATE_PAUSED:
1567             return TRUE;
1568
1569         default:
1570             return FALSE;
1571     }
1572 }
1573
1574 bool wxThread::IsPaused() const
1575 {
1576     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1577
1578     return (m_internal->GetState() == STATE_PAUSED);
1579 }
1580
1581 //--------------------------------------------------------------------
1582 // wxThreadModule
1583 //--------------------------------------------------------------------
1584
1585 class wxThreadModule : public wxModule
1586 {
1587 public:
1588     virtual bool OnInit();
1589     virtual void OnExit();
1590
1591 private:
1592     DECLARE_DYNAMIC_CLASS(wxThreadModule)
1593 };
1594
1595 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1596
1597 bool wxThreadModule::OnInit()
1598 {
1599     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
1600     if ( rc != 0 )
1601     {
1602         wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
1603
1604         return FALSE;
1605     }
1606
1607     gs_tidMain = pthread_self();
1608
1609     gs_mutexGui = new wxMutex();
1610     gs_mutexGui->Lock();
1611
1612     gs_mutexDeleteThread = new wxMutex();
1613     gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );
1614
1615     return TRUE;
1616 }
1617
1618 void wxThreadModule::OnExit()
1619 {
1620     wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );
1621
1622     // are there any threads left which are being deleted right now?
1623     size_t nThreadsBeingDeleted;
1624
1625     {
1626         wxMutexLocker lock( *gs_mutexDeleteThread );
1627         nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
1628
1629         if ( nThreadsBeingDeleted > 0 )
1630         {
1631             wxLogTrace(TRACE_THREADS,
1632                        _T("Waiting for %lu threads to disappear"),
1633                        (unsigned long)nThreadsBeingDeleted);
1634
1635             // have to wait until all of them disappear
1636             gs_condAllDeleted->Wait();
1637         }
1638     }
1639
1640     // terminate any threads left
1641     size_t count = gs_allThreads.GetCount();
1642     if ( count != 0u )
1643     {
1644         wxLogDebug(wxT("%lu threads were not terminated by the application."),
1645                    (unsigned long)count);
1646     }
1647
1648     for ( size_t n = 0u; n < count; n++ )
1649     {
1650         // Delete calls the destructor which removes the current entry. We
1651         // should only delete the first one each time.
1652         gs_allThreads[0]->Delete();
1653     }
1654
1655     // destroy GUI mutex
1656     gs_mutexGui->Unlock();
1657     delete gs_mutexGui;
1658
1659     // and free TLD slot
1660     (void)pthread_key_delete(gs_keySelf);
1661
1662     delete gs_condAllDeleted;
1663     delete gs_mutexDeleteThread;
1664 }
1665
1666 // ----------------------------------------------------------------------------
1667 // global functions
1668 // ----------------------------------------------------------------------------
1669
1670 static void ScheduleThreadForDeletion()
1671 {
1672     wxMutexLocker lock( *gs_mutexDeleteThread );
1673
1674     gs_nThreadsBeingDeleted++;
1675
1676     wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
1677                (unsigned long)gs_nThreadsBeingDeleted,
1678                gs_nThreadsBeingDeleted == 1 ? "" : "s");
1679 }
1680
1681 static void DeleteThread(wxThread *This)
1682 {
1683     // gs_mutexDeleteThread should be unlocked before signalling the condition
1684     // or wxThreadModule::OnExit() would deadlock
1685     wxMutexLocker locker( *gs_mutexDeleteThread );
1686
1687     wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
1688
1689     delete This;
1690
1691     wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
1692                  _T("no threads scheduled for deletion, yet we delete one?") );
1693
1694     wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
1695                (unsigned long)gs_nThreadsBeingDeleted - 1);
1696
1697     if ( !--gs_nThreadsBeingDeleted )
1698     {
1699         // no more threads left, signal it
1700         gs_condAllDeleted->Signal();
1701     }
1702 }
1703
1704 void wxMutexGuiEnter()
1705 {
1706     gs_mutexGui->Lock();
1707 }
1708
1709 void wxMutexGuiLeave()
1710 {
1711     gs_mutexGui->Unlock();
1712 }
1713
1714 // ----------------------------------------------------------------------------
1715 // include common implementation code
1716 // ----------------------------------------------------------------------------
1717
1718 #include "wx/thrimpl.cpp"
1719
1720 #endif // wxUSE_THREADS
1721