Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TThread.cxx
Go to the documentation of this file.
1// @(#)root/thread:$Id$
2// Author: Fons Rademakers 02/07/97
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12//////////////////////////////////////////////////////////////////////////
13// //
14// TThread //
15// //
16// This class implements threads. A thread is an execution environment //
17// much lighter than a process. A single process can have multiple //
18// threads. The actual work is done via the TThreadImp class (either //
19// TPosixThread or TWin32Thread). //
20// //
21//////////////////////////////////////////////////////////////////////////
22
23#include "RConfigure.h"
24
25#include "TThread.h"
26#include "TThreadImp.h"
27#include "TThreadFactory.h"
28#include "TROOT.h"
29#include "TCondition.h"
30#include "TApplication.h"
31#include "TVirtualPad.h"
32#include "TMethodCall.h"
33#include "TMutex.h"
34#include "TTimeStamp.h"
35#include "TInterpreter.h"
36#include "TError.h"
37#include "TSystem.h"
38#include "Varargs.h"
39#include "ThreadLocalStorage.h"
40#include "TThreadSlots.h"
41#include "TRWMutexImp.h"
42#include "snprintf.h"
43
46TThread *TThread::fgMain = nullptr;
48char *volatile TThread::fgXAct = nullptr;
51void **volatile TThread::fgXArr = nullptr;
52volatile Int_t TThread::fgXAnb = 0;
53volatile Int_t TThread::fgXArt = 0;
54
55static void CINT_alloc_lock() { gGlobalMutex->Lock(); }
57
58static TMutex *gMainInternalMutex = nullptr;
59
62
64
65extern "C" void ROOT_TThread_Initialize()
66{
68};
69
70//------------------------------------------------------------------------------
71
72// Set gGlobalMutex to 0 when Thread library gets unloaded
73class TThreadTearDownGuard {
74public:
75 TThreadTearDownGuard() { fgIsTearDown = kFALSE; }
76 ~TThreadTearDownGuard() {
77 // Note: we could insert here a wait for all thread to be finished.
78 // this is questionable though as we need to balance between fixing a
79 // user error (the thread was let lose and the caller did not explicit wait)
80 // and the risk that we can not terminate a failing process.
81
84 gGlobalMutex = 0;
85 delete m;
88 delete imp;
89 }
90};
91static TThreadTearDownGuard gTearDownGuard;
92
93//------------------------------------------------------------------------------
94
95class TJoinHelper {
96private:
97 TThread *fT;
98 TThread *fH;
99 void **fRet;
100 Long_t fRc;
101 TMutex *fM;
102 TCondition *fC;
103 Bool_t fJoined;
104
105 static void* JoinFunc(void *p);
106
107public:
108 TJoinHelper(TThread *th, void **ret);
109 ~TJoinHelper();
110
111 Int_t Join();
112};
113
114////////////////////////////////////////////////////////////////////////////////
115/// Constructor of Thread helper class.
116
117TJoinHelper::TJoinHelper(TThread *th, void **ret)
118 : fT(th), fRet(ret), fRc(0), fM(new TMutex), fC(new TCondition(fM)), fJoined(kFALSE)
119{
120 fH = new TThread("JoinHelper", JoinFunc, this);
121}
122
123////////////////////////////////////////////////////////////////////////////////
124/// Destructor.
125
126TJoinHelper::~TJoinHelper()
127{
128 delete fC;
129 delete fM;
130 delete fH;
131}
132
133////////////////////////////////////////////////////////////////////////////////
134/// Static method which runs in a separate thread to handle thread
135/// joins without blocking the main thread.
136/// Return a value (zero) so that it makes a joinable thread.
137
138void* TJoinHelper::JoinFunc(void *p)
139{
140 TJoinHelper *jp = (TJoinHelper*)p;
141
142 jp->fRc = jp->fT->Join(jp->fRet);
143
144 jp->fM->Lock();
145 jp->fJoined = kTRUE;
146 jp->fC->Signal();
147 jp->fM->UnLock();
148
149 TThread::Exit(0);
150
151 return 0;
152}
153
154////////////////////////////////////////////////////////////////////////////////
155/// Thread join function.
156
157Int_t TJoinHelper::Join()
158{
159 fM->Lock();
160 fH->Run();
161
162 while (kTRUE) {
163 // TimedWaitRelative will release the mutex (i.e. equivalent to fM->Unlock),
164 // then block on the condition variable. Upon return it will lock the mutex.
165 int r = fC->TimedWaitRelative(100); // 100 ms
166
167 // From the man page from pthread_ond_timedwait:
168
169 // When using condition variables there is always a Boolean predicate
170 // involving shared variables associated with each condition wait that
171 // is true if the thread should proceed. Spurious wakeups from the
172 // pthread_cond_timedwait() or pthread_cond_wait() functions may occur.
173 // Since the return from pthread_cond_timedwait() or pthread_cond_wait()
174 // does not imply anything about the value of this predicate, the
175 // predicate should be re-evaluated upon such return.
176
177 if (r == 0 || r == 1) {
178 // If we received the signal or timed out, let's check the value
179 if (fJoined) break;
180 } else {
181 // If any other error occured, there is no point in trying again
182 break;
183 }
184
186 }
187
188 fM->UnLock();
189
190 // And wait for the help to finish to avoid the risk that it is still
191 // running when the main tread is finished (and the thread library unloaded!)
193
194 return fRc;
195}
196
197
198//------------------------------------------------------------------------------
199
201
202
203////////////////////////////////////////////////////////////////////////////////
204/// Create a thread. Specify the function or static class method
205/// to be executed by the thread and a pointer to the argument structure.
206/// The user function should return a void*. To start the thread call Run().
207
208TThread::TThread(VoidRtnFunc_t fn, void *arg, EPriority pri)
209 : TNamed("<anon>", "")
210{
212 fFcnVoid = 0;
213 fFcnRetn = fn;
214 fPriority = pri;
215 fThreadArg = arg;
216 Constructor();
217 fNamed = kFALSE;
218}
219
220////////////////////////////////////////////////////////////////////////////////
221/// Create a detached thread. Specify the function or static class method
222/// to be executed by the thread and a pointer to the argument structure.
223/// To start the thread call Run().
224
225TThread::TThread(VoidFunc_t fn, void *arg, EPriority pri)
226 : TNamed("<anon>", "")
227{
229 fFcnRetn = 0;
230 fFcnVoid = fn;
231 fPriority = pri;
232 fThreadArg = arg;
233 Constructor();
234 fNamed = kFALSE;
235}
236
237////////////////////////////////////////////////////////////////////////////////
238/// Create thread with a name. Specify the function or static class method
239/// to be executed by the thread and a pointer to the argument structure.
240/// The user function should return a void*. To start the thread call Run().
241
242TThread::TThread(const char *thname, VoidRtnFunc_t fn, void *arg,
243 EPriority pri) : TNamed(thname, "")
244{
246 fFcnVoid = 0;
247 fFcnRetn = fn;
248 fPriority = pri;
249 fThreadArg = arg;
250 Constructor();
251 fNamed = kTRUE;
252}
253
254////////////////////////////////////////////////////////////////////////////////
255/// Create a detached thread with a name. Specify the function or static
256/// class method to be executed by the thread and a pointer to the argument
257/// structure. To start the thread call Run().
258
259TThread::TThread(const char *thname, VoidFunc_t fn, void *arg,
260 EPriority pri) : TNamed(thname, "")
261{
263 fFcnRetn = 0;
264 fFcnVoid = fn;
265 fPriority = pri;
266 fThreadArg = arg;
267 Constructor();
268 fNamed = kTRUE;
269}
270
271////////////////////////////////////////////////////////////////////////////////
272/// Create a TThread for a already running thread.
273
275{
277 fFcnRetn = 0;
278 fFcnVoid = 0;
280 fThreadArg = 0;
281 Constructor();
282
283 // Changing the id must be protected as it will be look at by multiple
284 // threads (see TThread::GetThread)
286 fNamed = kFALSE;
287 fId = (id ? id : SelfId());
290
291 if (gDebug)
292 Info("TThread::TThread", "TThread attached to running thread");
293}
294
295////////////////////////////////////////////////////////////////////////////////
296/// Initialize the Thread package. This initializes the TThread and ROOT
297/// global mutexes to make parts of ROOT thread safe/aware. This call is
298/// implicit in case a TThread is created.
299
301{
302 Init();
303}
304
305////////////////////////////////////////////////////////////////////////////////
306/// Return true, if the TThread objects have been initialize. If false,
307/// the process is (from ROOT's point of view) single threaded.
308
310{
311 if (fgThreadImp)
312 return kTRUE;
313 return kFALSE;
314}
315
316////////////////////////////////////////////////////////////////////////////////
317/// Initialize global state and variables once.
318
320{
321 if (fgThreadImp || fgIsTearDown) return;
322
323#if !defined (_REENTRANT) && !defined (WIN32)
324 // Not having it means (See TVirtualMutext.h) that the LOCKGUARD macro are empty.
325 ::Fatal("Init","_REENTRANT must be #define-d for TThread to work properly.");
326#endif
327
328 // 'Insure' gROOT is created before initializing the Thread safe behavior
329 // (to make sure we do not have two attempting to create it).
331
334
336 fgMainMutex = new TMutex(kTRUE);
339
340
341 // Create the single global mutex
343 // We need to make sure that gCling is initialized.
346
347 // To avoid deadlocks, gInterpreterMutex and gROOTMutex need
348 // to point at the same instance.
349 // Both are now deprecated in favor of ROOT::gCoreMutex
350 {
352 if (!ROOT::gCoreMutex) {
353 // To avoid dead locks, caused by shared library opening and/or static initialization
354 // taking the same lock as 'tls_get_addr_tail', we can not use UniqueLockRecurseCount.
355#ifdef R__HAS_TBB
357#else
359#endif
360 }
363 }
364}
365
366////////////////////////////////////////////////////////////////////////////////
367/// Common thread constructor.
368
370{
371 fHolder = 0;
372 fClean = 0;
374
375 fId = -1;
376 fHandle= 0;
377 if (!fgThreadImp) Init();
378
379 SetComment("Constructor: MainInternalMutex Locking");
381 SetComment("Constructor: MainInternalMutex Locked");
382
383 if (fgMain) fgMain->fPrev = this;
384 fNext = fgMain; fPrev = 0; fgMain = this;
385
387 SetComment();
388
389 // thread is set up in initialisation routine or Run().
390}
391
392////////////////////////////////////////////////////////////////////////////////
393/// Cleanup the thread.
394
396{
397 if (gDebug)
398 Info("TThread::~TThread", "thread deleted");
399
400 // Disconnect thread instance
401
402 SetComment("Destructor: MainInternalMutex Locking");
404 SetComment("Destructor: MainInternalMutex Locked");
405
406 if (fPrev) fPrev->fNext = fNext;
407 if (fNext) fNext->fPrev = fPrev;
408 if (fgMain == this) fgMain = fNext;
409
411 SetComment();
412 if (fHolder) *fHolder = 0;
413}
414
415////////////////////////////////////////////////////////////////////////////////
416/// Static method to delete the specified thread.
417/// Returns -1 in case the thread was running and has been killed. Returns
418/// 0 in case the thread has been Delete and Cleaned up. The th pointer is
419/// not valid anymore in that case.
420
422{
423 if (!th) return 0;
424 th->fHolder = &th;
425
426 if (th->fState == kRunningState) { // Cancel if running
428
429 if (gDebug)
430 th->Info("TThread::Delete", "deleting thread");
431
432 th->Kill();
433 return -1;
434 }
435
436 CleanUp();
437 return 0;
438}
439
440////////////////////////////////////////////////////////////////////////////////
441/// Static method to check if threads exist.
442/// Returns the number of running threads.
443
445{
447
448 Int_t num = 0;
449 for (TThread *l = fgMain; l; l = l->fNext)
450 num++; //count threads
451
453
454 return num;
455}
456
457////////////////////////////////////////////////////////////////////////////////
458/// Set thread priority.
459
461{
462 fPriority = pri;
463}
464
465////////////////////////////////////////////////////////////////////////////////
466/// Static method to find a thread by id.
467
469{
470 TThread *myTh;
471
473
474 for (myTh = fgMain; myTh && (myTh->fId != id); myTh = myTh->fNext) { }
475
477
478 return myTh;
479}
480
481////////////////////////////////////////////////////////////////////////////////
482/// Static method to find a thread by name.
483
485{
486 TThread *myTh;
487
489
490 for (myTh = fgMain; myTh && (strcmp(name, myTh->GetName())); myTh = myTh->fNext) { }
491
493
494 return myTh;
495}
496
497////////////////////////////////////////////////////////////////////////////////
498/// Static method returning pointer to current thread.
499
501{
502 TTHREAD_TLS(TThread*) self = 0;
503
504 if (!self || fgIsTearDown) {
505 if (fgIsTearDown) self = 0;
506 self = GetThread(SelfId());
507 }
508 return self;
509}
510
511
512////////////////////////////////////////////////////////////////////////////////
513/// Join this thread.
514
516{
517 if (fId == -1) {
518 Error("Join", "thread not running");
519 return -1;
520 }
521
522 if (fDetached) {
523 Error("Join", "cannot join detached thread");
524 return -1;
525 }
526
527 if (SelfId() != fgMainId)
528 return fgThreadImp->Join(this, ret);
529
530 // do not block the main thread, use helper thread
531 TJoinHelper helper(this, ret);
532
533 return helper.Join();
534}
535
536////////////////////////////////////////////////////////////////////////////////
537/// Static method to join a thread by id.
538
540{
541 TThread *myTh = GetThread(jid);
542
543 if (!myTh) {
544 ::Error("TThread::Join", "cannot find thread 0x%lx", jid);
545 return -1L;
546 }
547
548 return myTh->Join(ret);
549}
550
551////////////////////////////////////////////////////////////////////////////////
552/// Static method returning the id for the current thread.
553
555{
556 if (fgIsTearDown) return -1;
557 if (!fgThreadImp) Init();
558
559 return fgThreadImp->SelfId();
560}
561
562////////////////////////////////////////////////////////////////////////////////
563/// Start the thread. This starts the static method TThread::Function()
564/// which calls the user function specified in the TThread ctor with
565/// the arg argument. Returns 0 on success, otherwise an error number will
566/// be returned.
567
569{
570 if (arg) fThreadArg = arg;
571
572 SetComment("Run: MainInternalMutex locking");
574 SetComment("Run: MainMutex locked");
575
576 int iret = fgThreadImp->Run(this);
577
579
580 if (gDebug)
581 Info("TThread::Run", "thread run requested");
582
584 SetComment();
585 return iret;
586}
587
588////////////////////////////////////////////////////////////////////////////////
589/// Kill this thread. Returns 0 on success, otherwise an error number will
590/// be returned.
591
593{
595 if (gDebug)
596 Warning("TThread::Kill", "thread is not running");
597 return 13;
598 } else {
600 return fgThreadImp->Kill(this);
601 }
602}
603
604////////////////////////////////////////////////////////////////////////////////
605/// Static method to kill the thread by id. Returns 0 on success, otherwise
606/// an error number will be returned.
607
609{
610 TThread *th = GetThread(id);
611 if (th) {
612 return fgThreadImp->Kill(th);
613 } else {
614 if (gDebug)
615 ::Warning("TThread::Kill(Long_t)", "thread 0x%lx not found", id);
616 return 13;
617 }
618}
619
620////////////////////////////////////////////////////////////////////////////////
621/// Static method to kill thread by name. Returns 0 on success, otherwise
622/// an error number will be returned.
623
625{
626 TThread *th = GetThread(name);
627 if (th) {
628 return fgThreadImp->Kill(th);
629 } else {
630 if (gDebug)
631 ::Warning("TThread::Kill(const char*)", "thread %s not found", name);
632 return 13;
633 }
634}
635
636////////////////////////////////////////////////////////////////////////////////
637/// Static method to turn off thread cancellation. Returns 0 on success,
638/// otherwise an error number will be returned.
639
641{
642 return fgThreadImp ? fgThreadImp->SetCancelOff() : -1;
643}
644
645////////////////////////////////////////////////////////////////////////////////
646/// Static method to turn on thread cancellation. Returns 0 on success,
647/// otherwise an error number will be returned.
648
650{
651 return fgThreadImp ? fgThreadImp->SetCancelOn() : -1;
652}
653
654////////////////////////////////////////////////////////////////////////////////
655/// Static method to set the cancellation response type of the calling thread
656/// to asynchronous, i.e. cancel as soon as the cancellation request
657/// is received.
658
660{
662}
663
664////////////////////////////////////////////////////////////////////////////////
665/// Static method to set the cancellation response type of the calling thread
666/// to deferred, i.e. cancel only at next cancellation point.
667/// Returns 0 on success, otherwise an error number will be returned.
668
670{
672}
673
674////////////////////////////////////////////////////////////////////////////////
675/// Static method to set a cancellation point. Returns 0 on success, otherwise
676/// an error number will be returned.
677
679{
680 return fgThreadImp ? fgThreadImp->CancelPoint() : -1;
681}
682
683////////////////////////////////////////////////////////////////////////////////
684/// Static method which pushes thread cleanup method on stack.
685/// Returns 0 in case of success and -1 in case of error.
686
688{
689 TThread *th = Self();
690 if (th)
691 return fgThreadImp->CleanUpPush(&(th->fClean), free, arg);
692 return -1;
693}
694
695////////////////////////////////////////////////////////////////////////////////
696/// Static method which pops thread cleanup method off stack.
697/// Returns 0 in case of success and -1 in case of error.
698
700{
701 TThread *th = Self();
702 if (th)
703 return fgThreadImp->CleanUpPop(&(th->fClean), exe);
704 return -1;
705}
706
707////////////////////////////////////////////////////////////////////////////////
708/// Static method to cleanup the calling thread.
709
711{
712 TThread *th = Self();
713 if (!th) return 13;
714
715 fgThreadImp->CleanUp(&(th->fClean));
717 if (fgXActMutex)
719
721
722 if (th->fHolder)
723 delete th;
724
725 return 0;
726}
727
728////////////////////////////////////////////////////////////////////////////////
729/// Static method which is called after the thread has been canceled.
730
732{
733 if (th) {
735 if (gDebug)
736 th->Info("TThread::AfterCancel", "thread is canceled");
737 } else
738 ::Error("TThread::AfterCancel", "zero thread pointer passed");
739}
740
741////////////////////////////////////////////////////////////////////////////////
742/// Static method which terminates the execution of the calling thread.
743
745{
746 return fgThreadImp ? fgThreadImp->Exit(ret) : -1;
747}
748
749////////////////////////////////////////////////////////////////////////////////
750/// Static method to sleep the calling thread.
751
753{
754 UInt_t ms = UInt_t(secs * 1000) + UInt_t(nanos / 1000000);
755 if (gSystem) gSystem->Sleep(ms);
756 return 0;
757}
758
759////////////////////////////////////////////////////////////////////////////////
760/// Static method to get the current time. Returns
761/// the number of seconds.
762
764{
765 TTimeStamp t;
766 if (absSec) *absSec = t.GetSec();
767 if (absNanoSec) *absNanoSec = t.GetNanoSec();
768 return t.GetSec();
769}
770
771////////////////////////////////////////////////////////////////////////////////
772/// Static method to lock the main thread mutex.
773
775{
776 return (fgMainMutex ? fgMainMutex->Lock() : 0);
777}
778
779////////////////////////////////////////////////////////////////////////////////
780/// Static method to try to lock the main thread mutex.
781
783{
784 return (fgMainMutex ? fgMainMutex->TryLock() : 0);
785}
786
787////////////////////////////////////////////////////////////////////////////////
788/// Static method to unlock the main thread mutex.
789
791{
792 return (fgMainMutex ? fgMainMutex->UnLock() : 0);
793}
794
795////////////////////////////////////////////////////////////////////////////////
796/// Static method which is called by the system thread function and
797/// which in turn calls the actual user function.
798
799void *TThread::Function(void *ptr)
800{
801 TThread *th;
802 void *ret, *arg;
803
804 TThreadCleaner dummy;
805
806 th = (TThread *)ptr;
807
808 // Default cancel state is OFF
809 // Default cancel type is DEFERRED
810 // User can change it by call SetCancelOn() and SetCancelAsynchronous()
811 SetCancelOff();
813 CleanUpPush((void *)&AfterCancel, th); // Enable standard cancelling function
814
815 if (gDebug)
816 th->Info("TThread::Function", "thread is running");
817
818 arg = th->fThreadArg;
819 th->fState = kRunningState;
820
821 if (th->fDetached) {
822 //Detached, non joinable thread
823 (th->fFcnVoid)(arg);
824 ret = 0;
826 } else {
827 //UnDetached, joinable thread
828 ret = (th->fFcnRetn)(arg);
830 }
831
832 CleanUpPop(1); // Disable standard canceling function
833
834 if (gDebug)
835 th->Info("TThread::Function", "thread has finished");
836
837 TThread::Exit(ret);
838
839 return ret;
840}
841
842////////////////////////////////////////////////////////////////////////////////
843/// Static method listing the existing threads.
844
846{
847 TThread *l;
848 int i;
849
850 if (!fgMain) {
851 ::Info("TThread::Ps", "no threads have been created");
852 return;
853 }
854
856
857 int num = 0;
858 for (l = fgMain; l; l = l->fNext)
859 num++;
860
861 char cbuf[256];
862 printf(" Thread State\n");
863 for (l = fgMain; l; l = l->fNext) { // loop over threads
864 memset(cbuf, ' ', sizeof(cbuf));
865 snprintf(cbuf, sizeof(cbuf), "%3d %s:0x%lx", num--, l->GetName(), l->fId);
866 i = strlen(cbuf);
867 if (i < 30)
868 cbuf[i] = ' ';
869 cbuf[30] = 0;
870 printf("%30s", cbuf);
871
872 switch (l->fState) { // print states
873 case kNewState: printf("Idle "); break;
874 case kRunningState: printf("Running "); break;
875 case kTerminatedState: printf("Terminated "); break;
876 case kFinishedState: printf("Finished "); break;
877 case kCancelingState: printf("Canceling "); break;
878 case kCanceledState: printf("Canceled "); break;
879 case kDeletingState: printf("Deleting "); break;
880 default: printf("Invalid ");
881 }
882 if (l->fComment[0]) printf(" // %s", l->fComment);
883 printf("\n");
884 } // end of loop
885
887}
888
889////////////////////////////////////////////////////////////////////////////////
890/// Static method returning a pointer to thread specific data container
891/// of the calling thread.
892/// k should be between 0 and kMaxUserThreadSlot for user application.
893/// (and between kMaxUserThreadSlot and kMaxThreadSlot for ROOT libraries).
894/// See ROOT::EThreadSlotReservation
895
896void **TThread::Tsd(void *dflt, Int_t k)
897{
898 if (TThread::SelfId() == fgMainId) { //Main thread
899 return (void**)dflt;
900 } else {
901 return GetTls(k);
902 }
903}
904
905////////////////////////////////////////////////////////////////////////////////
906/// Static method that initializes the TLS array of a thread and returns the
907/// reference to a given position in that array.
908
910 TTHREAD_TLS_ARRAY(void*, ROOT::kMaxThreadSlot, tls);
911
912 // In order for the thread 'gDirectory' value to be properly
913 // initialized we set it now (otherwise it defaults
914 // to zero which is 'unexpected')
915 // We initialize it to gROOT rather than gDirectory, since
916 // TFile are currently expected to not be shared by two threads.
917 if (k == ROOT::kDirectoryThreadSlot && tls[k] == nullptr)
918 tls[k] = gROOT;
919
920 return &(tls[k]);
921}
922
923////////////////////////////////////////////////////////////////////////////////
924/// Static method providing a thread safe printf. Appends a newline.
925
926void TThread::Printf(const char *va_(fmt), ...)
927{
928 va_list ap;
929 va_start(ap,va_(fmt));
930
931 Int_t buf_size = 2048;
932 char *buf;
933
934again:
935 buf = new char[buf_size];
936
937 int n = vsnprintf(buf, buf_size, va_(fmt), ap);
938 // old vsnprintf's return -1 if string is truncated new ones return
939 // total number of characters that would have been written
940 if (n == -1 || n >= buf_size) {
941 buf_size *= 2;
942 delete [] buf;
943 goto again;
944 }
945
946 va_end(ap);
947
948 void *arr[2];
949 arr[1] = (void*) buf;
950 if (XARequest("PRTF", 2, arr, 0)) return;
951
952 printf("%s\n", buf);
953 fflush(stdout);
954
955 delete [] buf;
956}
957
958////////////////////////////////////////////////////////////////////////////////
959/// Thread specific error handler function.
960/// It calls the user set error handler in the main thread.
961
962void TThread::ErrorHandler(int level, const char *location, const char *fmt,
963 va_list ap) const
964{
965 Int_t buf_size = 2048;
966 char *buf, *bp;
967
968again:
969 buf = new char[buf_size];
970
971 int n = vsnprintf(buf, buf_size, fmt, ap);
972 // old vsnprintf's return -1 if string is truncated new ones return
973 // total number of characters that would have been written
974 if (n == -1 || n >= buf_size) {
975 buf_size *= 2;
976 delete [] buf;
977 goto again;
978 }
979 if (level >= kSysError && level < kFatal) {
980 char *buf1 = new char[buf_size + strlen(gSystem->GetError()) + 5];
981 sprintf(buf1, "%s (%s)", buf, gSystem->GetError());
982 bp = buf1;
983 delete [] buf;
984 } else
985 bp = buf;
986
987 void *arr[4];
988 arr[1] = (void*) Long_t(level);
989 arr[2] = (void*) location;
990 arr[3] = (void*) bp;
991 if (XARequest("ERRO", 4, arr, 0)) return;
992
993 if (level != kFatal)
994 ::GetErrorHandler()(level, level >= gErrorAbortLevel, location, bp);
995 else
996 ::GetErrorHandler()(level, kTRUE, location, bp);
997
998 delete [] bp;
999}
1000
1001////////////////////////////////////////////////////////////////////////////////
1002/// Interface to ErrorHandler. User has to specify the class name as
1003/// part of the location, just like for the global Info(), Warning() and
1004/// Error() functions.
1005
1006void TThread::DoError(int level, const char *location, const char *fmt,
1007 va_list va) const
1008{
1009 char *loc = 0;
1010
1011 if (location) {
1012 loc = new char[strlen(location) + strlen(GetName()) + 32];
1013 sprintf(loc, "%s %s:0x%lx", location, GetName(), fId);
1014 } else {
1015 loc = new char[strlen(GetName()) + 32];
1016 sprintf(loc, "%s:0x%lx", GetName(), fId);
1017 }
1018
1019 ErrorHandler(level, loc, fmt, va);
1020
1021 delete [] loc;
1022}
1023
1024////////////////////////////////////////////////////////////////////////////////
1025/// Static method used to allow commands to be executed by the main thread.
1026
1027Int_t TThread::XARequest(const char *xact, Int_t nb, void **ar, Int_t *iret)
1028{
1029 if (!gApplication || !gApplication->IsRunning()) return 0;
1030
1031 // The first time, create the related static vars
1032 if (!fgXActMutex && gGlobalMutex) {
1033 gGlobalMutex->Lock();
1034 if (!fgXActMutex) {
1035 fgXActMutex = new TMutex(kTRUE);
1036 fgXActCondi = new TCondition;
1037 new TThreadTimer;
1038 }
1040 }
1041
1042 TThread *th = Self();
1043 if (th && th->fId != fgMainId) { // we are in the thread
1044 th->SetComment("XARequest: XActMutex Locking");
1045 fgXActMutex->Lock();
1046 th->SetComment("XARequest: XActMutex Locked");
1047
1049 TMutexImp *condmutex = fgXActCondi->GetMutex()->fMutexImp;
1050
1051 // Lock now, so the XAction signal will wait
1052 // and never come before the wait
1053 condmutex->Lock();
1054
1055 fgXAnb = nb;
1056 fgXArr = ar;
1057 fgXArt = 0;
1058 fgXAct = (char*) xact;
1059 th->SetComment(fgXAct);
1060
1061 if (condimp) condimp->Wait();
1062 condmutex->UnLock();
1063
1064 if (iret) *iret = fgXArt;
1066 th->SetComment();
1067 return 1997;
1068 } else //we are in the main thread
1069 return 0;
1070}
1071
1072////////////////////////////////////////////////////////////////////////////////
1073/// Static method called via the thread timer to execute in the main
1074/// thread certain commands. This to avoid sophisticated locking and
1075/// possible deadlocking.
1076
1078{
1080 TMutexImp *condmutex = fgXActCondi->GetMutex()->fMutexImp;
1081 condmutex->Lock();
1082
1083 char const acts[] = "PRTF CUPD CANV CDEL PDCD METH ERRO";
1084 enum { kPRTF = 0, kCUPD = 5, kCANV = 10, kCDEL = 15,
1085 kPDCD = 20, kMETH = 25, kERRO = 30 };
1086 int iact = strstr(acts, fgXAct) - acts;
1087 char *cmd = 0;
1088
1089 switch (iact) {
1090
1091 case kPRTF:
1092 printf("%s\n", (const char*)fgXArr[1]);
1093 fflush(stdout);
1094 break;
1095
1096 case kERRO:
1097 {
1098 int level = (int)Long_t(fgXArr[1]);
1099 const char *location = (const char*)fgXArr[2];
1100 char *mess = (char*)fgXArr[3];
1101 if (level != kFatal)
1102 GetErrorHandler()(level, level >= gErrorAbortLevel, location, mess);
1103 else
1104 GetErrorHandler()(level, kTRUE, location, mess);
1105 delete [] mess;
1106 }
1107 break;
1108
1109 case kCUPD:
1110 //((TCanvas *)fgXArr[1])->Update();
1111 union CastFromFuncToVoidPtr_t {
1112 void (*fFuncPtr)(void*);
1113 void* fVoidPtr;
1114 } castFromFuncToVoidPtr;
1115 castFromFuncToVoidPtr.fVoidPtr = fgXArr[2];
1116 (*castFromFuncToVoidPtr.fFuncPtr)(fgXArr[1]); // aka TCanvas::Update()
1117 break;
1118
1119 case kCANV:
1120
1121 switch(fgXAnb) { // Over TCanvas constructors
1122
1123 case 2:
1124 //((TCanvas*)fgXArr[1])->Constructor();
1125 cmd = Form("((TCanvas *)0x%lx)->Constructor();",(Long_t)fgXArr[1]);
1126 gROOT->ProcessLine(cmd);
1127 break;
1128
1129 case 5:
1130 //((TCanvas*)fgXArr[1])->Constructor(
1131 // (char*)fgXArr[2],
1132 // (char*)fgXArr[3],
1133 // *((Int_t*)(fgXArr[4])));
1134 cmd = Form("((TCanvas *)0x%lx)->Constructor((char*)0x%lx,(char*)0x%lx,*((Int_t*)(0x%lx)));",(Long_t)fgXArr[1],(Long_t)fgXArr[2],(Long_t)fgXArr[3],(Long_t)fgXArr[4]);
1135 gROOT->ProcessLine(cmd);
1136 break;
1137 case 6:
1138 //((TCanvas*)fgXArr[1])->Constructor(
1139 // (char*)fgXArr[2],
1140 // (char*)fgXArr[3],
1141 // *((Int_t*)(fgXArr[4])),
1142 // *((Int_t*)(fgXArr[5])));
1143 cmd = Form("((TCanvas *)0x%lx)->Constructor((char*)0x%lx,(char*)0x%lx,*((Int_t*)(0x%lx)),*((Int_t*)(0x%lx)));",(Long_t)fgXArr[1],(Long_t)fgXArr[2],(Long_t)fgXArr[3],(Long_t)fgXArr[4],(Long_t)fgXArr[5]);
1144 gROOT->ProcessLine(cmd);
1145 break;
1146
1147 case 8:
1148 //((TCanvas*)fgXArr[1])->Constructor(
1149 // (char*)fgXArr[2],
1150 // (char*)fgXArr[3],
1151 // *((Int_t*)(fgXArr[4])),
1152 // *((Int_t*)(fgXArr[5])),
1153 // *((Int_t*)(fgXArr[6])),
1154 // *((Int_t*)(fgXArr[7])));
1155 cmd = Form("((TCanvas *)0x%lx)->Constructor((char*)0x%lx,(char*)0x%lx,*((Int_t*)(0x%lx)),*((Int_t*)(0x%lx)),*((Int_t*)(0x%lx)),*((Int_t*)(0x%lx)));",(Long_t)fgXArr[1],(Long_t)fgXArr[2],(Long_t)fgXArr[3],(Long_t)fgXArr[4],(Long_t)fgXArr[5],(Long_t)fgXArr[6],(Long_t)fgXArr[7]);
1156 gROOT->ProcessLine(cmd);
1157 break;
1158
1159 }
1160 break;
1161
1162 case kCDEL:
1163 //((TCanvas*)fgXArr[1])->Destructor();
1164 cmd = Form("((TCanvas *)0x%lx)->Destructor();",(Long_t)fgXArr[1]);
1165 gROOT->ProcessLine(cmd);
1166 break;
1167
1168 case kPDCD:
1169 ((TVirtualPad*) fgXArr[1])->Divide( *((Int_t*)(fgXArr[2])),
1170 *((Int_t*)(fgXArr[3])),
1171 *((Float_t*)(fgXArr[4])),
1172 *((Float_t*)(fgXArr[5])),
1173 *((Int_t*)(fgXArr[6])));
1174 break;
1175 case kMETH:
1176 ((TMethodCall *) fgXArr[1])->Execute((void*)(fgXArr[2]),(const char*)(fgXArr[3]));
1177 break;
1178
1179 default:
1180 ::Error("TThread::XAction", "wrong case");
1181 }
1182
1183 fgXAct = 0;
1184 if (condimp) condimp->Signal();
1185 condmutex->UnLock();
1186}
1187
1188
1189//////////////////////////////////////////////////////////////////////////
1190// //
1191// TThreadTimer //
1192// //
1193//////////////////////////////////////////////////////////////////////////
1194
1195////////////////////////////////////////////////////////////////////////////////
1196/// Create thread timer.
1197
1199{
1200 gSystem->AddTimer(this);
1201}
1202
1203////////////////////////////////////////////////////////////////////////////////
1204/// Periodically execute the TThread::XAxtion() method in the main thread.
1205
1207{
1209 Reset();
1210
1211 return kFALSE;
1212}
1213
1214
1215//////////////////////////////////////////////////////////////////////////
1216// //
1217// TThreadCleaner //
1218// //
1219//////////////////////////////////////////////////////////////////////////
1220
1221////////////////////////////////////////////////////////////////////////////////
1222/// Call user clean up routines.
1223
1225{
1227}
ROOT::R::TRInterface & r
Definition Object.C:4
int Int_t
Definition RtypesCore.h:45
unsigned int UInt_t
Definition RtypesCore.h:46
const Bool_t kFALSE
Definition RtypesCore.h:92
unsigned long ULong_t
Definition RtypesCore.h:55
long Long_t
Definition RtypesCore.h:54
bool Bool_t
Definition RtypesCore.h:63
float Float_t
Definition RtypesCore.h:57
const Bool_t kTRUE
Definition RtypesCore.h:91
#define ClassImp(name)
Definition Rtypes.h:364
R__EXTERN TApplication * gApplication
const Int_t kSysError
Definition TError.h:50
ErrorHandlerFunc_t GetErrorHandler()
Returns the current error handler function.
Definition TError.cxx:102
const Int_t kFatal
Definition TError.h:51
R__EXTERN Int_t gErrorAbortLevel
Definition TError.h:130
XFontStruct * id
Definition TGX11.cxx:109
char name[80]
Definition TGX11.cxx:110
R__EXTERN TVirtualMutex * gInterpreterMutex
R__EXTERN TInterpreter * gCling
Int_t gDebug
Definition TROOT.cxx:590
R__EXTERN TVirtualMutex * gROOTMutex
Definition TROOT.h:63
#define gROOT
Definition TROOT.h:406
char * Form(const char *fmt,...)
typedef void((*Func_t)())
R__EXTERN TSystem * gSystem
Definition TSystem.h:559
R__EXTERN TThreadFactory * gThreadFactory
R__EXTERN void **(* gThreadTsd)(void *, Int_t)
static TMutex * gMainInternalMutex
Definition TThread.cxx:58
static void ThreadInternalUnLock()
Definition TThread.cxx:61
static void CINT_alloc_lock()
Definition TThread.cxx:55
static TThreadTearDownGuard gTearDownGuard
Definition TThread.cxx:91
static Bool_t fgIsTearDown(kFALSE)
static void ThreadInternalLock()
Definition TThread.cxx:60
void ROOT_TThread_Initialize()
Definition TThread.cxx:65
static void CINT_alloc_unlock()
Definition TThread.cxx:56
R__EXTERN TVirtualMutex * gGlobalMutex
#define R__LOCKGUARD(mutex)
R__EXTERN Int_t(* gThreadXAR)(const char *xact, Int_t nb, void **ar, Int_t *iret)
#define va_(arg)
Definition Varargs.h:41
#define free
Definition civetweb.c:1539
#define snprintf
Definition civetweb.c:1540
Bool_t IsRunning() const
virtual Int_t Wait()=0
virtual Int_t Signal()=0
TConditionImp * fConditionImp
Definition TCondition.h:37
TMutex * GetMutex() const
Get internally created mutex.
virtual void SetAllocunlockfunc(void(*)()) const
virtual void SetAlloclockfunc(void(*)()) const
static TInterpreter * Instance()
returns gInterpreter global
Method or function calling interface.
Definition TMethodCall.h:37
virtual Int_t Lock()=0
virtual Int_t UnLock()=0
Int_t UnLock()
Unlock the mutex.
Definition TMutex.cxx:68
Int_t CleanUp()
Clean up of mutex.
Definition TMutex.cxx:76
Int_t Lock()
Lock the mutex.
Definition TMutex.cxx:46
Int_t TryLock()
Try to lock mutex.
Definition TMutex.cxx:57
TMutexImp * fMutexImp
Definition TMutex.h:36
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
virtual const char * GetName() const
Returns name of object.
Definition TNamed.h:47
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:879
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:893
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:921
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition TObject.cxx:867
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
Definition TSystem.cxx:472
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition TSystem.cxx:438
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition TSystem.cxx:417
virtual const char * GetError()
Return system error string.
Definition TSystem.cxx:251
~TThreadCleaner()
Call user clean up routines.
Definition TThread.cxx:1224
virtual TThreadImp * CreateThreadImp()=0
virtual Int_t Join(TThread *th, void **ret)=0
virtual Int_t SetCancelOff()=0
virtual Int_t Exit(void *ret)=0
virtual Int_t CleanUpPush(void **main, void *free, void *arg)=0
virtual Long_t SelfId()=0
virtual Int_t CancelPoint()=0
virtual Int_t SetCancelDeferred()=0
virtual Int_t Kill(TThread *th)=0
virtual Int_t CleanUpPop(void **main, Int_t exe)=0
virtual Int_t SetCancelAsynchronous()=0
virtual Int_t SetCancelOn()=0
virtual Int_t Run(TThread *th)=0
virtual Int_t CleanUp(void **main)=0
TThreadTimer(Long_t ms=kItimerResolution+10)
Create thread timer.
Definition TThread.cxx:1198
Bool_t Notify()
Periodically execute the TThread::XAxtion() method in the main thread.
Definition TThread.cxx:1206
VoidRtnFunc_t fFcnRetn
Definition TThread.h:84
static TThread * GetThread(Long_t id)
Static method to find a thread by id.
Definition TThread.cxx:468
static Int_t CleanUpPop(Int_t exe=0)
Static method which pops thread cleanup method off stack.
Definition TThread.cxx:699
static char *volatile fgXAct
Definition TThread.h:91
static Int_t CancelPoint()
Static method to set a cancellation point.
Definition TThread.cxx:678
static Int_t Sleep(ULong_t secs, ULong_t nanos=0)
Static method to sleep the calling thread.
Definition TThread.cxx:752
static void **volatile fgXArr
Definition TThread.h:92
static Int_t CleanUpPush(void *free, void *arg=nullptr)
Static method which pushes thread cleanup method on stack.
Definition TThread.cxx:687
static Int_t TryLock()
Static method to try to lock the main thread mutex.
Definition TThread.cxx:782
void SetPriority(EPriority pri)
Set thread priority.
Definition TThread.cxx:460
static Int_t Exists()
Static method to check if threads exist.
Definition TThread.cxx:444
TThread * fPrev
Definition TThread.h:75
static void Ps()
Static method listing the existing threads.
Definition TThread.cxx:845
static void ** GetTls(Int_t k)
Static method that initializes the TLS array of a thread and returns the reference to a given positio...
Definition TThread.cxx:909
static TThreadImp * fgThreadImp
Definition TThread.h:90
static Int_t UnLock()
Static method to unlock the main thread mutex.
Definition TThread.cxx:790
Int_t Kill()
Kill this thread.
Definition TThread.cxx:592
static TMutex * fgMainMutex
Definition TThread.h:97
EState fState
Definition TThread.h:78
static volatile Int_t fgXAnb
Definition TThread.h:93
Long_t fHandle
Definition TThread.h:81
static Long_t fgMainId
Definition TThread.h:95
Long_t Join(void **ret=nullptr)
Join this thread.
Definition TThread.cxx:515
static void XAction()
Static method called via the thread timer to execute in the main thread certain commands.
Definition TThread.cxx:1077
virtual ~TThread()
Cleanup the thread.
Definition TThread.cxx:395
Bool_t fDetached
Definition TThread.h:82
static Int_t SetCancelAsynchronous()
Static method to set the cancellation response type of the calling thread to asynchronous,...
Definition TThread.cxx:659
static Int_t CleanUp()
Static method to cleanup the calling thread.
Definition TThread.cxx:710
void ErrorHandler(int level, const char *location, const char *fmt, va_list ap) const
Thread specific error handler function.
Definition TThread.cxx:962
static Int_t GetTime(ULong_t *absSec, ULong_t *absNanoSec)
Static method to get the current time.
Definition TThread.cxx:763
static Long_t SelfId()
Static method returning the id for the current thread.
Definition TThread.cxx:554
void Constructor()
Common thread constructor.
Definition TThread.cxx:369
static Int_t SetCancelOn()
Static method to turn on thread cancellation.
Definition TThread.cxx:649
static void ** Tsd(void *dflt, Int_t k)
Static method returning a pointer to thread specific data container of the calling thread.
Definition TThread.cxx:896
void DoError(Int_t level, const char *location, const char *fmt, va_list va) const
Interface to ErrorHandler.
Definition TThread.cxx:1006
Long_t fId
Definition TThread.h:80
Bool_t fNamed
Definition TThread.h:83
static volatile Int_t fgXArt
Definition TThread.h:94
void SetComment(const char *txt=nullptr)
Definition TThread.h:103
static Int_t XARequest(const char *xact, Int_t nb, void **ar, Int_t *iret)
Static method used to allow commands to be executed by the main thread.
Definition TThread.cxx:1027
VoidFunc_t fFcnVoid
Definition TThread.h:85
static void * Function(void *ptr)
Static method which is called by the system thread function and which in turn calls the actual user f...
Definition TThread.cxx:799
EPriority fPriority
Definition TThread.h:77
static void Printf(const char *fmt,...)
Static method providing a thread safe printf. Appends a newline.
Definition TThread.cxx:926
static Int_t Lock()
Static method to lock the main thread mutex.
Definition TThread.cxx:774
@ kRunningState
Definition TThread.h:64
@ kNewState
Definition TThread.h:63
@ kCanceledState
Definition TThread.h:69
@ kCancelingState
Definition TThread.h:68
@ kFinishedState
Definition TThread.h:67
@ kTerminatedState
Definition TThread.h:65
@ kDeletingState
Definition TThread.h:70
@ kInvalidState
Definition TThread.h:62
friend class TThreadTimer
Definition TThread.h:44
static Int_t SetCancelOff()
Static method to turn off thread cancellation.
Definition TThread.cxx:640
static void Init()
Initialize global state and variables once.
Definition TThread.cxx:319
static Int_t SetCancelDeferred()
Static method to set the cancellation response type of the calling thread to deferred,...
Definition TThread.cxx:669
static void AfterCancel(TThread *th)
Static method which is called after the thread has been canceled.
Definition TThread.cxx:731
static TThread * fgMain
Definition TThread.h:96
static TMutex * fgXActMutex
Definition TThread.h:98
EPriority
Definition TThread.h:55
@ kNormalPriority
Definition TThread.h:57
static Bool_t IsInitialized()
Return true, if the TThread objects have been initialize.
Definition TThread.cxx:309
static TThread * Self()
Static method returning pointer to current thread.
Definition TThread.cxx:500
static Int_t Exit(void *ret=nullptr)
Static method which terminates the execution of the calling thread.
Definition TThread.cxx:744
static void Initialize()
Initialize the Thread package.
Definition TThread.cxx:300
void * fClean
Definition TThread.h:87
static TCondition * fgXActCondi
Definition TThread.h:99
friend class TJoinHelper
Definition TThread.h:48
void Delete(Option_t *option="")
Delete this object.
Definition TThread.h:127
Int_t Run(void *arg=nullptr)
Start the thread.
Definition TThread.cxx:568
TThread(const TThread &)=delete
TThread ** fHolder
Definition TThread.h:76
TThread * fNext
Definition TThread.h:74
void * fThreadArg
Definition TThread.h:86
The TTimeStamp encapsulates seconds and ns since EPOCH.
Definition TTimeStamp.h:71
time_t GetSec() const
Definition TTimeStamp.h:135
Int_t GetNanoSec() const
Definition TTimeStamp.h:136
Handles synchronous and a-synchronous timer events.
Definition TTimer.h:51
void Reset()
Reset the timer.
Definition TTimer.cxx:157
This class implements a mutex interface.
virtual Int_t UnLock()=0
virtual Int_t Lock()=0
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
const Int_t n
Definition legend1.C:16
R__EXTERN TVirtualRWMutex * gCoreMutex
@ kDirectoryThreadSlot
@ kMaxThreadSlot
TROOT * GetROOT()
Definition TROOT.cxx:465
auto * m
Definition textangle.C:8
auto * l
Definition textangle.C:4