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