---

PsController Class Reference

Defining what a controller is. More...

#include <PsController.h>

Inheritance diagram for PsController:

[legend]Collaboration diagram for PsController:

[legend]List of all members.

Public Types
enum	WarningLevels {   NoWarnings, SomeWarnings, AllWarnings, ExceptionOnWarnings,   FatalWarnings }
Public Methods
	PsController (PsObjectDescriptor &simulationTree, const PsDate &initialDate)
	Constructor for a classic controller.
virtual	~PsController ()
	Destructor.
virtual void	init ()
	initialise the object.
virtual void	run ()
	run start the controller on a infinite loop which will be broken if system events are sent to the controller
template<typename Type> list< const PsObjectDescriptor * > *	listDescendantsOfType (const PsName &objectName)
	List the descendants of an object that are of a certain type.
template<typename Type> list< const PsObjectDescriptor * > *	listBrothersOfType (const PsName objectName)
	list brothers of objectName in the simulation tree of that are of type t
virtual PsFrequency	computeAdequateFrequency (const PsFrequency &suggestedFrequency)
	Compute an adequate Frequency for an object dynamically created Should be used to adapt the desired frequency when an simulated object is dynamically created so that the creation doesn't cause recomputation of the scheduling.
virtual void	runControllersStep (PsnReferenceObjectHandle *objectHandle)
	run a controllers simulation step.
virtual void	compute ()
	compute : computes a new simulation step for all controlled objects, if the controller is in the running state, otherwise jsut react to system events sent to controlled objects
virtual void	finish ()
	finish the simulation.
void	showDateAndStepNumber (bool show=true)
	ask the controller to print (or not) to sdterr (cerr) the simulation date and the step number
virtual const PsDate &	getSimulatedDate () const
	returns a reference to an allways accurate simulation date, in ms
virtual int	getCycleFrequency () const
	get the simulation cycle frequency
virtual int	getCyclePeriod () const
	get the simulation cycle period, in simulated time (in ms)
virtual void	createObject (const PsObjectDescriptor &newObjectDescription, const PsName &fathersName)
	creation of an object unknown of in the simulation tree.
virtual void	destroyObject (const PsName &name, bool recursively)
	Destroy a simulated object.
virtual void	changeObjectsFather (const PsName &name, const PsName &newFather)
	Change the father of an object in the simulation tree.
virtual void	changeObjectsFather (PsObjectDescriptor *object, PsObjectDescriptor *newFather)
	Change the father of an object in the simulation tree.
virtual PsDuplicatedObject *	getPointerToDuplicatedObjectNamed (const PsName &name)
	get a pointer to a simulated object
virtual PsSimulatedObject *	getPointerToSimulatedObjectNamed (const PsName &name)
	get a pointer to a simulated object after return from this method, it's possible to querry any method of the simulated object that doesn't depend on the evolution of that object, as the object returned can have been created specially by the call.
virtual const PsObjectDescriptor &	getObjectDescriptorOfObject (const PsName &objectName)
	get the object descriptor of a given simulated object
virtual void	actOnSystemEvent (PsEvent *event)
	called when a reference object receives a system event
virtual void	reactToControlledObjectsSystemEvents ()
	process system events received by controlled objects
virtual void	processStartEventOf (PsnReferenceObjectHandle *objectHandle)
	process MaskStart systemEvent for the object with handle
virtual void	processDeleteEventOf (PsnReferenceObjectHandle *objectHandle)
	process MaskDelete systemEvent for object obj
virtual void	hasEventsToProcess (PsnReferenceObjectHandle *referenceObjectHandle)
	Add the object handled by referenceObjectHandle to the list of objects having events to process and therefore that need activation (and therefore possibly activated at the current simulation step).
virtual void	postponeEventProcessing (PsnReferenceObjectHandle *referenceObjectHandle)
	adds the object described by referenceObjectHandle to the list of object with events to process at the next simulaion step.
virtual void	noActivationNeededFor (PsnReferenceObjectHandle *referenceObjectHandle)
	removes object designated by referenceObjectHandle from the list of object needing activation by the controler because they have events pending.
virtual void	addToPendingEvents (PsEvent *)
	adds the event to the list of pending events.
virtual bool	addToPendingRegistrations (const PsEventIdentifier &sig, const PsName &producer, const PsEventIdentifier &eventId, const PsName &registrant)
	addToPendingRegistrations.
virtual bool	removeFromPendingRegistrations (const PsEventIdentifier &sig, const PsName &producer, const PsName &registrant)
	removeFromPendingRegistrations.
virtual bool	processEvent (PsEvent *)
	process events sent to the controller
virtual void	processEventsOfSuspendedObjects ()
	call processEvent for suspended objects having received events
virtual void	broadcastEventsForSignal (PsEvent &event, const PsEventIdentifier &sigId)
	broadcast events corresponding to a fired signal
virtual bool	receiveRegistrationForSignal (const PsEventIdentifier &sigId, const PsName &registrant, const PsEventIdentifier &eventId)
	register an object for a signal
virtual bool	receiveCancellationForSignal (const PsEventIdentifier &sigId, const PsName &registrant)
	cancel the registration of an object for a signal
template<typename Type> PsInput< Type > *	createInput (const PsName &name, PsSimulatedObject &owner, bool makeConnectable, int requestedPrecisionLevel)
	create an input
template<typename Type> PsSensitiveInput< Type > *	createSensitiveInput (const PsName &name, PsSimulatedObject &owner, bool makeConnectable, int requestedPrecisionLevel)
	create a sensitive input
template<typename Type> PsSensitiveNotifyingInput< Type > *	createSensitiveNotifyingInput (const PsName &name, PsSimulatedObject &owner, bool makeConnectable, int requestedPrecisionLevel)
	create a sensitive notifying input
template<typename Type> PsOutput< Type > *	createOutput (const PsName &name, PsSimulatedObject &owner, PsPolatorNT *polator)
	create an ouput
template<typename Type> PsControlParameter< Type > *	createControlParameter (const PsName &name, PsSimulatedObject &owner, PsPolatorNT *polator)
	create a control parameter
template<typename Type> PsInputAlias< Type > *	createInputAlias (const PsName &name, PsSimulatedObject &owner, PsAbstractInput< Type > *input, int requestedPrecisionLevel)
	create an input alias
template<typename Type> PsSensitiveInputAlias< Type > *	createSensitiveInputAlias (const PsName &name, PsSimulatedObject &owner, PsAbstractInput< Type > *input, int requestedPrecisionLevel)
	create a sensitive input alias
template<typename Type> PsSensitiveNotifyingInputAlias< Type > *	createSensitiveNotifyingInputAlias (const PsName &name, PsSimulatedObject &owner, PsAbstractInput< Type > *input, int requestedPrecisionLevel)
	create a sensitive notifying input alias
template<typename Type> PsOutputAlias< Type > *	createOutputAlias (const PsName &name, PsSimulatedObject &owner, PsOutput< Type > *output, PsPolatorNT *polator)
	create an ouput alias
Static Public Methods
void	error (const char *mess)
	included for ascendant compatibility : raises a PsUserException with the message passed as parameter
int	lcm (const int a, const int b)
int	gcd (const int a, const int b)
bool	setKernelObjectFactory (PsKernelObjectAbstractFactory *aFactory)
	set the kernelObjectfactory for the controller of this adressing space is only effective once for each adress space to be called before creation of the controller to be effective return : change effective
PsKernelObjectAbstractFactory *	getKernelObjectFactory ()
	get the active kernelObjectFactory
void	warning (const string &warningMessage, WarningLevels warningLevel)
	Print a warning.
Static Public Attributes
PsDate	initialSimulationDate = 0
	date at wich simulation was initialised
WarningLevels	warningLevel = PsController::NoWarnings
Protected Methods
virtual void	computeNextSimulationStep ()
	compute the next simulation step
virtual void	scheduleObject (PsnReferenceObjectHandle *ref)
	add a simulated object to the appropriate execution frames, without flagging it as executable
PsMultipleConfigurationParameter *	getSchedulingParametersOfObject (PsObjectDescriptor &)
	get a modifiable version of the scheduling parameters of an object.
PsSimulatedObject *	createDescribedObject (const PsObjectDescriptor *description)
	createDescribedObject.
virtual void	setProcessOfDescriptor (PsObjectDescriptor &objectDescription, const PsName &newProcessName)
virtual void	computeScheduling (bool fromOriginal)
	compute the scheduling data strucures.
virtual void	sendInitialEventsTo (PsnReferenceObjectHandle &objectHandle, const PsDate &dateOfMaskStart)
	send MaskStart to any created objects, and send any pending events which where stored (none by default) because send to an object before it was created
virtual void	deleteObject (PsObjectDescriptor *objectDescription)
	delete an object.
virtual PsnObjectHandle *	removeObjectFromDataStructures (const PsName &)
	remove any reference to a simulated object from all the controller's data structures
virtual void	processNewObjectDeclaration (PsObjectDescriptor &declaration, const PsDate &declarationDate)
	processNewObjectDeclaration once an object has been added to the simulation tree, this is called for creation and scheduling
virtual PsnReferenceObjectHandle *	createReferenceObject (const PsObjectDescriptor *idObjet)
	createReferenceObject.
virtual PsnScheduler *	createScheduler ()
	create the scheduler that is in charge of effective scheduling of the controlled objects
virtual void	scheduleControlledObjects ()
	scheduleControlledObjects schedule all controlled reference objects
virtual void	advanceSimulatedDate ()
	increment date and numberOfSimulatedSteps
virtual void	createControlledObjects (const PsObjectDescriptor *subTree)
	createControlledObjects create a reference object for all objects of a simulation tree
virtual void	setCycleFrequency (int newFrequency)
virtual void	setComputingState (PsnReferenceObjectHandle *, PsnReferenceObjectHandle::SimulatedObjectComputingState) const
	change the computing state of a reference object handle
virtual void	switchSystemEventList ()
	switch buffer of List Of Objects Needing Activation
virtual void	purgeMemoryFromOldEvents (const PsDate &dateOfOldestKept)
	the method used to purge the data structures from all outdated kepts events.
virtual PsDate	getPurgeDate ()
	get the date of the oldest event not purged by purgeMemoryFromOldEvents
virtual int	getOutputHistorySize (void)
	get the minimum history length pertinant for this controller The value returned is the value of the environement variable MaskHISTORYLENGTH, or a default value calculated so that get(-4 dt) return an exact value if it has been produced
virtual PsnReferenceObjectHandle *	createReferenceObjectHandle (PsSimulatedObject &obj)
	create a reference object handler appropriate for this controller
virtual PsnReferenceObjectHandle *	newPsnReferenceObjectHandle (PsSimulatedObject &object, PsController &controller, PsnSignalDispatcher *signalDispatcher)
	The controller is an abstract factory for reference object handles.
virtual void	deleteObjectHandle (PsnObjectHandle *objectHandle)
	as the controller is an abstract factory for object handlers, is should also be an abstract destroyer
Protected Attributes
PsNameToPointerMap< PsnReferenceObjectHandle >	_referenceObjectsMap
	data structure containing references to the ReferenceObjectHandlers
PsObjectDescriptor &	_simulationTree
	the simulation tree this controller is root of this has to be a reference to a allready constructed simulation tree, because the root descriptor of that tree is used a parameter of the ancestors constructor wich keeps a reference of that descriptor.
unsigned long int	_numberOfSimulatedSteps
	number of simulated steps up to now
PsFrequency	_stepFrequency
	frequency of a simulation step
int	_cycleFrequency
	the frequency at wich activation patterns repeat themselves
int	_cyclePeriod
	duration in simulated time of a simualtion cycle
int	_nbStepsByCycle
	number of simulation step by cycle : we have _cycleFrequency * stepFrequency = _nbStepsByCycle
int	_stepPeriod
	_stepPeriod.
PsDate	_date
	simulated date
bool	_showDateAndStepNumber
	flag indicating if the date and simulation step number are printed
PsnReferenceObjectHandle::SimulatedObjectComputingState *	_computeStatePointer
	a pointer for easy access to th computationnel state of the controller : if the controller is controlling itsekg, this computationnal state should be : running
PsnSignalDispatcher	_controledObjectsSignalsDispatcher
	signal dispatcher for objects interested in a signal whatever it's producer
bool	_forcedCompute
	to enable computations even in suspendedState, when the controller is controlled
PsnScheduler *	_scheduler
	the scheduler
list< PsnReferenceObjectHandle * > *	_objectsNeedingActivationList [2]
	double buffered list of controlled object needing activation because they have received events protect usage with _mutexForListEvt ;
int	_currentListOfObjectsNeedingActivation
	1 - _currentListOfObjectsNeedingActivation is used to store new object needing activation
list< PsEvent * > *	_systemEventsList [2]
	double buffered system event list
unsigned int	_currentWritableSystemEventsList
	_systemEventsList[_currentWritableSystemEventsList] is used to store system events sent to controlled objects
list< PsnReferenceObjectHandle * >	_listOfObjectsWithPostPonedEvents
	list of objects with postponed events
PsnMutexLock	_mutexSystemEventsList
	protecting access to _systemEventsList
map< PsName, list< PsEvent * > >	_pendingEventsList
	list of pending events (events sent to unknown objects)
PsnMutexLock	_mutexPendingDataStructures
	protecting the list of pending events and registrations
map< PsName, PsnSignalDispatcher * >	_pendingRegistrationRequests
	map of pending registration requests
list< pair< PsDate, PsnObjectHandle * > >	_deletedObjectHandles
	the list of recently deleted object handles.
Static Private Attributes
PsKernelObjectAbstractFactory *	kernelObjectFactory = NULL
	the kernel object factory used to create attribute of controlled object
Friends
class	PsInputNT
class	PsSimulatedObject

---

Detailed Description

Defining what a controller is.

a controller is in charge of simulating time and activating objects whose evolution are time related.

Author:

David Margery

Version:

2.1 redone event managing 2.0 (by siames ): inherited for PsSimulatedObject

Definition at line 47 of file PsController.h.

---

Member Enumeration Documentation

enum PsController::WarningLevels

Enumeration values: NoWarnings  SomeWarnings  AllWarnings  ExceptionOnWarnings  FatalWarnings  Definition at line 734 of file PsController.h. 00734 : 00735 enum WarningLevels { NoWarnings, 00736 SomeWarnings, 00737 AllWarnings, 00738 ExceptionOnWarnings, FatalWarnings};

---

Constructor & Destructor Documentation

PsController::PsController (  PsObjectDescriptor &    simulationTree, const PsDate &    initialDate )

Constructor for a classic controller. Parameters: initialObjects  the simulation tree describing the initial simulated objects to create. The root element of that tree is considered as describing the controller, and therfore it's class is ignored initialDate  the date at wich the simualtion is going to start Definition at line 69 of file PsController.cxx. References _computeStatePointer, _currentListOfObjectsNeedingActivation, _currentWritableSystemEventsList, PsObjectDescriptor::_destroySimulatedObject, PsSimulatedObject::_objectHandle, _objectsNeedingActivationList, PsObjectDescriptor::_pointerToSimulatedObject, _simulationTree, _systemEventsList, createReferenceObjectHandle(), PsnReferenceObjectHandle::initial, initialSimulationDate, PsDate, and PsNullOutputCreator::setController(). : PsSimulatedObject(*this, initialObjects ), _simulationTree ( initialObjects ), _nbStepsByCycle ( 0 ), _controledObjectsSignalsDispatcher( *this ), _numberOfSimulatedSteps ( 0 ), _showDateAndStepNumber ( false ), _scheduler (NULL), _forcedCompute (false) { PsNullOutputCreator::setController(this) ; initialSimulationDate = initialDate ; //as a controller created throught this constructor has no controller, create the illusion of being handled _objectHandle = createReferenceObjectHandle( *this ) ; _computeStatePointer = const_cast<PsnReferenceObjectHandle::SimulatedObjectComputingState *>(&(dynamic_cast<PsnReferenceObjectHandle *>(_objectHandle)->getComputingState () )) ; //connect the object description to the controller _simulationTree._pointerToSimulatedObject = this ; _simulationTree._destroySimulatedObject = false ; //create data structures for system events managed by the controller _systemEventsList [ 0 ] = new list <PsEvent *> () ; _systemEventsList [ 1 ] = new list <PsEvent *> () ; _currentWritableSystemEventsList = 0 ; //create data structures to keep track of objects needing activation because they have pending events _objectsNeedingActivationList[0]=new list<PsnReferenceObjectHandle *> () ; _objectsNeedingActivationList[1]=new list<PsnReferenceObjectHandle *> () ; _currentListOfObjectsNeedingActivation = 0 ; // initialisation de l'état du controleur assert ( _computeStatePointer != NULL ) ; *_computeStatePointer = PsnReferenceObjectHandle::initial ; }

PsController::~PsController (    )  [virtual]

Destructor. Definition at line 124 of file PsController.cxx. References _date, PsSimulatedObject::_objectHandle, _objectsNeedingActivationList, _pendingRegistrationRequests, _scheduler, _stepPeriod, _systemEventsList, map< PsName, PsnSignalDispatcher * >::begin(), map< PsName, PsnSignalDispatcher * >::end(), and purgeMemoryFromOldEvents(). { int i; int minor; if ( _scheduler != NULL ) { delete _scheduler ; _scheduler = NULL ; } // destruction of data structures related to event handling for(i=0;i<2;i++) { if ( _systemEventsList[i] != NULL ) delete _systemEventsList[i] ; if ( _objectsNeedingActivationList[i] != NULL) delete _objectsNeedingActivationList[i]; } purgeMemoryFromOldEvents ( _date + _stepPeriod ) ; // destruction of pending registrations for ( map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.begin() ; i != _pendingRegistrationRequests.end() ; ++i ) { // delete the signal dispatcher delete i->second ; // removal from the map omitted, because automatic at destruction of the data member } if ( _objectHandle != NULL ) delete _objectHandle ; }

---

Member Function Documentation

void PsController::actOnSystemEvent (  PsEvent *    event )  [virtual]

called when a reference object receives a system event Reimplemented in PsMomeController. Definition at line 1140 of file PsController.cxx. References _currentWritableSystemEventsList, _mutexSystemEventsList, _systemEventsList, PsEvent::clone(), PsSimulatedObject::getController(), PsSimulatedObject::getName(), PsEvent::insertInList(), PsnMutexLock::protect(), PsEvent::receiver, and PsnMutexLock::unprotect(). Referenced by PsMomeController::actOnSystemEvent(), and PsnReferenceObjectHandle::receiveEvent(). { //do not send a copy of a system event to oneself (avoids redundancy), except if the controller is being controlled if (event->receiver != getName() ) { _mutexSystemEventsList.protect() ; PsEvent::insertInList ( _systemEventsList[ _currentWritableSystemEventsList ], event->clone() ); _mutexSystemEventsList.unprotect() ; } else if (this != & getController() ) { //the controller is being controlled : send a copy of the event to the controllers controller getController().actOnSystemEvent ( event ) ; } }

void PsController::addToPendingEvents (  PsEvent *    )  [virtual]

adds the event to the list of pending events. Responsability for memory occupied by the event is transfered to the controller. Definition at line 784 of file PsController.cxx. References _mutexPendingDataStructures, _pendingEventsList, AllWarnings, map< PsName, list< PsEvent * > >::end(), map< PsName, list< PsEvent * > >::find(), map< PsName, list< PsEvent * > >::insert(), PsnMutexLock::protect(), PsEvent::receiver, PsnMutexLock::unprotect(), and warning(). Referenced by PsSimulatedObject::sendEvent(), and PsSimulatedObject::sendValuedEvent(). { if (event != NULL) { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"PsController::addToPendingEvents : Adding "<<*event<<" to pending events" <<" of yet unexisting object: "<<event->receiver<<endl; warning ( warningMessage.str() , AllWarnings ) ; #else ostrstream warningMessage ; warningMessage<<"PsController::addToPendingEvents : Adding "<<*event<<" to pending events" <<" of yet unexisting object: "<<event->receiver<<endl; warningMessage.put('\0') ; warning ( warningMessage.str() , AllWarnings ) ; delete warningMessage.str() ; #endif _mutexPendingDataStructures.protect() ; map<PsName, list <PsEvent *> >::iterator pendingEventsMapIterator = _pendingEventsList.find( event->receiver ) ; if ( pendingEventsMapIterator != _pendingEventsList.end() ) { pendingEventsMapIterator->second.push_back(event) ; } else { _pendingEventsList.insert (pair<PsName, list<PsEvent *> > (event->receiver, list<PsEvent *>(1,event) ) ) ; } _mutexPendingDataStructures.unprotect() ; } }

bool PsController::addToPendingRegistrations (  const PsEventIdentifier &    sig, const PsName &    producer, const PsEventIdentifier &    eventId, const PsName &    registrant )  [virtual]

addToPendingRegistrations. add a registration request for an object not created yet Parameters: sig  the signal to register for producer  the object producing the signal eventId  the event to send if producer fires signal registrant  the object registering for sig Returns: registration succeeded Definition at line 741 of file PsController.cxx. References _mutexPendingDataStructures, _pendingRegistrationRequests, map< PsName, PsnSignalDispatcher * >::end(), map< PsName, PsnSignalDispatcher * >::find(), pair< iterator, bool >::first, map< PsName, PsnSignalDispatcher * >::insert(), PsnMutexLock::protect(), and PsnMutexLock::unprotect(). Referenced by PsSimulatedObject::registerForSignalBy(). { _mutexPendingDataStructures.protect() ; map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.find (producer) ; if ( i == _pendingRegistrationRequests.end() ) { i = _pendingRegistrationRequests.insert ( pair <PsName,PsnSignalDispatcher *> (producer, new PsnSignalDispatcher(*this) ) ).first ; } i->second->registerForSignal( sig, registrant, eventId ) ; _mutexPendingDataStructures.unprotect() ; return true ; }

void PsController::advanceSimulatedDate (    )  [protected, virtual]

increment date and numberOfSimulatedSteps Reimplemented in PsBenchController< BenchedController >, PsPvmController, PsBenchController< PsMultiThreadedPvmController >, PsBenchController< PsMultiThreadedController >, and PsBenchController< APvmController >. Definition at line 579 of file PsController.cxx. References _date, _numberOfSimulatedSteps, and _stepPeriod. Referenced by compute(), and init(). { _numberOfSimulatedSteps++; _date = _date + _stepPeriod; if (_showDateAndStepNumber) { cout<< "Controller starting simulation step number : "<< _numberOfSimulatedSteps << " with date being "<<_date<<endl; } }

void PsController::broadcastEventsForSignal (  PsEvent &    event, const PsEventIdentifier &    sigId )  [virtual]

broadcast events corresponding to a fired signal Parameters: sigId  the signal fired event  the event prototype to send to registered objects Reimplemented in PsDistributedController. Definition at line 1579 of file PsController.cxx. References _controledObjectsSignalsDispatcher, and PsnSignalDispatcher::sendEventsForSignal(). Referenced by PsDistributedController::broadcastEventsForSignal(), PsSimulatedObject::fireSignal(), PsSimulatedObject::fireValuedSignal(), and PsnReferenceObjectHandle::sendEventsForSignal(). { //cerr<<"PsController::broadcastEventsForSignal "<<sigId<<endl; _controledObjectsSignalsDispatcher.sendEventsForSignal( event , sigId ) ; }

void PsController::changeObjectsFather (  PsObjectDescriptor *    object, PsObjectDescriptor *    newFather )  [virtual]

Change the father of an object in the simulation tree. effective change at the next simulation step, but doesn't affect the scheduling data structures Parameters: object  : the object which is changing father newfather  : the new father of the object Definition at line 687 of file PsController.cxx. References PsObjectDescriptor::setFathersDescription(). { assert ( object != NULL ) ; assert ( newFather != NULL ) ; object->setFathersDescription( newFather ) ; }

void PsController::changeObjectsFather (  const PsName &    name, const PsName &    newFather )  [virtual]

Change the father of an object in the simulation tree. effective change at the next simulation step, but doesn't affect the scheduling data structures Parameters: name  : the object which is changing father newfather  : the new father of the object Definition at line 696 of file PsController.cxx. References _simulationTree, PsObjectDescriptor::findDescendantNamed(), PsObjectDescriptor::setFathersDescription(), SomeWarnings, and warning(). Referenced by processEvent(). { PsObjectDescriptor * object = _simulationTree.findDescendantNamed ( name ) ; if ( object != NULL ) { PsObjectDescriptor * father = _simulationTree.findDescendantNamed ( newFather ) ; if (father != NULL) { object->setFathersDescription( father ) ; } else { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"PsController::changeObjectsFather new father ("<<newFather <<") for object "<<name<<"doesn't exist"<<endl; warning (warningMessage.str(), SomeWarnings) ; #else ostrstream warningMessage ; warningMessage<<"PsController::changeObjectsFather new father ("<<newFather <<") for object "<<name<<"doesn't exist"<<endl; warningMessage.put('\0') ; warning (warningMessage.str(), SomeWarnings) ; delete warningMessage.str() ; #endif } } else { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"PsController::changeObjectsFather object "<<name<<"doesn't exist"<<endl; warning (warningMessage.str(), SomeWarnings) ; #else ostrstream warningMessage ; warningMessage<<"PsController::changeObjectsFather object "<<name<<"doesn't exist"<<endl; warningMessage.put ('\0') ; warning (warningMessage.str(), SomeWarnings) ; delete warningMessage.str() ; #endif } }

void PsController::compute (    )  [virtual]

compute : computes a new simulation step for all controlled objects, if the controller is in the running state, otherwise jsut react to system events sent to controlled objects Reimplemented from PsSimulatedObject. Reimplemented in PsPvmBenchController< APvmController >, PsReactGlobalController, PsRealTimeController, PsBenchController< BenchedController >, PsBenchController< PsMultiThreadedPvmController >, PsBenchController< PsMultiThreadedController >, PsBenchController< APvmController >, and PsPvmBenchController< PsMultiThreadedPvmController >. Definition at line 512 of file PsController.cxx. References advanceSimulatedDate(), computeNextSimulationStep(), getPurgeDate(), and purgeMemoryFromOldEvents(). Referenced by PsBenchController< BenchedController >::compute(). { computeNextSimulationStep(); purgeMemoryFromOldEvents ( getPurgeDate() ) ; advanceSimulatedDate(); }

PsFrequency PsController::computeAdequateFrequency (  const PsFrequency &    suggestedFrequency )  [virtual]

Compute an adequate Frequency for an object dynamically created Should be used to adapt the desired frequency when an simulated object is dynamically created so that the creation doesn't cause recomputation of the scheduling. the result is the closest frequency to suggestedFrequency that can be inserted into the scheduler without changing the scheduling data structures. If two frequencies are at the same distance to correct frequencies, the higher frequency will be chosen. note : this member function should be delegated to the scheduler Definition at line 379 of file PsController.cxx. References _nbStepsByCycle, _stepFrequency, list< T, Alloc >::begin(), list< T, Alloc >::end(), getCycleFrequency(), PsFrequency, and list< T, Alloc >::push_back(). Referenced by PsDistributedController::getPointerToSimulatedObjectNamed(), processNewObjectDeclaration(), reactToControlledObjectsSystemEvents(), and scheduleObject(). { PsFrequency result ; list <PsFrequency> listOfAvailableFrequencies ; // construct the list of frequencies that can be scheduled without changing the frame structure for ( int i = 1 ; i <= _nbStepsByCycle ; ++i ) { if ( _stepFrequency % i == 0 ) { listOfAvailableFrequencies.push_back(_stepFrequency / i ) ; } } // find the closest frequency in listOfAvailableFrequencies to suggestedFrequency list<PsFrequency>::const_iterator frequencyIterator = listOfAvailableFrequencies.begin() ; while ( frequencyIterator != listOfAvailableFrequencies.end() && ( suggestedFrequency <= *frequencyIterator ) ) { ++frequencyIterator ; } if (frequencyIterator == listOfAvailableFrequencies.end() ) { //the suggested frequency is < _cycleFrequency result = getCycleFrequency() ; //cannot schedule object slower than _cycleFrequency } else { if ( frequencyIterator == listOfAvailableFrequencies.begin() ) { // *(listOfAvailableFrequencies.begin()) == _stepFrequency < suggestedFrequency result = _stepFrequency ; //cannot scheduleObject faster the _stepFrequency } else { // *(frequencyIterator) < suggestedFrequency <= *(frequencyIterator--) PsFrequency lowerEstimate = *frequencyIterator ; -- frequencyIterator ; PsFrequency higherEstimate = *frequencyIterator ; // lowerEstimate < suggestedFrequency <= higherEstimate if ( (suggestedFrequency - lowerEstimate) < (higherEstimate - suggestedFrequency) ) { result = lowerEstimate ; } else { result = higherEstimate ; } } } return result ; }

void PsController::computeNextSimulationStep (    )  [protected, virtual]

compute the next simulation step Reimplemented in PsMomeController, PsMultiThreadedPvmController, PsPvmBenchController< APvmController >, PsPvmController, and PsPvmBenchController< PsMultiThreadedPvmController >. Definition at line 593 of file PsController.cxx. References _nbStepsByCycle, _numberOfSimulatedSteps, _scheduler, list< Type, allocator >::begin(), list< Type, allocator >::end(), PsString::getCString(), PsSimulatedObject::getName(), getPointerToSimulatedObjectNamed(), PsSimulatedObject::listDescendantsOfType(), processEventsOfSuspendedObjects(), reactToControlledObjectsSystemEvents(), PsnScheduler::runStep(), and TYPEINFO. Referenced by compute(), PsPvmBenchController< APvmController >::computeNextSimulationStep(), and PsMomeController::computeNextSimulationStep(). { #ifdef _DEBUGEXEC cerr<<"PsController::computeNextSimulationStep"<<endl; cerr<<"calling reactToControlledObjectsSystemEvents "; #endif reactToControlledObjectsSystemEvents () ; #ifdef _DEBUGEXEC cerr<<"done "<<endl; #endif _scheduler->runStep( (_numberOfSimulatedSteps - 1) % _nbStepsByCycle ) ; processEventsOfSuspendedObjects () ; #ifdef _VERIFCOHERANCE //fast coded trace generator for the default controller PsString nomFich("/tmp/simul.") ; nomFich<<date; ofstream fichier(nomFich.getCString()); assert ( fichier.good() ) ; processEventsOfSuspendedObjects () ; PsList<PsName> * maListe = listDescendantsOfType( TYPEINFO(PsSimulatedObject) ); PsList<PsName>::iterator i = maListe->begin(); for(;i!=maListe->end(); ++i) { try { fichier<<getPointerToSimulatedObjectNamed(*i)->getName()<<" "<<*getPointerToSimulatedObjectNamed(*i)<<";"<<endl; } catch (PsException e) { fichier<<";"<<endl; } } fichier<<"_____________"<<endl; fichier.close() ; delete maListe ; #endif #ifdef _DEBUGEXEC cerr<<"PsController::computeNextSimulationStep done"<<endl; #endif }

void PsController::computeScheduling (  bool    fromOriginal )  [protected, virtual]

compute the scheduling data strucures. Parameters: fromOriginal  boolean indiscating if the scheduling has to be computed from the original scheduling information or from the current scheduling information This member function is called when when the controller creates its data structures at creation an object with an inadequate frequency is created the new frequency of an object is incompatible with the current scheduling data structures at users demand (send MaskRecomputeScheduling to the controller), to recompute the data structures using the originaly specified frequencies (those existing in the object descriptors, and which could have changed since, or because objects have been deleted or moved inside the simulation tree causing the current data structures to be inefficient or inaccurate Definition at line 188 of file PsController.cxx. References _date, _nbStepsByCycle, _referenceObjectsMap, _scheduler, _simulationTree, _stepFrequency, _stepPeriod, list< T, Alloc >::begin(), createScheduler(), list< T, Alloc >::end(), list< T, Alloc >::erase(), PsSimulatedObject::fireSignal(), gcd(), getCycleFrequency(), PsObjectDescriptor::getDescendants(), PsObjectDescriptor::getFrequency(), PsSimulatedObject::getName(), PsNameToPointerMap< PsnReferenceObjectHandle >::getObjectOfIndex(), PsObjectDescriptor::getOriginalFrequency(), PsSystemEventIdentifier::MaskChangeObjectFrequency, PsSystemEventIdentifier::MaskControllerFrequencyChange, PsnReferenceObjectHandle::receiveEvent(), setCycleFrequency(), PsObjectDescriptor::setFrequency(), SomeWarnings, and warning(). Referenced by PsDistributedController::getPointerToSimulatedObjectNamed(), init(), processEvent(), processNewObjectDeclaration(), and reactToControlledObjectsSystemEvents(). { //cerr<<"PsController::computeScheduling at date "<<_date<<endl; list<PsObjectDescriptor * > objectDescriptorList ; int freq; _simulationTree.getDescendants( &objectDescriptorList ); list<PsObjectDescriptor * >::iterator i ; //remove objects with no frequency from the list i = objectDescriptorList.begin () ; while ( i != objectDescriptorList.end() ) { if ( fromOriginal ) { if ((*i)->getOriginalFrequency() == 0 ) { i = objectDescriptorList.erase ( i ) ; } else { ++i ; } } else { if ( (*i)->getFrequency() == 0 ) { i = objectDescriptorList.erase ( i ) ; } else { ++i ; } } } i = objectDescriptorList.begin () ; if ( i == objectDescriptorList.end() ) { //no objects need regular activation if ( fromOriginal ) { _stepFrequency = _simulationTree.getOriginalFrequency() ; } else { _stepFrequency = _simulationTree.getFrequency() ; } if ( _stepFrequency == 0 ) { warning ("Controller needs a frequency: assigning 1", SomeWarnings) ; _stepFrequency = 1 ; } setCycleFrequency(_stepFrequency) ; } else { //initialise the loop with coherant values if (fromOriginal) { setCycleFrequency ( (*i)->getOriginalFrequency() ) ; } else { setCycleFrequency ( (*i)->getFrequency() ) ; } _stepFrequency = 1 ; } while ( i != objectDescriptorList.end() ) { if (fromOriginal) { freq = (*i)->getOriginalFrequency() ; if ( freq != (*i)->getFrequency() ) //the objects frequency has changed previously, { //reset it: (*i)->setFrequency ( freq ) ; //send MaskChangeObjectFrequency to the object PsnReferenceObjectHandle * referenceObjectHandle = _referenceObjectsMap.getObjectOfIndex ((*i)->getName() ) ; if ( referenceObjectHandle != NULL ) { //use receive event is sub optimal, because MaskChangeObjectFrequency is a system event, thus implying a copy is sent back to the controller, whithout effect referenceObjectHandle->receiveEvent ( new PsValuedEvent<PsFrequency> (PsSystemEventIdentifier::MaskChangeObjectFrequency, _date, getName(), (*i)->getName(), (*i)->getFrequency() ) ); } } } else { freq = (*i)->getFrequency() ; } if (freq != 0) { setCycleFrequency ( gcd( freq, getCycleFrequency() ) ) ; _stepFrequency=(int)((freq*_stepFrequency)/gcd(freq,_stepFrequency)); //lcm(freq,_stepFrequency); } ++ i ; } assert ( _stepFrequency != 0 ) ; if ( _stepFrequency != _simulationTree.getFrequency() ) {//the controller has changed frequency _simulationTree.setFrequency( _stepFrequency ) ; fireSignal(PsSystemEventIdentifier::MaskControllerFrequencyChange) ; } _stepPeriod = int(1000./_stepFrequency); _nbStepsByCycle = _stepFrequency/getCycleFrequency() ; if ( _scheduler != NULL ) delete _scheduler ; _scheduler = createScheduler() ; }

void PsController::createControlledObjects (  const PsObjectDescriptor *    subTree )  [protected, virtual]

createControlledObjects create a reference object for all objects of a simulation tree Reimplemented in PsDistributedController, and PsMomeController. Definition at line 161 of file PsController.cxx. References createReferenceObject(), and PsObjectDescriptor::getSons(). Referenced by init(). { assert ( subTree != NULL ) ; //go through the simulation tree to find all objects that have to be created list<PsObjectDescriptor *>::const_iterator i = subTree->getSons()->begin() ; while ( i != subTree->getSons()->end() ) { assert ( *i != NULL ) ; #ifdef _DEBUGOBJECTCREATION cerr<<"Creating "<< (*i)->getName() << endl ; #endif //create the object createReferenceObject ( *i ) ; //create the subTree of that object createControlledObjects ( *i ) ; #ifdef _DEBUGOBJECTCREATION cerr<<"Created "<< (*i)->getName() << endl ; #endif ++i ; } }

template<typename Type> PsControlParameter<Type>* PsController::createControlParameter (  const PsName &    name, PsSimulatedObject &    owner, PsPolatorNT *    polator )  [inline]

create a control parameter Parameters: t  the type of the control parameter created name  the name of the control parameter created owner  the owner of the control parameter Returns: the requested control parameter Definition at line 652 of file PsController.h. References getKernelObjectFactory(), and getOutputHistorySize(). { return getKernelObjectFactory ()->template createControlParameter<Type>(name,owner,getOutputHistorySize(),polator);

PsSimulatedObject * PsController::createDescribedObject (  const PsObjectDescriptor *    description )  [protected]

createDescribedObject. create a simulated object coresponding to the descriptor given as parameter, and update the descriptor accordingly object created are to be associated to an objectHandle the have deletion responsability transfered to that objectHanle Definition at line 934 of file PsController.cxx. References PsObjectDescriptor::createDescribedObject(). Referenced by PsDistributedController::createDuplicatedObject(), PsDistributedController::createMirrorObject(), createReferenceObject(), and PsDistributedController::getPointerToSimulatedObjectNamed(). { PsSimulatedObject * obj = description->createDescribedObject() ; return obj; }

template<typename Type> PsInput<Type>* PsController::createInput (  const PsName &    name, PsSimulatedObject &    owner, bool    makeConnectable, int    requestedPrecisionLevel )  [inline]

create an input Parameters: t  the type of input created name  the name of the input created owner  the owner of the input requestedPrecisionLevel  the polation level that willl be used by that input Returns: the requested input Definition at line 586 of file PsController.h. References getKernelObjectFactory(). { return getKernelObjectFactory ()->template createInput<Type> (name,owner,makeConnectable,requestedPrecisionLevel);

template<typename Type> PsInputAlias<Type>* PsController::createInputAlias (  const PsName &    name, PsSimulatedObject &    owner, PsAbstractInput< Type > *    input, int    requestedPrecisionLevel )  [inline]

create an input alias Parameters: t  the type of input alias created name  the name of the input alias created owner  the owner of the input alias input  the aliased input requestedPrecisionLevel  the polation level that willl be used by that input alias Returns: the requested input Definition at line 669 of file PsController.h. References getKernelObjectFactory(). { return getKernelObjectFactory ()->template createInputAlias<Type>(name,owner,input,requestedPrecisionLevel);

void PsController::createObject (  const PsObjectDescriptor &    newObjectDescription, const PsName &    fathersName )  [virtual]

creation of an object unknown of in the simulation tree. this sends an appropriate valued event to the controller, which is interpreted at the next simulation step this interpretation will add the object in the simulation tree, and create it. The object will be inserted in the scheduling data structures with the specified frequency, wich could imply a call to computeScheduling (false) ( See also: computeScheduling). To avoid this, the frequency specified can be adapted to the actual run-time data structure using computeAdequateFrequency ( computeAdequateFrequency) Parameters: fathersName  the name of the father of the object in the simulation tree newObjectDescription  a description of the object to create Reimplemented in PsDistributedController. Definition at line 635 of file PsController.cxx. References PsSimulatedObject::getName(), getSimulatedDate(), PsSystemEventIdentifier::MaskNewObject, and PsSimulatedObject::sendEvent(). Referenced by PsDistributedController::createObject(). { PsValuedEvent<PsPair<PsObjectDescriptor,PsName> > creationEvent(PsSystemEventIdentifier::MaskNewObject, getSimulatedDate(), getName(), getName(), PsPair<PsObjectDescriptor,PsName>(newObjectDescription, fathersName) ); sendEvent (creationEvent) ; }

template<typename Type> PsOutput<Type>* PsController::createOutput (  const PsName &    name, PsSimulatedObject &    owner, PsPolatorNT *    polator )  [inline]

create an ouput Parameters: t  the type of the output created name  the name of the output created owner  the owner of the output polator  the associated polator Returns: the requested output Definition at line 637 of file PsController.h. References getKernelObjectFactory(), and getOutputHistorySize(). { return getKernelObjectFactory ()->template createOutput<Type>(name,owner,getOutputHistorySize(),polator);

template<typename Type> PsOutputAlias<Type>* PsController::createOutputAlias (  const PsName &    name, PsSimulatedObject &    owner, PsOutput< Type > *    output, PsPolatorNT *    polator )  [inline]

create an ouput alias Parameters: t  the type of the output alias created name  the name of the output alias created owner  the owner of the output alias output  the aliased output polator  the associated polator Returns: the requested output alias Definition at line 721 of file PsController.h. References getKernelObjectFactory(), and getOutputHistorySize(). { return getKernelObjectFactory ()->template createOutputAlias<Type>(name,owner,output,getOutputHistorySize(),polator);

PsnReferenceObjectHandle * PsController::createReferenceObject (  const PsObjectDescriptor *    idObjet )  [protected, virtual]

createReferenceObject. effective creation of a reference object Definition at line 964 of file PsController.cxx. References _referenceObjectsMap, PsNameToPointerMap< PsnReferenceObjectHandle >::addObjectWithIndex(), createDescribedObject(), createReferenceObjectHandle(), and PsObjectDescriptor::getName(). Referenced by PsDistributedController::createControlledObjects(), createControlledObjects(), and processNewObjectDeclaration(). { assert (objectDescription != NULL ); #ifdef _DEBUGOBJECTCREATION cerr<<"PsController::createReferenceObject "<<endl; #endif PsnReferenceObjectHandle * result = NULL ; PsSimulatedObject * createdObject = createDescribedObject ( objectDescription ) ; if (createdObject != NULL) { result = createReferenceObjectHandle (*createdObject); _referenceObjectsMap.addObjectWithIndex (objectDescription->getName(), result); } else { cerr<<"PsController::createReferenceObject unable to create"<<*objectDescription<<endl; } #ifdef _DEBUGOBJECTCREATION cerr<<"PsController::createReferenceObject ended"<<endl; #endif return result; }

PsnReferenceObjectHandle * PsController::createReferenceObjectHandle (  PsSimulatedObject &    obj )  [protected, virtual]

create a reference object handler appropriate for this controller Parameters: obj  the object to handle the reference object created Definition at line 1611 of file PsController.cxx. References _pendingRegistrationRequests, map< PsName, PsnSignalDispatcher * >::end(), map< PsName, PsnSignalDispatcher * >::erase(), map< PsName, PsnSignalDispatcher * >::find(), PsSimulatedObject::getName(), and newPsnReferenceObjectHandle(). Referenced by createReferenceObject(), and PsController(). { /* no mutex protection needed, because this member function is only called by the controller during system event processing */ #ifdef _DEBUGOBJECTCREATION cerr<<"PsController::createReferenceObjectHandle"<<endl; #endif PsnReferenceObjectHandle * result ; map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.find( obj.getName() ) ; if ( i == _pendingRegistrationRequests.end() ) { result = newPsnReferenceObjectHandle(obj,*this, new PsnSignalDispatcher (*this) ); } else { result = newPsnReferenceObjectHandle(obj,*this, i->second) ; _pendingRegistrationRequests.erase ( i ) ; } #ifdef _DEBUGOBJECTCREATION cerr<<"PsController::createReferenceObjectHandle ended"<<endl; #endif return result ; }

PsnScheduler * PsController::createScheduler (    )  [protected, virtual]

create the scheduler that is in charge of effective scheduling of the controlled objects Reimplemented in PsBenchController< BenchedController >, PsMomeMultiThreadedController, PsMultiThreadedBenchmarkingController, PsMultiThreadedController, PsMultiThreadedPvmBenchmarkingController, PsMultiThreadedPvmController, PsPvmBenchController< APvmController >, PsBenchController< BenchedController >, PsBenchController< PsMultiThreadedPvmController >, PsBenchController< PsMultiThreadedPvmController >, PsBenchController< PsMultiThreadedController >, PsBenchController< PsMultiThreadedController >, PsBenchController< APvmController >, PsBenchController< APvmController >, and PsPvmBenchController< PsMultiThreadedPvmController >. Definition at line 323 of file PsController.cxx. References _nbStepsByCycle. Referenced by computeScheduling(). { return new PsnFrameScheduler ( _nbStepsByCycle ) ; }

template<typename Type> PsSensitiveInput<Type>* PsController::createSensitiveInput (  const PsName &    name, PsSimulatedObject &    owner, bool    makeConnectable, int    requestedPrecisionLevel )  [inline]

create a sensitive input Parameters: t  the type of sensitive input created name  the name of the sensitive input created owner  the owner of the sensitive input requestedPrecisionLevel  the polation level that willl be used by that input Returns: the requested sensitive input Definition at line 603 of file PsController.h. References getKernelObjectFactory(). { return getKernelObjectFactory ()->template createSensitiveInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel);

template<typename Type> PsSensitiveInputAlias<Type>* PsController::createSensitiveInputAlias (  const PsName &    name, PsSimulatedObject &    owner, PsAbstractInput< Type > *    input, int    requestedPrecisionLevel )  [inline]

create a sensitive input alias Parameters: t  the type of sensitive input alias created name  the name of the sensitive input alias created owner  the owner of the sensitive input alias input  the aliased input requestedPrecisionLevel  the polation level that willl be used by that sensitive input alias Returns: the requested sensitive input Definition at line 687 of file PsController.h. References getKernelObjectFactory(). { return getKernelObjectFactory ()->template createSensitiveInputAlias<Type>(name,owner,input,requestedPrecisionLevel);

template<typename Type> PsSensitiveNotifyingInput<Type>* PsController::createSensitiveNotifyingInput (  const PsName &    name, PsSimulatedObject &    owner, bool    makeConnectable, int    requestedPrecisionLevel )  [inline]

create a sensitive notifying input Parameters: t  the type of sensitive notifying input created name  the name of the sensitive notifying input created owner  the owner of the sensitive notifying input requestedPrecisionLevel  the polation level that willl be used by that sensitive notifying input Returns: the requested sensitive notifying input Definition at line 620 of file PsController.h. References getKernelObjectFactory(). { return getKernelObjectFactory ()->template createSensitiveNotifyingInput<Type>(name,owner,makeConnectable,requestedPrecisionLevel);

template<typename Type> PsSensitiveNotifyingInputAlias<Type>* PsController::createSensitiveNotifyingInputAlias (  const PsName &    name, PsSimulatedObject &    owner, PsAbstractInput< Type > *    input, int    requestedPrecisionLevel )  [inline]

create a sensitive notifying input alias Parameters: t  the type of sensitive notifying input alias created name  the name of the sensitive notifying input alias created owner  the owner of the sensitive notifying input alias input  the aliased input requestedPrecisionLevel  the polation level that willl be used by that sensitive notifying input alias Returns: the requested sensitive notifying input Definition at line 704 of file PsController.h. References getKernelObjectFactory(). { return getKernelObjectFactory ()->template createSensitiveNotifyingInputAlias<Type>(name,owner,input,requestedPrecisionLevel);

void PsController::deleteObject (  PsObjectDescriptor *    objectDescription )  [protected, virtual]

delete an object. This member function performs destruction when MaskDelete is received for that object by doing the following removes all reference to that object from the controller's data structures deletes the object handle, thus delete the simulated object deletes the object descriptor Definition at line 904 of file PsController.cxx. References _date, _deletedObjectHandles, PsObjectDescriptor::getFathersObjectDescriptor(), PsObjectDescriptor::getName(), PsSimulatedObject::getObjectDescriptor(), make_pair(), list< pair< PsDate, PsnObjectHandle * > >::push_back(), removeObjectFromDataStructures(), and PsObjectDescriptor::removeSon(). Referenced by processDeleteEventOf(), and PsDistributedController::processEvent(). { #ifdef _DEBUGEXEC cerr <<"PsController::deleteObject "<<objectDescriptor->getName()<<endl; #endif if (objectDescriptor != &getObjectDescriptor() ) //shouldn't delete oneself ! { assert ( objectDescriptor != NULL) ; // remove from the kernel's data structures PsnObjectHandle * toDelete = removeObjectFromDataStructures( objectDescriptor->getName() ) ; //remove the object descriptor from the simulation tree if ( objectDescriptor->getFathersObjectDescriptor() != objectDescriptor ) { objectDescriptor->getFathersObjectDescriptor()->removeSon ( objectDescriptor ) ; } if ( toDelete != NULL ) { //put the object handle in the list of object to be deleted _deletedObjectHandles.push_back ( make_pair ( _date, toDelete) ) ; } } }

void PsController::deleteObjectHandle (  PsnObjectHandle *    objectHandle )  [protected, virtual]

as the controller is an abstract factory for object handlers, is should also be an abstract destroyer Reimplemented in PsDistributedController. Definition at line 885 of file PsController.cxx. References PsObjectDescriptor::_pointerToSimulatedObject, PsObjectDescriptor::getName(), PsSimulatedObject::getObjectDescriptor(), and PsnObjectHandle::getSimulatedObject(). Referenced by purgeMemoryFromOldEvents(). { PsObjectDescriptor * objectDescriptor = const_cast<PsObjectDescriptor *>(& objectHandle->getSimulatedObject().getObjectDescriptor() ) ; delete objectHandle ; //The object description is referenced by the simulation tree and the simulated object //delete the object description only if it isn't referenced by its simulated object if ( objectDescriptor->_pointerToSimulatedObject == NULL ) { #ifdef _DEBUGEXEC cerr<<"PsController::deleteObject: deleting object descriptor of object "<<objectDescriptor->getName()<<endl; #endif delete objectDescriptor; } }

void PsController::destroyObject (  const PsName &    name, bool    recursively )  [virtual]

Destroy a simulated object. Delete any data structure related to the specified object, including its description in the simulation tree. Sends MaskStop then MaskDelete to the object, and optionnaly recursively to the sons of the object effective destruction takes place at the next simulation step Parameters: name  : the name of the object to destroy recursive  : destroy recursively the sons in the simulation of the specified object Definition at line 648 of file PsController.cxx. References _simulationTree, PsObjectDescriptor::findDescendantNamed(), PsName::getNameServer(), PsObjectDescriptor::getSons(), PsSystemEventIdentifier::MaskDelete, PsSystemEventIdentifier::MaskStop, PsNameServer::printToStream(), PsSimulatedObject::sendEvent(), SomeWarnings, and warning(). Referenced by finish(). { PsObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed ( name ) ; if( objectDescriptor != NULL ) { if ( recursively ) { for ( PsObjectDescriptor::SonsContainerType::iterator i = objectDescriptor->getSons().begin() ; i != objectDescriptor->getSons().end() ; ++i ) { assert ( (*i) != NULL ) ; destroyObject ( (*i)->getName() ,true ) ; } } sendEvent(name, PsSystemEventIdentifier::MaskStop); sendEvent(name, PsSystemEventIdentifier::MaskDelete); } else { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"PsController::destroyObject "<<name<<" not found"<<endl; PsName::getNameServer()->printToStream(warningMessage,"\n") ; warning (warningMessage.str(), SomeWarnings) ; #else ostrstream warningMessage ; warningMessage<<"PsController::destroyObject "<<name<<" not found"<<endl; PsName::getNameServer()->printToStream(warningMessage,"\n") ; warningMessage.put ('\0') ; warning (warningMessage.str(), SomeWarnings) ; delete warningMessage.str() ; #endif } }

void PsController::error (  const char *    mess )  [static]

included for ascendant compatibility : raises a PsUserException with the message passed as parameter Parameters: errorMessage  the message associated to the user exception Definition at line 1113 of file PsController.cxx. Referenced by PsSimulatedObject::addInputAlias(), PsSimulatedObject::addOutputAlias(), PsSimulatedObject::addSensitiveInputAlias(), PsSimulatedObject::addSensitiveNotifyingInputAlias(), PsnMultiThreadedAsynchronousScheduler::addToScheduable(), PsString::alloue(), PsKernelObjectAbstractFactory::createControlParameter(), PsKernelObjectAbstractFactory::createInput(), PsKernelObjectAbstractFactory::createInputAlias(), PsKernelObjectAbstractFactory::createOutput(), PsKernelObjectAbstractFactory::createOutputAlias(), PsKernelObjectAbstractFactory::createSensitiveInput(), PsKernelObjectAbstractFactory::createSensitiveInputAlias(), PsKernelObjectAbstractFactory::createSensitiveNotifyingInput(), PsKernelObjectAbstractFactory::createSensitiveNotifyingInputAlias(), error(), getPointerToDuplicatedObjectNamed(), PsnReferenceObjectHandle::insertInStream(), PsnPvmReferenceObjectHandle::insertInStream(), PsString::operator++(), PsString::operator[](), PsnSequentialSemaphore::P(), PsnMutexLock::protect(), PsMomeOutput< Type >::PsMomeOutput(), PsnCondition::PsnCondition(), PsnMultiThreadedBenchedScheduler::PsnMultiThreadedBenchedScheduler(), PsnMultiThreadedBenchmarkingScheduler::PsnMultiThreadedBenchmarkingScheduler(), PsnMultiThreadedScheduler::PsnMultiThreadedScheduler(), PsnMutexLock::PsnMutexLock(), PsString::PsString(), PsnCondition::signalChange(), PsnMutexLock::unprotect(), PsnCondition::waitForChange(), and PsnMutexLock::~PsnMutexLock(). { throw PsUserException(Errormess) ; }

void PsController::finish (    )  [virtual]

finish the simulation. called when MaskStop is received by the controller Reimplemented from PsSimulatedObject. Reimplemented in PsPvmController. Definition at line 108 of file PsController.cxx. References _simulationTree, destroyObject(), and PsObjectDescriptor::getSons(). Referenced by processEvent(), and reactToControlledObjectsSystemEvents(). { #ifdef _DEBUGEXEC cerr<<"PsController::finish()"<<endl; #endif //call destroyObject on all the sons for ( PsObjectDescriptor::SonsContainerType::iterator i = _simulationTree.getSons().begin() ; i != _simulationTree.getSons().end() ; ++i ) { assert ( (*i) != NULL ) ; destroyObject ( (*i)->getName() ,true ) ; } }

int PsController::gcd (  const int    a, const int    b )  [static]

Definition at line 1096 of file PsController.cxx. Referenced by computeScheduling(), and lcm(). { int res = a ; if (b != 0) { res = gcd (b, a % b) ; } return res ; }

int PsController::getCycleFrequency (    )  const [virtual]

get the simulation cycle frequency Definition at line 1079 of file PsController.cxx. References _cycleFrequency. Referenced by computeAdequateFrequency(), computeScheduling(), and init(). { return _cycleFrequency ; }

int PsController::getCyclePeriod (    )  const [virtual]

get the simulation cycle period, in simulated time (in ms) Definition at line 1085 of file PsController.cxx. References _cyclePeriod. Referenced by PsnMirrorObjectHandle::unpack(). { return _cyclePeriod ; }

PsKernelObjectAbstractFactory * PsController::getKernelObjectFactory (    )  [static]

get the active kernelObjectFactory Definition at line 57 of file PsController.cxx. References kernelObjectFactory. Referenced by createControlParameter(), createInput(), createInputAlias(), createOutput(), createOutputAlias(), createSensitiveInput(), createSensitiveInputAlias(), createSensitiveNotifyingInput(), and createSensitiveNotifyingInputAlias(). { if ( kernelObjectFactory == NULL ) { kernelObjectFactory = new PsKernelObjectClassicFactory () ; } return kernelObjectFactory ; }

const PsObjectDescriptor & PsController::getObjectDescriptorOfObject (  const PsName &    objectName )  [virtual]

get the object descriptor of a given simulated object Parameters: objectName  the name of the given object Returns: the PsObjectDescriptor corresponding to that object throw a UserException if a descriptor corresponding to name doesn't exist Definition at line 1039 of file PsController.cxx. References _deletedObjectHandles, _simulationTree, list< pair< PsDate, PsnObjectHandle * > >::begin(), list< pair< PsDate, PsnObjectHandle * > >::end(), and PsObjectDescriptor::findDescendantNamed(). { if (_simulationTree.findDescendantNamed(objectName) != NULL ) { return *(_simulationTree.findDescendantNamed(objectName)); } else { //the object might have just been deleted : look for it in _deletedObjectHandles list <pair <PsDate, PsnObjectHandle *> >::iterator i = _deletedObjectHandles.begin() ; while ( i != _deletedObjectHandles.end() ) { if (i->second->getSimulatedObject().getName() == objectName ) { return i->second->getSimulatedObject().getObjectDescriptor() ; } ++i ; } PsUserException e("UnknownObject :") ; e<<objectName ; throw e ; } }

int PsController::getOutputHistorySize (  void    )  [protected, virtual]

get the minimum history length pertinant for this controller The value returned is the value of the environement variable MaskHISTORYLENGTH, or a default value calculated so that get(-4 dt) return an exact value if it has been produced Reimplemented in PsMomeController, and PsPvmController. Definition at line 1560 of file PsController.cxx. References _nbStepsByCycle. Referenced by createControlParameter(), createOutput(), createOutputAlias(), and PsMomeController::getOutputHistorySize(). { // each output keeps an history to enable polations // _nbStepsByCycle * 4 --> the minimum history lenght for the default max extrapolation to work // + 1 because of uncertainty about relative order of simulated object activation int result ; char * environementValue = getenv("MaskHISTORYLENGTH"); if (environementValue == NULL ) { result = _nbStepsByCycle*4+1 ; } else { result = atoi (environementValue) ; } return result ; }

PsDuplicatedObject * PsController::getPointerToDuplicatedObjectNamed (  const PsName &    name )  [virtual]

get a pointer to a simulated object Parameters: name  the name of the object Returns: a pointer to a simulated object corresponding to the description given in the simulation tree, NULL if object isn't described Definition at line 993 of file PsController.cxx. References _referenceObjectsMap, error(), PsString::getCString(), PsNameToPointerMap< PsnReferenceObjectHandle >::getObjectOfIndex(), and getPointerToSimulatedObjectNamed(). { PsString messErreur="PsController::getPointerToDuplicatedObjectNamed "; PsSimulatedObject * resultatPossible; PsDuplicatedObject * resul; //Soit l'objet est déjà un référentiel, soit il faut en faire un référentiel resultatPossible=getPointerToSimulatedObjectNamed(nom); if (resultatPossible==NULL) { PsnReferenceObjectHandle * refe = _referenceObjectsMap.getObjectOfIndex(nom); if (refe==NULL) { messErreur=messErreur+"\n Pas d'objet "+nom+" dans le processus"; PsController::error(messErreur.getCString()); } } else { resul=dynamic_cast<PsDuplicatedObject *>(resultatPossible); if (resul==NULL) { messErreur=messErreur+": Impossible d'obtenir un pointeur sur l'objet : "; messErreur=messErreur+nom+": Ce n'est pas un objet duplicable"; PsController::error(messErreur.getCString()); } } return resul; }

PsSimulatedObject * PsController::getPointerToSimulatedObjectNamed (  const PsName &    name )  [virtual]

get a pointer to a simulated object after return from this method, it's possible to querry any method of the simulated object that doesn't depend on the evolution of that object, as the object returned can have been created specially by the call. of course, querrying the interface of that object (outputs control parameters and event listeners should yield a correct result after a least one simulation step Parameters: name  the name of the object Returns: a pointer to a simulated object corresponding to the description given in the simulation tree, NULL if object isn't described Reimplemented in PsDistributedController, PsMultiThreadedPvmController, and PsReactController. Definition at line 1019 of file PsController.cxx. References _referenceObjectsMap, PsSimulatedObject::getName(), PsNameToPointerMap< PsnReferenceObjectHandle >::getObjectOfIndex(), and PsnObjectHandle::getSimulatedObject(). Referenced by PsSimulatedObject::addInputAlias(), PsSimulatedObject::addOutputAlias(), PsSimulatedObject::addSensitiveInputAlias(), PsSimulatedObject::addSensitiveNotifyingInputAlias(), PsSimulatedObject::cancelRegistrationForSignalBy(), computeNextSimulationStep(), PsOutputNT::connect(), PsInput< Type >::connect(), PsInput< Type >::connectToControlParameter(), PsSimulatedObject::getFather(), getPointerToDuplicatedObjectNamed(), reactToControlledObjectsSystemEvents(), PsSimulatedObject::registerForSignalBy(), PsSimulatedObject::sendEvent(), PsnSignalDispatcher::sendEventsForSignal(), and PsSimulatedObject::sendValuedEvent(). { PsSimulatedObject * resul; //Soit l'objet est déjà un référentiel, soit il faut en faire un référentiel PsnReferenceObjectHandle * refe = _referenceObjectsMap.getObjectOfIndex(nom); if (refe==NULL) { if ( nom == getName() ) { resul = this ; } else { resul = NULL; } } else { resul=&refe->getSimulatedObject(); } return resul; }

PsDate PsController::getPurgeDate (    )  [protected, virtual]

get the date of the oldest event not purged by purgeMemoryFromOldEvents Reimplemented in PsPvmController. Definition at line 521 of file PsController.cxx. References _date, _stepPeriod, and PsDate. Referenced by compute(). { return _date - _stepPeriod ; }

PsMultipleConfigurationParameter * PsController::getSchedulingParametersOfObject (  PsObjectDescriptor &    )  [protected]

get a modifiable version of the scheduling parameters of an object. defined here for use by derived controllers Definition at line 1642 of file PsController.cxx. References PsObjectDescriptor::getSchedulingParameters(). { return objectDescription.getSchedulingParameters () ; }

const PsDate & PsController::getSimulatedDate (    )  const [virtual]

returns a reference to an allways accurate simulation date, in ms Reimplemented from PsSimulatedObject. Definition at line 1068 of file PsController.cxx. References _date. Referenced by PsnReferenceObjectHandle::compute(), createObject(), PsSimulatedObject::getSimulatedDate(), PsCalculus::getSimulatedDate(), PsOutput< Type >::localGet(), PsnReferenceObjectHandle::processEvents(), PsSimulatedObject::sendEvent(), PsnMirrorObjectHandle::sendRequestToReferenceObject(), PsSimulatedObject::sendValuedEvent(), PsOutput< Type >::suggest(), PsnSvm::synchroniseReceiveAndProcessMessages(), and PsnMirrorObjectHandle::unpack(). { return _date; }

void PsController::hasEventsToProcess (  PsnReferenceObjectHandle *    referenceObjectHandle )  [virtual]

Add the object handled by referenceObjectHandle to the list of objects having events to process and therefore that need activation (and therefore possibly activated at the current simulation step). Behaviour is unspecified if the referenceObject is in running state Parameters: referenceObjectHandle  objectHandle added Definition at line 1487 of file PsController.cxx. References _currentListOfObjectsNeedingActivation, _date, PsnReferenceObjectHandle::_isInObjectNeedingActivationList, PsSimulatedObject::_objectHandle, _objectsNeedingActivationList, _stepPeriod, PsSimulatedObject::getController(), PsSimulatedObject::getName(), and PsnObjectHandle::getSimulatedObject(). Referenced by processEventsOfSuspendedObjects(), reactToControlledObjectsSystemEvents(), and PsnReferenceObjectHandle::receiveEvent(). { // the object handle should be correct (because this member function is called by it) assert ( dynamic_cast<PsnReferenceObjectHandle *>(_objectHandle) != NULL ) ; //the controller shouldn't try and schedule itself if it isn't controlled if (refObjet != _objectHandle) { if (!refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ]) { #ifdef _DEBUGEVT cerr<<"PsController::hasEventsToProcess of " << refObjet->getSimulatedObject().getName() << " at date "<< _date + _stepPeriod << endl; #endif _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->push_back ( refObjet ); refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ] = true ; } #ifdef _DEBUGEVT else { cerr<< "PsController::hasEventsToProcess of " << refObjet->getSimulatedObject().getName() << " at date "<< _date + _stepPeriod << " not necessary "<< endl; } #endif } else if ( & getController() != this ) { getController().hasEventsToProcess( refObjet ) ; } }

void PsController::init (    )  [virtual]

initialise the object. Use this member function for any initilisation than can only be done when all the simulated objects have been created. In particular, plugging the input of the objects should be done here. By default, this member function calls the initialisation of the associated computational object. Reimplemented from PsSimulatedObject. Reimplemented in PsnGuiController, PsMomeController, PsPvmController, PsReactController, PsReactGlobalController, PsBenchController< BenchedController >, PsBenchController< PsMultiThreadedPvmController >, PsBenchController< PsMultiThreadedController >, and PsBenchController< APvmController >. Definition at line 433 of file PsController.cxx. References _date, _referenceObjectsMap, _simulationTree, _stepFrequency, _stepPeriod, PsNameToPointerMap< PsnReferenceObjectHandle >::addObjectWithIndex(), advanceSimulatedDate(), AllWarnings, map< PsName, PsnReferenceObjectHandle * >::begin(), computeScheduling(), createControlledObjects(), map< PsName, PsnReferenceObjectHandle * >::end(), getCycleFrequency(), PsSimulatedObject::getName(), PsSimulatedObject::getObjectHandle(), initialSimulationDate, scheduleControlledObjects(), sendInitialEventsTo(), and warning(). Referenced by PsBenchController< BenchedController >::init(), PsMomeController::init(), openMaskMain(), processEvent(), and PsMultiThreadedController::run(). { PsNameToPointerMap<PsnReferenceObjectHandle>::iterator pTab; computeScheduling(true) ; #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage << "PsController::init : controler's cycle frequency : " << getCycleFrequency() <<" Hz"<< endl ; warningMessage << "PsController::init : controler's step frequency : " << _stepFrequency <<" Hz"<< endl ; warning ( warningMessage.str() , AllWarnings ) ; #else ostrstream warningMessage ; warningMessage << "PsController::init : controler's cycle frequency : " << getCycleFrequency() <<" Hz"<< endl ; warningMessage << "PsController::init : controler's step frequency : " << _stepFrequency <<" Hz"<< endl ; warningMessage.put('\0'); warning ( warningMessage.str() , AllWarnings ) ; delete warningMessage.str() ; #endif createControlledObjects ( &_simulationTree ) ; scheduleControlledObjects() ; _referenceObjectsMap.addObjectWithIndex (getName(), (PsnReferenceObjectHandle *)getObjectHandle()); PsNameToPointerMap<PsInputNT>::iterator i; //pretend init order was sent just before initialsimulationDate _date = PsController::initialSimulationDate - _stepPeriod ; //all initial simulation objects are started for ( pTab = _referenceObjectsMap.begin(); pTab != _referenceObjectsMap.end(); pTab++ ) { sendInitialEventsTo ( *(*pTab).second, _date ) ; } advanceSimulatedDate() ; //only if initialisation happens at a different simulation date than the first simulation step //reactToControlledObjectsSystemEvents(); }

int PsController::lcm (  const int    a, const int    b )  [static]

Definition at line 1092 of file PsController.cxx. References gcd(). Referenced by PsnProcess::PsnProcess(). { return (a * b / gcd (a, b)) ; }

template<typename Type> list<const PsObjectDescriptor * >* PsController::listBrothersOfType (  const PsName    objectName )  [inline]

list brothers of objectName in the simulation tree of that are of type t Parameters: objectName  : name of the brother Returns: a list of the brothers of objectName that are of the type of the template parameter. The resulting list should be destroyed after usage Definition at line 93 of file PsController.h. { const PsObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ; if ( objectDescriptor != NULL ) { objectDescriptor = objectDescriptor->getFathersDescriptor() ; if ( objectDescriptor != NULL ) { return objectDescriptor->template listBrothersOfType<Type> () ; } else { return new list<const PsObjectDescriptor *>() ; } } else { return new list<const PsObjectDescriptor *>() ; }

template<typename Type> list<const PsObjectDescriptor *>* PsController::listDescendantsOfType (  const PsName &    objectName )  [inline]

List the descendants of an object that are of a certain type. Parameters: objectName  : the ancestor object Returns: a list of the descendants of objectName that are of the type of the template parameter. The resulting list should be destroyed after usage Definition at line 76 of file PsController.h. { const PsObjectDescriptor * objectDescriptor = getObjectDescriptor ().findDescendantNamed ( objectName ) ; if ( objectDescriptor != NULL ) { return objectDescriptor->template listDescendantsOfType<Type> () ; } else { return new list<const PsObjectDescriptor *>() ; }

PsnReferenceObjectHandle * PsController::newPsnReferenceObjectHandle (  PsSimulatedObject &    object, PsController &    controller, PsnSignalDispatcher *    signalDispatcher )  [protected, virtual]

The controller is an abstract factory for reference object handles. Parameters: obj  the object to handle controller  the controller of that object the  signal dispatche used by that object the reference object created Reimplemented in PsMomeController, and PsPvmController. Definition at line 1602 of file PsController.cxx. Referenced by createReferenceObjectHandle(). { return new PsnReferenceObjectHandle(object, controller, signalDispatcher) ; }

void PsController::noActivationNeededFor (  PsnReferenceObjectHandle *    referenceObjectHandle )  [virtual]

removes object designated by referenceObjectHandle from the list of object needing activation by the controler because they have events pending. removal should occur if the reference object is becomming active Parameters: referenceObjectHandle  : reference handle of object wich doesn't need acivation any more. Definition at line 1481 of file PsController.cxx. References _currentListOfObjectsNeedingActivation, PsnReferenceObjectHandle::_isInObjectNeedingActivationList, and _objectsNeedingActivationList. Referenced by processStartEventOf(), and reactToControlledObjectsSystemEvents(). { _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->remove( refObjet ); refObjet->_isInObjectNeedingActivationList[ _currentListOfObjectsNeedingActivation ] = false ; assert ( refObjet->_isInObjectNeedingActivationList[ 1 - _currentListOfObjectsNeedingActivation ] == false ); }

void PsController::postponeEventProcessing (  PsnReferenceObjectHandle *    referenceObjectHandle )  [virtual]

adds the object described by referenceObjectHandle to the list of object with events to process at the next simulaion step. Definition at line 1519 of file PsController.cxx. References _listOfObjectsWithPostPonedEvents, and list< PsnReferenceObjectHandle * >::push_back(). Referenced by PsnReferenceObjectHandle::processEvents(). { _listOfObjectsWithPostPonedEvents.push_back(refObjet) ; }

void PsController::processDeleteEventOf (  PsnReferenceObjectHandle *    objectHandle )  [virtual]

process MaskDelete systemEvent for object obj Definition at line 1309 of file PsController.cxx. References deleteObject(), PsnReferenceObjectHandle::destroyed, PsSimulatedObject::fireValuedSignal(), PsnReferenceObjectHandle::getComputingState(), PsObjectDescriptor::getName(), PsSimulatedObject::getName(), PsSimulatedObject::getObjectDescriptor(), PsnObjectHandle::getSimulatedObject(), PsSystemEventIdentifier::MaskObjectDestroyed, setComputingState(), and PsnReferenceObjectHandle::stopped. Referenced by reactToControlledObjectsSystemEvents(). { #ifdef _DEBUGEXEC cerr<<" PsController::processDeleteEventOf() "<<objectHandle->getSimulatedObject().getName()<<endl; #endif if(objectHandle->getComputingState() == PsnReferenceObjectHandle::stopped) { fireValuedSignal( PsSystemEventIdentifier::MaskObjectDestroyed, objectHandle->getSimulatedObject().getObjectDescriptor().getName() ) ; setComputingState ( objectHandle, PsnReferenceObjectHandle::destroyed ); deleteObject(const_cast<PsObjectDescriptor *>(&objectHandle->getSimulatedObject().getObjectDescriptor()) ); } }

bool PsController::processEvent (  PsEvent *    )  [virtual]

process events sent to the controller Reimplemented from PsSimulatedObject. Reimplemented in PsDistributedController. Definition at line 1157 of file PsController.cxx. References _computeStatePointer, _forcedCompute, _simulationTree, AllWarnings, changeObjectsFather(), computeScheduling(), PsEvent::date, PsnReferenceObjectHandle::destroyed, PsEvent::eventId, PsObjectDescriptor::findDescendantNamed(), finish(), PsSimulatedObject::fireValuedSignal(), PsSimulatedObject::getName(), PsObjectDescriptor::getName(), init(), PsnReferenceObjectHandle::initial, PsSystemEventIdentifier::MaskDelete, PsSystemEventIdentifier::MaskNewObject, PsSystemEventIdentifier::MaskObjectCreated, PsSystemEventIdentifier::MaskRecomputeScheduling, PsSystemEventIdentifier::MaskRestart, PsSystemEventIdentifier::MaskResume, PsSystemEventIdentifier::MaskStart, PsSystemEventIdentifier::MaskStop, PsSystemEventIdentifier::MaskSuspend, processNewObjectDeclaration(), PsnReferenceObjectHandle::running, scheduleControlledObjects(), SomeWarnings, PsnReferenceObjectHandle::stopped, PsnReferenceObjectHandle::suspended, PsValuedEvent< UserType >::value, and warning(). Referenced by PsDistributedController::processEvent(). { const PsEventIdentifier & eventId ( event->eventId ) ; if (eventId == PsSystemEventIdentifier::MaskRestart) { if (*_computeStatePointer == PsnReferenceObjectHandle::stopped) { *_computeStatePointer = PsnReferenceObjectHandle::initial ; //implementation very difficult, because the original simulation tree has been modified init() ; assert (false) ; } else { warning(" PsController::processEvent should be stopped before restarted", AllWarnings); } } else if ( eventId == PsSystemEventIdentifier::MaskResume ) { *_computeStatePointer = PsnReferenceObjectHandle::running; } else if ( eventId == PsSystemEventIdentifier::MaskSuspend ) { if (*_computeStatePointer != PsnReferenceObjectHandle::suspended ) { // moving in suspended mode // stop computations, even forced _forcedCompute = false ; *_computeStatePointer = PsnReferenceObjectHandle::suspended ; } } else if ( eventId == PsSystemEventIdentifier::MaskStop ) { if (*_computeStatePointer != PsnReferenceObjectHandle::stopped ) { *_computeStatePointer=PsnReferenceObjectHandle::stopped ; finish() ; } } else if ( eventId == PsSystemEventIdentifier::MaskStart ) { *_computeStatePointer=PsnReferenceObjectHandle::running; //this produces incorrect behaviour from the point of view of an object controlling the controller //if(_date==PsController::initialSimulationDate) advanceSimulatedDate(); } else if (eventId == PsSystemEventIdentifier::MaskDelete ) { *_computeStatePointer=PsnReferenceObjectHandle::destroyed; } else if ( eventId == PsSystemEventIdentifier::MaskNewObject ) { PsValuedEvent <PsPair <PsObjectDescriptor,PsName> > * creationEvent = dynamic_cast<PsValuedEvent <PsPair <PsObjectDescriptor,PsName> >* > ( event ) ; assert (creationEvent != NULL ) ; // add the described object in the simulation tree : this is a declaration PsObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed( creationEvent->value.first.getName() ); if ( objectDescriptor == NULL ) { PsObjectDescriptor * newObjectDescriptor = new PsObjectDescriptor(creationEvent->value.first) ; PsObjectDescriptor * fathersDescription = _simulationTree.findDescendantNamed ( creationEvent->value.second ) ; if (fathersDescription == NULL) { fathersDescription = & _simulationTree ; #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"Attached new object named "<<newObjectDescriptor->getName()<<" to "<<getName() <<" because object "<<creationEvent->value.second<<"is unknown"<<endl; warning ( warningMessage.str() , SomeWarnings ) ; #else ostrstream warningMessage ; warningMessage<<"Attached new object named "<<newObjectDescriptor->getName()<<" to "<<getName() <<" because object "<<creationEvent->value.second<<"is unknown"<<endl; warningMessage.put ('\0') ; warning ( warningMessage.str() , SomeWarnings ) ; delete warningMessage.str() ; #endif } changeObjectsFather (newObjectDescriptor, fathersDescription) ; //create the described object processNewObjectDeclaration ( *newObjectDescriptor, event->date ) ; // notify other objects that an object has been created fireValuedSignal(PsSystemEventIdentifier::MaskObjectCreated,creationEvent->value.first.getName() ) ; } else { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"WARNING: an object of name "<<creationEvent->value.first.getName()<<" already exists"<<endl; warning ( warningMessage.str() , SomeWarnings ) ; #else ostrstream warningMessage ; warningMessage<<"WARNING: an object of name "<<creationEvent->value.first.getName()<<" already exists"<<endl; warningMessage.put ('\0') ; warning ( warningMessage.str() , SomeWarnings ) ; delete warningMessage.str() ; #endif } } else if ( eventId == PsSystemEventIdentifier::MaskRecomputeScheduling) { computeScheduling( true ) ; scheduleControlledObjects() ; } else { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"WARNING:PsController::traiterEvt événement système non géré"<<endl; warning ( warningMessage.str() , SomeWarnings ) ; #else ostrstream warningMessage ; warningMessage<<"WARNING:PsController::traiterEvt événement système non géré"<<endl; warningMessage.put('\0') ; warning ( warningMessage.str() , SomeWarnings ) ; delete warningMessage.str() ; #endif } return true ; }

void PsController::processEventsOfSuspendedObjects (    )  [virtual]

call processEvent for suspended objects having received events Definition at line 1523 of file PsController.cxx. References _currentListOfObjectsNeedingActivation, _date, PsnReferenceObjectHandle::_isInObjectNeedingActivationList, _listOfObjectsWithPostPonedEvents, _objectsNeedingActivationList, list< PsnReferenceObjectHandle * >::begin(), list< PsnReferenceObjectHandle * >::end(), list< PsnReferenceObjectHandle * >::erase(), hasEventsToProcess(), and PsnReferenceObjectHandle::processEvents(). Referenced by computeNextSimulationStep(). { #ifdef _DEBUGEVT cerr<<"PsController::processEventsOfSuspendedObjects "<< _date << endl; #endif while ( ! _objectsNeedingActivationList[ _currentListOfObjectsNeedingActivation ]->empty() ) { //using a iteration to be able to process ASAP events generated throught this phase int indiceFile = _currentListOfObjectsNeedingActivation ; _currentListOfObjectsNeedingActivation = 1 - _currentListOfObjectsNeedingActivation ; PsnReferenceObjectHandle * courant; list<PsnReferenceObjectHandle *>::iterator i; i=_objectsNeedingActivationList[indiceFile]->begin(); while(i!=_objectsNeedingActivationList[indiceFile]->end()) { list<PsnReferenceObjectHandle *>::iterator needsDelete; courant=(*i); courant->processEvents () ; courant->_isInObjectNeedingActivationList[indiceFile]= false ; needsDelete=i; i++; _objectsNeedingActivationList[indiceFile]->erase(needsDelete); } } list < PsnReferenceObjectHandle * >::iterator j = _listOfObjectsWithPostPonedEvents.begin() ; list < PsnReferenceObjectHandle * >::iterator toErase ; while ( j != _listOfObjectsWithPostPonedEvents.end() ) { hasEventsToProcess (*j) ; toErase = j ; j++ ; _listOfObjectsWithPostPonedEvents.erase( toErase ) ; } #ifdef _DEBUGEVT cerr<<"PsController::processEventsOfSuspendedObjects fin "<< _date <<endl; #endif }

void PsController::processNewObjectDeclaration (  PsObjectDescriptor &    declaration, const PsDate &    declarationDate )  [protected, virtual]

processNewObjectDeclaration once an object has been added to the simulation tree, this is called for creation and scheduling Reimplemented in PsDistributedController. Definition at line 943 of file PsController.cxx. References computeAdequateFrequency(), computeScheduling(), createReferenceObject(), PsObjectDescriptor::getFrequency(), PsDate, scheduleControlledObjects(), scheduleObject(), and sendInitialEventsTo(). Referenced by processEvent(), and PsDistributedController::processNewObjectDeclaration(). { PsnReferenceObjectHandle * objectHandle = createReferenceObject ( & declaration ) ; assert ( objectHandle != NULL ) ; if ( declaration.getFrequency() != computeAdequateFrequency ( declaration.getFrequency() ) ) { //the whole scheduling data structure needs recalculating computeScheduling ( false ) ; //the new object will therefore be scheduled with all the others scheduleControlledObjects() ; } else { scheduleObject ( objectHandle ) ; } sendInitialEventsTo ( *objectHandle, declarationDate ) ; }

void PsController::processStartEventOf (  PsnReferenceObjectHandle *    objectHandle )  [virtual]

process MaskStart systemEvent for the object with handle Reimplemented in PsDistributedController. Definition at line 1287 of file PsController.cxx. References _scheduler, PsnReferenceObjectHandle::getComputingState(), PsSimulatedObject::getName(), PsnObjectHandle::getSimulatedObject(), PsnReferenceObjectHandle::init(), PsnReferenceObjectHandle::initial, noActivationNeededFor(), PsnReferenceObjectHandle::running, PsnScheduler::schedule(), and setComputingState(). Referenced by PsDistributedController::processStartEventOf(), and reactToControlledObjectsSystemEvents(). { if(objectHandle->getComputingState() == PsnReferenceObjectHandle::initial) { setComputingState (objectHandle, PsnReferenceObjectHandle::running ) ; noActivationNeededFor ( objectHandle ); #ifdef _DEBUGEVT cerr<<"PsController:: Init of "<<objectHandle->getSimulatedObject().getName()<<endl; #endif objectHandle->init() ; #ifdef _DEBUGEVT cerr<<"PsController:: end of init of "<<objectHandle->getSimulatedObject().getName()<<endl; #endif _scheduler->schedule( objectHandle ); } }

void PsController::purgeMemoryFromOldEvents (  const PsDate &    dateOfOldestKept )  [protected, virtual]

the method used to purge the data structures from all outdated kepts events. For example, an event sent to an uncreated object would be purged if no object claims the event Reimplemented in PsDistributedController. Definition at line 527 of file PsController.cxx. References _deletedObjectHandles, _pendingEventsList, map< Key, T, Compare, Alloc >::begin(), map< PsName, list< PsEvent * > >::begin(), deleteObjectHandle(), list< pair< PsDate, PsnObjectHandle * > >::empty(), map< Key, T, Compare, Alloc >::empty(), map< Key, T, Compare, Alloc >::end(), map< PsName, list< PsEvent * > >::end(), map< PsName, list< PsEvent * > >::erase(), map< Key, T, Compare, Alloc >::erase(), pair< T1, T2 >::first, list< pair< PsDate, PsnObjectHandle * > >::front(), list< pair< PsDate, PsnObjectHandle * > >::pop_front(), PsDate, and pair< T1, T2 >::second. Referenced by compute(), PsDistributedController::purgeMemoryFromOldEvents(), and ~PsController(). { // purge old events with no known receiver map<PsName, list <PsEvent *> >::iterator pendingEventsMapIterator = _pendingEventsList.begin() ; while ( pendingEventsMapIterator != _pendingEventsList.end() ) { list<PsEvent *>::iterator eventListIterator = pendingEventsMapIterator->second.begin() ; while ( eventListIterator != pendingEventsMapIterator->second.end() ) { if ( (*eventListIterator)->date < dateOfOldestKept ) { delete *eventListIterator ; eventListIterator = pendingEventsMapIterator->second.erase ( eventListIterator ) ; } else { ++ eventListIterator ; } } if ( pendingEventsMapIterator->second.empty() ) { _pendingEventsList.erase ( pendingEventsMapIterator++ ) ; } else { pendingEventsMapIterator++ ; } } //purge deleted objects, objects handles and object descriptors bool disposableElements = !_deletedObjectHandles.empty() ; pair <PsDate, PsnObjectHandle *> examinedObjectHandle ; while ( disposableElements ) { examinedObjectHandle = _deletedObjectHandles.front() ; if ( examinedObjectHandle.first < dateOfOldestKept ) { #ifdef _DEBUGEXEC cerr<<"PsDistributedController::eventsProcessed: deleting "<<examinedObjectHandle.second->getSimulatedObject().getName()<<endl; #endif deleteObjectHandle ( examinedObjectHandle.second ) ; _deletedObjectHandles.pop_front() ; disposableElements = !_deletedObjectHandles.empty() ; } else { disposableElements = false ; } } }

void PsController::reactToControlledObjectsSystemEvents (    )  [virtual]

process system events received by controlled objects Reimplemented in PsReactController. Definition at line 1323 of file PsController.cxx. References _currentWritableSystemEventsList, _referenceObjectsMap, _scheduler, _simulationTree, _systemEventsList, AllWarnings, list< PsEvent * >::begin(), computeAdequateFrequency(), computeScheduling(), list< PsEvent * >::end(), list< PsEvent * >::erase(), PsEvent::eventId, PsObjectDescriptor::findDescendantNamed(), finish(), PsnReferenceObjectHandle::getComputingState(), PsName::getCString(), PsSimulatedObject::getName(), PsSimulatedObject::getObjectHandle(), PsNameToPointerMap< PsnReferenceObjectHandle >::getObjectOfIndex(), getPointerToSimulatedObjectNamed(), hasEventsToProcess(), PsSimulatedObject::init(), PsSystemEventIdentifier::MaskChangeObjectFrequency, PsSystemEventIdentifier::MaskDelete, PsSystemEventIdentifier::MaskRestart, PsSystemEventIdentifier::MaskResume, PsSystemEventIdentifier::MaskStart, PsSystemEventIdentifier::MaskStop, PsSystemEventIdentifier::MaskSuspend, noActivationNeededFor(), processDeleteEventOf(), PsnReferenceObjectHandle::processEvents(), processStartEventOf(), PsEvent::receiver, PsnScheduler::removeFromScheduable(), PsnReferenceObjectHandle::running, PsnScheduler::schedule(), scheduleControlledObjects(), scheduleObject(), setComputingState(), PsObjectDescriptor::setFrequency(), SomeWarnings, PsnReferenceObjectHandle::stopped, PsnReferenceObjectHandle::suspended, switchSystemEventList(), PsnScheduler::unschedule(), PsValuedEvent< UserType >::value, and warning(). Referenced by computeNextSimulationStep(). { PsSimulatedObject * receiverObject ; PsnReferenceObjectHandle * receiverReferential ; PsEvent * currentEvent ; switchSystemEventList() ; list< PsEvent * > & myEventList = *_systemEventsList [ 1 - _currentWritableSystemEventsList ] ; list< PsEvent * >::iterator i = myEventList.begin() ; list< PsEvent * >::iterator toErase ; while ( i != myEventList.end() ) { receiverObject = getPointerToSimulatedObjectNamed( (*i)->receiver ) ; currentEvent = (*i) ; if ( receiverObject == NULL ) { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"WARNING : object " << currentEvent ->receiver.getCString() <<", who has received event " << *currentEvent <<" doesn't exist (anymore)"<<endl; warning ( warningMessage.str() , AllWarnings ) ; #else ostrstream warningMessage ; warningMessage<<"WARNING : object " << currentEvent ->receiver.getCString() <<", who has received event " << *currentEvent <<" doesn't exist (anymore)"<<endl; warningMessage.put('\0') ; warning ( warningMessage.str() , AllWarnings ) ; delete warningMessage.str() ; #endif } else { receiverReferential = dynamic_cast<PsnReferenceObjectHandle *>(receiverObject->getObjectHandle() ); assert (receiverReferential != NULL) ; #if defined (_DEBUGEXEC) || defined (_DEBUGEVT) cerr<<*currentEvent<<" received by "<<receiverObject->getName() <<endl; #endif if ( currentEvent->eventId == PsSystemEventIdentifier::MaskStart ) { processStartEventOf ( receiverReferential ); } else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskStop ) { #ifdef _DEBUGEVT cout<< currentEvent->receiver <<" will be stopped "<<endl; #endif if((receiverReferential->getComputingState() == PsnReferenceObjectHandle::running)|| (receiverReferential->getComputingState() == PsnReferenceObjectHandle::suspended)) { setComputingState (receiverReferential, PsnReferenceObjectHandle::stopped ); receiverReferential->processEvents () ; receiverObject -> finish() ; _scheduler->unschedule( receiverReferential ); } } else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskSuspend ) { #ifdef _DEBUGEVT cout<<currentEvent->receiver <<" will be suspended "<<endl; #endif if(receiverReferential->getComputingState() == PsnReferenceObjectHandle::running) { setComputingState (receiverReferential, PsnReferenceObjectHandle::suspended ) ; hasEventsToProcess (receiverReferential) ; // à la fin du pas de temps l'événement MaskSuspend sera traité, ainsi que d'autres événements éventuels _scheduler->unschedule ( receiverReferential ); } else { assert ( false ) ; } } else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskResume ) { #ifdef _DEBUGEVT cout<<currentEvent->receiver <<" will resume execution"<<endl; #endif if ( receiverReferential -> getComputingState() == PsnReferenceObjectHandle::suspended ) { setComputingState (receiverReferential, PsnReferenceObjectHandle::running ); // inutile de traiter l'événement : les compute à venir le feront noActivationNeededFor ( receiverReferential ); _scheduler->schedule( (PsnReferenceObjectHandle *)receiverObject -> getObjectHandle() ); } } else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskDelete ) { processDeleteEventOf ( receiverReferential ) ; } else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskRestart ) { #ifdef _DEBUGEVT cout<<currentEvent->receiver <<" will be restarted"<<endl; #endif if (receiverReferential->getComputingState() == PsnReferenceObjectHandle::stopped) { setComputingState(receiverReferential, PsnReferenceObjectHandle::running) ; // inutile de traiter l'événement : les compute à venir le feront noActivationNeededFor( receiverReferential ); receiverObject->init(); //on sait que c'est un référentiel _scheduler->schedule( receiverReferential ) ; } } else if ( currentEvent->eventId == PsSystemEventIdentifier::MaskChangeObjectFrequency ) { PsValuedEvent<PsFrequency> * realEvent ; realEvent = dynamic_cast<PsValuedEvent<PsFrequency> *> (currentEvent ) ; assert (realEvent != NULL) ; PsObjectDescriptor * objectDescription = _simulationTree.findDescendantNamed (realEvent->receiver) ; if (objectDescription != NULL) { objectDescription->setFrequency ( realEvent->value ) ; if ( realEvent->value == computeAdequateFrequency ( realEvent->value ) ) { PsnReferenceObjectHandle * referenceObjectHandle = _referenceObjectsMap.getObjectOfIndex (realEvent->receiver) ; if ( referenceObjectHandle != NULL ) { _scheduler->unschedule( referenceObjectHandle ) ; _scheduler->removeFromScheduable( referenceObjectHandle ) ; scheduleObject ( _referenceObjectsMap.getObjectOfIndex (realEvent->receiver) ) ; } } else { computeScheduling ( false ) ; //false necessary because otherwise no change would happen scheduleControlledObjects () ; } } else { #ifdef _USESSTREAM ostringstream warningMessage ; warningMessage<<"PsController received MaskChangeObjectFrequency for "<<realEvent->receiver<<" which is unknown "<<endl; warning ( warningMessage.str() , SomeWarnings ) ; #else ostrstream warningMessage ; warningMessage<<"PsController received MaskChangeObjectFrequency for "<<realEvent->receiver<<" which is unknown "<<endl; warningMessage.put('\0') ; warning ( warningMessage.str() , SomeWarnings ) ; delete warningMessage.str() ; #endif } } } toErase = i ; i++ ; myEventList.erase ( toErase ) ; } }

bool PsController::receiveCancellationForSignal (  const PsEventIdentifier &    sigId, const PsName &    registrant )  [virtual]

cancel the registration of an object for a signal Parameters: sigId  the signal for wich there is a cancellation registrant  the object cancelling registration Reimplemented in PsDistributedController. Definition at line 1595 of file PsController.cxx. References _controledObjectsSignalsDispatcher, and PsnSignalDispatcher::cancelRegistrationForSignal(). Referenced by PsSimulatedObject::cancelRegistrationForSignal(). { return _controledObjectsSignalsDispatcher.cancelRegistrationForSignal (sigId , registrant) ; }

bool PsController::receiveRegistrationForSignal (  const PsEventIdentifier &    sigId, const PsName &    registrant, const PsEventIdentifier &    eventId )  [virtual]

register an object for a signal Parameters: sigId  the signal to react to registrant  the simulated object registering to signal sigId eventId  the eventId to send to registrant when sigId is emitted Reimplemented in PsDistributedController. Definition at line 1586 of file PsController.cxx. References _controledObjectsSignalsDispatcher, and PsnSignalDispatcher::registerForSignal(). Referenced by PsSimulatedObject::registerForSignal(). { //cerr<<"PsController::receiveRegistrationForSignal "<<sig<<" "<<registrant<<" "<<eventId<<endl; return _controledObjectsSignalsDispatcher.registerForSignal(sig , registrant , eventId) ; }

bool PsController::removeFromPendingRegistrations (  const PsEventIdentifier &    sig, const PsName &    producer, const PsName &    registrant )  [virtual]

removeFromPendingRegistrations. Remove a pending registration Parameters: sig  the signal to cancel registration for producer  the object producing the signal registrant  the object cancelling registration for sig Returns: cancellation succeeded Definition at line 761 of file PsController.cxx. References _mutexPendingDataStructures, _pendingRegistrationRequests, map< PsName, PsnSignalDispatcher * >::end(), map< PsName, PsnSignalDispatcher * >::find(), PsnMutexLock::protect(), and PsnMutexLock::unprotect(). Referenced by PsSimulatedObject::cancelRegistrationForSignalBy(). { bool result ; _mutexPendingDataStructures.protect() ; map<PsName, PsnSignalDispatcher *>::iterator i = _pendingRegistrationRequests.find (producer) ; if ( i == _pendingRegistrationRequests.end() ) { result = false ; } else { result = i->second->cancelRegistrationForSignal ( sig, registrant ) ; } _mutexPendingDataStructures.unprotect() ; return result ; }

PsnObjectHandle * PsController::removeObjectFromDataStructures (  const PsName &    )  [protected, virtual]

remove any reference to a simulated object from all the controller's data structures Returns: an ObjectHandle that is the last object referencing the simulated object does not act on the simualtion tree Reimplemented in PsnGuiController, and PsPvmController. Definition at line 863 of file PsController.cxx. References _listOfObjectsWithPostPonedEvents, _objectsNeedingActivationList, _referenceObjectsMap, _scheduler, map< PsName, PsnReferenceObjectHandle * >::erase(), PsNameToPointerMap< PsnReferenceObjectHandle >::getObjectOfIndex(), list< PsnReferenceObjectHandle * >::remove(), PsnScheduler::removeFromScheduable(), and PsnScheduler::unschedule(). Referenced by deleteObject(). { PsnReferenceObjectHandle * referentiel = NULL ; referentiel = _referenceObjectsMap.getObjectOfIndex(nom); //Purge all data structures related to event management for(int i=0;i<2;i++) { _objectsNeedingActivationList[i]->remove( referentiel ); } _listOfObjectsWithPostPonedEvents.remove ( referentiel ) ; _referenceObjectsMap.erase(nom); _scheduler->unschedule( referentiel ) ; _scheduler->removeFromScheduable( referentiel ) ; return referentiel; }

void PsController::run (    )  [virtual]

run start the controller on a infinite loop which will be broken if system events are sent to the controller Reimplemented in PsnGuiController, PsMultiThreadedController, PsMultiThreadedPvmController, PsPvmController, PsPvmGlobalController, and PsReactGlobalController. Definition at line 480 of file PsController.cxx. References _computeStatePointer, runControllersStep(), and PsnReferenceObjectHandle::running. Referenced by openMaskMain(), and PsMultiThreadedController::run(). { PsnReferenceObjectHandle * objectHandle = dynamic_cast<PsnReferenceObjectHandle *> ( _objectHandle ) ; assert ( objectHandle != NULL ) ; *_computeStatePointer = PsnReferenceObjectHandle::running ; while(*_computeStatePointer == PsnReferenceObjectHandle::running) { runControllersStep (objectHandle) ; }//while }

void PsController::runControllersStep (  PsnReferenceObjectHandle *    objectHandle )  [virtual]

run a controllers simulation step. To be used by the code controlling the simulation loop (generally run or the interface call compute of the objecthandle : therefore receive and process all events sent to the controller call compute increment the simulation date Definition at line 492 of file PsController.cxx. References _computeStatePointer, _forcedCompute, PsnReferenceObjectHandle::compute(), PsnReferenceObjectHandle::processEvents(), and PsnReferenceObjectHandle::running. Referenced by run(). { #ifdef _DEBUGEXEC cerr<<"PsController::runControllersStep"<<endl; #endif assert ( objectHandle != NULL ); _forcedCompute = true ; //the controller has to process system events adressed to itself objectHandle->processEvents() ; //the controller has schedule itself if( (*_computeStatePointer == PsnReferenceObjectHandle::running) || _forcedCompute ) { objectHandle->compute(); } _forcedCompute = false ; }

void PsController::scheduleControlledObjects (    )  [protected, virtual]

scheduleControlledObjects schedule all controlled reference objects Definition at line 331 of file PsController.cxx. References _referenceObjectsMap, map< PsName, PsnReferenceObjectHandle * >::begin(), map< PsName, PsnReferenceObjectHandle * >::end(), PsSimulatedObject::getObjectHandle(), and scheduleObject(). Referenced by PsDistributedController::getPointerToSimulatedObjectNamed(), init(), processEvent(), processNewObjectDeclaration(), and reactToControlledObjectsSystemEvents(). { PsNameToPointerMap<PsnReferenceObjectHandle>::iterator pTab; //for all controlled objects for (pTab=_referenceObjectsMap.begin(); pTab!= _referenceObjectsMap.end(); pTab++) { if ((*pTab).second != getObjectHandle() ) //a controller shouldn't schedule itself. { //schedule object correctly on the each frame of a cycle scheduleObject((*pTab).second); } } }

void PsController::scheduleObject (  PsnReferenceObjectHandle *    ref )  [protected, virtual]

add a simulated object to the appropriate execution frames, without flagging it as executable Parameters: ref  the object handle of the simulated object Definition at line 348 of file PsController.cxx. References PsSimulatedObject::_controller, _nbStepsByCycle, _scheduler, _stepFrequency, PsnScheduler::addToScheduable(), computeAdequateFrequency(), PsnReferenceObjectHandle::getComputingState(), PsObjectDescriptor::getFrequency(), PsSimulatedObject::getObjectDescriptor(), PsnObjectHandle::getSimulatedObject(), PsnReferenceObjectHandle::running, and PsnScheduler::schedule(). Referenced by PsDistributedController::getPointerToSimulatedObjectNamed(), processNewObjectDeclaration(), reactToControlledObjectsSystemEvents(), and scheduleControlledObjects(). { assert (_scheduler != NULL) ; int objectFrequency = ref->getSimulatedObject().getObjectDescriptor().getFrequency() ; #ifndef NDEBUG int adaptedFrequency = computeAdequateFrequency ( objectFrequency ) ; assert ( (objectFrequency == adaptedFrequency) || ( objectFrequency == 0 ) ) ; #endif if ( objectFrequency != 0 ) { int nbFramesARaterPlusUn=int(_controller._stepFrequency/objectFrequency); for(int minor=0;minor<_nbStepsByCycle;minor++) { if (minor%nbFramesARaterPlusUn==0) { //earliest execution _scheduler->addToScheduable( ref , minor ); } } if ( ref->getComputingState() == PsnReferenceObjectHandle::running ) { _scheduler->schedule ( ref ) ; } } }

void PsController::sendInitialEventsTo (  PsnReferenceObjectHandle &    objectHandle, const PsDate &    dateOfMaskStart )  [protected, virtual]

send MaskStart to any created objects, and send any pending events which where stored (none by default) because send to an object before it was created Definition at line 816 of file PsController.cxx. References _pendingEventsList, map< Key, T, Compare, Alloc >::begin(), map< Key, T, Compare, Alloc >::end(), map< PsName, list< PsEvent * > >::end(), map< PsName, list< PsEvent * > >::erase(), map< PsName, list< PsEvent * > >::find(), PsObjectDescriptor::getFrequency(), PsSimulatedObject::getName(), PsObjectDescriptor::getName(), PsSimulatedObject::getObjectDescriptor(), PsnObjectHandle::getSimulatedObject(), PsSystemEventIdentifier::MaskStart, PsSystemEventIdentifier::MaskSuspend, PsDate, and PsSimulatedObject::sendEvent(). Referenced by PsDistributedController::getPointerToSimulatedObjectNamed(), init(), and processNewObjectDeclaration(). { if (&objectHandle.getSimulatedObject() != this ) { #ifdef _DEBUGEXEC cerr<<"Sending init event to "<<objectHandle.getSimulatedObject().getObjectDescriptor().getName()<<endl; #endif PsEvent * startEvent = new PsEvent(PsSystemEventIdentifier::MaskStart, dateOfMaskStart, getName(), objectHandle.getSimulatedObject().getObjectDescriptor().getName() ) ; sendEvent ( startEvent ) ; //objects whose frequency is 0 must be suspended if( objectHandle.getSimulatedObject().getObjectDescriptor().getFrequency() == 0 ) { sendEvent(&objectHandle.getSimulatedObject(),PsSystemEventIdentifier::MaskSuspend); } //send any pending events /* no mutex protection needed, because this is only called during controller's system event processing */ map<PsName, list <PsEvent *> >::iterator pendingEvents = _pendingEventsList.find(objectHandle.getSimulatedObject().getObjectDescriptor().getName() ) ; if ( pendingEvents != _pendingEventsList.end() ) { #ifdef _DEBUGEXEC cerr<<"Found pending events for "<<objectHandle.getSimulatedObject().getObjectDescriptor().getName()<<endl; #endif for ( list <PsEvent *>::iterator pendingEventsListIterator = pendingEvents->second.begin() ; pendingEventsListIterator != pendingEvents->second.end() ; ++pendingEventsListIterator) { #ifdef _DEBUGEXEC cerr<<"sent "<<**pendingEventsListIterator<< "to "<<objectHandle.getSimulatedObject().getObjectDescriptor().getName()<<endl; #endif objectHandle.getSimulatedObject().sendEvent(*pendingEventsListIterator) ; } _pendingEventsList.erase ( pendingEvents ) ; } } }

void PsController::setComputingState (  PsnReferenceObjectHandle *   , PsnReferenceObjectHandle::SimulatedObjectComputingState    )  const [protected, virtual]

change the computing state of a reference object handle Definition at line 1635 of file PsController.cxx. References PsnReferenceObjectHandle::_computingState, and PsnReferenceObjectHandle::SimulatedObjectComputingState. Referenced by processDeleteEventOf(), PsDistributedController::processStartEventOf(), processStartEventOf(), and reactToControlledObjectsSystemEvents(). { handle->_computingState = state ; }

void PsController::setCycleFrequency (  int    newFrequency )  [protected, virtual]

Definition at line 1073 of file PsController.cxx. References _cycleFrequency, and _cyclePeriod. Referenced by computeScheduling(). { _cycleFrequency = newFreq ; _cyclePeriod = 1000/newFreq ; }

bool PsController::setKernelObjectFactory (  PsKernelObjectAbstractFactory *    aFactory )  [static]

set the kernelObjectfactory for the controller of this adressing space is only effective once for each adress space to be called before creation of the controller to be effective return : change effective Definition at line 44 of file PsController.cxx. References kernelObjectFactory. { if ( kernelObjectFactory != NULL ) { kernelObjectFactory = aFactory ; return true ; } else { return false ; } }

void PsController::setProcessOfDescriptor (  PsObjectDescriptor &    objectDescription, const PsName &    newProcessName )  [protected, virtual]

Definition at line 1647 of file PsController.cxx. References PsObjectDescriptor::setProcess(). { objectDescription.setProcess ( newProcessName ) ; }

void PsController::showDateAndStepNumber (  bool    show = true )

ask the controller to print (or not) to sdterr (cerr) the simulation date and the step number Parameters: show  if true information will be printed Definition at line 1107 of file PsController.cxx. References _showDateAndStepNumber. { _showDateAndStepNumber = show; }

void PsController::switchSystemEventList (    )  [protected, virtual]

switch buffer of List Of Objects Needing Activation Definition at line 1136 of file PsController.cxx. References _currentWritableSystemEventsList. Referenced by reactToControlledObjectsSystemEvents(). { _currentWritableSystemEventsList = 1 - _currentWritableSystemEventsList ; }

void PsController::warning (  const string &    warningMessage, WarningLevels    warningLevel )  [static]

Print a warning. Warnings are printed on cerr, and throw string as exceptions depending on the warning level Parameters: warningMessage  the warning to print warningLevel  the warning level as from which the warning should be displayed Definition at line 1118 of file PsController.cxx. References ExceptionOnWarnings, FatalWarnings, NoWarnings, and warningLevel. Referenced by PsObjectDescriptor::addSon(), addToPendingEvents(), PsMultipleConfigurationParameter::appendSubDescriptorsOf(), changeObjectsFather(), computeScheduling(), PsOutputNT::connect(), PsObjectDescriptor::createDescribedObject(), destroyObject(), PsnSvm::getLinkToProcessNamed(), PsSimulatedObject::getPointerToOutputNamed(), PsnSvm::getProcessDescriptorNamed(), init(), processEvent(), reactToControlledObjectsSystemEvents(), PsObjectDescriptor::setFathersDescription(), PsnSvm::synchroniseReceiveAndProcessMessages(), and PsnSvm::waitForAnswerToBlockingRequest(). { assert ( minWarningLevel != NoWarnings ) ; if ( warningLevel >= minWarningLevel ) { cerr<<warningMessage<<endl ; } if ( warningLevel == ExceptionOnWarnings ) { throw warningMessage ; } if ( warningLevel == FatalWarnings ) { exit ( -1 ) ; } }

---

Friends And Related Function Documentation

friend class PsInputNT [friend]

Reimplemented from PsSimulatedObject. Definition at line 279 of file PsController.h.

friend class PsSimulatedObject [friend]

Definition at line 280 of file PsController.h.

---

Member Data Documentation

PsnReferenceObjectHandle::SimulatedObjectComputingState* PsController::_computeStatePointer [protected]

a pointer for easy access to th computationnel state of the controller : if the controller is controlling itsekg, this computationnal state should be : running Definition at line 375 of file PsController.h. Referenced by processEvent(), PsController(), run(), and runControllersStep().

PsnSignalDispatcher PsController::_controledObjectsSignalsDispatcher [protected]

signal dispatcher for objects interested in a signal whatever it's producer Definition at line 480 of file PsController.h. Referenced by broadcastEventsForSignal(), PsDistributedController::processEvent(), receiveCancellationForSignal(), and receiveRegistrationForSignal().

int PsController::_currentListOfObjectsNeedingActivation [protected]

1 - _currentListOfObjectsNeedingActivation is used to store new object needing activation Definition at line 498 of file PsController.h. Referenced by hasEventsToProcess(), noActivationNeededFor(), processEventsOfSuspendedObjects(), and PsController().

unsigned int PsController::_currentWritableSystemEventsList [protected]

_systemEventsList[_currentWritableSystemEventsList] is used to store system events sent to controlled objects Definition at line 507 of file PsController.h. Referenced by actOnSystemEvent(), PsController(), reactToControlledObjectsSystemEvents(), and switchSystemEventList().

int PsController::_cycleFrequency [protected]

the frequency at wich activation patterns repeat themselves Definition at line 351 of file PsController.h. Referenced by getCycleFrequency(), and setCycleFrequency().

int PsController::_cyclePeriod [protected]

duration in simulated time of a simualtion cycle Definition at line 354 of file PsController.h. Referenced by getCyclePeriod(), and setCycleFrequency().

PsDate PsController::_date [protected]

simulated date Definition at line 367 of file PsController.h. Referenced by advanceSimulatedDate(), PsBenchController< BenchedController >::advanceSimulatedDate(), PsDistributedController::broadcastEventsForSignal(), PsBenchController< BenchedController >::compute(), PsPvmBenchController< APvmController >::compute(), computeScheduling(), deleteObject(), PsDistributedController::deleteObjectHandle(), PsDistributedController::getPointerToSimulatedObjectNamed(), getPurgeDate(), getSimulatedDate(), hasEventsToProcess(), init(), processEventsOfSuspendedObjects(), PsDistributedController::receiveCancellationForSignal(), PsDistributedController::receiveRegistrationForSignal(), ~PsController(), and PsDistributedController::~PsDistributedController().

list<pair <PsDate, PsnObjectHandle *> > PsController::_deletedObjectHandles [protected]

the list of recently deleted object handles. Deleted objects pass through purge because objects reacting to MaskObjectDestroyed might attempt to access the objects they should pass through purge in a distributed context Definition at line 535 of file PsController.h. Referenced by deleteObject(), PsDistributedController::deleteObjectHandle(), getObjectDescriptorOfObject(), and purgeMemoryFromOldEvents().

bool PsController::_forcedCompute [protected]

to enable computations even in suspendedState, when the controller is controlled Definition at line 487 of file PsController.h. Referenced by processEvent(), and runControllersStep().

list<PsnReferenceObjectHandle * > PsController::_listOfObjectsWithPostPonedEvents [protected]

list of objects with postponed events Definition at line 510 of file PsController.h. Referenced by postponeEventProcessing(), processEventsOfSuspendedObjects(), and removeObjectFromDataStructures().

PsnMutexLock PsController::_mutexPendingDataStructures [protected]

protecting the list of pending events and registrations Definition at line 519 of file PsController.h. Referenced by addToPendingEvents(), addToPendingRegistrations(), and removeFromPendingRegistrations().

PsnMutexLock PsController::_mutexSystemEventsList [protected]

protecting access to _systemEventsList Definition at line 513 of file PsController.h. Referenced by actOnSystemEvent().

int PsController::_nbStepsByCycle [protected]

number of simulation step by cycle : we have _cycleFrequency * stepFrequency = _nbStepsByCycle Definition at line 358 of file PsController.h. Referenced by computeAdequateFrequency(), computeNextSimulationStep(), computeScheduling(), PsMultiThreadedPvmController::createScheduler(), PsMultiThreadedPvmBenchmarkingController::createScheduler(), PsMultiThreadedController::createScheduler(), PsMultiThreadedBenchmarkingController::createScheduler(), PsMomeMultiThreadedController::createScheduler(), createScheduler(), PsBenchController< BenchedController >::createScheduler(), PsMomeController::getOutputHistorySize(), getOutputHistorySize(), and scheduleObject().

unsigned long int PsController::_numberOfSimulatedSteps [protected]

number of simulated steps up to now Definition at line 343 of file PsController.h. Referenced by advanceSimulatedDate(), PsBenchController< BenchedController >::compute(), and computeNextSimulationStep().

list<PsnReferenceObjectHandle *>* PsController::_objectsNeedingActivationList[2] [protected]

double buffered list of controlled object needing activation because they have received events protect usage with _mutexForListEvt ; Definition at line 495 of file PsController.h. Referenced by hasEventsToProcess(), noActivationNeededFor(), processEventsOfSuspendedObjects(), PsController(), removeObjectFromDataStructures(), and ~PsController().

map<PsName, list<PsEvent *> > PsController::_pendingEventsList [protected]

list of pending events (events sent to unknown objects) Definition at line 516 of file PsController.h. Referenced by addToPendingEvents(), PsDistributedController::processNewObjectDeclaration(), purgeMemoryFromOldEvents(), and sendInitialEventsTo().

map<PsName, PsnSignalDispatcher *> PsController::_pendingRegistrationRequests [protected]

map of pending registration requests Definition at line 522 of file PsController.h. Referenced by addToPendingRegistrations(), createReferenceObjectHandle(), removeFromPendingRegistrations(), and ~PsController().

PsNameToPointerMap<PsnReferenceObjectHandle> PsController::_referenceObjectsMap [protected]

data structure containing references to the ReferenceObjectHandlers Definition at line 333 of file PsController.h. Referenced by PsPvmBenchController< APvmController >::computeNextSimulationStep(), computeScheduling(), PsDistributedController::createDuplicatedObject(), createReferenceObject(), PsDistributedController::dispatchEvent(), getPointerToDuplicatedObjectNamed(), PsDistributedController::getPointerToSimulatedObjectNamed(), getPointerToSimulatedObjectNamed(), init(), reactToControlledObjectsSystemEvents(), removeObjectFromDataStructures(), and scheduleControlledObjects().

PsnScheduler* PsController::_scheduler [protected]

the scheduler Definition at line 490 of file PsController.h. Referenced by computeNextSimulationStep(), computeScheduling(), processStartEventOf(), reactToControlledObjectsSystemEvents(), removeObjectFromDataStructures(), scheduleObject(), PsBenchController< BenchedController >::~PsBenchController(), and ~PsController().

bool PsController::_showDateAndStepNumber [protected]

flag indicating if the date and simulation step number are printed Definition at line 371 of file PsController.h. Referenced by showDateAndStepNumber().

PsObjectDescriptor& PsController::_simulationTree [protected]

the simulation tree this controller is root of this has to be a reference to a allready constructed simulation tree, because the root descriptor of that tree is used a parameter of the ancestors constructor wich keeps a reference of that descriptor. Therefore, problems will arise if _simulationTree is a copy Definition at line 339 of file PsController.h. Referenced by changeObjectsFather(), computeScheduling(), destroyObject(), finish(), getObjectDescriptorOfObject(), PsDistributedController::getPointerToSimulatedObjectNamed(), init(), PsDistributedController::processEvent(), processEvent(), PsController(), and reactToControlledObjectsSystemEvents().

PsFrequency PsController::_stepFrequency [protected]

frequency of a simulation step Definition at line 348 of file PsController.h. Referenced by computeAdequateFrequency(), computeScheduling(), init(), and scheduleObject().

int PsController::_stepPeriod [protected]

_stepPeriod. duration in simulated time of a simulated step Definition at line 363 of file PsController.h. Referenced by advanceSimulatedDate(), PsBenchController< BenchedController >::compute(), computeScheduling(), PsMultiThreadedPvmBenchmarkingController::createScheduler(), PsMultiThreadedBenchmarkingController::createScheduler(), PsBenchController< BenchedController >::createScheduler(), getPurgeDate(), hasEventsToProcess(), PsBenchController< BenchedController >::init(), PsMomeController::init(), init(), PsBenchController< BenchedController >::printToStream(), ~PsController(), and PsDistributedController::~PsDistributedController().

list<PsEvent *>* PsController::_systemEventsList[ 2 ] [protected]

double buffered system event list Definition at line 504 of file PsController.h. Referenced by actOnSystemEvent(), PsController(), reactToControlledObjectsSystemEvents(), and ~PsController().

PsDate PsController::initialSimulationDate = 0 [static]

date at wich simulation was initialised Definition at line 39 of file PsController.cxx. Referenced by PsMultiThreadedPvmBenchmarkingController::createScheduler(), PsMultiThreadedBenchmarkingController::createScheduler(), PsBenchController< BenchedController >::createScheduler(), PsBenchController< BenchedController >::init(), init(), PsSimulatedObject::insertInStream(), PsSimulatedObject::pack(), PsController(), PsnReferenceObjectHandle::PsnReferenceObjectHandle(), and PsTimerController< ControleurAncetre >::PsTimerController().

PsKernelObjectAbstractFactory * PsController::kernelObjectFactory = NULL [static, private]

the kernel object factory used to create attribute of controlled object Definition at line 42 of file PsController.cxx. Referenced by getKernelObjectFactory(), and setKernelObjectFactory().

PsController::WarningLevels PsController::warningLevel = PsController::NoWarnings [static]

Definition at line 40 of file PsController.cxx. Referenced by PsSimulatedObject::addInstanceCreator(), PsnPvmOutgoingMessage::checkForChangedBuffer(), PsnPvmIncomingMessage::checkForGetErrors(), PsnPvmOutgoingMessage::checkForPackErrors(), PsnPvmOutgoingMessage::checkForSendErrors(), PsnPvmSvmLink::testForAnyMessage(), and warning().

---

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

• PsController.h
• PsController.cxx

---