src/palmos/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/palmos/thread.cpp
   3 // Purpose:     wxThread Implementation
   4 // Author:      William Osborne - minimal working wxPalmOS port
   5 // Modified by:
   6 // Created:     10/13/04
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) William Osborne
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ----------------------------------------------------------------------------
  13 // headers
  14 // ----------------------------------------------------------------------------
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #if defined(__BORLANDC__)
  20     #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/intl.h"
  25     #include "wx/app.h"
  26 #endif
  27
  28 #if wxUSE_THREADS
  29
  30 #include "wx/apptrait.h"
  31
  32 #include "wx/palmos/private.h"
  33 #include "wx/palmos/missing.h"
  34
  35 #include "wx/module.h"
  36 #include "wx/thread.h"
  37
  38 // must have this symbol defined to get _beginthread/_endthread declarations
  39 #ifndef _MT
  40     #define _MT
  41 #endif
  42
  43 #if defined(__BORLANDC__)
  44     #if !defined(__MT__)
  45         // I can't set -tWM in the IDE (anyone?) so have to do this
  46         #define __MT__
  47     #endif
  48
  49     #if !defined(__MFC_COMPAT__)
  50         // Needed to know about _beginthreadex etc..
  51         #define __MFC_COMPAT__
  52     #endif
  53 #endif // BC++
  54
  55 // define wxUSE_BEGIN_THREAD if the compiler has _beginthreadex() function
  56 // which should be used instead of Win32 ::CreateThread() if possible
  57 #if defined(__VISUALC__) || \
  58     (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \
  59     (defined(__GNUG__) && defined(__MSVCRT__)) || \
  60     defined(__WATCOMC__) || defined(__MWERKS__)
  61
  62 #ifndef __WXWINCE__
  63     #undef wxUSE_BEGIN_THREAD
  64     #define wxUSE_BEGIN_THREAD
  65 #endif
  66
  67 #endif
  68
  69 #ifdef wxUSE_BEGIN_THREAD
  70     // the return type of the thread function entry point
  71     typedef unsigned THREAD_RETVAL;
  72
  73     // the calling convention of the thread function entry point
  74     #define THREAD_CALLCONV __stdcall
  75 #else
  76     // the settings for CreateThread()
  77     typedef DWORD THREAD_RETVAL;
  78     #define THREAD_CALLCONV WINAPI
  79 #endif
  80
  81 // ----------------------------------------------------------------------------
  82 // constants
  83 // ----------------------------------------------------------------------------
  84
  85 // the possible states of the thread ("=>" shows all possible transitions from
  86 // this state)
  87 enum wxThreadState
  88 {
  89     STATE_NEW,          // didn't start execution yet (=> RUNNING)
  90     STATE_RUNNING,      // thread is running (=> PAUSED, CANCELED)
  91     STATE_PAUSED,       // thread is temporarily suspended (=> RUNNING)
  92     STATE_CANCELED,     // thread should terminate a.s.a.p. (=> EXITED)
  93     STATE_EXITED        // thread is terminating
  94 };
  95
  96 // ----------------------------------------------------------------------------
  97 // this module globals
  98 // ----------------------------------------------------------------------------
  99
 100 // TLS index of the slot where we store the pointer to the current thread
 101 static DWORD gs_tlsThisThread = 0xFFFFFFFF;
 102
 103 // id of the main thread - the one which can call GUI functions without first
 104 // calling wxMutexGuiEnter()
 105 static DWORD gs_idMainThread = 0;
 106
 107 // if it's false, some secondary thread is holding the GUI lock
 108 static bool gs_bGuiOwnedByMainThread = true;
 109
 110 // critical section which controls access to all GUI functions: any secondary
 111 // thread (i.e. except the main one) must enter this crit section before doing
 112 // any GUI calls
 113 static wxCriticalSection *gs_critsectGui = NULL;
 114
 115 // critical section which protects gs_nWaitingForGui variable
 116 static wxCriticalSection *gs_critsectWaitingForGui = NULL;
 117
 118 // critical section which serializes WinThreadStart() and WaitForTerminate()
 119 // (this is a potential bottleneck, we use a single crit sect for all threads
 120 // in the system, but normally time spent inside it should be quite short)
 121 static wxCriticalSection *gs_critsectThreadDelete = NULL;
 122
 123 // number of threads waiting for GUI in wxMutexGuiEnter()
 124 static size_t gs_nWaitingForGui = 0;
 125
 126 // are we waiting for a thread termination?
 127 static bool gs_waitingForThread = false;
 128
 129 // ============================================================================
 130 // Windows implementation of thread and related classes
 131 // ============================================================================
 132
 133 // ----------------------------------------------------------------------------
 134 // wxCriticalSection
 135 // ----------------------------------------------------------------------------
 136
 137 wxCriticalSection::wxCriticalSection()
 138 {
 139 }
 140
 141 wxCriticalSection::~wxCriticalSection()
 142 {
 143 }
 144
 145 void wxCriticalSection::Enter()
 146 {
 147 }
 148
 149 void wxCriticalSection::Leave()
 150 {
 151 }
 152
 153 // ----------------------------------------------------------------------------
 154 // wxMutex
 155 // ----------------------------------------------------------------------------
 156
 157 class wxMutexInternal
 158 {
 159 public:
 160     wxMutexInternal(wxMutexType mutexType);
 161     ~wxMutexInternal();
 162
 163     bool IsOk() const { return m_mutex != NULL; }
 164
 165     wxMutexError Lock() { return LockTimeout(INFINITE); }
 166     wxMutexError TryLock() { return LockTimeout(0); }
 167     wxMutexError Unlock();
 168
 169 private:
 170     wxMutexError LockTimeout(DWORD milliseconds);
 171
 172     HANDLE m_mutex;
 173
 174     DECLARE_NO_COPY_CLASS(wxMutexInternal)
 175 };
 176
 177 // all mutexes are recursive under Win32 so we don't use mutexType
 178 wxMutexInternal::wxMutexInternal(wxMutexType WXUNUSED(mutexType))
 179 {
 180 }
 181
 182 wxMutexInternal::~wxMutexInternal()
 183 {
 184 }
 185
 186 wxMutexError wxMutexInternal::LockTimeout(DWORD milliseconds)
 187 {
 188     return wxMUTEX_NO_ERROR;
 189 }
 190
 191 wxMutexError wxMutexInternal::Unlock()
 192 {
 193     return wxMUTEX_NO_ERROR;
 194 }
 195
 196 // --------------------------------------------------------------------------
 197 // wxSemaphore
 198 // --------------------------------------------------------------------------
 199
 200 // a trivial wrapper around Win32 semaphore
 201 class wxSemaphoreInternal
 202 {
 203 public:
 204     wxSemaphoreInternal(int initialcount, int maxcount);
 205     ~wxSemaphoreInternal();
 206
 207     bool IsOk() const { return m_semaphore != NULL; }
 208
 209     wxSemaError Wait() { return WaitTimeout(INFINITE); }
 210
 211     wxSemaError TryWait()
 212     {
 213         wxSemaError rc = WaitTimeout(0);
 214         if ( rc == wxSEMA_TIMEOUT )
 215             rc = wxSEMA_BUSY;
 216
 217         return rc;
 218     }
 219
 220     wxSemaError WaitTimeout(unsigned long milliseconds);
 221
 222     wxSemaError Post();
 223
 224 private:
 225     HANDLE m_semaphore;
 226
 227     DECLARE_NO_COPY_CLASS(wxSemaphoreInternal)
 228 };
 229
 230 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
 231 {
 232 }
 233
 234 wxSemaphoreInternal::~wxSemaphoreInternal()
 235 {
 236 }
 237
 238 wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
 239 {
 240     return wxSEMA_NO_ERROR;
 241 }
 242
 243 wxSemaError wxSemaphoreInternal::Post()
 244 {
 245     return wxSEMA_NO_ERROR;
 246 }
 247
 248 // ----------------------------------------------------------------------------
 249 // wxThread implementation
 250 // ----------------------------------------------------------------------------
 251
 252 // wxThreadInternal class
 253 // ----------------------
 254
 255 class wxThreadInternal
 256 {
 257 public:
 258     wxThreadInternal(wxThread *thread)
 259     {
 260         m_thread = thread;
 261         m_hThread = 0;
 262         m_state = STATE_NEW;
 263         m_priority = WXTHREAD_DEFAULT_PRIORITY;
 264         m_nRef = 1;
 265     }
 266
 267     ~wxThreadInternal()
 268     {
 269         Free();
 270     }
 271
 272     void Free()
 273     {
 274         if ( m_hThread )
 275         {
 276             if ( !::CloseHandle(m_hThread) )
 277             {
 278                 wxLogLastError(wxT("CloseHandle(thread)"));
 279             }
 280
 281             m_hThread = 0;
 282         }
 283     }
 284
 285     // create a new (suspended) thread (for the given thread object)
 286     bool Create(wxThread *thread, unsigned int stackSize);
 287
 288     // wait for the thread to terminate, either by itself, or by asking it
 289     // (politely, this is not Kill()!) to do it
 290     wxThreadError WaitForTerminate(wxCriticalSection& cs,
 291                                    wxThread::ExitCode *pRc,
 292                                    wxThread *threadToDelete = NULL);
 293
 294     // kill the thread unconditionally
 295     wxThreadError Kill();
 296
 297     // suspend/resume/terminate
 298     bool Suspend();
 299     bool Resume();
 300     void Cancel() { m_state = STATE_CANCELED; }
 301
 302     // thread state
 303     void SetState(wxThreadState state) { m_state = state; }
 304     wxThreadState GetState() const { return m_state; }
 305
 306     // thread priority
 307     void SetPriority(unsigned int priority);
 308     unsigned int GetPriority() const { return m_priority; }
 309
 310     // thread handle and id
 311     HANDLE GetHandle() const { return m_hThread; }
 312     DWORD  GetId() const { return m_tid; }
 313
 314     // thread function
 315     static THREAD_RETVAL THREAD_CALLCONV WinThreadStart(void *thread);
 316
 317     void KeepAlive()
 318     {
 319         if ( m_thread->IsDetached() )
 320             ::InterlockedIncrement(&m_nRef);
 321     }
 322
 323     void LetDie()
 324     {
 325         if ( m_thread->IsDetached() && !::InterlockedDecrement(&m_nRef) )
 326             delete m_thread;
 327     }
 328
 329 private:
 330     // the thread we're associated with
 331     wxThread *m_thread;
 332
 333     HANDLE        m_hThread;    // handle of the thread
 334     wxThreadState m_state;      // state, see wxThreadState enum
 335     unsigned int  m_priority;   // thread priority in "wx" units
 336     DWORD         m_tid;        // thread id
 337
 338     // number of threads which need this thread to remain alive, when the count
 339     // reaches 0 we kill the owning wxThread -- and die ourselves with it
 340     LONG m_nRef;
 341
 342     DECLARE_NO_COPY_CLASS(wxThreadInternal)
 343 };
 344
 345 // small class which keeps a thread alive during its lifetime
 346 class wxThreadKeepAlive
 347 {
 348 public:
 349     wxThreadKeepAlive(wxThreadInternal& thrImpl) : m_thrImpl(thrImpl)
 350         { m_thrImpl.KeepAlive(); }
 351     ~wxThreadKeepAlive()
 352         { m_thrImpl.LetDie(); }
 353
 354 private:
 355     wxThreadInternal& m_thrImpl;
 356 };
 357
 358
 359 THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param)
 360 {
 361     THREAD_RETVAL rc;
 362
 363     return rc;
 364 }
 365
 366 void wxThreadInternal::SetPriority(unsigned int priority)
 367 {
 368 }
 369
 370 bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
 371 {
 372     return false;
 373 }
 374
 375 wxThreadError wxThreadInternal::Kill()
 376 {
 377     return wxTHREAD_NO_ERROR;
 378 }
 379
 380 wxThreadError
 381 wxThreadInternal::WaitForTerminate(wxCriticalSection& cs,
 382                                    wxThread::ExitCode *pRc,
 383                                    wxThread *threadToDelete)
 384 {
 385     return wxTHREAD_NO_ERROR;
 386 }
 387
 388 bool wxThreadInternal::Suspend()
 389 {
 390     return true;
 391 }
 392
 393 bool wxThreadInternal::Resume()
 394 {
 395     return true;
 396 }
 397
 398 // static functions
 399 // ----------------
 400
 401 wxThread *wxThread::This()
 402 {
 403     return NULL;
 404 }
 405
 406 bool wxThread::IsMain()
 407 {
 408     return true;
 409 }
 410
 411 void wxThread::Yield()
 412 {
 413 }
 414
 415 void wxThread::Sleep(unsigned long milliseconds)
 416 {
 417 }
 418
 419 int wxThread::GetCPUCount()
 420 {
 421     return 1;
 422 }
 423
 424 unsigned long wxThread::GetCurrentId()
 425 {
 426     return 0;
 427 }
 428
 429 bool wxThread::SetConcurrency(size_t level)
 430 {
 431     return true;
 432 }
 433
 434 // ctor and dtor
 435 // -------------
 436
 437 wxThread::wxThread(wxThreadKind kind)
 438 {
 439 }
 440
 441 wxThread::~wxThread()
 442 {
 443 }
 444
 445 // create/start thread
 446 // -------------------
 447
 448 wxThreadError wxThread::Create(unsigned int stackSize)
 449 {
 450     return wxTHREAD_NO_ERROR;
 451 }
 452
 453 wxThreadError wxThread::Run()
 454 {
 455     return wxTHREAD_RUNNING;
 456 }
 457
 458 // suspend/resume thread
 459 // ---------------------
 460
 461 wxThreadError wxThread::Pause()
 462 {
 463     return wxTHREAD_NO_ERROR;
 464 }
 465
 466 wxThreadError wxThread::Resume()
 467 {
 468     return wxTHREAD_NO_ERROR;
 469 }
 470
 471 // stopping thread
 472 // ---------------
 473
 474 wxThread::ExitCode wxThread::Wait()
 475 {
 476     return 0;
 477 }
 478
 479 wxThreadError wxThread::Delete(ExitCode *pRc)
 480 {
 481     return wxTHREAD_NO_ERROR;
 482 }
 483
 484 wxThreadError wxThread::Kill()
 485 {
 486     return wxTHREAD_NO_ERROR;
 487 }
 488
 489 void wxThread::Exit(ExitCode status)
 490 {
 491 }
 492
 493 // priority setting
 494 // ----------------
 495
 496 void wxThread::SetPriority(unsigned int prio)
 497 {
 498 }
 499
 500 unsigned int wxThread::GetPriority() const
 501 {
 502     return 1;
 503 }
 504
 505 unsigned long wxThread::GetId() const
 506 {
 507     return 0;
 508 }
 509
 510 bool wxThread::IsRunning() const
 511 {
 512     return true;
 513 }
 514
 515 bool wxThread::IsAlive() const
 516 {
 517     return true;
 518 }
 519
 520 bool wxThread::IsPaused() const
 521 {
 522     return false;
 523 }
 524
 525 bool wxThread::TestDestroy()
 526 {
 527     return true;
 528 }
 529
 530 // ----------------------------------------------------------------------------
 531 // Automatic initialization for thread module
 532 // ----------------------------------------------------------------------------
 533
 534 class wxThreadModule : public wxModule
 535 {
 536 public:
 537     virtual bool OnInit();
 538     virtual void OnExit();
 539
 540 private:
 541     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 542 };
 543
 544 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 545
 546 bool wxThreadModule::OnInit()
 547 {
 548     return true;
 549 }
 550
 551 void wxThreadModule::OnExit()
 552 {
 553 }
 554
 555 // ----------------------------------------------------------------------------
 556 // under Windows, these functions are implemented using a critical section and
 557 // not a mutex, so the names are a bit confusing
 558 // ----------------------------------------------------------------------------
 559
 560 void WXDLLIMPEXP_BASE wxMutexGuiEnter()
 561 {
 562 }
 563
 564 void WXDLLIMPEXP_BASE wxMutexGuiLeave()
 565 {
 566 }
 567
 568 void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
 569 {
 570 }
 571
 572 bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
 573 {
 574     return true;
 575 }
 576
 577 // wake up the main thread if it's in ::GetMessage()
 578 void WXDLLIMPEXP_BASE wxWakeUpMainThread()
 579 {
 580 }
 581
 582 bool WXDLLIMPEXP_BASE wxIsWaitingForThread()
 583 {
 584     return false;
 585 }
 586
 587 // ----------------------------------------------------------------------------
 588 // include common implementation code
 589 // ----------------------------------------------------------------------------
 590
 591 #include "wx/thrimpl.cpp"
 592
 593 #endif // wxUSE_THREADS
 594