src/gtk1/threadpsx.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        threadpsx.cpp
   3 // Purpose:     wxThread (Posix) Implementation
   4 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
   5 // Modified by:
   6 // Created:     04/22/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Wolfram Gloger (1996, 1997)
   9 //                  Guilhem Lavaux (1998)
  10 //                  Robert Roebling (1999)
  11 // Licence:     wxWindows licence
  12 /////////////////////////////////////////////////////////////////////////////
  13
  14 #ifdef __GNUG__
  15     #pragma implementation "thread.h"
  16 #endif
  17
  18 #include <stdio.h>
  19 #include <unistd.h>
  20 #include <pthread.h>
  21 #include <errno.h>
  22
  23 #ifdef __linux__
  24     #include <sched.h>
  25 #endif
  26
  27 #include "wx/thread.h"
  28 #include "wx/module.h"
  29 #include "wx/utils.h"
  30 #include "wx/log.h"
  31 #include "wx/intl.h"
  32 #include "wx/dynarray.h"
  33
  34 #include "gdk/gdk.h"
  35 #include "gtk/gtk.h"
  36
  37 enum thread_state
  38 {
  39     STATE_NEW,          // didn't start execution yet (=> RUNNING)
  40     STATE_RUNNING,
  41     STATE_PAUSED,
  42     STATE_CANCELED,
  43     STATE_EXITED
  44 };
  45
  46 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
  47
  48 // -----------------------------------------------------------------------------
  49 // global data
  50 // -----------------------------------------------------------------------------
  51
  52 // we keep the list of all threads created by the application to be able to
  53 // terminate them on exit if there are some left - otherwise the process would
  54 // be left in memory
  55 static wxArrayThread gs_allThreads;
  56
  57 // the id of the main thread
  58 static pthread_t gs_tidMain;
  59
  60 // the key for the pointer to the associated wxThread object
  61 static pthread_key_t gs_keySelf;
  62
  63 // this mutex must be acquired before any call to a GUI function
  64 static wxMutex *gs_mutexGui;
  65
  66 //--------------------------------------------------------------------
  67 // common GUI thread code
  68 //--------------------------------------------------------------------
  69
  70 #include "threadgui.inc"
  71
  72 //--------------------------------------------------------------------
  73 // wxMutex (Posix implementation)
  74 //--------------------------------------------------------------------
  75
  76 class wxMutexInternal
  77 {
  78 public:
  79   pthread_mutex_t p_mutex;
  80 };
  81
  82 wxMutex::wxMutex()
  83 {
  84     p_internal = new wxMutexInternal;
  85     pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
  86     m_locked = 0;
  87 }
  88
  89 wxMutex::~wxMutex()
  90 {
  91     if (m_locked > 0)
  92         wxLogDebug("Freeing a locked mutex (%d locks)", m_locked);
  93
  94     pthread_mutex_destroy( &(p_internal->p_mutex) );
  95     delete p_internal;
  96 }
  97
  98 wxMutexError wxMutex::Lock()
  99 {
 100     int err = pthread_mutex_lock( &(p_internal->p_mutex) );
 101     if (err == EDEADLK)
 102     {
 103         wxLogDebug("Locking this mutex would lead to deadlock!");
 104
 105         return wxMUTEX_DEAD_LOCK;
 106     }
 107
 108     m_locked++;
 109
 110     return wxMUTEX_NO_ERROR;
 111 }
 112
 113 wxMutexError wxMutex::TryLock()
 114 {
 115     if (m_locked)
 116     {
 117         return wxMUTEX_BUSY;
 118     }
 119
 120     int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
 121     switch (err)
 122     {
 123         case EBUSY: return wxMUTEX_BUSY;
 124     }
 125
 126     m_locked++;
 127
 128     return wxMUTEX_NO_ERROR;
 129 }
 130
 131 wxMutexError wxMutex::Unlock()
 132 {
 133     if (m_locked > 0)
 134     {
 135         m_locked--;
 136     }
 137     else
 138     {
 139         wxLogDebug("Unlocking not locked mutex.");
 140
 141         return wxMUTEX_UNLOCKED;
 142     }
 143
 144     pthread_mutex_unlock( &(p_internal->p_mutex) );
 145
 146     return wxMUTEX_NO_ERROR;
 147 }
 148
 149 //--------------------------------------------------------------------
 150 // wxCondition (Posix implementation)
 151 //--------------------------------------------------------------------
 152
 153 class wxConditionInternal
 154 {
 155 public:
 156   pthread_cond_t p_condition;
 157 };
 158
 159 wxCondition::wxCondition()
 160 {
 161     p_internal = new wxConditionInternal;
 162     pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
 163 }
 164
 165 wxCondition::~wxCondition()
 166 {
 167     pthread_cond_destroy( &(p_internal->p_condition) );
 168
 169     delete p_internal;
 170 }
 171
 172 void wxCondition::Wait(wxMutex& mutex)
 173 {
 174     pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
 175 }
 176
 177 bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
 178 {
 179     struct timespec tspec;
 180
 181     tspec.tv_sec = time(0L)+sec;
 182     tspec.tv_nsec = nsec;
 183     return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
 184 }
 185
 186 void wxCondition::Signal()
 187 {
 188     pthread_cond_signal( &(p_internal->p_condition) );
 189 }
 190
 191 void wxCondition::Broadcast()
 192 {
 193     pthread_cond_broadcast( &(p_internal->p_condition) );
 194 }
 195
 196 //--------------------------------------------------------------------
 197 // wxThread (Posix implementation)
 198 //--------------------------------------------------------------------
 199
 200 class wxThreadInternal
 201 {
 202 public:
 203     wxThreadInternal();
 204     ~wxThreadInternal();
 205
 206     // thread entry function
 207     static void *PthreadStart(void *ptr);
 208
 209     // thread actions
 210         // start the thread
 211     wxThreadError Run();
 212         // ask the thread to terminate
 213     void Cancel();
 214         // wake up threads waiting for our termination
 215     void SignalExit();
 216         // go to sleep until Resume() is called
 217     void Pause();
 218         // resume the thread
 219     void Resume();
 220
 221     // accessors
 222         // priority
 223     int GetPriority() const { return m_prio; }
 224     void SetPriority(int prio) { m_prio = prio; }
 225         // state
 226     thread_state GetState() const { return m_state; }
 227     void SetState(thread_state state) { m_state = state; }
 228         // id
 229     pthread_t GetId() const { return thread_id; }
 230         // "cancelled" flag
 231     bool WasCancelled() const { return m_cancelled; }
 232
 233 //private: -- should be!
 234     pthread_t thread_id;
 235
 236 private:
 237     thread_state m_state;    // see thread_state enum
 238     int          m_prio;     // in wxWindows units: from 0 to 100
 239
 240     // set when the thread should terminate
 241     bool m_cancelled;
 242
 243     // this (mutex, cond) pair is used to synchronize the main thread and this
 244     // thread in several situations:
 245     //  1. The thread function blocks until condition is signaled by Run() when
 246     //     it's initially created - this allows create thread in "suspended"
 247     //     state
 248     //  2. The Delete() function blocks until the condition is signaled when the
 249     //     thread exits.
 250     wxMutex     m_mutex;
 251     wxCondition m_cond;
 252
 253     // another (mutex, cond) pair for Pause()/Resume() usage
 254     //
 255     // VZ: it's possible that we might reuse the mutex and condition from above
 256     //     for this too, but as I'm not at all sure that it won't create subtle
 257     //     problems with race conditions between, say, Pause() and Delete() I
 258     //     prefer this may be a bit less efficient but much safer solution
 259     wxMutex     m_mutexSuspend;
 260     wxCondition m_condSuspend;
 261 };
 262
 263 void *wxThreadInternal::PthreadStart(void *ptr)
 264 {
 265     wxThread *thread = (wxThread *)ptr;
 266     wxThreadInternal *pthread = thread->p_internal;
 267
 268     if ( pthread_setspecific(gs_keySelf, thread) != 0 )
 269     {
 270         wxLogError(_("Can not start thread: error writing TLS."));
 271
 272         return (void *)-1;
 273     }
 274
 275     // wait for the condition to be signaled from Run()
 276     // mutex state: currently locked by the thread which created us
 277     pthread->m_cond.Wait(pthread->m_mutex);
 278
 279     // mutex state: locked again on exit of Wait()
 280
 281     // call the main entry
 282     void* status = thread->Entry();
 283
 284     // terminate the thread
 285     thread->Exit(status);
 286
 287     wxFAIL_MSG("wxThread::Exit() can't return.");
 288
 289     return NULL;
 290 }
 291
 292 wxThreadInternal::wxThreadInternal()
 293 {
 294     m_state = STATE_NEW;
 295     m_cancelled = FALSE;
 296
 297     // this mutex is locked during almost all thread lifetime - it will only be
 298     // unlocked in the very end
 299     m_mutex.Lock();
 300
 301     // this mutex is used in Pause()/Resume() and is also locked all the time
 302     // unless the thread is paused
 303     m_mutexSuspend.Lock();
 304 }
 305
 306 wxThreadInternal::~wxThreadInternal()
 307 {
 308     m_mutexSuspend.Unlock();
 309
 310     // note that m_mutex will be unlocked by the thread which waits for our
 311     // termination
 312 }
 313
 314 wxThreadError wxThreadInternal::Run()
 315 {
 316     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
 317                  "thread may only be started once after successful Create()" );
 318
 319     // the mutex was locked on Create(), so we will be able to lock it again
 320     // only when the thread really starts executing and enters the wait -
 321     // otherwise we might signal the condition before anybody is waiting for it
 322     wxMutexLocker lock(m_mutex);
 323     m_cond.Signal();
 324
 325     m_state = STATE_RUNNING;
 326
 327     return wxTHREAD_NO_ERROR;
 328
 329     // now the mutex is unlocked back - but just to allow Wait() function to
 330     // terminate by relocking it, so the net result is that the worker thread
 331     // starts executing and the mutex is still locked
 332 }
 333
 334 void wxThreadInternal::Cancel()
 335 {
 336     // if the thread we're waiting for is waiting for the GUI mutex, we will
 337     // deadlock so make sure we release it temporarily
 338     if ( wxThread::IsMain() )
 339         wxMutexGuiLeave();
 340
 341     // nobody ever writes this variable so it's safe to not use any
 342     // synchronization here
 343     m_cancelled = TRUE;
 344
 345     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
 346     // it and to signal us its termination
 347     m_cond.Wait(m_mutex);
 348
 349     // mutex is still in the locked state - relocked on exit from Wait(), so
 350     // unlock it - we don't need it any more, the thread has already terminated
 351     m_mutex.Unlock();
 352
 353     // reacquire GUI mutex
 354     if ( wxThread::IsMain() )
 355         wxMutexGuiEnter();
 356 }
 357
 358 void wxThreadInternal::SignalExit()
 359 {
 360     // as mutex is currently locked, this will block until some other thread
 361     // (normally the same which created this one) unlocks it by entering Wait()
 362     m_mutex.Lock();
 363
 364     // wake up all the threads waiting for our termination
 365     m_cond.Broadcast();
 366
 367     // after this call mutex will be finally unlocked
 368     m_mutex.Unlock();
 369 }
 370
 371 void wxThreadInternal::Pause()
 372 {
 373     wxCHECK_RET( m_state == STATE_PAUSED,
 374                  "thread must first be paused with wxThread::Pause()." );
 375
 376     // wait until the condition is signaled from Resume()
 377     m_condSuspend.Wait(m_mutexSuspend);
 378 }
 379
 380 void wxThreadInternal::Resume()
 381 {
 382     wxCHECK_RET( m_state == STATE_PAUSED,
 383                  "can't resume thread which is not suspended." );
 384
 385     // we will be able to lock this mutex only when Pause() starts waiting
 386     wxMutexLocker lock(m_mutexSuspend);
 387     m_condSuspend.Signal();
 388
 389     SetState(STATE_RUNNING);
 390 }
 391
 392 // -----------------------------------------------------------------------------
 393 // static functions
 394 // -----------------------------------------------------------------------------
 395
 396 wxThread *wxThread::This()
 397 {
 398     return (wxThread *)pthread_getspecific(gs_keySelf);
 399 }
 400
 401 bool wxThread::IsMain()
 402 {
 403     return (bool)pthread_equal(pthread_self(), gs_tidMain);
 404 }
 405
 406 void wxThread::Yield()
 407 {
 408     sched_yield();
 409 }
 410
 411 void wxThread::Sleep(unsigned long milliseconds)
 412 {
 413     // FIXME how to test for nanosleep() availability?
 414
 415     usleep(milliseconds * 1000); // usleep(3) wants microseconds
 416 }
 417
 418 // -----------------------------------------------------------------------------
 419 // creating thread
 420 // -----------------------------------------------------------------------------
 421
 422 wxThread::wxThread()
 423 {
 424     // add this thread to the global list of all threads
 425     gs_allThreads.Add(this);
 426
 427     p_internal = new wxThreadInternal();
 428 }
 429
 430 wxThreadError wxThread::Create()
 431 {
 432     if (p_internal->GetState() != STATE_NEW)
 433         return wxTHREAD_RUNNING;
 434
 435     // set up the thread attribute: right now, we only set thread priority
 436     pthread_attr_t attr;
 437     pthread_attr_init(&attr);
 438
 439     int prio;
 440     if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
 441     {
 442         wxLogError(_("Can not retrieve thread scheduling policy."));
 443     }
 444
 445     int min_prio = sched_get_priority_min(prio),
 446         max_prio = sched_get_priority_max(prio);
 447
 448     if ( min_prio == -1 || max_prio == -1 )
 449     {
 450         wxLogError(_("Can not get priority range for scheduling policy %d."),
 451                    prio);
 452     }
 453     else
 454     {
 455         struct sched_param sp;
 456         pthread_attr_getschedparam(&attr, &sp);
 457         sp.sched_priority = min_prio +
 458                            (p_internal->GetPriority()*(max_prio-min_prio))/100;
 459         pthread_attr_setschedparam(&attr, &sp);
 460     }
 461
 462     // create the new OS thread object
 463     int rc = pthread_create(&p_internal->thread_id, &attr,
 464                             wxThreadInternal::PthreadStart, (void *)this);
 465     pthread_attr_destroy(&attr);
 466
 467     if ( rc != 0 )
 468     {
 469         p_internal->SetState(STATE_EXITED);
 470         return wxTHREAD_NO_RESOURCE;
 471     }
 472
 473     return wxTHREAD_NO_ERROR;
 474 }
 475
 476 wxThreadError wxThread::Run()
 477 {
 478     return p_internal->Run();
 479 }
 480
 481 // -----------------------------------------------------------------------------
 482 // misc accessors
 483 // -----------------------------------------------------------------------------
 484
 485 void wxThread::SetPriority(unsigned int prio)
 486 {
 487     wxCHECK_RET( (WXTHREAD_MIN_PRIORITY <= prio) &&
 488                  (prio <= WXTHREAD_MAX_PRIORITY), "invalid thread priority" );
 489
 490     wxCriticalSectionLocker lock(m_critsect);
 491
 492     switch ( p_internal->GetState() )
 493     {
 494         case STATE_NEW:
 495             // thread not yet started, priority will be set when it is
 496             p_internal->SetPriority(prio);
 497             break;
 498
 499         case STATE_RUNNING:
 500         case STATE_PAUSED:
 501             {
 502                 struct sched_param sparam;
 503                 sparam.sched_priority = prio;
 504
 505                 if ( pthread_setschedparam(p_internal->GetId(),
 506                                            SCHED_OTHER, &sparam) != 0 )
 507                 {
 508                     wxLogError(_("Failed to set thread priority %d."), prio);
 509                 }
 510             }
 511             break;
 512
 513         case STATE_EXITED:
 514         default:
 515             wxFAIL_MSG("impossible to set thread priority in this state");
 516     }
 517 }
 518
 519 unsigned int wxThread::GetPriority() const
 520 {
 521     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 522
 523     return p_internal->GetPriority();
 524 }
 525
 526 unsigned long wxThread::GetID() const
 527 {
 528     return (unsigned long)p_internal->thread_id;
 529 }
 530
 531 // -----------------------------------------------------------------------------
 532 // pause/resume
 533 // -----------------------------------------------------------------------------
 534
 535 wxThreadError wxThread::Pause()
 536 {
 537     wxCriticalSectionLocker lock(m_critsect);
 538
 539     if ( p_internal->GetState() != STATE_RUNNING )
 540     {
 541         wxLogDebug("Can't pause thread which is not running.");
 542
 543         return wxTHREAD_NOT_RUNNING;
 544     }
 545
 546     p_internal->SetState(STATE_PAUSED);
 547
 548     return wxTHREAD_NO_ERROR;
 549 }
 550
 551 wxThreadError wxThread::Resume()
 552 {
 553     wxCriticalSectionLocker lock(m_critsect);
 554
 555     if ( p_internal->GetState() == STATE_PAUSED )
 556     {
 557         p_internal->Resume();
 558
 559         return wxTHREAD_NO_ERROR;
 560     }
 561     else
 562     {
 563         wxLogDebug("Attempt to resume a thread which is not paused.");
 564
 565         return wxTHREAD_MISC_ERROR;
 566     }
 567 }
 568
 569 // -----------------------------------------------------------------------------
 570 // exiting thread
 571 // -----------------------------------------------------------------------------
 572
 573 wxThread::ExitCode wxThread::Delete()
 574 {
 575     m_critsect.Enter();
 576     thread_state state = p_internal->GetState();
 577     m_critsect.Leave();
 578
 579     switch ( state )
 580     {
 581         case STATE_NEW:
 582         case STATE_EXITED:
 583             // nothing to do
 584             break;
 585
 586         case STATE_PAUSED:
 587             // resume the thread first
 588             Resume();
 589
 590             // fall through
 591
 592         default:
 593             // set the flag telling to the thread to stop and wait
 594             p_internal->Cancel();
 595     }
 596
 597     return NULL;
 598 }
 599
 600 wxThreadError wxThread::Kill()
 601 {
 602     switch ( p_internal->GetState() )
 603     {
 604         case STATE_NEW:
 605         case STATE_EXITED:
 606             return wxTHREAD_NOT_RUNNING;
 607
 608         default:
 609             if ( pthread_cancel(p_internal->GetId()) != 0 )
 610             {
 611                 wxLogError(_("Failed to terminate a thread."));
 612
 613                 return wxTHREAD_MISC_ERROR;
 614             }
 615
 616             return wxTHREAD_NO_ERROR;
 617     }
 618 }
 619
 620 void wxThread::Exit(void *status)
 621 {
 622     // first call user-level clean up code
 623     OnExit();
 624
 625     // next wake up the threads waiting for us (OTOH, this function won't return
 626     // until someone waited for us!)
 627     p_internal->SignalExit();
 628
 629     p_internal->SetState(STATE_EXITED);
 630
 631     // delete both C++ thread object and terminate the OS thread object
 632     delete this;
 633     pthread_exit(status);
 634 }
 635
 636 // also test whether we were paused
 637 bool wxThread::TestDestroy()
 638 {
 639     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 640
 641     if ( p_internal->GetState() == STATE_PAUSED )
 642     {
 643         // leave the crit section or the other threads will stop too if they try
 644         // to call any of (seemingly harmless) IsXXX() functions while we sleep
 645         m_critsect.Leave();
 646
 647         p_internal->Pause();
 648
 649         // enter it back before it's finally left in lock object dtor
 650         m_critsect.Enter();
 651     }
 652
 653     return p_internal->WasCancelled();
 654 }
 655
 656 wxThread::~wxThread()
 657 {
 658     // remove this thread from the global array
 659     gs_allThreads.Remove(this);
 660 }
 661
 662 // -----------------------------------------------------------------------------
 663 // state tests
 664 // -----------------------------------------------------------------------------
 665
 666 bool wxThread::IsRunning() const
 667 {
 668     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 669
 670     return p_internal->GetState() == STATE_RUNNING;
 671 }
 672
 673 bool wxThread::IsAlive() const
 674 {
 675     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 676
 677     switch ( p_internal->GetState() )
 678     {
 679         case STATE_RUNNING:
 680         case STATE_PAUSED:
 681             return TRUE;
 682
 683         default:
 684             return FALSE;
 685     }
 686 }
 687
 688 //--------------------------------------------------------------------
 689 // wxThreadModule
 690 //--------------------------------------------------------------------
 691
 692 class wxThreadModule : public wxModule
 693 {
 694 public:
 695     virtual bool OnInit();
 696     virtual void OnExit();
 697
 698 private:
 699     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 700 };
 701
 702 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 703
 704 bool wxThreadModule::OnInit()
 705 {
 706     if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
 707     {
 708         wxLogError(_("Thread module initialization failed: "
 709                      "failed to create pthread key."));
 710
 711         return FALSE;
 712     }
 713
 714     gs_mutexGui = new wxMutex();
 715     wxThreadGuiInit();
 716     gs_tidMain = pthread_self();
 717     gs_mutexGui->Lock();
 718
 719     return TRUE;
 720 }
 721
 722 void wxThreadModule::OnExit()
 723 {
 724     wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" );
 725
 726     // terminate any threads left
 727     size_t count = gs_allThreads.GetCount();
 728     if ( count != 0u )
 729         wxLogDebug("Some threads were not terminated by the application.");
 730
 731     for ( size_t n = 0u; n < count; n++ )
 732     {
 733         gs_allThreads[n]->Delete();
 734     }
 735
 736     // destroy GUI mutex
 737     gs_mutexGui->Unlock();
 738     wxThreadGuiExit();
 739     delete gs_mutexGui;
 740
 741     // and free TLD slot
 742     (void)pthread_key_delete(gs_keySelf);
 743 }