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     wxUsleep(milliseconds);
 414 }
 415
 416 // -----------------------------------------------------------------------------
 417 // creating thread
 418 // -----------------------------------------------------------------------------
 419
 420 wxThread::wxThread()
 421 {
 422     // add this thread to the global list of all threads
 423     gs_allThreads.Add(this);
 424
 425     p_internal = new wxThreadInternal();
 426 }
 427
 428 wxThreadError wxThread::Create()
 429 {
 430     if (p_internal->GetState() != STATE_NEW)
 431         return wxTHREAD_RUNNING;
 432
 433     // set up the thread attribute: right now, we only set thread priority
 434     pthread_attr_t attr;
 435     pthread_attr_init(&attr);
 436
 437     int prio;
 438     if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
 439     {
 440         wxLogError(_("Can not retrieve thread scheduling policy."));
 441     }
 442
 443     int min_prio = sched_get_priority_min(prio),
 444         max_prio = sched_get_priority_max(prio);
 445
 446     if ( min_prio == -1 || max_prio == -1 )
 447     {
 448         wxLogError(_("Can not get priority range for scheduling policy %d."),
 449                    prio);
 450     }
 451     else
 452     {
 453         struct sched_param sp;
 454         pthread_attr_getschedparam(&attr, &sp);
 455         sp.sched_priority = min_prio +
 456                            (p_internal->GetPriority()*(max_prio-min_prio))/100;
 457         pthread_attr_setschedparam(&attr, &sp);
 458     }
 459
 460     // create the new OS thread object
 461     int rc = pthread_create(&p_internal->thread_id, &attr,
 462                             wxThreadInternal::PthreadStart, (void *)this);
 463     pthread_attr_destroy(&attr);
 464
 465     if ( rc != 0 )
 466     {
 467         p_internal->SetState(STATE_EXITED);
 468         return wxTHREAD_NO_RESOURCE;
 469     }
 470
 471     return wxTHREAD_NO_ERROR;
 472 }
 473
 474 wxThreadError wxThread::Run()
 475 {
 476     return p_internal->Run();
 477 }
 478
 479 // -----------------------------------------------------------------------------
 480 // misc accessors
 481 // -----------------------------------------------------------------------------
 482
 483 void wxThread::SetPriority(unsigned int prio)
 484 {
 485     wxCHECK_RET( (WXTHREAD_MIN_PRIORITY <= prio) &&
 486                  (prio <= WXTHREAD_MAX_PRIORITY), "invalid thread priority" );
 487
 488     wxCriticalSectionLocker lock(m_critsect);
 489
 490     switch ( p_internal->GetState() )
 491     {
 492         case STATE_NEW:
 493             // thread not yet started, priority will be set when it is
 494             p_internal->SetPriority(prio);
 495             break;
 496
 497         case STATE_RUNNING:
 498         case STATE_PAUSED:
 499             {
 500                 struct sched_param sparam;
 501                 sparam.sched_priority = prio;
 502
 503                 if ( pthread_setschedparam(p_internal->GetId(),
 504                                            SCHED_OTHER, &sparam) != 0 )
 505                 {
 506                     wxLogError(_("Failed to set thread priority %d."), prio);
 507                 }
 508             }
 509             break;
 510
 511         case STATE_EXITED:
 512         default:
 513             wxFAIL_MSG("impossible to set thread priority in this state");
 514     }
 515 }
 516
 517 unsigned int wxThread::GetPriority() const
 518 {
 519     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 520
 521     return p_internal->GetPriority();
 522 }
 523
 524 unsigned long wxThread::GetID() const
 525 {
 526     return (unsigned long)p_internal->thread_id;
 527 }
 528
 529 // -----------------------------------------------------------------------------
 530 // pause/resume
 531 // -----------------------------------------------------------------------------
 532
 533 wxThreadError wxThread::Pause()
 534 {
 535     wxCriticalSectionLocker lock(m_critsect);
 536
 537     if ( p_internal->GetState() != STATE_RUNNING )
 538     {
 539         wxLogDebug("Can't pause thread which is not running.");
 540
 541         return wxTHREAD_NOT_RUNNING;
 542     }
 543
 544     p_internal->SetState(STATE_PAUSED);
 545
 546     return wxTHREAD_NO_ERROR;
 547 }
 548
 549 wxThreadError wxThread::Resume()
 550 {
 551     wxCriticalSectionLocker lock(m_critsect);
 552
 553     if ( p_internal->GetState() == STATE_PAUSED )
 554     {
 555         p_internal->Resume();
 556
 557         return wxTHREAD_NO_ERROR;
 558     }
 559     else
 560     {
 561         wxLogDebug("Attempt to resume a thread which is not paused.");
 562
 563         return wxTHREAD_MISC_ERROR;
 564     }
 565 }
 566
 567 // -----------------------------------------------------------------------------
 568 // exiting thread
 569 // -----------------------------------------------------------------------------
 570
 571 wxThread::ExitCode wxThread::Delete()
 572 {
 573     m_critsect.Enter();
 574     thread_state state = p_internal->GetState();
 575     m_critsect.Leave();
 576
 577     switch ( state )
 578     {
 579         case STATE_NEW:
 580         case STATE_EXITED:
 581             // nothing to do
 582             break;
 583
 584         case STATE_PAUSED:
 585             // resume the thread first
 586             Resume();
 587
 588             // fall through
 589
 590         default:
 591             // set the flag telling to the thread to stop and wait
 592             p_internal->Cancel();
 593     }
 594
 595     return NULL;
 596 }
 597
 598 wxThreadError wxThread::Kill()
 599 {
 600     switch ( p_internal->GetState() )
 601     {
 602         case STATE_NEW:
 603         case STATE_EXITED:
 604             return wxTHREAD_NOT_RUNNING;
 605
 606         default:
 607             if ( pthread_cancel(p_internal->GetId()) != 0 )
 608             {
 609                 wxLogError(_("Failed to terminate a thread."));
 610
 611                 return wxTHREAD_MISC_ERROR;
 612             }
 613
 614             return wxTHREAD_NO_ERROR;
 615     }
 616 }
 617
 618 void wxThread::Exit(void *status)
 619 {
 620     // first call user-level clean up code
 621     OnExit();
 622
 623     // next wake up the threads waiting for us (OTOH, this function won't return
 624     // until someone waited for us!)
 625     p_internal->SignalExit();
 626
 627     p_internal->SetState(STATE_EXITED);
 628
 629     // delete both C++ thread object and terminate the OS thread object
 630     delete this;
 631     pthread_exit(status);
 632 }
 633
 634 // also test whether we were paused
 635 bool wxThread::TestDestroy()
 636 {
 637     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 638
 639     if ( p_internal->GetState() == STATE_PAUSED )
 640     {
 641         // leave the crit section or the other threads will stop too if they try
 642         // to call any of (seemingly harmless) IsXXX() functions while we sleep
 643         m_critsect.Leave();
 644
 645         p_internal->Pause();
 646
 647         // enter it back before it's finally left in lock object dtor
 648         m_critsect.Enter();
 649     }
 650
 651     return p_internal->WasCancelled();
 652 }
 653
 654 wxThread::~wxThread()
 655 {
 656     // remove this thread from the global array
 657     gs_allThreads.Remove(this);
 658 }
 659
 660 // -----------------------------------------------------------------------------
 661 // state tests
 662 // -----------------------------------------------------------------------------
 663
 664 bool wxThread::IsRunning() const
 665 {
 666     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 667
 668     return p_internal->GetState() == STATE_RUNNING;
 669 }
 670
 671 bool wxThread::IsAlive() const
 672 {
 673     wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
 674
 675     switch ( p_internal->GetState() )
 676     {
 677         case STATE_RUNNING:
 678         case STATE_PAUSED:
 679             return TRUE;
 680
 681         default:
 682             return FALSE;
 683     }
 684 }
 685
 686 //--------------------------------------------------------------------
 687 // wxThreadModule
 688 //--------------------------------------------------------------------
 689
 690 class wxThreadModule : public wxModule
 691 {
 692 public:
 693     virtual bool OnInit();
 694     virtual void OnExit();
 695
 696 private:
 697     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 698 };
 699
 700 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 701
 702 bool wxThreadModule::OnInit()
 703 {
 704     if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
 705     {
 706         wxLogError(_("Thread module initialization failed: "
 707                      "failed to create pthread key."));
 708
 709         return FALSE;
 710     }
 711
 712     gs_mutexGui = new wxMutex();
 713     wxThreadGuiInit();
 714     gs_tidMain = pthread_self();
 715     gs_mutexGui->Lock();
 716
 717     return TRUE;
 718 }
 719
 720 void wxThreadModule::OnExit()
 721 {
 722     wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" );
 723
 724     // terminate any threads left
 725     size_t count = gs_allThreads.GetCount();
 726     if ( count != 0u )
 727         wxLogDebug("Some threads were not terminated by the application.");
 728
 729     for ( size_t n = 0u; n < count; n++ )
 730     {
 731         gs_allThreads[n]->Delete();
 732     }
 733
 734     // destroy GUI mutex
 735     gs_mutexGui->Unlock();
 736     wxThreadGuiExit();
 737     delete gs_mutexGui;
 738
 739     // and free TLD slot
 740     (void)pthread_key_delete(gs_keySelf);
 741 }