---

PsDistributedController.cxx

Go to the documentation of this file.

/*
 * This file is part of openMask © INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software
 * 
 * The Software has been developped within the Siames Project. 
 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200
 *
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 
 * for the software may use this file in accordance with that specific license 
 *
 */
#include <PsDistributedController.h>
#include <PsDuplicatedObject.h>
#include <PsnMirrorObjectHandle.h>
#include <PsnDuplicatedObjectHandle.h>
#include <PsObjectDescriptor.h>
#include "PsSystemEventIdentifier.h"
#include "PsUnInitialisedAttributeException.h"
#include "PsnCurrentActiveObject.h"

//------------------------------------------------------------------------------

PsDistributedController::PsDistributedController( PsObjectDescriptor & initialObjects, const PsDate & initialDate ) 
   : PsController(initialObjects, initialDate),
     _processName (initialObjects.getProcess())
{
}

//------------------------------------------------------------------------------

PsDistributedController::~PsDistributedController() 
{
  purgeMemoryFromOldEvents ( _date + _stepPeriod ) ;
}


PsnDuplicatedObjectHandle * PsDistributedController::createDuplicatedObject( PsObjectDescriptor * objectDescription ) 
{
   PsnDuplicatedObjectHandle * result ;

   PsSimulatedObject * createdObject = createDescribedObject(objectDescription) ;

   if (createdObject == NULL) 
      {
         cerr<<"PsController::createReferenceObject: unable to create "<<*objectDescription<<endl;
      }
   else
      {
         result = newPsnDuplicatedObjectHandle(*createdObject) ;
         
         _referenceObjectsMap.addObjectWithIndex (objectDescription->getName(), result);
         _duplicatedObjectsMap.addObjectWithIndex (objectDescription->getName(),result);
      }
   return result ;
}

//------------------------------------------------------------------------------

PsSimulatedObject * PsDistributedController::getPointerToSimulatedObjectNamed (const PsName & nom) {
   //in case of dynamic creation of objects
   PsnCurrentActiveObject context ( NULL ) ;   

   PsSimulatedObject * resultat = NULL ;
   // On verifie que l'objet est un referentiel
   //cerr<<"PsDistributedController::getPointerToSimulatedObjectNamed("<<nom<<")"<<endl;
   if (nom == getName() ) 
      {
         resultat = this ;
      }
   else if (_referenceObjectsMap.find (nom) != _referenceObjectsMap.end ()) 
      {
         // On recupere le referentiel
         resultat = & _referenceObjectsMap.getObjectOfIndex (nom)->getSimulatedObject() ;
      } 
   else 
      {
         MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.find (nom) ;
         if ( i != _mirrorObjectsMap.end ()) 
            {
               // On recupere le miroir
               resultat = & ( i->second->getSimulatedObject() ) ;
            } 
         else if (_duplicatedObjectsMap.find (nom) != _duplicatedObjectsMap.end()) 
            {
               //this shouldn't happen, as duplicate objects are also in the referenceObjectMap
               cout<<"PsPvmController::getPointerToSimulatedObjectNamed : found in _duplicatedObjectsMap: problem"<<endl;
               resultat = &_duplicatedObjectsMap.getObjectOfIndex (nom)->getSimulatedObject() ;
            }
         else {
            PsObjectDescriptor * objectDescription = _simulationTree.findDescendantNamed (nom) ;
            if ( objectDescription != NULL ) 
               {
                  PsSimulatedObject * obj = createDescribedObject ( objectDescription ) ;
                  
                  PsDuplicatedObject * objDup = dynamic_cast<PsDuplicatedObject *>(obj);
                  
                  if( objDup == NULL ) 
                     {
                        createMirrorObject ( objectDescription ) ;
                     }
                  else 
                     {
                        PsnDuplicatedObjectHandle * newObjectHandle = createDuplicatedObject ( objectDescription );   
                        
                        if ( objectDescription->getFrequency() != computeAdequateFrequency (objectDescription->getFrequency()) )
                           {
                              //the whole scheduling data structure needs recalculating
                              computeScheduling ( false ) ;
                              
                              //the new object will therefore be scheduled with all the others
                              scheduleControlledObjects() ;
                           }
                        else
                           {
                              scheduleObject ( newObjectHandle ) ;
                           }
                        
                        sendInitialEventsTo ( *newObjectHandle, _date ) ; 
                        fireValuedSignal(PsSystemEventIdentifier::MaskObjectCreated,nom ) ;
                        
                        //here, nothing is done for creation process coherence. It might be usefull to initialise the object for duplicated objects
                     }
                  resultat = obj ;
               }
         }
      }
   return resultat ;
}


//------------------------------------------------------------------------------

void PsDistributedController::processStartEventOf(PsnReferenceObjectHandle * objectHandle)
{
  try 
    {
      PsController::processStartEventOf ( objectHandle ) ;
      tableDesInitialises.addObjectWithIndex ( objectHandle->getSimulatedObject ().getName (), 
                                               objectHandle) ;
#ifdef _DEBUGDISTRIBUTEDINIT
      cerr<<"PsDistributedController::processStartEventOf init of "
          << objectHandle->getSimulatedObject ().getName ()
          <<" successfull"<<endl;
#endif
    }
  catch (PsUnInitialisedAttributeException & e) 
    {
#ifdef _DEBUGDISTRIBUTEDINIT
      cerr<<"PsDistributedController::processStartEventOf init of "
          << objectHandle->getSimulatedObject ().getName ()
          <<" failed"<<endl;
#endif
      setComputingState (objectHandle, PsnReferenceObjectHandle::initial ) ;
      tableDesNonInitialises.addObjectWithIndex ( objectHandle->getSimulatedObject ().getName () , 
                                                  objectHandle) ;
    }
}


//------------------------------------------------------------------------------

void PsDistributedController::dispatchEvent(PsEvent * event) {
#ifdef _DEBUGEVT
   cerr<<"PsDistributedController::dispatchEvent pour "<<event->receiver<<endl;
#endif
   PsNameToPointerMap<PsnReferenceObjectHandle>::iterator i = _referenceObjectsMap.find(event->receiver);
   assert(i!=_referenceObjectsMap.end());
   (*i).second->receiveEvent( event );
#ifdef _DEBUGEVT
         cerr<<"PsDistributedController::dispatchEvent fin"<<endl;
#endif
} 

//------------------------------------------------------------------------------

PsnMirrorObjectHandle * PsDistributedController::createMirrorObject(PsObjectDescriptor * objectDescription) 
{
   PsnMirrorObjectHandle * result = NULL ;
   PsSimulatedObject * obj = createDescribedObject( objectDescription ) ;
   if ( obj == NULL )
      {
         cerr<<"PsController::createReferenceObject: unable to create "<<*objectDescription<<endl;
      }
   else
      {
         result = newPsnMirrorObjectHandle(*obj) ;
                 
         _mirrorObjectsMap.insert ( MirrorObjectsContainerType::value_type(objectDescription->getName (), result ) ) ;
      }
   return result ;   
}

//------------------------------------------------------------------------------

void PsDistributedController::createControlledObjects( const PsObjectDescriptor * subTree ) 
{
   //go through the simulation tree to find all objects that have to be created
   PsObjectDescriptor::SonsContainerType::const_iterator i = subTree->getSons()->begin() ;
   while ( i != subTree->getSons()->end() )
      {
         if ( (*i)->getProcess() == _processName ) 
            {
               cerr<<"Creating "<< (*i)->getName() << endl ;
               //create the object
               createReferenceObject ( (*i) ) ;
            }    
         else 
            {
               cerr<<"Not Creating "<< (*i)->getName() 
                   <<" of process "<< (*i)->getProcess()
                   <<endl ;
            }
         //create the subTree of that object
         createControlledObjects ( *i ) ;
         
         ++i ;
      }
}

void PsDistributedController::processNewObjectDeclaration ( PsObjectDescriptor & declaration, const PsDate & declarationDate )
{
  //cerr<<"PsDistributedController::processNewObjectDeclaration "<<_processName<<" "<<declaration.getProcess()<<endl;
   if ( _processName == declaration.getProcess() ) 
      {
         PsController::processNewObjectDeclaration ( declaration, declarationDate ) ;
      }
   else
      {
         map<PsName, list <PsEvent *> >::iterator pendingEvents = _pendingEventsList.find( declaration.getName() ) ;
         if ( pendingEvents != _pendingEventsList.end() )
            {
#ifdef _DEBUGEXEC
               cerr<<"Found pending events for "<<declaration.getName()<<endl;
#endif
               for ( list <PsEvent *>::iterator pendingEventsListIterator = pendingEvents->second.begin() ;
                     pendingEventsListIterator != pendingEvents->second.end() ;
                     ++pendingEventsListIterator)
                  {
#ifdef _DEBUGEXEC
                     cerr<<"sent "<<**pendingEventsListIterator<< "to "<<declaration.getName()<<endl;
#endif
                     assert ( getPointerToSimulatedObjectNamed(declaration.getName()) != NULL ) ;
                     getPointerToSimulatedObjectNamed(declaration.getName())->sendEvent(*pendingEventsListIterator) ; 
                  }
               _pendingEventsList.erase ( pendingEvents ) ;
            }
      }
}

   
bool PsDistributedController::processEvent ( PsEvent * event )
{
   bool result ;
   if ( event->eventId == PsSystemEventIdentifier::MaskRegisterForSignal )
      {
         PsValuedEvent<RegistrationData> * realEvent = dynamic_cast<PsValuedEvent<RegistrationData> *>( event ) ;
         assert (realEvent != NULL ) ;
         
         cerr<<"PsDistributedController::processEvent received registration from "<<realEvent->value._registrant<<endl;

         _controledObjectsSignalsDispatcher.registerForSignal(realEvent->value._sig , 
                                                              realEvent->value._registrant , 
                                                              realEvent->value._eventId) ;

         result = true ;

         //find out if an allready broadcasted signal should sent to the registrant
         for ( list<pair<PsEventIdentifier, pair <PsEvent *, PsDate> > >::iterator i = _broadcastedSignals.begin() ;
               i != _broadcastedSignals.end() ;
               ++i )
            {
               if ( i->first == realEvent->value._sig )
                  {
        
                     if ( i->second.second >= realEvent->date )
                        {
                           PsEvent * sentEvent = i->second.first->clone() ;
                           sentEvent->eventId = realEvent->value._eventId ;
                           sentEvent->receiver = realEvent->value._registrant ;
                           sendEvent ( sentEvent ) ;
                        }
                  }
            }

      }
   else if ( event->eventId == PsSystemEventIdentifier::MaskCancelRegistrationForSignal )
      {
         PsValuedEvent<CancellationData> * realEvent = dynamic_cast<PsValuedEvent<CancellationData> *>( event ) ;

         assert (realEvent != NULL ) ;

         _controledObjectsSignalsDispatcher.cancelRegistrationForSignal (realEvent->value._sigId , 
                                                                         realEvent->value._registrant) ;
         result = true ;
      }
   else if (event->eventId == PsSystemEventIdentifier::MaskObjectDestroyed)
      {
         PsValuedEvent<PsName> * realEvent = dynamic_cast<PsValuedEvent<PsName> *>( event ) ;

         assert ( realEvent != NULL ) ;

         PsObjectDescriptor * objectDescriptor = _simulationTree.findDescendantNamed ( realEvent->value ) ;

         if (objectDescriptor != NULL )
            {
               deleteObject( objectDescriptor ) ;
            }
         result = PsController::processEvent ( event ) ;
      } 
   else
      {
         result = PsController::processEvent ( event ) ;
      }
   return result ;
}
 


void PsDistributedController::deleteObjectHandle ( PsnObjectHandle * objectHandle )
{
   _deletedObjectHandles.push_back ( make_pair ( _date,objectHandle ) ) ;
}



void PsDistributedController::createObject(const PsObjectDescriptor & newObjectDescription, const PsName & fathersName)
{
   PsName noProcess ;
   if ( newObjectDescription.getProcess() == noProcess )
      {
         PsObjectDescriptor modifiableObjectDescription ( newObjectDescription ) ;
         modifiableObjectDescription.setProcess ( _processName ) ;
         PsController::createObject( modifiableObjectDescription, fathersName ) ;
      }
   else
      {
         PsController::createObject( newObjectDescription, fathersName ) ;
      }
}

void PsDistributedController::purgeMemoryFromOldEvents ( const PsDate & dateOfOldestKept )
{
   PsController::purgeMemoryFromOldEvents ( dateOfOldestKept ) ;
   //purge the list of old broadcasted signals. 2 * _stepPeriod is arbitrary. The effective distributed controller should redefine this according to it's latency
   pair<PsEventIdentifier, pair <PsEvent *, PsDate> > examinedPair ;
   bool disposableElements = !_broadcastedSignals.empty() ;
   while ( disposableElements )
      {
         examinedPair = _broadcastedSignals.front() ;
         if ( examinedPair.second.second < dateOfOldestKept )
            {
               delete examinedPair.second.first ;
               _broadcastedSignals.pop_front() ;
               disposableElements = !_broadcastedSignals.empty() ;
            }
         else 
            {
               disposableElements = false ;
            }
      }

}

void PsDistributedController::broadcastEventsForSignal ( PsEvent & event, const PsEventIdentifier & sigId )
{
   PsController::broadcastEventsForSignal ( event, sigId ) ;

   //remember the broadcasted signal to be able to send it to objects whose registration is still under way
   _broadcastedSignals.push_back ( make_pair ( sigId, make_pair (event.clone(), _date) ) ) ;

}

bool PsDistributedController::receiveRegistrationForSignal(const PsEventIdentifier & sig,
                                                           const PsName & registrant, 
                                                           const PsEventIdentifier & eventId)
{
   PsValuedEvent<RegistrationData> * event ;
   event= new PsValuedEvent<RegistrationData> (PsSystemEventIdentifier::MaskRegisterForSignal, _date, getName(), getName() ,RegistrationData (sig, registrant, eventId) ) ;
   sendEvent (event) ;
   return true ;
}


bool PsDistributedController::receiveCancellationForSignal ( const PsEventIdentifier & sigId , const PsName & registrant ) {
   PsValuedEvent<CancellationData> * event ;
   event= new PsValuedEvent<CancellationData> (PsSystemEventIdentifier::MaskCancelRegistrationForSignal, _date, getName(), getName() ,CancellationData (sigId, registrant) ) ;
   sendEvent (event) ;
   return true ;
}

PsDistributedController::RegistrationData::RegistrationData (const PsEventIdentifier & sig,
                                                                  const PsName & registrant, 
                                                             const PsEventIdentifier & eventId) :
   _sig ( sig ),
   _registrant (registrant),
   _eventId (eventId)
{
}

PsDistributedController::RegistrationData::~RegistrationData ()
{
}
void PsDistributedController::RegistrationData::unpack (PsIncomingSynchronisationMessage & in ) 
{
   in>>_sig>>_registrant>>_eventId ;  
}

void PsDistributedController::RegistrationData::pack (PsOutgoingSynchronisationMessage & out) const 
{
   out<<_sig<<_registrant<<_eventId;
}

void PsDistributedController::RegistrationData::extract (istream & in ) 
{
   in>>_sig>>_registrant>>_eventId ;  
}

void PsDistributedController::RegistrationData::insertInStream (ostream &  out) const 
{
   out<<_sig<<" "<<_registrant<<" "<<_eventId<<" ";
}



PsPolatorNT * PsDistributedController::RegistrationData::createPolator() 
{
   return new PsPolator<RegistrationData>() ;
}
PsPolatorNT * PsDistributedController::CancellationData::createPolator() 
{
   return new PsPolator<CancellationData>() ;
}
PsDistributedController::CancellationData::CancellationData (const PsEventIdentifier & sigId,
                                                             const PsName & registrant ) :
   _sigId ( sigId ),
   _registrant (registrant)
{
}

PsDistributedController::CancellationData::~CancellationData ()
{
}
void PsDistributedController::CancellationData::unpack (PsIncomingSynchronisationMessage & in ) 
{
   in>>_sigId>>_registrant;  
}

void PsDistributedController::CancellationData::pack (PsOutgoingSynchronisationMessage & out) const 
{
   out<<_sigId<<_registrant;
}

void PsDistributedController::CancellationData::extract (istream & in ) 
{
   in>>_sigId>>_registrant;  
}

void PsDistributedController::CancellationData::insertInStream (ostream &  out) const 
{
   out<<_sigId<<" "<<_registrant<<" ";
}

---