]> git.saurik.com Git - wxWidgets.git/blob - src/unix/threadpsx.cpp
some stupid attempts to make utf8 work - it doesn't, but the code does no harm and...
[wxWidgets.git] / src / unix / threadpsx.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: threadpsx.cpp
3 // Purpose: wxThread (Posix) Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux
5 // Modified by:
6 // Created: 04/22/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Wolfram Gloger (1996, 1997)
9 // Guilhem Lavaux (1998)
10 // 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 // don't call OnExit() here, it can only be called in the
1264 // threads context and we're in the context of another thread
1265
1266 DeleteThread(this);
1267 #endif // HAVE_THREAD_CLEANUP_FUNCTIONS
1268 }
1269 else
1270 {
1271 m_internal->SetExitCode(EXITCODE_CANCELLED);
1272 }
1273
1274 return wxTHREAD_NO_ERROR;
1275 }
1276 }
1277
1278 void wxThread::Exit(ExitCode status)
1279 {
1280 wxASSERT_MSG( This() == this,
1281 _T("wxThread::Exit() can only be called in the "
1282 "context of the same thread") );
1283
1284 // from the moment we call OnExit(), the main program may terminate at any
1285 // moment, so mark this thread as being already in process of being
1286 // deleted or wxThreadModule::OnExit() will try to delete it again
1287 ScheduleThreadForDeletion();
1288
1289 // don't enter m_critsect before calling OnExit() because the user code
1290 // might deadlock if, for example, it signals a condition in OnExit() (a
1291 // common case) while the main thread calls any of functions entering
1292 // m_critsect on us (almost all of them do)
1293 OnExit();
1294
1295 // now do enter it because SignalExit() will change our state
1296 m_critsect.Enter();
1297
1298 // next wake up the threads waiting for us (OTOH, this function won't return
1299 // until someone waited for us!)
1300 m_internal->SignalExit();
1301
1302 // leave the critical section before entering the dtor which tries to
1303 // enter it
1304 m_critsect.Leave();
1305
1306 // delete C++ thread object if this is a detached thread - user is
1307 // responsible for doing this for joinable ones
1308 if ( m_isDetached )
1309 {
1310 // FIXME I'm feeling bad about it - what if another thread function is
1311 // called (in another thread context) now? It will try to access
1312 // half destroyed object which will probably result in something
1313 // very bad - but we can't protect this by a crit section unless
1314 // we make it a global object, but this would mean that we can
1315 // only call one thread function at a time :-(
1316 DeleteThread(this);
1317 }
1318
1319 // terminate the thread (pthread_exit() never returns)
1320 pthread_exit(status);
1321
1322 wxFAIL_MSG(_T("pthread_exit() failed"));
1323 }
1324
1325 // also test whether we were paused
1326 bool wxThread::TestDestroy()
1327 {
1328 wxASSERT_MSG( This() == this,
1329 _T("wxThread::TestDestroy() can only be called in the "
1330 "context of the same thread") );
1331
1332 m_critsect.Enter();
1333
1334 if ( m_internal->GetState() == STATE_PAUSED )
1335 {
1336 m_internal->SetReallyPaused(TRUE);
1337
1338 // leave the crit section or the other threads will stop too if they
1339 // try to call any of (seemingly harmless) IsXXX() functions while we
1340 // sleep
1341 m_critsect.Leave();
1342
1343 m_internal->Pause();
1344 }
1345 else
1346 {
1347 // thread wasn't requested to pause, nothing to do
1348 m_critsect.Leave();
1349 }
1350
1351 return m_internal->WasCancelled();
1352 }
1353
1354 wxThread::~wxThread()
1355 {
1356 #ifdef __WXDEBUG__
1357 m_critsect.Enter();
1358
1359 // check that the thread either exited or couldn't be created
1360 if ( m_internal->GetState() != STATE_EXITED &&
1361 m_internal->GetState() != STATE_NEW )
1362 {
1363 wxLogDebug(_T("The thread %ld is being destroyed although it is still "
1364 "running! The application may crash."), GetId());
1365 }
1366
1367 m_critsect.Leave();
1368 #endif // __WXDEBUG__
1369
1370 delete m_internal;
1371
1372 // remove this thread from the global array
1373 gs_allThreads.Remove(this);
1374
1375 // detached thread will decrement this counter in DeleteThread(), but it
1376 // is not called for the joinable threads, so do it here
1377 if ( !m_isDetached )
1378 {
1379 MutexLock lock(gs_mutexDeleteThread);
1380 gs_nThreadsBeingDeleted--;
1381
1382 wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
1383 gs_nThreadsBeingDeleted - 1);
1384 }
1385 }
1386
1387 // -----------------------------------------------------------------------------
1388 // state tests
1389 // -----------------------------------------------------------------------------
1390
1391 bool wxThread::IsRunning() const
1392 {
1393 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
1394
1395 return m_internal->GetState() == STATE_RUNNING;
1396 }
1397
1398 bool wxThread::IsAlive() const
1399 {
1400 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1401
1402 switch ( m_internal->GetState() )
1403 {
1404 case STATE_RUNNING:
1405 case STATE_PAUSED:
1406 return TRUE;
1407
1408 default:
1409 return FALSE;
1410 }
1411 }
1412
1413 bool wxThread::IsPaused() const
1414 {
1415 wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
1416
1417 return (m_internal->GetState() == STATE_PAUSED);
1418 }
1419
1420 //--------------------------------------------------------------------
1421 // wxThreadModule
1422 //--------------------------------------------------------------------
1423
1424 class wxThreadModule : public wxModule
1425 {
1426 public:
1427 virtual bool OnInit();
1428 virtual void OnExit();
1429
1430 private:
1431 DECLARE_DYNAMIC_CLASS(wxThreadModule)
1432 };
1433
1434 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1435
1436 bool wxThreadModule::OnInit()
1437 {
1438 int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
1439 if ( rc != 0 )
1440 {
1441 wxLogSysError(rc, _("Thread module initialization failed: "
1442 "failed to create thread key"));
1443
1444 return FALSE;
1445 }
1446
1447 gs_tidMain = pthread_self();
1448
1449 #if wxUSE_GUI
1450 gs_mutexGui = new wxMutex();
1451
1452 gs_mutexGui->Lock();
1453 #endif // wxUSE_GUI
1454
1455 // under Solaris we get a warning from CC when using
1456 // PTHREAD_MUTEX_INITIALIZER, so do it dynamically
1457 pthread_mutex_init(&gs_mutexDeleteThread, NULL);
1458
1459 return TRUE;
1460 }
1461
1462 void wxThreadModule::OnExit()
1463 {
1464 wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );
1465
1466 // are there any threads left which are being deleted right now?
1467 size_t nThreadsBeingDeleted;
1468 {
1469 MutexLock lock(gs_mutexDeleteThread);
1470 nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
1471 }
1472
1473 if ( nThreadsBeingDeleted > 0 )
1474 {
1475 wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
1476 nThreadsBeingDeleted);
1477
1478 // have to wait until all of them disappear
1479 gs_condAllDeleted->Wait();
1480 }
1481
1482 // terminate any threads left
1483 size_t count = gs_allThreads.GetCount();
1484 if ( count != 0u )
1485 {
1486 wxLogDebug(wxT("%u threads were not terminated by the application."),
1487 count);
1488 }
1489
1490 for ( size_t n = 0u; n < count; n++ )
1491 {
1492 // Delete calls the destructor which removes the current entry. We
1493 // should only delete the first one each time.
1494 gs_allThreads[0]->Delete();
1495 }
1496
1497 #if wxUSE_GUI
1498 // destroy GUI mutex
1499 gs_mutexGui->Unlock();
1500
1501 delete gs_mutexGui;
1502 #endif // wxUSE_GUI
1503
1504 // and free TLD slot
1505 (void)pthread_key_delete(gs_keySelf);
1506 }
1507
1508 // ----------------------------------------------------------------------------
1509 // global functions
1510 // ----------------------------------------------------------------------------
1511
1512 static void ScheduleThreadForDeletion()
1513 {
1514 MutexLock lock(gs_mutexDeleteThread);
1515
1516 if ( gs_nThreadsBeingDeleted == 0 )
1517 {
1518 gs_condAllDeleted = new wxCondition;
1519 }
1520
1521 gs_nThreadsBeingDeleted++;
1522
1523 wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
1524 gs_nThreadsBeingDeleted,
1525 gs_nThreadsBeingDeleted == 1 ? "" : "s");
1526 }
1527
1528 static void DeleteThread(wxThread *This)
1529 {
1530 // gs_mutexDeleteThread should be unlocked before signalling the condition
1531 // or wxThreadModule::OnExit() would deadlock
1532 {
1533 MutexLock lock(gs_mutexDeleteThread);
1534
1535 wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
1536
1537 delete This;
1538
1539 wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
1540 _T("no threads scheduled for deletion, yet we delete "
1541 "one?") );
1542 }
1543
1544 wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
1545 gs_nThreadsBeingDeleted - 1);
1546
1547 if ( !--gs_nThreadsBeingDeleted )
1548 {
1549 // no more threads left, signal it
1550 gs_condAllDeleted->Signal();
1551
1552 delete gs_condAllDeleted;
1553 gs_condAllDeleted = (wxCondition *)NULL;
1554 }
1555 }
1556
1557 void wxMutexGuiEnter()
1558 {
1559 #if wxUSE_GUI
1560 gs_mutexGui->Lock();
1561 #endif // wxUSE_GUI
1562 }
1563
1564 void wxMutexGuiLeave()
1565 {
1566 #if wxUSE_GUI
1567 gs_mutexGui->Unlock();
1568 #endif // wxUSE_GUI
1569 }
1570
1571 #endif
1572 // wxUSE_THREADS