23 #include "RConfigure.h"
44 TMutex *TThread::fgXActMutex = 0;
53 static TMutex *gMainInternalMutex = 0;
68 class TThreadTearDownGuard {
71 ~TThreadTearDownGuard() {
82 TThread::fgThreadImp = 0;
100 static void* JoinFunc(
void *p);
103 TJoinHelper(
TThread *th,
void **ret);
112 TJoinHelper::TJoinHelper(
TThread *th,
void **ret)
115 fH =
new TThread(
"JoinHelper", JoinFunc,
this);
121 TJoinHelper::~TJoinHelper()
133 void* TJoinHelper::JoinFunc(
void *p)
135 TJoinHelper *jp = (TJoinHelper*)p;
137 jp->fRc = jp->fT->Join(jp->fRet);
152 Int_t TJoinHelper::Join()
160 int r = fC->TimedWaitRelative(100);
172 if (r == 0 || r == 1) {
187 TThread::fgThreadImp->
Join(fH, 0);
287 Info(
"TThread::TThread",
"TThread attached to running thread");
318 #if !defined (_REENTRANT) && !defined (WIN32)
320 ::Fatal(
"Init",
"_REENTRANT must be #define-d for TThread to work properly.");
362 SetComment(
"Constructor: MainInternalMutex Locking");
364 SetComment(
"Constructor: MainInternalMutex Locked");
381 Info(
"TThread::~TThread",
"thread deleted");
385 SetComment(
"Destructor: MainInternalMutex Locking");
387 SetComment(
"Destructor: MainInternalMutex Locked");
413 th->
Info(
"TThread::Delete",
"deleting thread");
485 TTHREAD_TLS(
TThread*)
self = 0;
501 Error(
"Join",
"thread not running");
506 Error(
"Join",
"cannot join detached thread");
516 return helper.Join();
527 ::Error(
"TThread::Join",
"cannot find thread 0x%lx", jid);
531 return myTh->
Join(ret);
564 Info(
"TThread::Run",
"thread run requested");
579 Warning(
"TThread::Kill",
"thread is not running");
598 ::Warning(
"TThread::Kill(Long_t)",
"thread 0x%lx not found",
id);
614 ::Warning(
"TThread::Kill(const char*)",
"thread %s not found", name);
719 th->
Info(
"TThread::AfterCancel",
"thread is canceled");
721 ::Error(
"TThread::AfterCancel",
"zero thread pointer passed");
749 if (absSec) *absSec = t.
GetSec();
799 th->
Info(
"TThread::Function",
"thread is running");
818 th->
Info(
"TThread::Function",
"thread has finished");
834 ::Info(
"TThread::Ps",
"no threads have been created");
845 printf(
" Thread State\n");
847 memset(cbuf,
' ',
sizeof(cbuf));
848 snprintf(cbuf,
sizeof(cbuf),
"%3d %s:0x%lx", num--, l->
GetName(), l->
fId);
863 default:
printf(
"Invalid ");
912 va_start(ap,
va_(fmt));
914 Int_t buf_size = 2048;
918 buf =
new char[buf_size];
920 int n = vsnprintf(buf, buf_size,
va_(fmt), ap);
923 if (n == -1 || n >= buf_size) {
932 arr[1] = (
void*) buf;
933 if (
XARequest(
"PRTF", 2, arr, 0))
return;
948 Int_t buf_size = 2048;
952 buf =
new char[buf_size];
954 int n = vsnprintf(buf, buf_size, fmt, ap);
957 if (n == -1 || n >= buf_size) {
971 arr[1] = (
void*)
Long_t(level);
972 arr[2] = (
void*) location;
974 if (
XARequest(
"ERRO", 4, arr, 0))
return;
995 loc =
new char[strlen(location) + strlen(
GetName()) + 32];
996 sprintf(loc,
"%s %s:0x%lx", location,
GetName(),
fId);
998 loc =
new char[strlen(
GetName()) + 32];
1027 th->
SetComment(
"XARequest: XActMutex Locking");
1029 th->
SetComment(
"XARequest: XActMutex Locked");
1044 if (condimp) condimp->
Wait();
1047 if (iret) *iret =
fgXArt;
1066 char const acts[] =
"PRTF CUPD CANV CDEL PDCD METH ERRO";
1067 enum { kPRTF = 0, kCUPD = 5, kCANV = 10, kCDEL = 15,
1068 kPDCD = 20, kMETH = 25, kERRO = 30 };
1069 int iact = strstr(acts,
fgXAct) - acts;
1082 const char *location = (
const char*)
fgXArr[2];
1083 char *mess = (
char*)
fgXArr[3];
1095 gROOT->ProcessLine(cmd);
1104 cmd =
Form(
"((TCanvas *)0x%lx)->Constructor();",(
Long_t)fgXArr[1]);
1105 gROOT->ProcessLine(cmd);
1113 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]);
1114 gROOT->ProcessLine(cmd);
1122 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]);
1123 gROOT->ProcessLine(cmd);
1134 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]);
1135 gROOT->ProcessLine(cmd);
1143 cmd =
Form(
"((TCanvas *)0x%lx)->Destructor();",(
Long_t)fgXArr[1]);
1144 gROOT->ProcessLine(cmd);
1149 *((
Int_t*)(fgXArr[3])),
1152 *((
Int_t*)(fgXArr[6])));
1155 ((
TMethodCall *) fgXArr[1])->Execute((
void*)(fgXArr[2]),(
const char*)(fgXArr[3]));
1159 ::Error(
"TThread::XAction",
"wrong case");
1163 if (condimp) condimp->
Signal();
static void ** GetTls(Int_t k)
Static method that initializes the TLS array of a thread and returns the reference to a given positio...
static void AfterCancel(TThread *th)
Static method which is called after the thread has been canceled.
static Int_t SetCancelDeferred()
Static method to set the cancellation response type of the calling thread to deferred, i.e.
static void ThreadInternalUnLock()
static Bool_t IsInitialized()
Return true, if the TThread objects have been initialize.
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
virtual TVirtualMutex * Factory(Bool_t=kFALSE)=0
static void XAction()
Static method called via the thread timer to execute in the main thread certain commands.
virtual Int_t Join(TThread *th, void **ret)=0
static TCondition * fgXActCondi
void ErrorHandler(int level, const char *location, const char *fmt, va_list ap) const
Thread specific error handler function.
void Reset()
Reset the timer.
friend class TThreadTimer
static void Initialize()
Initialize the Thread package.
RooArgList L(const RooAbsArg &v1)
R__EXTERN TVirtualMutex * gInterpreterMutex
void Constructor()
Common thread constructor.
static Int_t SetCancelOff()
Static method to turn off thread cancellation.
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
virtual Long_t SelfId()=0
This class implements a mutex interface.
static void Printf(const char *fmt,...)
Static method providing a thread safe printf. Appends a newline.
R__EXTERN Int_t gErrorAbortLevel
static Int_t SetCancelOn()
Static method to turn on thread cancellation.
static TThreadImp * fgThreadImp
R__EXTERN TVirtualMutex * gROOTMutex
R__EXTERN TThreadFactory * gThreadFactory
static Int_t TryLock()
Static method to try to lock the main thread mutex.
R__EXTERN TApplication * gApplication
virtual Int_t CleanUpPush(void **main, void *free, void *arg)=0
R__EXTERN void **(* gThreadTsd)(void *, Int_t)
Int_t UnLock()
Unlock the mutex.
virtual TThreadImp * CreateThreadImp()=0
static Int_t CleanUpPop(Int_t exe=0)
Static method which pops thread cleanup method off stack.
static volatile Int_t fgXArt
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
virtual Int_t CleanUp(void **main)=0
static Int_t SetCancelAsynchronous()
Static method to set the cancellation response type of the calling thread to asynchronous, i.e.
static void CINT_alloc_unlock()
virtual void SetAllocunlockfunc(void(*)()) const
Vc_ALWAYS_INLINE void free(T *p)
Frees memory that was allocated with Vc::malloc.
void SetComment(const char *txt=0)
R__EXTERN Int_t(* gThreadXAR)(const char *xact, Int_t nb, void **ar, Int_t *iret)
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
The TNamed class is the base class for all named ROOT classes.
~TThreadCleaner()
Call user clean up routines.
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.
virtual Int_t SetCancelDeferred()=0
static Long_t SelfId()
Static method returning the id for the current thread.
void DoError(Int_t level, const char *location, const char *fmt, va_list va) const
Interface to ErrorHandler.
Method or function calling interface.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Int_t Run(void *arg=0)
Start the thread.
TVirtualPad is an abstract base class for the Pad and Canvas classes.
void Error(const char *location, const char *msgfmt,...)
R__EXTERN TVirtualMutex * gGlobalMutex
virtual ~TThread()
Cleanup the thread.
static TThread * GetThread(Long_t id)
Static method to find a thread by id.
virtual Int_t SetCancelOff()=0
static TMutex * fgMainMutex
static Int_t Exists()
Static method to check if threads exist.
R__EXTERN TSystem * gSystem
static void Init()
Initialize global state and variables once.
TMutex * GetMutex() const
Get internally created mutex.
TConditionImp * fConditionImp
static char *volatile fgXAct
virtual Int_t Run(TThread *th)=0
char * Form(const char *fmt,...)
Handles synchronous and a-synchronous timer events.
virtual const char * GetName() const
Returns name of object.
static Int_t CleanUpPush(void *free, void *arg=0)
Static method which pushes thread cleanup method on stack.
static Int_t CancelPoint()
Static method to set a cancellation point.
Long_t Join(void **ret=0)
Join this thread.
virtual Int_t SetCancelAsynchronous()=0
Int_t Kill()
Kill this thread.
Int_t CleanUp()
Clean up of mutex.
static Int_t Lock()
Static method to lock the main thread mutex.
virtual void SetAlloclockfunc(void(*)()) const
static TInterpreter * Instance()
returns gInterpreter global
Int_t TryLock()
Try to lock mutex.
static void Ps()
Static method listing the existing threads.
static TMutex * fgXActMutex
Bool_t Notify()
Periodically execute the TThread::XAxtion() method in the main thread.
static void **volatile fgXArr
static Bool_t fgIsTearDown(kFALSE)
static Int_t CleanUp()
Static method to cleanup the calling thread.
virtual Int_t SetCancelOn()=0
static void ** Tsd(void *dflt, Int_t k)
Static method returning a pointer to thread specific data container of the calling thread...
static Int_t UnLock()
Static method to unlock the main thread mutex.
static TThread * Self()
Static method returning pointer to current thread.
TThreadTimer(Long_t ms=kItimerResolution+10)
Create thread timer.
ClassImp(TMCParticle) void TMCParticle printf(": p=(%7.3f,%7.3f,%9.3f) ;", fPx, fPy, fPz)
The TTimeStamp encapsulates seconds and ns since EPOCH.
void SetPriority(EPriority pri)
Set thread priority.
static void CINT_alloc_lock()
static RooMathCoreReg dummy
virtual Int_t Exit(void *ret)=0
Int_t Lock()
Lock the mutex.
#define R__LOCKGUARD(mutex)
virtual Int_t CancelPoint()=0
static Int_t GetTime(ULong_t *absSec, ULong_t *absNanoSec)
Static method to get the current time.
virtual Int_t Kill(TThread *th)=0
ClassImp(TThread) TThread
Create a thread.
void ROOT_TThread_Initialize()
static Int_t Exit(void *ret=0)
Static method which terminates the execution of the calling thread.
ErrorHandlerFunc_t GetErrorHandler()
Returns the current error handler function.
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
static TThreadTearDownGuard gTearDownGuard
virtual Int_t CleanUpPop(void **main, Int_t exe)=0
static Int_t Sleep(ULong_t secs, ULong_t nanos=0)
Static method to sleep the calling thread.
R__EXTERN TInterpreter * gCling
static void ThreadInternalLock()
virtual const char * GetError()
Return system error string.
static void * Function(void *ptr)
Static method which is called by the system thread function and which in turn calls the actual user f...
static volatile Int_t fgXAnb
void Delete(Option_t *option="")
Delete this object.
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.