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)
virtual	~GThread()
int	Cancel()
static GThread::CState	CancelOff()
static GThread::CState	CancelOn()
static TClass*	Class()
int	Detach()
static void	Exit(void* ret = 0)
static void	FiniMain()
bool	GetDetached()
void*	GetEndArg()
GThread_cu_foo	GetEndFoo()
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()
static GThread*	InitMain()
virtual TClass*	IsA() const
int	Join(void** tret = 0)
int	Kill(GThread::Signal signal = SigSTOP)
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)
void	SetEndArg(void* endarg)
void	SetEndFoo(GThread_cu_foo endfoo)
static void	SetMinStackSize(int ss)
void	SetName(const Text_t* s)
void	SetNice(int nice)
void	SetStackSize(int stacksize)
void	SetStartArg(void* startarg)
void	SetStartFoo(GThread_foo startfoo)
virtual void	ShowMembers(TMemberInspector& insp, char* parent)
int	Spawn()
virtual void	Streamer(TBuffer& b)
void	StreamerNVirtual(TBuffer& b)
TString	StrName() const
static void	TestCancel()

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 {	SigHUP
	SigINT
	SigQUIT
	SigILL
	SigTRAP
	SigABRT
	SigIOT
	SigBUS
	SigFPE
	SigKILL
	SigUSR1
	SigSEGV
	SigUSR2
	SigPIPE
	SigALRM
	SigTERM
	SigSTKFLT
	SigCLD
	SigCHLD
	SigCONT
	SigSTOP
	SigTSTP
	SigTTIN
	SigTTOU
	SigURG
	SigXCPU
	SigXFSZ
	SigVTALRM
	SigPROF
	SigWINCH
	SigPOLL
	SigIO
	SigPWR
	SigUNUSED
};
enum RState {	RS_Incubating
	RS_Spawning
	RS_Running
	RS_Terminating
	RS_Finished
	RS_ErrorSpawning
};

private:

static unsigned int	TSD_Self
bool	bDetached	X{g}
void*	mEndArg	X{gs}
GThread_cu_foo	mEndFoo	X{gs}
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
GThread::RState	mRunningState	X{g}
int	mStackSize	X{gs}
void*	mStartArg	X{gs}
GThread_foo	mStartFoo	X{gs}
list<GThread,allocator<GThread> >::iterator	mThreadListIt
static GMutex	sContainerLock
static bool	sMainInitDone
static GThread*	sMainThread
static int	sMinStackSize
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)

 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.

~GThread()

 Destructor.
 Thread is unregistered from the thread list.

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()

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.

const char* RunningStateName(GThread::RState state)

void ListThreads()

GThread* InitMain()

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

void FiniMain()

int GetMinStackSize()

void SetMinStackSize(int ss)

void set_owner(ZMirEmittingEntity* owner)

{ mOwner = owner; }

ZMirEmittingEntity* get_owner() const

{ return mOwner; }

void set_mir(ZMIR* mir)

{ mMIR = mir; }

ZMIR* get_mir() const

{ return mMIR; }

GThread(const Text_t* name)

CState SetCancelState(GThread::CState s)

CState CancelOn()

{ return SetCancelState(CS_Enable); }

CState CancelOff()

{ return SetCancelState(CS_Disable); }

CType SetCancelType(GThread::CType t)