]> git.saurik.com Git - wxWidgets.git/blame - src/unix/threadpsx.cpp
reformat for readability
[wxWidgets.git] / src / unix / threadpsx.cpp
CommitLineData
518b5d2f
VZ
1/////////////////////////////////////////////////////////////////////////////
2// Name: threadpsx.cpp
3// Purpose: wxThread (Posix) Implementation
4// Author: Original from Wolfram Gloger/Guilhem Lavaux
be809868 5// Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
518b5d2f
VZ
6// Created: 04/22/98
7// RCS-ID: $Id$
8// Copyright: (c) Wolfram Gloger (1996, 1997)
9// Guilhem Lavaux (1998)
8d5eff60 10// Vadim Zeitlin (1999-2002)
518b5d2f 11// Robert Roebling (1999)
be809868 12// K. S. Sreeram (2002)
65571936 13// Licence: wxWindows licence
518b5d2f
VZ
14/////////////////////////////////////////////////////////////////////////////
15
16// ============================================================================
17// declaration
18// ============================================================================
19
20// ----------------------------------------------------------------------------
21// headers
22// ----------------------------------------------------------------------------
23
14f355c2
VS
24// for compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
518b5d2f 26
7bcb11d3 27#if wxUSE_THREADS
518b5d2f 28
7bcb11d3 29#include "wx/thread.h"
518b5d2f
VZ
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"
2be028e2 35#include "wx/timer.h"
e61ec95a 36#include "wx/stopwatch.h"
518b5d2f
VZ
37
38#include <stdio.h>
39#include <unistd.h>
40#include <pthread.h>
41#include <errno.h>
42#include <time.h>
4f66d445 43#ifdef HAVE_SCHED_H
518b5d2f
VZ
44 #include <sched.h>
45#endif
46
ef8d96c2
VZ
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"
7bfe6a32
JS
54 // For setpriority.
55 #include <sys/time.h>
56 #include <sys/resource.h>
ef8d96c2
VZ
57#endif
58
ef4f69ec
VZ
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
518b5d2f
VZ
65// ----------------------------------------------------------------------------
66// constants
67// ----------------------------------------------------------------------------
68
882eefb1
VZ
69// the possible states of the thread and transitions from them
70enum wxThreadState
518b5d2f
VZ
71{
72 STATE_NEW, // didn't start execution yet (=> RUNNING)
882eefb1
VZ
73 STATE_RUNNING, // running (=> PAUSED or EXITED)
74 STATE_PAUSED, // suspended (=> RUNNING or EXITED)
75 STATE_EXITED // thread doesn't exist any more
518b5d2f
VZ
76};
77
9fc3ad34
VZ
78// the exit value of a thread which has been cancelled
79static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
80
9e84b847 81// trace mask for wxThread operations
9fc3ad34
VZ
82#define TRACE_THREADS _T("thread")
83
9e84b847
VZ
84// you can get additional debugging messages for the semaphore operations
85#define TRACE_SEMA _T("semaphore")
86
9fc3ad34
VZ
87// ----------------------------------------------------------------------------
88// private functions
89// ----------------------------------------------------------------------------
90
91static void ScheduleThreadForDeletion();
92static void DeleteThread(wxThread *This);
93
882eefb1 94// ----------------------------------------------------------------------------
9e84b847 95// private classes
882eefb1
VZ
96// ----------------------------------------------------------------------------
97
9e84b847 98// an (non owning) array of pointers to threads
0d2c74c6 99WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
518b5d2f 100
9e84b847
VZ
101// an entry for a thread we can wait for
102
518b5d2f
VZ
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
110static wxArrayThread gs_allThreads;
111
112// the id of the main thread
5b65f136 113static pthread_t gs_tidMain = (pthread_t)-1;
518b5d2f
VZ
114
115// the key for the pointer to the associated wxThread object
116static pthread_key_t gs_keySelf;
117
9fc3ad34
VZ
118// the number of threads which are being deleted - the program won't exit
119// until there are any left
120static size_t gs_nThreadsBeingDeleted = 0;
121
122// a mutex to protect gs_nThreadsBeingDeleted
be809868 123static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
9fc3ad34
VZ
124
125// and a condition variable which will be signaled when all
126// gs_nThreadsBeingDeleted will have been deleted
127static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
128
c80217d1
VS
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)
132static wxMutex *gs_mutexGui = NULL;
518b5d2f 133
9e84b847
VZ
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
518b5d2f 143// ============================================================================
8d5eff60 144// wxMutex implementation
518b5d2f
VZ
145// ============================================================================
146
8d5eff60
VZ
147// ----------------------------------------------------------------------------
148// wxMutexInternal
149// ----------------------------------------------------------------------------
518b5d2f 150
9e84b847
VZ
151// this is a simple wrapper around pthread_mutex_t which provides error
152// checking
518b5d2f
VZ
153class wxMutexInternal
154{
155public:
9e84b847 156 wxMutexInternal(wxMutexType mutexType);
8d5eff60
VZ
157 ~wxMutexInternal();
158
159 wxMutexError Lock();
160 wxMutexError TryLock();
161 wxMutexError Unlock();
162
9e84b847
VZ
163 bool IsOk() const { return m_isOk; }
164
8d5eff60 165private:
9fc3ad34 166 pthread_mutex_t m_mutex;
9e84b847 167 bool m_isOk;
be809868 168
9e84b847 169 // wxConditionInternal uses our m_mutex
be809868 170 friend class wxConditionInternal;
518b5d2f
VZ
171};
172
123dca7d
VZ
173#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
174 wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
707a3782
VS
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)
177extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
178#endif
179
9e84b847 180wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
518b5d2f 181{
9e84b847
VZ
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
d9b9876f 191#ifdef HAVE_PTHREAD_MUTEXATTR_T
9e84b847
VZ
192 {
193 pthread_mutexattr_t attr;
194 pthread_mutexattr_init(&attr);
195 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
d9b9876f 196
9e84b847
VZ
197 err = pthread_mutex_init(&m_mutex, &attr);
198 }
d9b9876f 199#elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
9e84b847
VZ
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 }
d9b9876f 207#else // no recursive mutexes
9e84b847 208 err = EINVAL;
d9b9876f 209#endif // HAVE_PTHREAD_MUTEXATTR_T/...
9e84b847
VZ
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 {
401eb3de 224 wxLogApiError( wxT("pthread_mutex_init()"), err);
9e84b847 225 }
8d5eff60
VZ
226}
227
228wxMutexInternal::~wxMutexInternal()
229{
9e84b847
VZ
230 if ( m_isOk )
231 {
232 int err = pthread_mutex_destroy(&m_mutex);
233 if ( err != 0 )
234 {
401eb3de 235 wxLogApiError( wxT("pthread_mutex_destroy()"), err);
9e84b847
VZ
236 }
237 }
8d5eff60
VZ
238}
239
240wxMutexError wxMutexInternal::Lock()
241{
242 int err = pthread_mutex_lock(&m_mutex);
243 switch ( err )
244 {
245 case EDEADLK:
9e84b847
VZ
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") );
8d5eff60
VZ
249 return wxMUTEX_DEAD_LOCK;
250
8d5eff60 251 case EINVAL:
9e84b847
VZ
252 wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
253 break;
8d5eff60
VZ
254
255 case 0:
256 return wxMUTEX_NO_ERROR;
9e84b847
VZ
257
258 default:
259 wxLogApiError(_T("pthread_mutex_lock()"), err);
8d5eff60 260 }
9e84b847
VZ
261
262 return wxMUTEX_MISC_ERROR;
8d5eff60
VZ
263}
264
265wxMutexError wxMutexInternal::TryLock()
266{
267 int err = pthread_mutex_trylock(&m_mutex);
268 switch ( err )
269 {
270 case EBUSY:
9e84b847
VZ
271 // not an error: mutex is already locked, but we're prepared for
272 // this
8d5eff60
VZ
273 return wxMUTEX_BUSY;
274
8d5eff60 275 case EINVAL:
9e84b847
VZ
276 wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
277 break;
8d5eff60
VZ
278
279 case 0:
280 return wxMUTEX_NO_ERROR;
9e84b847
VZ
281
282 default:
283 wxLogApiError(_T("pthread_mutex_trylock()"), err);
8d5eff60 284 }
9e84b847
VZ
285
286 return wxMUTEX_MISC_ERROR;
8d5eff60
VZ
287}
288
289wxMutexError 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
8d5eff60 298 case EINVAL:
9e84b847
VZ
299 wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
300 break;
8d5eff60
VZ
301
302 case 0:
303 return wxMUTEX_NO_ERROR;
518b5d2f 304
9e84b847
VZ
305 default:
306 wxLogApiError(_T("pthread_mutex_unlock()"), err);
518b5d2f
VZ
307 }
308
9e84b847 309 return wxMUTEX_MISC_ERROR;
518b5d2f
VZ
310}
311
be809868 312// ===========================================================================
8d5eff60 313// wxCondition implementation
be809868 314// ===========================================================================
8d5eff60 315
be809868 316// ---------------------------------------------------------------------------
8d5eff60 317// wxConditionInternal
be809868 318// ---------------------------------------------------------------------------
518b5d2f 319
9e84b847
VZ
320// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
321// with a pthread_mutex_t)
518b5d2f
VZ
322class wxConditionInternal
323{
324public:
c112e100 325 wxConditionInternal(wxMutex& mutex);
9fc3ad34
VZ
326 ~wxConditionInternal();
327
9e84b847 328 bool IsOk() const { return m_isOk && m_mutex.IsOk(); }
4c460b34 329
9e84b847
VZ
330 wxCondError Wait();
331 wxCondError WaitTimeout(unsigned long milliseconds);
547b93ab 332
9e84b847
VZ
333 wxCondError Signal();
334 wxCondError Broadcast();
4c460b34 335
be809868 336private:
c112e100 337 // get the POSIX mutex associated with us
9e84b847 338 pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }
518b5d2f 339
c112e100 340 wxMutex& m_mutex;
be809868 341 pthread_cond_t m_cond;
9e84b847
VZ
342
343 bool m_isOk;
8d5eff60 344};
547b93ab 345
c112e100
VZ
346wxConditionInternal::wxConditionInternal(wxMutex& mutex)
347 : m_mutex(mutex)
9fc3ad34 348{
9e84b847 349 int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
9fc3ad34 350
9e84b847 351 m_isOk = err == 0;
9fc3ad34 352
9e84b847 353 if ( !m_isOk )
9fc3ad34 354 {
9e84b847 355 wxLogApiError(_T("pthread_cond_init()"), err);
9fc3ad34
VZ
356 }
357}
358
9e84b847 359wxConditionInternal::~wxConditionInternal()
4c460b34 360{
9e84b847 361 if ( m_isOk )
c112e100 362 {
9e84b847
VZ
363 int err = pthread_cond_destroy(&m_cond);
364 if ( err != 0 )
365 {
366 wxLogApiError(_T("pthread_cond_destroy()"), err);
367 }
c112e100 368 }
be809868 369}
4c460b34 370
9e84b847 371wxCondError wxConditionInternal::Wait()
be809868 372{
9e84b847
VZ
373 int err = pthread_cond_wait(&m_cond, GetPMutex());
374 if ( err != 0 )
375 {
376 wxLogApiError(_T("pthread_cond_wait()"), err);
4c460b34 377
9e84b847 378 return wxCOND_MISC_ERROR;
be809868 379 }
4c460b34 380
9e84b847 381 return wxCOND_NO_ERROR;
be809868 382}
60ce696e 383
9e84b847 384wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
be809868 385{
be809868 386 wxLongLong curtime = wxGetLocalTimeMillis();
9e84b847 387 curtime += milliseconds;
be809868
VZ
388 wxLongLong temp = curtime / 1000;
389 int sec = temp.GetLo();
9e84b847 390 temp *= 1000;
be809868
VZ
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;
4c460b34 398
9e84b847
VZ
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;
9fc3ad34
VZ
413}
414
9e84b847 415wxCondError wxConditionInternal::Signal()
9fc3ad34 416{
9e84b847
VZ
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;
be809868 426}
547b93ab 427
9e84b847 428wxCondError wxConditionInternal::Broadcast()
be809868 429{
9e84b847
VZ
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;
be809868
VZ
439}
440
441// ===========================================================================
442// wxSemaphore implementation
443// ===========================================================================
9fc3ad34 444
be809868
VZ
445// ---------------------------------------------------------------------------
446// wxSemaphoreInternal
447// ---------------------------------------------------------------------------
448
9e84b847
VZ
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
be809868
VZ
452class wxSemaphoreInternal
453{
454public:
9e84b847 455 wxSemaphoreInternal(int initialcount, int maxcount);
be809868 456
9e84b847 457 bool IsOk() const { return m_isOk; }
be809868 458
9e84b847
VZ
459 wxSemaError Wait();
460 wxSemaError TryWait();
461 wxSemaError WaitTimeout(unsigned long milliseconds);
be809868 462
9e84b847 463 wxSemaError Post();
be809868
VZ
464
465private:
466 wxMutex m_mutex;
467 wxCondition m_cond;
468
9e84b847
VZ
469 size_t m_count,
470 m_maxcount;
471
472 bool m_isOk;
be809868
VZ
473};
474
9e84b847 475wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
c112e100 476 : m_cond(m_mutex)
be809868
VZ
477{
478
9e84b847
VZ
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
be809868 487 {
9e84b847
VZ
488 m_maxcount = (size_t)maxcount;
489 m_count = (size_t)initialcount;
547b93ab 490 }
547b93ab 491
9e84b847 492 m_isOk = m_mutex.IsOk() && m_cond.IsOk();
be809868 493}
547b93ab 494
9e84b847 495wxSemaError wxSemaphoreInternal::Wait()
be809868 496{
cd10339a 497 wxMutexLocker locker(m_mutex);
60ce696e 498
9e84b847 499 while ( m_count == 0 )
9fc3ad34 500 {
9e84b847 501 wxLogTrace(TRACE_SEMA,
5031200a 502 _T("Thread %ld waiting for semaphore to become signalled"),
9e84b847
VZ
503 wxThread::GetCurrentId());
504
505 if ( m_cond.Wait() != wxCOND_NO_ERROR )
506 return wxSEMA_MISC_ERROR;
507
508 wxLogTrace(TRACE_SEMA,
5031200a 509 _T("Thread %ld finished waiting for semaphore, count = %lu"),
2b5f62a0 510 wxThread::GetCurrentId(), (unsigned long)m_count);
9fc3ad34 511 }
be809868 512
9e84b847
VZ
513 m_count--;
514
515 return wxSEMA_NO_ERROR;
be809868
VZ
516}
517
9e84b847 518wxSemaError wxSemaphoreInternal::TryWait()
be809868 519{
cd10339a 520 wxMutexLocker locker(m_mutex);
be809868 521
9e84b847
VZ
522 if ( m_count == 0 )
523 return wxSEMA_BUSY;
be809868 524
9e84b847 525 m_count--;
be809868 526
9e84b847 527 return wxSEMA_NO_ERROR;
be809868
VZ
528}
529
9e84b847 530wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
be809868 531{
cd10339a 532 wxMutexLocker locker(m_mutex);
be809868
VZ
533
534 wxLongLong startTime = wxGetLocalTimeMillis();
535
9e84b847 536 while ( m_count == 0 )
9fc3ad34 537 {
be809868 538 wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
9e84b847 539 long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
be809868 540 if ( remainingTime <= 0 )
9e84b847
VZ
541 {
542 // timeout
543 return wxSEMA_TIMEOUT;
544 }
be809868 545
918dc519
VZ
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 }
9fc3ad34 557 }
8d5eff60 558
9e84b847 559 m_count--;
be809868 560
9e84b847 561 return wxSEMA_NO_ERROR;
be809868
VZ
562}
563
9e84b847 564wxSemaError wxSemaphoreInternal::Post()
be809868 565{
cd10339a 566 wxMutexLocker locker(m_mutex);
be809868 567
9e84b847 568 if ( m_maxcount > 0 && m_count == m_maxcount )
60ce696e 569 {
9e84b847 570 return wxSEMA_OVERFLOW;
60ce696e 571 }
be809868 572
9e84b847 573 m_count++;
518b5d2f 574
9e84b847 575 wxLogTrace(TRACE_SEMA,
5031200a 576 _T("Thread %ld about to signal semaphore, count = %lu"),
2b5f62a0
VZ
577 wxThread::GetCurrentId(), (unsigned long)m_count);
578
9e84b847
VZ
579 return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
580 : wxSEMA_MISC_ERROR;
518b5d2f
VZ
581}
582
be809868 583// ===========================================================================
8d5eff60 584// wxThread implementation
be809868 585// ===========================================================================
518b5d2f 586
295272bd
VZ
587// the thread callback functions must have the C linkage
588extern "C"
589{
590
816a7358 591#ifdef wxHAVE_PTHREAD_CLEANUP
295272bd
VZ
592 // thread exit function
593 void wxPthreadCleanup(void *ptr);
816a7358 594#endif // wxHAVE_PTHREAD_CLEANUP
90350682 595
295272bd 596void *wxPthreadStart(void *ptr);
90350682 597
295272bd 598} // extern "C"
90350682 599
8d5eff60
VZ
600// ----------------------------------------------------------------------------
601// wxThreadInternal
602// ----------------------------------------------------------------------------
603
518b5d2f
VZ
604class wxThreadInternal
605{
606public:
607 wxThreadInternal();
608 ~wxThreadInternal();
609
610 // thread entry function
295272bd 611 static void *PthreadStart(wxThread *thread);
518b5d2f
VZ
612
613 // thread actions
614 // start the thread
615 wxThreadError Run();
9e84b847
VZ
616 // unblock the thread allowing it to run
617 void SignalRun() { m_semRun.Post(); }
518b5d2f 618 // ask the thread to terminate
882eefb1 619 void Wait();
518b5d2f
VZ
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
882eefb1 630 wxThreadState GetState() const { return m_state; }
9e84b847
VZ
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."),
2b5f62a0 643 (long)GetId(), stateNames[m_state], stateNames[state]);
9e84b847
VZ
644#endif // __WXDEBUG__
645
646 m_state = state;
647 }
518b5d2f 648 // id
882eefb1
VZ
649 pthread_t GetId() const { return m_threadId; }
650 pthread_t *GetIdPtr() { return &m_threadId; }
518b5d2f 651 // "cancelled" flag
882eefb1 652 void SetCancelFlag() { m_cancelled = TRUE; }
518b5d2f 653 bool WasCancelled() const { return m_cancelled; }
9fc3ad34
VZ
654 // exit code
655 void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
656 wxThread::ExitCode GetExitCode() const { return m_exitcode; }
657
4c460b34
VZ
658 // the pause flag
659 void SetReallyPaused(bool paused) { m_isPaused = paused; }
660 bool IsReallyPaused() const { return m_isPaused; }
661
9fc3ad34 662 // tell the thread that it is a detached one
4c460b34
VZ
663 void Detach()
664 {
9e84b847
VZ
665 wxCriticalSectionLocker lock(m_csJoinFlag);
666
667 m_shouldBeJoined = FALSE;
4c460b34
VZ
668 m_isDetached = TRUE;
669 }
518b5d2f 670
816a7358 671#ifdef wxHAVE_PTHREAD_CLEANUP
90350682
VZ
672 // this is used by wxPthreadCleanup() only
673 static void Cleanup(wxThread *thread);
816a7358 674#endif // wxHAVE_PTHREAD_CLEANUP
90350682 675
518b5d2f 676private:
882eefb1
VZ
677 pthread_t m_threadId; // id of the thread
678 wxThreadState m_state; // see wxThreadState enum
77ffb593 679 int m_prio; // in wxWidgets units: from 0 to 100
518b5d2f 680
9fc3ad34 681 // this flag is set when the thread should terminate
518b5d2f
VZ
682 bool m_cancelled;
683
be809868 684 // this flag is set when the thread is blocking on m_semSuspend
4c460b34
VZ
685 bool m_isPaused;
686
9fc3ad34
VZ
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;
4c460b34 695 bool m_isDetached;
9fc3ad34 696
be809868 697 // this semaphore is posted by Run() and the threads Entry() is not
9fc3ad34 698 // called before it is done
be809868 699 wxSemaphore m_semRun;
9fc3ad34
VZ
700
701 // this one is signaled when the thread should resume after having been
702 // Pause()d
be809868 703 wxSemaphore m_semSuspend;
518b5d2f
VZ
704};
705
9fc3ad34
VZ
706// ----------------------------------------------------------------------------
707// thread startup and exit functions
708// ----------------------------------------------------------------------------
709
295272bd
VZ
710void *wxPthreadStart(void *ptr)
711{
712 return wxThreadInternal::PthreadStart((wxThread *)ptr);
713}
714
715void *wxThreadInternal::PthreadStart(wxThread *thread)
518b5d2f 716{
9fc3ad34 717 wxThreadInternal *pthread = thread->m_internal;
518b5d2f 718
ef4f69ec
VZ
719 wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread));
720
9fc3ad34
VZ
721 // associate the thread pointer with the newly created thread so that
722 // wxThread::This() will work
862cc6f9
VZ
723 int rc = pthread_setspecific(gs_keySelf, thread);
724 if ( rc != 0 )
518b5d2f 725 {
58230fb1 726 wxLogSysError(rc, _("Cannot start thread: error writing TLS"));
518b5d2f
VZ
727
728 return (void *)-1;
729 }
9fc3ad34 730
4c460b34
VZ
731 // have to declare this before pthread_cleanup_push() which defines a
732 // block!
733 bool dontRunAtAll;
734
816a7358 735#ifdef wxHAVE_PTHREAD_CLEANUP
9fc3ad34
VZ
736 // install the cleanup handler which will be called if the thread is
737 // cancelled
295272bd 738 pthread_cleanup_push(wxPthreadCleanup, thread);
816a7358 739#endif // wxHAVE_PTHREAD_CLEANUP
518b5d2f 740
be809868
VZ
741 // wait for the semaphore to be posted from Run()
742 pthread->m_semRun.Wait();
518b5d2f 743
4c460b34
VZ
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);
9fc3ad34 748
4c460b34
VZ
749 dontRunAtAll = pthread->GetState() == STATE_NEW &&
750 pthread->WasCancelled();
751 }
9fc3ad34 752
4c460b34 753 if ( !dontRunAtAll )
9fc3ad34 754 {
4c460b34 755 // call the main entry
ef4f69ec
VZ
756 wxLogTrace(TRACE_THREADS,
757 _T("Thread %ld about to enter its Entry()."),
758 THR_ID(pthread));
759
4c460b34 760 pthread->m_exitcode = thread->Entry();
5092b3ad 761
ef4f69ec
VZ
762 wxLogTrace(TRACE_THREADS,
763 _T("Thread %ld Entry() returned %lu."),
17a1ebd1 764 THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
ef4f69ec 765
4c460b34
VZ
766 {
767 wxCriticalSectionLocker lock(thread->m_critsect);
768
4c460b34 769 // change the state of the thread to "exited" so that
90350682 770 // wxPthreadCleanup handler won't do anything from now (if it's
4c460b34
VZ
771 // called before we do pthread_cleanup_pop below)
772 pthread->SetState(STATE_EXITED);
773 }
9fc3ad34
VZ
774 }
775
741d91c5
VZ
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!
816a7358 778#ifdef wxHAVE_PTHREAD_CLEANUP
741d91c5
VZ
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
9fc3ad34 785 // remove the cleanup handler without executing it
062c4861 786 pthread_cleanup_pop(FALSE);
741d91c5
VZ
787
788 #ifdef __DECCXX
789 #pragma message restore
790 #endif
816a7358 791#endif // wxHAVE_PTHREAD_CLEANUP
518b5d2f 792
4c460b34
VZ
793 if ( dontRunAtAll )
794 {
9e84b847 795 // FIXME: deleting a possibly joinable thread here???
4c460b34 796 delete thread;
518b5d2f 797
4c460b34
VZ
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."));
518b5d2f 806
4c460b34
VZ
807 return NULL;
808 }
518b5d2f
VZ
809}
810
816a7358 811#ifdef wxHAVE_PTHREAD_CLEANUP
5092b3ad 812
9fc3ad34 813// this handler is called when the thread is cancelled
90350682 814extern "C" void wxPthreadCleanup(void *ptr)
5092b3ad 815{
90350682
VZ
816 wxThreadInternal::Cleanup((wxThread *)ptr);
817}
5092b3ad 818
90350682
VZ
819void wxThreadInternal::Cleanup(wxThread *thread)
820{
9fc3ad34
VZ
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 }
5092b3ad 829
9fc3ad34
VZ
830 // exit the thread gracefully
831 thread->Exit(EXITCODE_CANCELLED);
832}
5092b3ad 833
816a7358 834#endif // wxHAVE_PTHREAD_CLEANUP
5092b3ad 835
9fc3ad34
VZ
836// ----------------------------------------------------------------------------
837// wxThreadInternal
838// ----------------------------------------------------------------------------
5092b3ad 839
518b5d2f
VZ
840wxThreadInternal::wxThreadInternal()
841{
842 m_state = STATE_NEW;
843 m_cancelled = FALSE;
bbfa0322
VZ
844 m_prio = WXTHREAD_DEFAULT_PRIORITY;
845 m_threadId = 0;
9fc3ad34 846 m_exitcode = 0;
518b5d2f 847
be809868 848 // set to TRUE only when the thread starts waiting on m_semSuspend
4c460b34
VZ
849 m_isPaused = FALSE;
850
9fc3ad34
VZ
851 // defaults for joinable threads
852 m_shouldBeJoined = TRUE;
4c460b34 853 m_isDetached = FALSE;
518b5d2f
VZ
854}
855
856wxThreadInternal::~wxThreadInternal()
857{
518b5d2f
VZ
858}
859
860wxThreadError wxThreadInternal::Run()
861{
862 wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
9fc3ad34 863 wxT("thread may only be started once after Create()") );
518b5d2f 864
9fc3ad34 865 SetState(STATE_RUNNING);
518b5d2f 866
9e84b847
VZ
867 // wake up threads waiting for our start
868 SignalRun();
869
518b5d2f 870 return wxTHREAD_NO_ERROR;
518b5d2f
VZ
871}
872
882eefb1 873void wxThreadInternal::Wait()
518b5d2f 874{
9e84b847
VZ
875 wxCHECK_RET( !m_isDetached, _T("can't wait for a detached thread") );
876
518b5d2f
VZ
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
547b93ab 882 wxLogTrace(TRACE_THREADS,
ef4f69ec
VZ
883 _T("Starting to wait for thread %ld to exit."),
884 THR_ID(this));
885
9e84b847
VZ
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
9fc3ad34 888 {
4c460b34
VZ
889 wxCriticalSectionLocker lock(m_csJoinFlag);
890
891 if ( m_shouldBeJoined )
9fc3ad34 892 {
4c460b34
VZ
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
2b5f62a0 897 if ( pthread_join(GetId(), &m_exitcode) != 0 )
4c460b34 898 {
9e84b847
VZ
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
76a6e803 903 wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
4c460b34 904 }
9fc3ad34 905
4c460b34
VZ
906 m_shouldBeJoined = FALSE;
907 }
9fc3ad34 908 }
9111db68 909
518b5d2f
VZ
910 // reacquire GUI mutex
911 if ( wxThread::IsMain() )
912 wxMutexGuiEnter();
913}
914
518b5d2f
VZ
915void wxThreadInternal::Pause()
916{
882eefb1
VZ
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
518b5d2f 919 wxCHECK_RET( m_state == STATE_PAUSED,
223d09f6 920 wxT("thread must first be paused with wxThread::Pause().") );
518b5d2f 921
ef4f69ec
VZ
922 wxLogTrace(TRACE_THREADS,
923 _T("Thread %ld goes to sleep."), THR_ID(this));
924
be809868
VZ
925 // wait until the semaphore is Post()ed from Resume()
926 m_semSuspend.Wait();
518b5d2f
VZ
927}
928
929void wxThreadInternal::Resume()
930{
931 wxCHECK_RET( m_state == STATE_PAUSED,
223d09f6 932 wxT("can't resume thread which is not suspended.") );
518b5d2f 933
4c460b34
VZ
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 {
ef4f69ec
VZ
938 wxLogTrace(TRACE_THREADS,
939 _T("Waking up thread %ld"), THR_ID(this));
940
4c460b34 941 // wake up Pause()
be809868 942 m_semSuspend.Post();
4c460b34
VZ
943
944 // reset the flag
945 SetReallyPaused(FALSE);
946 }
947 else
948 {
ef4f69ec
VZ
949 wxLogTrace(TRACE_THREADS,
950 _T("Thread %ld is not yet really paused"), THR_ID(this));
4c460b34 951 }
518b5d2f
VZ
952
953 SetState(STATE_RUNNING);
954}
955
956// -----------------------------------------------------------------------------
9fc3ad34 957// wxThread static functions
518b5d2f
VZ
958// -----------------------------------------------------------------------------
959
960wxThread *wxThread::This()
961{
962 return (wxThread *)pthread_getspecific(gs_keySelf);
963}
964
965bool wxThread::IsMain()
966{
5b65f136 967 return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1;
518b5d2f
VZ
968}
969
970void wxThread::Yield()
971{
6f837e5c 972#ifdef HAVE_SCHED_YIELD
518b5d2f 973 sched_yield();
6f837e5c 974#endif
518b5d2f
VZ
975}
976
977void wxThread::Sleep(unsigned long milliseconds)
978{
cf25117b 979 wxMilliSleep(milliseconds);
518b5d2f
VZ
980}
981
ef8d96c2
VZ
982int wxThread::GetCPUCount()
983{
1e6feb95 984#if defined(__LINUX__) && wxUSE_FFILE
ef8d96c2
VZ
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 {
9ec1ed2a
VZ
996 // (ab)use Replace() to find the number of "processor: num" strings
997 size_t count = s.Replace(_T("processor\t:"), _T(""));
ef8d96c2
VZ
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
ef4f69ec
VZ
1023// VMS is a 64 bit system and threads have 64 bit pointers.
1024// FIXME: also needed for other systems????
a7aef4a9 1025#ifdef __VMS
a7aef4a9
JJ
1026unsigned long long wxThread::GetCurrentId()
1027{
1028 return (unsigned long long)pthread_self();
ef4f69ec
VZ
1029}
1030
1031#else // !__VMS
1032
1fcfb40d
RD
1033unsigned long wxThread::GetCurrentId()
1034{
1035 return (unsigned long)pthread_self();
1036}
1037
ef4f69ec
VZ
1038#endif // __VMS/!__VMS
1039
1040
ef8d96c2
VZ
1041bool 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
518b5d2f
VZ
1057// -----------------------------------------------------------------------------
1058// creating thread
1059// -----------------------------------------------------------------------------
1060
acb8423c 1061wxThread::wxThread(wxThreadKind kind)
518b5d2f
VZ
1062{
1063 // add this thread to the global list of all threads
1064 gs_allThreads.Add(this);
1065
9fc3ad34 1066 m_internal = new wxThreadInternal();
acb8423c
VZ
1067
1068 m_isDetached = kind == wxTHREAD_DETACHED;
518b5d2f
VZ
1069}
1070
8a077f28
SN
1071#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1072 #define WXUNUSED_STACKSIZE(identifier) identifier
1073#else
1074 #define WXUNUSED_STACKSIZE(identifier) WXUNUSED(identifier)
1075#endif
1076
1077wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))
518b5d2f 1078{
9fc3ad34
VZ
1079 if ( m_internal->GetState() != STATE_NEW )
1080 {
1081 // don't recreate thread
518b5d2f 1082 return wxTHREAD_RUNNING;
9fc3ad34 1083 }
518b5d2f
VZ
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
8a077f28
SN
1089#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
1090 if (stackSize)
1091 pthread_attr_setstacksize(&attr, stackSize);
1092#endif
1093
fc9ef629 1094#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
9fc3ad34
VZ
1095 int policy;
1096 if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
518b5d2f 1097 {
58230fb1 1098 wxLogError(_("Cannot retrieve thread scheduling policy."));
518b5d2f
VZ
1099 }
1100
fb10f04c
JJ
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
1fcfb40d 1110
fb10f04c
JJ
1111 int max_prio = sched_get_priority_max(policy),
1112 min_prio = sched_get_priority_min(policy),
9fc3ad34 1113 prio = m_internal->GetPriority();
518b5d2f
VZ
1114
1115 if ( min_prio == -1 || max_prio == -1 )
1116 {
58230fb1 1117 wxLogError(_("Cannot get priority range for scheduling policy %d."),
9fc3ad34 1118 policy);
518b5d2f 1119 }
bbfa0322
VZ
1120 else if ( max_prio == min_prio )
1121 {
9fc3ad34 1122 if ( prio != WXTHREAD_DEFAULT_PRIORITY )
bbfa0322
VZ
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 }
518b5d2f
VZ
1131 else
1132 {
1133 struct sched_param sp;
9fc3ad34
VZ
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 }
518b5d2f 1145 }
34f8c26e 1146#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
518b5d2f 1147
58230fb1
VZ
1148#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
1149 // this will make the threads created by this process really concurrent
9fc3ad34
VZ
1150 if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
1151 {
1152 wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
1153 }
58230fb1
VZ
1154#endif // HAVE_PTHREAD_ATTR_SETSCOPE
1155
9fc3ad34
VZ
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
518b5d2f 1171 // create the new OS thread object
9fc3ad34
VZ
1172 int rc = pthread_create
1173 (
1174 m_internal->GetIdPtr(),
1175 &attr,
295272bd 1176 wxPthreadStart,
9fc3ad34
VZ
1177 (void *)this
1178 );
1179
1180 if ( pthread_attr_destroy(&attr) != 0 )
1181 {
1182 wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
1183 }
518b5d2f
VZ
1184
1185 if ( rc != 0 )
1186 {
9fc3ad34
VZ
1187 m_internal->SetState(STATE_EXITED);
1188
518b5d2f
VZ
1189 return wxTHREAD_NO_RESOURCE;
1190 }
1191
1192 return wxTHREAD_NO_ERROR;
1193}
1194
1195wxThreadError wxThread::Run()
1196{
9fc3ad34
VZ
1197 wxCriticalSectionLocker lock(m_critsect);
1198
1199 wxCHECK_MSG( m_internal->GetId(), wxTHREAD_MISC_ERROR,
223d09f6 1200 wxT("must call wxThread::Create() first") );
bbfa0322 1201
9fc3ad34 1202 return m_internal->Run();
518b5d2f
VZ
1203}
1204
1205// -----------------------------------------------------------------------------
1206// misc accessors
1207// -----------------------------------------------------------------------------
1208
1209void wxThread::SetPriority(unsigned int prio)
1210{
34f8c26e
VZ
1211 wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
1212 ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
223d09f6 1213 wxT("invalid thread priority") );
518b5d2f
VZ
1214
1215 wxCriticalSectionLocker lock(m_critsect);
1216
9fc3ad34 1217 switch ( m_internal->GetState() )
518b5d2f
VZ
1218 {
1219 case STATE_NEW:
1220 // thread not yet started, priority will be set when it is
9fc3ad34 1221 m_internal->SetPriority(prio);
518b5d2f
VZ
1222 break;
1223
1224 case STATE_RUNNING:
1225 case STATE_PAUSED:
34f8c26e 1226#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
7bfe6a32 1227#if defined(__LINUX__)
17a1ebd1
VZ
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!!
7bfe6a32 1237
17a1ebd1
VZ
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);
7bfe6a32
JS
1243 }
1244#else // __LINUX__
518b5d2f
VZ
1245 {
1246 struct sched_param sparam;
1247 sparam.sched_priority = prio;
1248
9fc3ad34 1249 if ( pthread_setschedparam(m_internal->GetId(),
518b5d2f
VZ
1250 SCHED_OTHER, &sparam) != 0 )
1251 {
1252 wxLogError(_("Failed to set thread priority %d."), prio);
1253 }
1254 }
7bfe6a32 1255#endif // __LINUX__
34f8c26e 1256#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
518b5d2f
VZ
1257 break;
1258
1259 case STATE_EXITED:
1260 default:
223d09f6 1261 wxFAIL_MSG(wxT("impossible to set thread priority in this state"));
518b5d2f
VZ
1262 }
1263}
1264
1265unsigned int wxThread::GetPriority() const
1266{
1267 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1268
9fc3ad34 1269 return m_internal->GetPriority();
518b5d2f
VZ
1270}
1271
547b93ab 1272wxThreadIdType wxThread::GetId() const
13d068d9 1273{
df744f4d 1274 return (wxThreadIdType) m_internal->GetId();
518b5d2f
VZ
1275}
1276
1277// -----------------------------------------------------------------------------
1278// pause/resume
1279// -----------------------------------------------------------------------------
1280
1281wxThreadError wxThread::Pause()
1282{
4c460b34
VZ
1283 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1284 _T("a thread can't pause itself") );
1285
518b5d2f
VZ
1286 wxCriticalSectionLocker lock(m_critsect);
1287
9fc3ad34 1288 if ( m_internal->GetState() != STATE_RUNNING )
518b5d2f 1289 {
223d09f6 1290 wxLogDebug(wxT("Can't pause thread which is not running."));
518b5d2f
VZ
1291
1292 return wxTHREAD_NOT_RUNNING;
1293 }
1294
9fc3ad34
VZ
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);
518b5d2f
VZ
1298
1299 return wxTHREAD_NO_ERROR;
1300}
1301
1302wxThreadError wxThread::Resume()
1303{
4c460b34
VZ
1304 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1305 _T("a thread can't resume itself") );
518b5d2f 1306
4c460b34 1307 wxCriticalSectionLocker lock(m_critsect);
518b5d2f 1308
4c460b34 1309 wxThreadState state = m_internal->GetState();
9fc3ad34
VZ
1310
1311 switch ( state )
518b5d2f 1312 {
9fc3ad34 1313 case STATE_PAUSED:
4c460b34 1314 wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
9fc3ad34
VZ
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;
518b5d2f 1325
9fc3ad34
VZ
1326 default:
1327 wxLogDebug(_T("Attempt to resume a thread which is not paused."));
1328
1329 return wxTHREAD_MISC_ERROR;
518b5d2f
VZ
1330 }
1331}
1332
1333// -----------------------------------------------------------------------------
1334// exiting thread
1335// -----------------------------------------------------------------------------
1336
9fc3ad34 1337wxThread::ExitCode wxThread::Wait()
b568d04f 1338{
9fc3ad34
VZ
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();
b568d04f 1346
9fc3ad34 1347 return m_internal->GetExitCode();
b568d04f
VZ
1348}
1349
1350wxThreadError wxThread::Delete(ExitCode *rc)
518b5d2f 1351{
4c460b34
VZ
1352 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1353 _T("a thread can't delete itself") );
1354
9e84b847
VZ
1355 bool isDetached = m_isDetached;
1356
518b5d2f 1357 m_critsect.Enter();
9fc3ad34 1358 wxThreadState state = m_internal->GetState();
518b5d2f 1359
882eefb1 1360 // ask the thread to stop
9fc3ad34
VZ
1361 m_internal->SetCancelFlag();
1362
9111db68
GL
1363 m_critsect.Leave();
1364
518b5d2f
VZ
1365 switch ( state )
1366 {
1367 case STATE_NEW:
4c460b34 1368 // we need to wake up the thread so that PthreadStart() will
9e84b847
VZ
1369 // terminate - right now it's blocking on run semaphore in
1370 // PthreadStart()
4c460b34
VZ
1371 m_internal->SignalRun();
1372
1373 // fall through
1374
518b5d2f
VZ
1375 case STATE_EXITED:
1376 // nothing to do
1377 break;
1378
1379 case STATE_PAUSED:
9e84b847 1380 // resume the thread first
9fc3ad34 1381 m_internal->Resume();
518b5d2f
VZ
1382
1383 // fall through
1384
1385 default:
9e84b847 1386 if ( !isDetached )
9fc3ad34 1387 {
9e84b847
VZ
1388 // wait until the thread stops
1389 m_internal->Wait();
9fc3ad34 1390
9e84b847
VZ
1391 if ( rc )
1392 {
1393 // return the exit code of the thread
1394 *rc = m_internal->GetExitCode();
1395 }
9fc3ad34 1396 }
9e84b847 1397 //else: can't wait for detached threads
518b5d2f
VZ
1398 }
1399
acb8423c 1400 return wxTHREAD_NO_ERROR;
518b5d2f
VZ
1401}
1402
1403wxThreadError wxThread::Kill()
1404{
9fc3ad34
VZ
1405 wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
1406 _T("a thread can't kill itself") );
1407
1408 switch ( m_internal->GetState() )
518b5d2f
VZ
1409 {
1410 case STATE_NEW:
1411 case STATE_EXITED:
1412 return wxTHREAD_NOT_RUNNING;
1413
9fc3ad34
VZ
1414 case STATE_PAUSED:
1415 // resume the thread first
1416 Resume();
1417
1418 // fall through
1419
518b5d2f 1420 default:
9fc3ad34
VZ
1421#ifdef HAVE_PTHREAD_CANCEL
1422 if ( pthread_cancel(m_internal->GetId()) != 0 )
741d91c5 1423#endif // HAVE_PTHREAD_CANCEL
518b5d2f
VZ
1424 {
1425 wxLogError(_("Failed to terminate a thread."));
1426
1427 return wxTHREAD_MISC_ERROR;
1428 }
9fc3ad34 1429
741d91c5 1430#ifdef HAVE_PTHREAD_CANCEL
9fc3ad34
VZ
1431 if ( m_isDetached )
1432 {
1433 // if we use cleanup function, this will be done from
90350682 1434 // wxPthreadCleanup()
816a7358 1435#ifndef wxHAVE_PTHREAD_CLEANUP
9fc3ad34
VZ
1436 ScheduleThreadForDeletion();
1437
b18cfdd9
VZ
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
9fc3ad34
VZ
1440
1441 DeleteThread(this);
816a7358 1442#endif // wxHAVE_PTHREAD_CLEANUP
9fc3ad34
VZ
1443 }
1444 else
1445 {
1446 m_internal->SetExitCode(EXITCODE_CANCELLED);
1447 }
518b5d2f
VZ
1448
1449 return wxTHREAD_NO_ERROR;
741d91c5 1450#endif // HAVE_PTHREAD_CANCEL
518b5d2f
VZ
1451 }
1452}
1453
b568d04f 1454void wxThread::Exit(ExitCode status)
518b5d2f 1455{
4c460b34 1456 wxASSERT_MSG( This() == this,
76a6e803 1457 _T("wxThread::Exit() can only be called in the context of the same thread") );
4c460b34 1458
9e84b847
VZ
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 }
9fc3ad34
VZ
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)
518b5d2f
VZ
1471 OnExit();
1472
9fc3ad34
VZ
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 }
343b1669
RR
1485 else
1486 {
1487 m_critsect.Enter();
1488 m_internal->SetState(STATE_EXITED);
1489 m_critsect.Leave();
1490 }
9fc3ad34
VZ
1491
1492 // terminate the thread (pthread_exit() never returns)
518b5d2f 1493 pthread_exit(status);
9fc3ad34
VZ
1494
1495 wxFAIL_MSG(_T("pthread_exit() failed"));
518b5d2f
VZ
1496}
1497
1498// also test whether we were paused
1499bool wxThread::TestDestroy()
1500{
4c460b34 1501 wxASSERT_MSG( This() == this,
76a6e803 1502 _T("wxThread::TestDestroy() can only be called in the context of the same thread") );
4c460b34 1503
9fc3ad34 1504 m_critsect.Enter();
518b5d2f 1505
9fc3ad34 1506 if ( m_internal->GetState() == STATE_PAUSED )
518b5d2f 1507 {
4c460b34
VZ
1508 m_internal->SetReallyPaused(TRUE);
1509
9fc3ad34
VZ
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
518b5d2f
VZ
1513 m_critsect.Leave();
1514
9fc3ad34
VZ
1515 m_internal->Pause();
1516 }
1517 else
1518 {
1519 // thread wasn't requested to pause, nothing to do
1520 m_critsect.Leave();
518b5d2f
VZ
1521 }
1522
9fc3ad34 1523 return m_internal->WasCancelled();
518b5d2f
VZ
1524}
1525
1526wxThread::~wxThread()
1527{
9fc3ad34 1528#ifdef __WXDEBUG__
062c4861 1529 m_critsect.Enter();
9fc3ad34
VZ
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 )
bbfa0322 1534 {
17a1ebd1
VZ
1535 wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."),
1536 (long)GetId());
bbfa0322 1537 }
062c4861
GL
1538
1539 m_critsect.Leave();
9fc3ad34 1540#endif // __WXDEBUG__
062c4861 1541
9fc3ad34 1542 delete m_internal;
bbfa0322 1543
518b5d2f
VZ
1544 // remove this thread from the global array
1545 gs_allThreads.Remove(this);
1546}
1547
1548// -----------------------------------------------------------------------------
1549// state tests
1550// -----------------------------------------------------------------------------
1551
1552bool wxThread::IsRunning() const
1553{
1554 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1555
9fc3ad34 1556 return m_internal->GetState() == STATE_RUNNING;
518b5d2f
VZ
1557}
1558
1559bool wxThread::IsAlive() const
1560{
1561 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1562
9fc3ad34 1563 switch ( m_internal->GetState() )
518b5d2f
VZ
1564 {
1565 case STATE_RUNNING:
1566 case STATE_PAUSED:
1567 return TRUE;
1568
1569 default:
1570 return FALSE;
1571 }
1572}
1573
a737331d
GL
1574bool wxThread::IsPaused() const
1575{
1576 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1577
9fc3ad34 1578 return (m_internal->GetState() == STATE_PAUSED);
a737331d
GL
1579}
1580
518b5d2f
VZ
1581//--------------------------------------------------------------------
1582// wxThreadModule
1583//--------------------------------------------------------------------
1584
1585class wxThreadModule : public wxModule
1586{
1587public:
1588 virtual bool OnInit();
1589 virtual void OnExit();
1590
1591private:
1592 DECLARE_DYNAMIC_CLASS(wxThreadModule)
1593};
1594
1595IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1596
1597bool wxThreadModule::OnInit()
1598{
58230fb1
VZ
1599 int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
1600 if ( rc != 0 )
518b5d2f 1601 {
76a6e803 1602 wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
518b5d2f
VZ
1603
1604 return FALSE;
1605 }
1606
518b5d2f 1607 gs_tidMain = pthread_self();
19da4326 1608
9fc3ad34 1609 gs_mutexGui = new wxMutex();
518b5d2f
VZ
1610 gs_mutexGui->Lock();
1611
be809868 1612 gs_mutexDeleteThread = new wxMutex();
c112e100 1613 gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );
88e243b2 1614
518b5d2f
VZ
1615 return TRUE;
1616}
1617
1618void wxThreadModule::OnExit()
1619{
223d09f6 1620 wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );
518b5d2f 1621
9fc3ad34
VZ
1622 // are there any threads left which are being deleted right now?
1623 size_t nThreadsBeingDeleted;
be809868 1624
9fc3ad34 1625 {
be809868 1626 wxMutexLocker lock( *gs_mutexDeleteThread );
9fc3ad34 1627 nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
9fc3ad34 1628
be809868 1629 if ( nThreadsBeingDeleted > 0 )
9e84b847 1630 {
2b5f62a0
VZ
1631 wxLogTrace(TRACE_THREADS,
1632 _T("Waiting for %lu threads to disappear"),
1633 (unsigned long)nThreadsBeingDeleted);
9fc3ad34 1634
be809868
VZ
1635 // have to wait until all of them disappear
1636 gs_condAllDeleted->Wait();
1637 }
9fc3ad34
VZ
1638 }
1639
518b5d2f
VZ
1640 // terminate any threads left
1641 size_t count = gs_allThreads.GetCount();
1642 if ( count != 0u )
4c460b34 1643 {
2b5f62a0
VZ
1644 wxLogDebug(wxT("%lu threads were not terminated by the application."),
1645 (unsigned long)count);
4c460b34 1646 }
518b5d2f
VZ
1647
1648 for ( size_t n = 0u; n < count; n++ )
1649 {
bbfa0322
VZ
1650 // Delete calls the destructor which removes the current entry. We
1651 // should only delete the first one each time.
0ac77ef5 1652 gs_allThreads[0]->Delete();
518b5d2f
VZ
1653 }
1654
1655 // destroy GUI mutex
1656 gs_mutexGui->Unlock();
518b5d2f
VZ
1657 delete gs_mutexGui;
1658
1659 // and free TLD slot
1660 (void)pthread_key_delete(gs_keySelf);
be809868
VZ
1661
1662 delete gs_condAllDeleted;
1663 delete gs_mutexDeleteThread;
518b5d2f
VZ
1664}
1665
1666// ----------------------------------------------------------------------------
1667// global functions
1668// ----------------------------------------------------------------------------
1669
9fc3ad34
VZ
1670static void ScheduleThreadForDeletion()
1671{
be809868 1672 wxMutexLocker lock( *gs_mutexDeleteThread );
9fc3ad34
VZ
1673
1674 gs_nThreadsBeingDeleted++;
1675
2b5f62a0
VZ
1676 wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
1677 (unsigned long)gs_nThreadsBeingDeleted,
fcc3d7cb 1678 gs_nThreadsBeingDeleted == 1 ? "" : "s");
9fc3ad34
VZ
1679}
1680
1681static void DeleteThread(wxThread *This)
1682{
1683 // gs_mutexDeleteThread should be unlocked before signalling the condition
1684 // or wxThreadModule::OnExit() would deadlock
be809868 1685 wxMutexLocker locker( *gs_mutexDeleteThread );
9fc3ad34 1686
be809868 1687 wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
9fc3ad34 1688
be809868 1689 delete This;
9fc3ad34 1690
be809868 1691 wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
9e84b847 1692 _T("no threads scheduled for deletion, yet we delete one?") );
9fc3ad34 1693
2b5f62a0
VZ
1694 wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
1695 (unsigned long)gs_nThreadsBeingDeleted - 1);
4c460b34 1696
9fc3ad34
VZ
1697 if ( !--gs_nThreadsBeingDeleted )
1698 {
1699 // no more threads left, signal it
1700 gs_condAllDeleted->Signal();
9fc3ad34
VZ
1701 }
1702}
1703
518b5d2f
VZ
1704void wxMutexGuiEnter()
1705{
9fc3ad34 1706 gs_mutexGui->Lock();
518b5d2f
VZ
1707}
1708
1709void wxMutexGuiLeave()
1710{
9fc3ad34 1711 gs_mutexGui->Unlock();
518b5d2f 1712}
80cb83be 1713
9e84b847
VZ
1714// ----------------------------------------------------------------------------
1715// include common implementation code
1716// ----------------------------------------------------------------------------
1717
1718#include "wx/thrimpl.cpp"
1719
1720#endif // wxUSE_THREADS
1721