Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

PsDistributedController Class Reference

A controller who has a notion of distribution A distributed controller only controls part of the simulation. More...

#include <PsDistributedController.h>

Inheritance diagram for PsDistributedController:

Inheritance graph
[legend]
Collaboration diagram for PsDistributedController:

Collaboration graph
[legend]
List of all members.

Public Methods

 PsDistributedController (PsObjectDescriptor &initialObjects, const PsDate &initialDate)
 constructor

virtual ~PsDistributedController ()
 destructor

virtual PsSimulatedObject * getPointerToSimulatedObjectNamed (const PsName &objectName)
 get a pointer to a simulation object.

virtual void dispatchEvent (PsEvent *event)
 dispatch an event received from an other controller to the corresponding referenceObjectHandle

virtual bool processEvent (PsEvent *event)
 redefine event processing to broadcast system events to other controllers

virtual void purgeMemoryFromOldEvents (const PsDate &dateOfOldestKept)
 redefine to purge the list of remembered broadcasted signals

virtual void broadcastEventsForSignal (PsEvent &event, const PsEventIdentifier &sigId)
 redefine so that signals broadcasted are remembered.

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


Protected Types

typedef hash_map< PsName,
PsnMirrorObjectHandle *,
PsName::hashFunctionObject > 		MirrorObjectsContainerType

Protected Methods

virtual PsnMirrorObjectHandle * newPsnMirrorObjectHandle (PsSimulatedObject &obj)=0
 create an mirror object handle adapted to distribution mode

virtual PsnDuplicatedObjectHandle * newPsnDuplicatedObjectHandle (PsSimulatedObject &obj)=0
 create a duplicated object handle adapted to distribution mode

virtual void deleteObjectHandle (PsnObjectHandle *objectHandle)
 as the controller is an abstract factory for object handlers, is should also be an abstract destroyer

virtual void createControlledObjects (const PsObjectDescriptor *subTree)
 redefine createControlledObjects so as to create only object assigned to this controller

virtual void createObject (const PsObjectDescriptor &newObjectDescription, const PsName &fathersName)
 redefine to make sure a process is given to the created object.

virtual void processNewObjectDeclaration (PsObjectDescriptor &declaration, const PsDate &declarationDate)
 redefine to create only declarations pertinant to the current node

virtual PsnMirrorObjectHandle * createMirrorObject (PsObjectDescriptor *objectDescription)
 createMirrorObject effective creation of a simulated object wich will act as a mirror for other simulated objects controlled by the local controller

virtual PsnDuplicatedObjectHandle * createDuplicatedObject (PsObjectDescriptor *objectDescription)
 create a duplicated object

virtual void processStartEventOf (PsnReferenceObjectHandle *objectHandle)
 initialisation des referentiels ...


Protected Attributes

MirrorObjectsContainerType _mirrorObjectsMap
 data structure containing references to the MirrorObjectHandlers

PsNameToPointerMap< PsnDuplicatedObjectHandle > _duplicatedObjectsMap
 data structure containing references to the DuplicatedObjectHandlers

PsNameToPointerMap< PsnReferenceObjectHandle > tableDesNonInitialises
 la table des référentiels non-initilisés

PsNameToPointerMap< PsnReferenceObjectHandle > tableDesInitialises
 la table des référentiels initilisés

PsName _processName
 name of the process this controller is controlling

list< pair< PsEventIdentifier,
pair< PsEvent *, PsDate > > > 		_broadcastedSignals
 the list storing the recently broadcasted signals

Detailed Description

A controller who has a notion of distribution A distributed controller only controls part of the simulation.

Author:
David Margery
Version:
0.8 0.7 -> 0.8 delegated much of what was linked to distribution from the general controller to the distributed controller

Definition at line 36 of file PsDistributedController.h.

Member Typedef Documentation

typedef hash_map<PsName,PsnMirrorObjectHandle *,PsName::hashFunctionObject > PsDistributedController::MirrorObjectsContainerType [protected]
 

Definition at line 120 of file PsDistributedController.h.

Constructor & Destructor Documentation

PsDistributedController::PsDistributedController (  PsObjectDescriptor &    initialObjects,
const PsDate &    initialDate
) 
 

constructor

Definition at line 29 of file PsDistributedController.cxx.

References PsDate. 

00030    : PsController(initialObjects, initialDate),
00031      _processName (initialObjects.getProcess())
00032 {
00033 }

PsDistributedController::~PsDistributedController (    )  [virtual]
 

destructor

Definition at line 37 of file PsDistributedController.cxx.

References PsController::_date, PsController::_stepPeriod, and purgeMemoryFromOldEvents(). 

00038 {
00039   purgeMemoryFromOldEvents ( _date + _stepPeriod ) ;
00040 }

Member Function Documentation

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

redefine so that signals broadcasted are remembered.

They need to be remembered, because registration to a signal is delayed for the sake of distribution

Reimplemented from PsController.

Definition at line 370 of file PsDistributedController.cxx.

References _broadcastedSignals, PsController::_date, PsController::broadcastEventsForSignal(), PsEvent::clone(), make_pair(), and list< pair< PsEventIdentifier, pair< PsEvent *, PsDate > > >::push_back(). 

00371 {
00372    PsController::broadcastEventsForSignal ( event, sigId ) ;
00373 
00374    //remember the broadcasted signal to be able to send it to objects whose registration is still under way
00375    _broadcastedSignals.push_back ( make_pair ( sigId, make_pair (event.clone(), _date) ) ) ;
00376 
00377 }

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

redefine createControlledObjects so as to create only object assigned to this controller

Reimplemented from PsController.

Reimplemented in PsMomeController.

Definition at line 201 of file PsDistributedController.cxx.

References _processName, PsController::createReferenceObject(), and PsObjectDescriptor::getSons().

Referenced by PsMomeController::createControlledObjects(). 

00202 {
00203    //go through the simulation tree to find all objects that have to be created
00204    PsObjectDescriptor::SonsContainerType::const_iterator i = subTree->getSons()->begin() ;
00205    while ( i != subTree->getSons()->end() )
00206       {
00207          if ( (*i)->getProcess() == _processName ) 
00208             {
00209                cerr<<"Creating "<< (*i)->getName() << endl ;
00210                //create the object
00211                createReferenceObject ( (*i) ) ;
00212             }    
00213          else 
00214             {
00215                cerr<<"Not Creating "<< (*i)->getName() 
00216                    <<" of process "<< (*i)->getProcess()
00217                    <<endl ;
00218             }
00219          //create the subTree of that object
00220          createControlledObjects ( *i ) ;
00221          
00222          ++i ;
00223       }
00224 }

PsnDuplicatedObjectHandle * PsDistributedController::createDuplicatedObject (  PsObjectDescriptor *    objectDescription )  [protected, virtual]
 

create a duplicated object

Definition at line 43 of file PsDistributedController.cxx.

References _duplicatedObjectsMap, PsController::_referenceObjectsMap, PsNameToPointerMap< PsnDuplicatedObjectHandle >::addObjectWithIndex(), PsNameToPointerMap< PsnReferenceObjectHandle >::addObjectWithIndex(), PsController::createDescribedObject(), PsObjectDescriptor::getName(), and newPsnDuplicatedObjectHandle().

Referenced by getPointerToSimulatedObjectNamed(). 

00044 {
00045    PsnDuplicatedObjectHandle * result ;
00046 
00047    PsSimulatedObject * createdObject = createDescribedObject(objectDescription) ;
00048 
00049    if (createdObject == NULL) 
00050       {
00051          cerr<<"PsController::createReferenceObject: unable to create "<<*objectDescription<<endl;
00052       }
00053    else
00054       {
00055          result = newPsnDuplicatedObjectHandle(*createdObject) ;
00056          
00057          _referenceObjectsMap.addObjectWithIndex (objectDescription->getName(), result);
00058          _duplicatedObjectsMap.addObjectWithIndex (objectDescription->getName(),result);
00059       }
00060    return result ;
00061 }

PsnMirrorObjectHandle * PsDistributedController::createMirrorObject (  PsObjectDescriptor *    objectDescription )  [protected, virtual]
 

createMirrorObject effective creation of a simulated object wich will act as a mirror for other simulated objects controlled by the local controller

Reimplemented in PsPvmController.

Definition at line 182 of file PsDistributedController.cxx.

References _mirrorObjectsMap, PsController::createDescribedObject(), PsObjectDescriptor::getName(), hash_map< PsName, PsnMirrorObjectHandle *, PsName::hashFunctionObject >::insert(), and newPsnMirrorObjectHandle().

Referenced by getPointerToSimulatedObjectNamed(). 

00183 {
00184    PsnMirrorObjectHandle * result = NULL ;
00185    PsSimulatedObject * obj = createDescribedObject( objectDescription ) ;
00186    if ( obj == NULL )
00187       {
00188          cerr<<"PsController::createReferenceObject: unable to create "<<*objectDescription<<endl;
00189       }
00190    else
00191       {
00192          result = newPsnMirrorObjectHandle(*obj) ;
00193                  
00194          _mirrorObjectsMap.insert ( MirrorObjectsContainerType::value_type(objectDescription->getName (), result ) ) ;
00195       }
00196    return result ;   
00197 }

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

redefine to make sure a process is given to the created object.

If no process is specified, the current process will be inserted

Reimplemented from PsController.

Definition at line 332 of file PsDistributedController.cxx.

References _processName, PsController::createObject(), PsObjectDescriptor::getProcess(), and PsObjectDescriptor::setProcess(). 

00333 {
00334    PsName noProcess ;
00335    if ( newObjectDescription.getProcess() == noProcess )
00336       {
00337          PsObjectDescriptor modifiableObjectDescription ( newObjectDescription ) ;
00338          modifiableObjectDescription.setProcess ( _processName ) ;
00339          PsController::createObject( modifiableObjectDescription, fathersName ) ;
00340       }
00341    else
00342       {
00343          PsController::createObject( newObjectDescription, fathersName ) ;
00344       }
00345 }

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

as the controller is an abstract factory for object handlers, is should also be an abstract destroyer

Reimplemented from PsController.

Definition at line 325 of file PsDistributedController.cxx.

References PsController::_date, PsController::_deletedObjectHandles, make_pair(), and list< pair< PsDate, PsnObjectHandle * > >::push_back(). 

00326 {
00327    _deletedObjectHandles.push_back ( make_pair ( _date,objectHandle ) ) ;
00328 }

void PsDistributedController::dispatchEvent (  PsEvent *    event )  [virtual]
 

dispatch an event received from an other controller to the corresponding referenceObjectHandle

Definition at line 168 of file PsDistributedController.cxx.

References PsController::_referenceObjectsMap, map< PsName, PsnReferenceObjectHandle * >::end(), map< PsName, PsnReferenceObjectHandle * >::find(), and PsEvent::receiver. 

00168                                                            {
00169 #ifdef _DEBUGEVT
00170    cerr<<"PsDistributedController::dispatchEvent pour "<<event->receiver<<endl;
00171 #endif
00172    PsNameToPointerMap<PsnReferenceObjectHandle>::iterator i = _referenceObjectsMap.find(event->receiver);
00173    assert(i!=_referenceObjectsMap.end());
00174    (*i).second->receiveEvent( event );
00175 #ifdef _DEBUGEVT
00176          cerr<<"PsDistributedController::dispatchEvent fin"<<endl;
00177 #endif
00178 }

PsSimulatedObject * PsDistributedController::getPointerToSimulatedObjectNamed (  const PsName &    objectName )  [virtual]
 

get a pointer to a simulation object.

Redefined from PsController, because if the object hasn't been locally created, a mirror of this object will be created

Parameters:
objectName the name of the object for wich a pointer is needed
Returns:
a pointer to the corresponding object, non-const because thah pointer can be used to send events to the object

Reimplemented from PsController.

Reimplemented in PsMultiThreadedPvmController.

Definition at line 65 of file PsDistributedController.cxx.

References PsController::_date, _duplicatedObjectsMap, _mirrorObjectsMap, PsController::_referenceObjectsMap, PsController::_simulationTree, PsController::computeAdequateFrequency(), PsController::computeScheduling(), PsController::createDescribedObject(), createDuplicatedObject(), createMirrorObject(), map< PsName, PsnDuplicatedObjectHandle * >::end(), hash_map< PsName, PsnMirrorObjectHandle *, PsName::hashFunctionObject >::end(), map< PsName, PsnReferenceObjectHandle * >::end(), map< PsName, PsnDuplicatedObjectHandle * >::find(), hash_map< PsName, PsnMirrorObjectHandle *, PsName::hashFunctionObject >::find(), map< PsName, PsnReferenceObjectHandle * >::find(), PsObjectDescriptor::findDescendantNamed(), PsSimulatedObject::fireValuedSignal(), PsObjectDescriptor::getFrequency(), PsSimulatedObject::getName(), PsNameToPointerMap< PsnDuplicatedObjectHandle >::getObjectOfIndex(), PsNameToPointerMap< PsnReferenceObjectHandle >::getObjectOfIndex(), PsnObjectHandle::getSimulatedObject(), PsSystemEventIdentifier::MaskObjectCreated, PsController::scheduleControlledObjects(), PsController::scheduleObject(), and PsController::sendInitialEventsTo().

Referenced by PsMultiThreadedPvmController::getPointerToSimulatedObjectNamed(), and processNewObjectDeclaration(). 

00065                                                                                                  {
00066    //in case of dynamic creation of objects
00067    PsnCurrentActiveObject context ( NULL ) ;   
00068 
00069    PsSimulatedObject * resultat = NULL ;
00070    // On verifie que l'objet est un referentiel
00071    //cerr<<"PsDistributedController::getPointerToSimulatedObjectNamed("<<nom<<")"<<endl;
00072    if (nom == getName() ) 
00073       {
00074          resultat = this ;
00075       }
00076    else if (_referenceObjectsMap.find (nom) != _referenceObjectsMap.end ()) 
00077       {
00078          // On recupere le referentiel
00079          resultat = & _referenceObjectsMap.getObjectOfIndex (nom)->getSimulatedObject() ;
00080       } 
00081    else 
00082       {
00083          MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.find (nom) ;
00084          if ( i != _mirrorObjectsMap.end ()) 
00085             {
00086                // On recupere le miroir
00087                resultat = & ( i->second->getSimulatedObject() ) ;
00088             } 
00089          else if (_duplicatedObjectsMap.find (nom) != _duplicatedObjectsMap.end()) 
00090             {
00091                //this shouldn't happen, as duplicate objects are also in the referenceObjectMap
00092                cout<<"PsPvmController::getPointerToSimulatedObjectNamed : found in _duplicatedObjectsMap: problem"<<endl;
00093                resultat = &_duplicatedObjectsMap.getObjectOfIndex (nom)->getSimulatedObject() ;
00094             }
00095          else {
00096             PsObjectDescriptor * objectDescription = _simulationTree.findDescendantNamed (nom) ;
00097             if ( objectDescription != NULL ) 
00098                {
00099                   PsSimulatedObject * obj = createDescribedObject ( objectDescription ) ;
00100                   
00101                   PsDuplicatedObject * objDup = dynamic_cast<PsDuplicatedObject *>(obj);
00102                   
00103                   if( objDup == NULL ) 
00104                      {
00105                         createMirrorObject ( objectDescription ) ;
00106                      }
00107                   else 
00108                      {
00109                         PsnDuplicatedObjectHandle * newObjectHandle = createDuplicatedObject ( objectDescription );   
00110                         
00111                         if ( objectDescription->getFrequency() != computeAdequateFrequency (objectDescription->getFrequency()) )
00112                            {
00113                               //the whole scheduling data structure needs recalculating
00114                               computeScheduling ( false ) ;
00115                               
00116                               //the new object will therefore be scheduled with all the others
00117                               scheduleControlledObjects() ;
00118                            }
00119                         else
00120                            {
00121                               scheduleObject ( newObjectHandle ) ;
00122                            }
00123                         
00124                         sendInitialEventsTo ( *newObjectHandle, _date ) ; 
00125                         fireValuedSignal(PsSystemEventIdentifier::MaskObjectCreated,nom ) ;
00126                         
00127                         //here, nothing is done for creation process coherence. It might be usefull to initialise the object for duplicated objects
00128                      }
00129                   resultat = obj ;
00130                }
00131          }
00132       }
00133    return resultat ;
00134 }

virtual PsnDuplicatedObjectHandle* PsDistributedController::newPsnDuplicatedObjectHandle (  PsSimulatedObject &    obj )  [protected, pure virtual]
 

create a duplicated object handle adapted to distribution mode

Parameters:
obj : the object to encapsulate in an objetc handle : a duplicated object handle encapsulating the object

Implemented in PsPvmController.

Referenced by createDuplicatedObject().

virtual PsnMirrorObjectHandle* PsDistributedController::newPsnMirrorObjectHandle (  PsSimulatedObject &    obj )  [protected, pure virtual]
 

create an mirror object handle adapted to distribution mode

Parameters:
obj : the object to encapsulate in an objetc handle : a mirror object handle encapsulating the object

Implemented in PsMomeController, and PsPvmController.

Referenced by createMirrorObject().

bool PsDistributedController::processEvent (  PsEvent *    event )  [virtual]
 

redefine event processing to broadcast system events to other controllers

Reimplemented from PsController.

Definition at line 257 of file PsDistributedController.cxx.

References _broadcastedSignals, PsController::_controledObjectsSignalsDispatcher, PsController::_simulationTree, list< pair< PsEventIdentifier, pair< PsEvent *, PsDate > > >::begin(), PsnSignalDispatcher::cancelRegistrationForSignal(), PsEvent::date, PsController::deleteObject(), list< pair< PsEventIdentifier, pair< PsEvent *, PsDate > > >::end(), PsEvent::eventId, PsObjectDescriptor::findDescendantNamed(), PsSystemEventIdentifier::MaskCancelRegistrationForSignal, PsSystemEventIdentifier::MaskObjectDestroyed, PsSystemEventIdentifier::MaskRegisterForSignal, PsController::processEvent(), PsEvent::receiver, PsnSignalDispatcher::registerForSignal(), PsSimulatedObject::sendEvent(), and PsValuedEvent< UserType >::value. 

00258 {
00259    bool result ;
00260    if ( event->eventId == PsSystemEventIdentifier::MaskRegisterForSignal )
00261       {
00262          PsValuedEvent<RegistrationData> * realEvent = dynamic_cast<PsValuedEvent<RegistrationData> *>( event ) ;
00263          assert (realEvent != NULL ) ;
00264          
00265          cerr<<"PsDistributedController::processEvent received registration from "<<realEvent->value._registrant<<endl;
00266 
00267          _controledObjectsSignalsDispatcher.registerForSignal(realEvent->value._sig , 
00268                                                               realEvent->value._registrant , 
00269                                                               realEvent->value._eventId) ;
00270 
00271          result = true ;
00272 
00273          //find out if an allready broadcasted signal should sent to the registrant
00274          for ( list<pair<PsEventIdentifier, pair <PsEvent *, PsDate> > >::iterator i = _broadcastedSignals.begin() ;
00275                i != _broadcastedSignals.end() ;
00276                ++i )
00277             {
00278                if ( i->first == realEvent->value._sig )
00279                   {
00280         
00281                      if ( i->second.second >= realEvent->date )
00282                         {
00283                            PsEvent * sentEvent = i->second.first->clone() ;
00284                            sentEvent->eventId = realEvent->value._eventId ;
00285                            sentEvent->receiver = realEvent->value._registrant ;
00286                            sendEvent ( sentEvent ) ;
00287                         }
00288                   }
00289             }
00290 
00291       }
00292    else if ( event->eventId == PsSystemEventIdentifier::MaskCancelRegistrationForSignal )
00293       {
00294          PsValuedEvent<CancellationData> * realEvent = dynamic_cast<PsValuedEvent<CancellationData> *>( event ) ;
00295 
00296          assert (realEvent != NULL ) ;
00297 
00298          _controledObjectsSignalsDispatcher.cancelRegistrationForSignal (realEvent->value._sigId , 
00299                                                                          realEvent->value._registrant) ;
00300          result = true ;
00301       }
00302    else if (event->eventId == PsSystemEventIdentifier::MaskObjectDestroyed)
00303       {
00304          PsValuedEvent<PsName> * realEvent = dynamic_cast<PsValuedEvent<PsName> *>( event ) ;
00305 
00306          assert ( realEvent != NULL ) ;
00307 
00308          PsObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed ( realEvent->value ) ;
00309 
00310          if (objectDescriptor != NULL )
00311             {
00312                deleteObject( objectDescriptor ) ;
00313             }
00314          result = PsController::processEvent ( event ) ;
00315       } 
00316    else
00317       {
00318          result = PsController::processEvent ( event ) ;
00319       }
00320    return result ;
00321 }

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

redefine to create only declarations pertinant to the current node

Reimplemented from PsController.

Definition at line 226 of file PsDistributedController.cxx.

References PsController::_pendingEventsList, _processName, 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::getName(), getPointerToSimulatedObjectNamed(), PsObjectDescriptor::getProcess(), PsController::processNewObjectDeclaration(), PsDate, and PsSimulatedObject::sendEvent(). 

00227 {
00228   //cerr<<"PsDistributedController::processNewObjectDeclaration "<<_processName<<" "<<declaration.getProcess()<<endl;
00229    if ( _processName == declaration.getProcess() ) 
00230       {
00231          PsController::processNewObjectDeclaration ( declaration, declarationDate ) ;
00232       }
00233    else
00234       {
00235          map<PsName, list <PsEvent *> >::iterator pendingEvents = _pendingEventsList.find( declaration.getName() ) ;
00236          if ( pendingEvents != _pendingEventsList.end() )
00237             {
00238 #ifdef _DEBUGEXEC
00239                cerr<<"Found pending events for "<<declaration.getName()<<endl;
00240 #endif
00241                for ( list <PsEvent *>::iterator pendingEventsListIterator = pendingEvents->second.begin() ;
00242                      pendingEventsListIterator != pendingEvents->second.end() ;
00243                      ++pendingEventsListIterator)
00244                   {
00245 #ifdef _DEBUGEXEC
00246                      cerr<<"sent "<<**pendingEventsListIterator<< "to "<<declaration.getName()<<endl;
00247 #endif
00248                      assert ( getPointerToSimulatedObjectNamed(declaration.getName()) != NULL ) ;
00249                      getPointerToSimulatedObjectNamed(declaration.getName())->sendEvent(*pendingEventsListIterator) ; 
00250                   }
00251                _pendingEventsList.erase ( pendingEvents ) ;
00252             }
00253       }
00254 }

void PsDistributedController::processStartEventOf (  PsnReferenceObjectHandle *    objectHandle )  [protected, virtual]
 

initialisation des referentiels ...

a redefinir en distribue

Returns:
: TRUE si l'init a échouée

Reimplemented from PsController.

Definition at line 139 of file PsDistributedController.cxx.

References PsNameToPointerMap< PsnReferenceObjectHandle >::addObjectWithIndex(), PsSimulatedObject::getName(), PsnObjectHandle::getSimulatedObject(), PsnReferenceObjectHandle::initial, PsController::processStartEventOf(), PsController::setComputingState(), tableDesInitialises, and tableDesNonInitialises. 

00140 {
00141   try 
00142     {
00143       PsController::processStartEventOf ( objectHandle ) ;
00144       tableDesInitialises.addObjectWithIndex ( objectHandle->getSimulatedObject ().getName (), 
00145                                                objectHandle) ;
00146 #ifdef _DEBUGDISTRIBUTEDINIT
00147       cerr<<"PsDistributedController::processStartEventOf init of "
00148           << objectHandle->getSimulatedObject ().getName ()
00149           <<" successfull"<<endl;
00150 #endif
00151     }
00152   catch (PsUnInitialisedAttributeException & e) 
00153     {
00154 #ifdef _DEBUGDISTRIBUTEDINIT
00155       cerr<<"PsDistributedController::processStartEventOf init of "
00156           << objectHandle->getSimulatedObject ().getName ()
00157           <<" failed"<<endl;
00158 #endif
00159       setComputingState (objectHandle, PsnReferenceObjectHandle::initial ) ;
00160       tableDesNonInitialises.addObjectWithIndex ( objectHandle->getSimulatedObject ().getName () , 
00161                                                   objectHandle) ;
00162     }
00163 }

void PsDistributedController::purgeMemoryFromOldEvents (  const PsDate &    dateOfOldestKept )  [virtual]
 

redefine to purge the list of remembered broadcasted signals

Reimplemented from PsController.

Definition at line 347 of file PsDistributedController.cxx.

References _broadcastedSignals, list< pair< PsEventIdentifier, pair< PsEvent *, PsDate > > >::empty(), list< pair< PsEventIdentifier, pair< PsEvent *, PsDate > > >::front(), list< pair< PsEventIdentifier, pair< PsEvent *, PsDate > > >::pop_front(), PsDate, PsController::purgeMemoryFromOldEvents(), and pair< T1, T2 >::second.

Referenced by ~PsDistributedController(). 

00348 {
00349    PsController::purgeMemoryFromOldEvents ( dateOfOldestKept ) ;
00350    //purge the list of old broadcasted signals. 2 * _stepPeriod is arbitrary. The effective distributed controller should redefine this according to it's latency
00351    pair<PsEventIdentifier, pair <PsEvent *, PsDate> > examinedPair ;
00352    bool disposableElements = !_broadcastedSignals.empty() ;
00353    while ( disposableElements )
00354       {
00355          examinedPair = _broadcastedSignals.front() ;
00356          if ( examinedPair.second.second < dateOfOldestKept )
00357             {
00358                delete examinedPair.second.first ;
00359                _broadcastedSignals.pop_front() ;
00360                disposableElements = !_broadcastedSignals.empty() ;
00361             }
00362          else 
00363             {
00364                disposableElements = false ;
00365             }
00366       }
00367 
00368 }

bool PsDistributedController::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 from PsController.

Definition at line 390 of file PsDistributedController.cxx.

References PsController::_date, PsSimulatedObject::getName(), PsSystemEventIdentifier::MaskCancelRegistrationForSignal, and PsSimulatedObject::sendEvent(). 

00390                                                                                                                          {
00391    PsValuedEvent<CancellationData> * event ;
00392    event= new PsValuedEvent<CancellationData> (PsSystemEventIdentifier::MaskCancelRegistrationForSignal, _date, getName(), getName() ,CancellationData (sigId, registrant) ) ;
00393    sendEvent (event) ;
00394    return true ;
00395 }

bool PsDistributedController::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 from PsController.

Definition at line 379 of file PsDistributedController.cxx.

References PsController::_date, PsSimulatedObject::getName(), PsSystemEventIdentifier::MaskRegisterForSignal, and PsSimulatedObject::sendEvent(). 

00382 {
00383    PsValuedEvent<RegistrationData> * event ;
00384    event= new PsValuedEvent<RegistrationData> (PsSystemEventIdentifier::MaskRegisterForSignal, _date, getName(), getName() ,RegistrationData (sig, registrant, eventId) ) ;
00385    sendEvent (event) ;
00386    return true ;
00387 }

Member Data Documentation

list<pair<PsEventIdentifier, pair <PsEvent *, PsDate> > > PsDistributedController::_broadcastedSignals [protected]
 

the list storing the recently broadcasted signals

Definition at line 147 of file PsDistributedController.h.

Referenced by broadcastEventsForSignal(), processEvent(), and purgeMemoryFromOldEvents().

PsNameToPointerMap<PsnDuplicatedObjectHandle> PsDistributedController::_duplicatedObjectsMap [protected]
 

data structure containing references to the DuplicatedObjectHandlers

Definition at line 128 of file PsDistributedController.h.

Referenced by createDuplicatedObject(), and getPointerToSimulatedObjectNamed().

MirrorObjectsContainerType PsDistributedController::_mirrorObjectsMap [protected]
 

data structure containing references to the MirrorObjectHandlers

Definition at line 124 of file PsDistributedController.h.

Referenced by createMirrorObject(), and getPointerToSimulatedObjectNamed().

PsName PsDistributedController::_processName [protected]
 

name of the process this controller is controlling

Definition at line 144 of file PsDistributedController.h.

Referenced by createControlledObjects(), createObject(), and processNewObjectDeclaration().

PsNameToPointerMap<PsnReferenceObjectHandle> PsDistributedController::tableDesInitialises [protected]
 

la table des référentiels initilisés

Definition at line 141 of file PsDistributedController.h.

Referenced by processStartEventOf().

PsNameToPointerMap<PsnReferenceObjectHandle> PsDistributedController::tableDesNonInitialises [protected]
 

la table des référentiels non-initilisés

Definition at line 138 of file PsDistributedController.h.

Referenced by PsMomeController::init(), and processStartEventOf().

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

Documentation generated on Mon Nov 25 15:25:57 2002

Generated with doxygen 1.2.12 by Dimitri van Heesch ,   1997-2001