Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file source file viewVC header viewVC source

Sections: class description function members data members class charts

class GThread


 POSIX thread wrapper class - Gled specific as it provides
 data members required for authorization and MIR processing.

Function Members (Methods)

public:

	GThread(const GThread&)
	GThread(const Text_t* name, GThread_foo foo, void* arg = 0, bool detached = false, bool detach_on_exit = false)
virtual	~GThread()
static void	BlockAllSignals()
static void	BlockSignal(GThread::Signal sig)
int	Cancel()
static void	CancelAllThreads(bool join_p)
static GThread::CState	CancelOff()
static GThread::CState	CancelOn()
static TClass*	Class()
void	CleanupPop(bool execute_p)
void	CleanupPush(GThread_cu_foo foo, void* arg)
bool	ClearDetachOnExit()
void	ClearRootTThreadRepresentation()
int	Detach()
static void	Exit(void* ret = 0)
static void	FiniMain()
bool	GetDetachOnExit()
pthread_t	GetId()
int	GetIndex()
static int	GetMinStackSize()
const Text_t*	GetName() const
int	GetNice()
GThread::RState	GetRunningState()
int	GetStackSize()
void*	GetStartArg()
GThread_foo	GetStartFoo()
GThread::TerminalPolicy	GetTerminalPolicy() const
static GThread*	InitMain()
static void	InvalidatePtr(GThread*& thr)
virtual TClass*	IsA() const
bool	IsDetached() const
static bool	IsValidPtr(GThread* thr)
int	Join(void** tret = 0)
int	Kill(GThread::Signal signal = SigSTOP)
static void	ListSignalState()
static void	ListThreads()
static ZMIR*	MIR()
GThread&	operator=(const GThread&)
static ZMirEmittingEntity*	Owner()
static const char*	RunningStateName(GThread::RState state)
static GThread*	Self()
static GThread::CState	SetCancelState(GThread::CState s)
static GThread::CType	SetCancelType(GThread::CType t)
static GThread_sh_foo	SetDefaultSignalHandler(GThread_sh_foo foo)
void	SetDetachOnExit(bool detachonexit)
static void	SetMinStackSize(int ss)
void	SetName(const Text_t* s)
void	SetNice(int nice)
static GThread_sh_foo	SetSignalHandler(GThread::Signal sig, GThread_sh_foo foo, bool unblock = false)
void	SetStackSize(int stacksize)
void	SetStartArg(void* startarg)
void	SetStartFoo(GThread_foo startfoo)
void	SetTerminalPolicy(GThread::TerminalPolicy tp)
virtual void	ShowMembers(TMemberInspector& insp)
static const char*	SignalName(GThread::Signal sig)
int	Spawn()
virtual void	Streamer(TBuffer& b)
void	StreamerNVirtual(TBuffer& b)
TString	StrName() const
static GThread::Signal	SysToGledSignal(Int_t sys_sig)
static void	TestCancel()
static void	TheSignalHandler(GSignal* sig)
static void	ToRootsSignalHandler(GSignal* sig)
static void	UnblockCpuExceptionSignals(bool unblock_fpe)
static void	UnblockSignal(GThread::Signal sig)
static int	Yield()

private:

	GThread(const Text_t* name)
ZMIR*	get_mir() const
ZMirEmittingEntity*	get_owner() const
void	set_mir(ZMIR* mir)
void	set_owner(ZMirEmittingEntity* owner)
static void	thread_reaper(void* arg)
static void*	thread_spawner(void* arg)

Data Members

public:

enum CState {	CS_Enable
	CS_Disable
};
enum CType {	CT_Async
	CT_Deferred
};
enum Signal {	SigUNDEF
	SigMIN
	SigHUP
	SigINT
	SigQUIT
	SigILL
	SigTRAP
	SigABRT
	SigBUS
	SigFPE
	SigKILL
	SigUSR1
	SigSEGV
	SigUSR2
	SigPIPE
	SigALRM
	SigTERM
	SigXXX1
	SigCHLD
	SigCONT
	SigSTOP
	SigTSTP
	SigTTIN
	SigTTOU
	SigURG
	SigXCPU
	SigXFSZ
	SigVTALRM
	SigPROF
	SigWINCH
	SigIO
	SigXXX2
	SigSYS
	SigMAX
	SigMAXRT
};
enum RState {	RS_Incubating
	RS_Spawning
	RS_Running
	RS_Terminating
	RS_Finished
	RS_ErrorSpawning
};
enum TerminalPolicy {	TP_ThreadExit
	TP_GledExit
	TP_SysExit
};

private:

static unsigned int	TSD_Self
bool	bDetachOnExit	X{gs}
bool	bDetached
list<GThread::Cleanup,allocator<GThread::Cleanup> >	mCleanups
pthread_t	mId	X{g} This will become GThreadInternalRep*
int	mIndex	X{g}
ZMIR*	mMIR
TString	mName	X{Gs}
int	mNice	X{gs}
ZMirEmittingEntity*	mOwner
TThread*	mRootTThread
GThread::RState	mRunningState	X{g}
GThread_sh_foo	mSigHandlerDefault
vector<void*>	mSigHandlerVector
int	mStackSize	X{gs}
void*	mStartArg	X{gs}
GThread_foo	mStartFoo	X{gs}
void*	mTerminalContext
GThread::TerminalPolicy	mTerminalPolicy
int	mTerminalSignal
list<GThread,allocator<GThread> >::iterator	mThreadListIt
static GMutex	sContainerLock
static GMutex	sDetachCtrlLock
static GThread*	sInvalidPtr
static GThread*	sMainThread
static int	sMinStackSize
static int	sSigMap[32]
static int	sThreadCount
static list<GThread*>	sThreadList
static map<unsigned long,GThread*>	sThreadMap

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

GThread(const Text_t* name)

 Private constructor for wrapping of existing threads.
 Thread is put into 'Running' state, registered into the thread list
 and assigned an internal thread-index.
 The owner of the thread is set to 0.

GThread(const Text_t* name, GThread_foo foo, void* arg = 0, bool detached = false, bool detach_on_exit = false)

 Normal constructor.
 Thread is put into 'Incubating' state, registered into the thread list
 and assigned an internal thread-index.
 The owner of the thread is set be the same as the owner of the calling thread.
 Termination policy is also copied.

~GThread()

 Destructor.
 Thread is unregistered from the thread list.

void CleanupPush(GThread_cu_foo foo, void* arg)

void CleanupPop(bool execute_p)

void* thread_spawner(void* arg)

void thread_reaper(void* arg)

int Spawn()

int Join(void** tret = 0)

int Kill(GThread::Signal signal = SigSTOP)

int Cancel()

int Detach()

bool IsDetached() const

bool ClearDetachOnExit()

void ClearRootTThreadRepresentation()

 Wipe root's TThread representation of the calling thread.
 This is needed as root's TSD schema expects TThread representation
 does not exist for whatever it calls the main thread.
 So we wipe it from the Root application thread.

int Yield()

void TestCancel()

void Exit(void* ret = 0)

GThread* Self()

 Static - returns current thread.

ZMirEmittingEntity* Owner()

 Static - returns owner of current thread.

ZMIR* MIR()

 Static - returns MIR processed in current thread.

void BlockAllSignals()

 Block all signals but the unblockable ones - KILL, STOP.

void UnblockCpuExceptionSignals(bool unblock_fpe)

 Unblock CPU exception signals SIGILL, SIGSEGV, SIGBUS
 and, if unblock_fpe is true, also SIGFPE.

void BlockSignal(GThread::Signal sig)

void UnblockSignal(GThread::Signal sig)

GThread_sh_foo SetDefaultSignalHandler(GThread_sh_foo foo)

GThread_sh_foo SetSignalHandler(GThread::Signal sig, GThread_sh_foo foo, bool unblock = false)

void TheSignalHandler(GSignal* sig)

void ToRootsSignalHandler(GSignal* sig)

 Root remaps signals in an even funnier way, see TUnixSystem.cxx.

void ListThreads()

void ListSignalState()

void CancelAllThreads(bool join_p)

GThread* InitMain()

 This will create a GThread wrapper around the calling thread.
 To be called from ::main thread, somewhere early during the
 system initialization.

 Blocks all signals but CPU exception ones.
 GThread signal handler is installed for USR1, USR2 and CPU exceptions.

void FiniMain()

int GetMinStackSize()

void SetMinStackSize(int ss)

const char* RunningStateName(GThread::RState state)

const char* SignalName(GThread::Signal sig)

void set_owner(ZMirEmittingEntity* owner)

{ mOwner = owner; }

ZMirEmittingEntity* get_owner() const

{ return mOwner; }

void set_mir(ZMIR* mir)

{ mMIR = mir; }

ZMIR* get_mir() const