---

PsnMultiThreadedScheduler Class Reference

class PsnMultiThreadedScheduler : uses threads to schedule the different simulation objects More...

#include <PsnMultiThreadedScheduler.h>

Inheritance diagram for PsnMultiThreadedScheduler:

[legend]Collaboration diagram for PsnMultiThreadedScheduler:

[legend]List of all members.

Public Methods
	PsnMultiThreadedScheduler (unsigned int numberOfSteps, unsigned int numberOfThreads, bool createThreadAndLocalSchedulers)
	constructor
virtual	~PsnMultiThreadedScheduler ()
	destructor
virtual void	addToScheduable (PsnReferenceObjectHandle *ref, unsigned int when)
	redefine so that simulated objects are assigned to threads in a cyclic manner
virtual void	addToScheduable (PsnReferenceObjectHandle *ref, unsigned int when, unsigned int whichThread)
	add a simulated object to a specific thread
virtual void	removeFromScheduable (PsnReferenceObjectHandle *ref)
	redefine to remove the simulated object from schedulers local to a thread
virtual void	schedule (PsnReferenceObjectHandle *ref)
	mark a scheduable object as active
virtual void	unschedule (PsnReferenceObjectHandle *ref)
	mark a scheduable object as inactive
virtual void	runStep (unsigned int which)
	run a simulation step
virtual void	run (unsigned int whichFrameScheduler)
	run one of the local frame schedulers ( called by the thread container function
Static Protected Methods
void *	_threadContainer (void *)
	used to start threads
Protected Attributes
unsigned int	_currentStep
	the shared simulation step number
unsigned int	_numberOfThreads
	the number of threads
vector< PsnScheduler * > *	_localSchedulers
	for each thread, a local frame scheduler is created
PsnScheduler *	_duplicatedObjectScheduler
	a specific scheduler is created for duplicated objects
PsnBarrier *	_barrier
	the synchronisation barrier between al lthe threads
unsigned int	_nextThreadForScheduling
	cycles through all threads, for cyclic alloaction of simulated objects to threads
map< PsnReferenceObjectHandle *, unsigned int >	_whichThread
	remember to wich thread a simulated object was assigned
pthread_t *	_threadIds
	store the thread ids
itimerval *	_profilingTimer
	store timer used for profiling (with the -pg option of gcc)
vector< pair< PsnScheduler *, unsigned int > * > *	_threadData
	store for each created thread, a pointer to the scheduler and thread specific data
long **	_localWaitingTimes
	used to bench waiting times if _BENCHWAITINGTIMES is defined
int	_numberOfSamples
	used to bench waiting times if _BENCHWAITINGTIMES is defined

---

Detailed Description

class PsnMultiThreadedScheduler : uses threads to schedule the different simulation objects

Author:

David Margery

Version:

:

Definition at line 36 of file PsnMultiThreadedScheduler.h.

---

Constructor & Destructor Documentation

PsnMultiThreadedScheduler::PsnMultiThreadedScheduler (  unsigned int    numberOfSteps, unsigned int    numberOfThreads, bool    createThreadAndLocalSchedulers )

constructor Parameters: numberOfSteps  number of simulation steps in a simualtion cycle numberOfThreads  number of threads to create to simulata each step createThreadAndLocalSchedulers  if false, no threads are created (enables redefintion) Definition at line 31 of file PsnMultiThreadedScheduler.cxx. References _barrier, _duplicatedObjectScheduler, _localSchedulers, _numberOfThreads, _profilingTimer, _threadContainer(), _threadData, _threadIds, and PsController::error(). : PsnScheduler(numberOfSteps), _numberOfThreads(numberOfThreads), _currentStep ( 0 ), _nextThreadForScheduling ( 0 ) { _barrier = new PsnBarrier ( _numberOfThreads + 1) ; _threadIds = new pthread_t [ _numberOfThreads ] ; //onlu used when profiling _profilingTimer = new itimerval [ _numberOfThreads ] ; _threadData = new vector <pair<PsnScheduler *, unsigned int> * > ( _numberOfThreads ) ; for (int i = 0 ; i < _numberOfThreads ; i++ ) { (*_threadData)[i] = new pair<PsnScheduler *, unsigned int> (this, i) ; // get the data associated to the timer used for profiling getitimer(ITIMER_PROF, &(_profilingTimer[i] )); } _localSchedulers = new vector <PsnScheduler *> ( _numberOfThreads ) ; int ret; #ifdef _SGI //for better use of the cpus available pthread_setconcurrency(_numberOfThreads) ; #endif if ( createThreadAndLocalSchedulers ) { _duplicatedObjectScheduler = new PsnFrameScheduler( numberOfSteps ) ; for (int i = 0 ; i < _numberOfThreads ; i++ ) { (*_localSchedulers)[i] = new PsnFrameScheduler( numberOfSteps ) ; } for (int i = 0 ; i < _numberOfThreads ; i++ ) { ret = pthread_create( & (_threadIds [i]), 0, (void *(*)(void *))_threadContainer, (*_threadData)[i]); if (ret) { PsController::error("Thread creation impossible") ; } } } }

PsnMultiThreadedScheduler::~PsnMultiThreadedScheduler (    )  [virtual]

destructor Definition at line 91 of file PsnMultiThreadedScheduler.cxx. References _barrier, _duplicatedObjectScheduler, _localSchedulers, _numberOfThreads, _profilingTimer, _threadData, and _threadIds. { for (int i = 0 ; i < _numberOfThreads ; i++ ) { delete (*_localSchedulers)[i] ; delete (*_threadData)[i] ; } delete _profilingTimer ; delete _localSchedulers ; delete _barrier ; delete [] _threadIds ; delete _threadData ; delete _duplicatedObjectScheduler ; }

---

Member Function Documentation

void * PsnMultiThreadedScheduler::_threadContainer (  void *    )  [static, protected]

used to start threads Reimplemented in PsnMultiThreadedBenchedScheduler. Definition at line 231 of file PsnMultiThreadedScheduler.cxx. References PsnMemoryManager::allocateSizeRemembered(), HeapStackTop::getSystemMemoryManager(), and PsnMemoryManager::init(). Referenced by PsnMultiThreadedScheduler(). { // install the memory managers HeapStackTop systemMemoryManager ( HeapStackTop::getSystemMemoryManager() ) ; PsnMemoryManager * currentMemoryManager = HeapStackTop::getSystemMemoryManager() ; assert ( currentMemoryManager != 0 ) ; size_t initialAllocatatedMemory = 1024 * 1024 ; void * startMemory = currentMemoryManager->allocateSizeRemembered ( initialAllocatatedMemory ) ; PsnDescriptorMemoryManager * descriptorMemoryManager = new PsnDescriptorMemoryManager ( *currentMemoryManager ) ; descriptorMemoryManager->init() ; PsnThreadMemoryManager * memoryManagerForThisThread ; memoryManagerForThisThread = new PsnThreadMemoryManager ( startMemory, initialAllocatatedMemory, *currentMemoryManager, *descriptorMemoryManager ) ; memoryManagerForThisThread -> init() ; HeapStackTop allocationContextForThisThread ( memoryManagerForThisThread ) ; // get the data specific to this thread pair<PsnMultiThreadedScheduler *, unsigned int> * threadData = ( pair<PsnMultiThreadedScheduler *, unsigned int> * ) myThreadData ; // get the eventual profiler to profile this thread setitimer(ITIMER_PROF, &(( * threadData ).first->_profilingTimer[( * threadData ).second]), NULL); cerr<<"Thread now profiled ?"<<endl; ( * threadData ).first->run( ( * threadData ).second ) ; return threadData ; }

void PsnMultiThreadedScheduler::addToScheduable (  PsnReferenceObjectHandle *    ref, unsigned int    when, unsigned int    whichThread )  [virtual]

add a simulated object to a specific thread Definition at line 146 of file PsnMultiThreadedScheduler.cxx. References _duplicatedObjectScheduler, addToScheduable(), and PsnScheduler::addToScheduable(). { //cerr<<"PsnMultiThreadedScheduler::addToScheduable"<<((PsnReferenceObjectHandle *)ref)->objetSimul()->Nom()<<endl; if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) { _duplicatedObjectScheduler->addToScheduable ( ref , when ) ; } else { (*_localSchedulers)[ whichThread ] -> addToScheduable( ref , when ) ; } }

void PsnMultiThreadedScheduler::addToScheduable (  PsnReferenceObjectHandle *    ref, unsigned int    when )  [virtual]

redefine so that simulated objects are assigned to threads in a cyclic manner Implements PsnScheduler. Reimplemented in PsnMultiThreadedAsynchronousScheduler. Definition at line 159 of file PsnMultiThreadedScheduler.cxx. References _duplicatedObjectScheduler, _nextThreadForScheduling, _numberOfThreads, _whichThread, PsnScheduler::addToScheduable(), map< PsnReferenceObjectHandle *, unsigned int >::end(), map< PsnReferenceObjectHandle *, unsigned int >::find(), PsSimulatedObject::getFather(), PsObjectDescriptor::getName(), PsSimulatedObject::getObjectDescriptor(), PsSimulatedObject::getObjectHandle(), and PsnObjectHandle::getSimulatedObject(). Referenced by addToScheduable(), and PsnMultiThreadedAsynchronousScheduler::addToScheduable(). { //cerr<<"PsnMultiThreadedScheduler::addToScheduable "<<((PsnReferenceObjectHandle *)ref)->objetSimul()->Nom()<<endl; if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) { _duplicatedObjectScheduler->addToScheduable ( ref , when ) ; } else { assert ( ref != NULL ) ; assert ( ref->getSimulatedObject().getFather () != NULL ); map<PsnReferenceObjectHandle *, unsigned int>::iterator i = _whichThread.find((PsnReferenceObjectHandle *)ref->getSimulatedObject().getFather()->getObjectHandle() ) ; if ( i==_whichThread.end() ){ (*_localSchedulers)[ _nextThreadForScheduling ] -> addToScheduable( ref , when ) ; #ifdef _DEBUGSCHEDULER cout<<ref->getSimulatedObject().getObjectDescriptor().getName()<< " goes to thread "<<_nextThreadForScheduling<<endl; #endif _whichThread [ ref ] = _nextThreadForScheduling ; _nextThreadForScheduling = ( _nextThreadForScheduling + 1 ) % _numberOfThreads ; } else {//schedule on the same thread as ref's father (*_localSchedulers)[ (*i).second ] -> addToScheduable( ref , when ) ; #ifdef _DEBUGSCHEDULER cout<<ref->getSimulatedObject().getObjectDescriptor().getName()<< " goes to thread "<<(*i).second<<endl; #endif _whichThread [ ref ] = (*i).second ; } } }

void PsnMultiThreadedScheduler::removeFromScheduable (  PsnReferenceObjectHandle *    ref )  [virtual]

redefine to remove the simulated object from schedulers local to a thread Implements PsnScheduler. Reimplemented in PsnMultiThreadedAsynchronousScheduler. Definition at line 195 of file PsnMultiThreadedScheduler.cxx. References _duplicatedObjectScheduler, _whichThread, and PsnScheduler::removeFromScheduable(). Referenced by PsnMultiThreadedAsynchronousScheduler::removeFromScheduable(). { if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) { _duplicatedObjectScheduler->removeFromScheduable ( ref ) ; } else { (*_localSchedulers) [ _whichThread [ ref ] ] ->removeFromScheduable (ref ) ; } }

void PsnMultiThreadedScheduler::run (  unsigned int    whichFrameScheduler )  [virtual]

run one of the local frame schedulers ( called by the thread container function Reimplemented in PsnMultiThreadedBenchedScheduler. Definition at line 273 of file PsnMultiThreadedScheduler.cxx. References _barrier, _currentStep, and PsnBarrier::Sync(). { while ( true ) { _barrier->Sync() ; (*_localSchedulers)[ whichFrameScheduler ]->runStep ( _currentStep ) ; _barrier->Sync() ; } }

void PsnMultiThreadedScheduler::runStep (  unsigned int    which )  [virtual]

run a simulation step Implements PsnScheduler. Reimplemented in PsnMultiThreadedAsynchronousScheduler, and PsnMultiThreadedBenchedScheduler. Definition at line 117 of file PsnMultiThreadedScheduler.cxx. References _barrier, _currentStep, _duplicatedObjectScheduler, _numberOfThreads, PsnThreadMemoryManager::freeLeakedMemoryBlocks(), PsnScheduler::runStep(), and PsnBarrier::Sync(). Referenced by PsnMultiThreadedBenchedScheduler::runStep(), and PsnMultiThreadedAsynchronousScheduler::runStep(). { _currentStep = which ; _duplicatedObjectScheduler->runStep (which) ; #if defined (_DEBUGSCHEDULER) cerr<<"Execution par block pour debug "<<endl; for ( int i = 0 ; i < _numberOfThreads ; i++ ) { cerr<<"Lot "<<i<<" ***********************************"<<endl; (*_localSchedulers)[ i ]->runStep (which) ; } #else // let the thread do their work _barrier->Sync() ; // wait for the threads to finish their work _barrier->Sync() ; //let the controller do it's work //purge the memory manager from memory that couldn't be freed efficiently PsnThreadMemoryManager::freeLeakedMemoryBlocks() ; #endif }

void PsnMultiThreadedScheduler::schedule (  PsnReferenceObjectHandle *    ref )  [virtual]

mark a scheduable object as active Implements PsnScheduler. Reimplemented in PsnMultiThreadedAsynchronousScheduler. Definition at line 207 of file PsnMultiThreadedScheduler.cxx. References _duplicatedObjectScheduler, _whichThread, and PsnScheduler::schedule(). Referenced by PsnMultiThreadedAsynchronousScheduler::schedule(). { if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) { _duplicatedObjectScheduler->schedule ( ref ) ; } else { (*_localSchedulers) [ _whichThread [ ref ] ] -> schedule (ref) ; } }

void PsnMultiThreadedScheduler::unschedule (  PsnReferenceObjectHandle *    ref )  [virtual]

mark a scheduable object as inactive Implements PsnScheduler. Reimplemented in PsnMultiThreadedAsynchronousScheduler. Definition at line 219 of file PsnMultiThreadedScheduler.cxx. References _duplicatedObjectScheduler, _whichThread, and PsnScheduler::unschedule(). Referenced by PsnMultiThreadedAsynchronousScheduler::unschedule(). { if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) { _duplicatedObjectScheduler->unschedule ( ref ) ; } else { (*_localSchedulers) [ _whichThread [ ref ] ] -> unschedule (ref) ; } }

---

Member Data Documentation

PsnBarrier* PsnMultiThreadedScheduler::_barrier [protected]

the synchronisation barrier between al lthe threads Definition at line 88 of file PsnMultiThreadedScheduler.h. Referenced by PsnMultiThreadedScheduler(), run(), PsnMultiThreadedBenchedScheduler::run(), runStep(), and ~PsnMultiThreadedScheduler().

unsigned int PsnMultiThreadedScheduler::_currentStep [protected]

the shared simulation step number Definition at line 76 of file PsnMultiThreadedScheduler.h. Referenced by run(), PsnMultiThreadedBenchedScheduler::run(), and runStep().

PsnScheduler* PsnMultiThreadedScheduler::_duplicatedObjectScheduler [protected]

a specific scheduler is created for duplicated objects Definition at line 85 of file PsnMultiThreadedScheduler.h. Referenced by addToScheduable(), PsnMultiThreadedBenchedScheduler::PsnMultiThreadedBenchedScheduler(), PsnMultiThreadedScheduler(), removeFromScheduable(), runStep(), schedule(), unschedule(), and ~PsnMultiThreadedScheduler().

vector<PsnScheduler * >* PsnMultiThreadedScheduler::_localSchedulers [protected]

for each thread, a local frame scheduler is created Definition at line 82 of file PsnMultiThreadedScheduler.h. Referenced by PsnMultiThreadedScheduler(), and ~PsnMultiThreadedScheduler().

long* * PsnMultiThreadedScheduler::_localWaitingTimes [protected]

used to bench waiting times if _BENCHWAITINGTIMES is defined Reimplemented in PsnMultiThreadedBenchedScheduler. Definition at line 106 of file PsnMultiThreadedScheduler.h.

unsigned int PsnMultiThreadedScheduler::_nextThreadForScheduling [protected]

cycles through all threads, for cyclic alloaction of simulated objects to threads Definition at line 91 of file PsnMultiThreadedScheduler.h. Referenced by addToScheduable().

int PsnMultiThreadedScheduler::_numberOfSamples [protected]

used to bench waiting times if _BENCHWAITINGTIMES is defined Reimplemented in PsnMultiThreadedBenchedScheduler. Definition at line 109 of file PsnMultiThreadedScheduler.h.

unsigned int PsnMultiThreadedScheduler::_numberOfThreads [protected]

the number of threads Definition at line 79 of file PsnMultiThreadedScheduler.h. Referenced by addToScheduable(), PsnMultiThreadedBenchedScheduler::PsnMultiThreadedBenchedScheduler(), PsnMultiThreadedScheduler(), runStep(), PsnMultiThreadedBenchedScheduler::~PsnMultiThreadedBenchedScheduler(), and ~PsnMultiThreadedScheduler().

itimerval* PsnMultiThreadedScheduler::_profilingTimer [protected]

store timer used for profiling (with the -pg option of gcc) Definition at line 100 of file PsnMultiThreadedScheduler.h. Referenced by PsnMultiThreadedScheduler(), and ~PsnMultiThreadedScheduler().

vector<pair<PsnScheduler *, unsigned int> * >* PsnMultiThreadedScheduler::_threadData [protected]

store for each created thread, a pointer to the scheduler and thread specific data Definition at line 103 of file PsnMultiThreadedScheduler.h. Referenced by PsnMultiThreadedBenchedScheduler::PsnMultiThreadedBenchedScheduler(), PsnMultiThreadedScheduler(), and ~PsnMultiThreadedScheduler().

pthread_t* PsnMultiThreadedScheduler::_threadIds [protected]

store the thread ids Definition at line 97 of file PsnMultiThreadedScheduler.h. Referenced by PsnMultiThreadedBenchedScheduler::PsnMultiThreadedBenchedScheduler(), PsnMultiThreadedScheduler(), and ~PsnMultiThreadedScheduler().

map<PsnReferenceObjectHandle *, unsigned int> PsnMultiThreadedScheduler::_whichThread [protected]

remember to wich thread a simulated object was assigned Definition at line 94 of file PsnMultiThreadedScheduler.h. Referenced by addToScheduable(), removeFromScheduable(), schedule(), and unschedule().

---

The documentation for this class was generated from the following files:

• PsnMultiThreadedScheduler.h
• PsnMultiThreadedScheduler.cxx

---