OMKDistributedController.cpp

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 <OMKDistributedController.h>

#include <OMKMirrorObjectHandle.h>
#include <OMKObjectDescriptor.h>

#include <OMKReferenceObjectHandle.h>
#include "OMKSystemEventIdentifier.h"
#include "OMKUnInitialisedAttributeException.h"
#include "OMKCurrentActiveObject.h"
#include "OMKTracer.h"
#include <OMKScheduler.h>
#ifdef _MSC_VER
#include <time.h>
#else
#include <sys/time.h>
#endif

using namespace std ;
using namespace OMK ;
using namespace OMK::Type ;


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

DistributedController::DistributedController( ObjectDescriptor & initialObjects, const Date & initialDate ) 
  : Controller(initialObjects, initialDate),
    _processName (initialObjects.getProcess())
{
}

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

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


DuplicatedObjectHandle * DistributedController::createDuplicatedObject( ObjectDescriptor * objectDescription ) 
{
  DuplicatedObjectHandle * result = NULL ;

  SimulatedObject * createdObject = createDescribedObject(objectDescription) ;

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

//------------------------------------------------------------------------------
SimulatedObject * DistributedController::getPointerToSimulatedObjectNamed (const Name & nom) {
   //std::cout << "***** process " << getObjectDescriptor ().getProcess () << " : demande de " << nom << std::endl ;
  //in case of dynamic creation of objects
  CurrentActiveObject context ( NULL ) ;   
  
  SimulatedObject * resultat = NULL ;
  // On verifie que l'objet est un referentiel
  //cerr<<"DistributedController::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<<"DistributedController::getPointerToSimulatedObjectNamed : found in _duplicatedObjectsMap: problem"<<endl;
          resultat = &_duplicatedObjectsMap.getObjectOfIndex (nom)->getSimulatedObject() ;
        }
      
      else if (_localObjectsMap.find (nom) != _localObjectsMap.end()) 
        {
          //this shouldn't happen, as Local objects are also in the referenceObjectMap
           //cout<<"DistributedController::getPointerToSimulatedObjectNamed : found in _LocalObjectsMap: problem: "<<nom<<endl;
          // TDTD : I think local objects are NOT in the referenceObjectMap...
          // BEGIN TDTD : pour voir si ça évite d'avoir un miroir : je renvoie NULL, mais ça ne change rien... !!!
          resultat = &_localObjectsMap.getObjectOfIndex (nom)->getSimulatedObject() ;
          //resultat = NULL ;
          // END TDTD
        }
      
      else {
        
        ObjectDescriptor * objectDescription = _simulationTree.findDescendantNamed (nom) ;
        if ( objectDescription != NULL ) 
          {
            SimulatedObject * obj = createDescribedObject ( objectDescription ) ;
            bool isDuplicatedOject = objectDescription->getDistribution() == ObjectDescriptor::DUPLICATED_OBJECT ;
            bool isLocalOject = objectDescription->getDistribution() == ObjectDescriptor::LOCAL_OBJECT ;
            if( !isDuplicatedOject && !isLocalOject ) 
              {
                createMirrorObject ( objectDescription ) ;
              }
            else if ( isLocalOject )  
              {
                 // BEGIN TDTD : enlever les locaux des autres processus
                 // ici il y a une amélioration notable, mais ce n'est pas encore cela...
                 //std::cout << "##### process " << getObjectDescriptor ().getProcess () << " : demande de " << nom << " qui est sur process " << objLoc->getObjectDescriptor ().getProcess () << std::endl ;
                 if (obj->getObjectDescriptor ().getProcess () == getObjectDescriptor ().getProcess ()) {
                    //std::cout << "~~~~~ process " << getObjectDescriptor ().getProcess () << " : demande de " << nom << " qui est sur process " << objLoc->getObjectDescriptor ().getProcess () << std::endl ;
                    _localObjectsMap.addObjectWithIndex (obj->getName(),(LocalObjectHandle *)getObjectHandle() );
                 } else {
                    obj = NULL ;
                 }
                 //_localObjectsMap.addObjectWithIndex (obj->getName(),(LocalObjectHandle *)getObjectHandle() );
                 // END TDTD
              }
            else if ( isDuplicatedOject )
              {
                DuplicatedObjectHandle * 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(SystemEventIdentifier::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 DistributedController::createLocalObject(const ObjectDescriptor & newLObjectDescription, const Name & fathersLName ) 
{

  _localObjectsMap.addObjectWithIndex (newLObjectDescription.getName(),
                                       (LocalObjectHandle *)getObjectHandle()  );
  
  Name noProcess ;
  if ( newLObjectDescription.getProcess() == noProcess )
    {
      ObjectDescriptor modifiableObjectDescription ( newLObjectDescription ) ;
      modifiableObjectDescription.setProcess ( _processName ) ;
      Controller::createLocalObject( modifiableObjectDescription, fathersLName ) ;
    }
  else
    {
      Controller::createLocalObject( newLObjectDescription, fathersLName ) ;
    }
}
/************************************/
int DistributedController::getMirrorsNbre() {
  int j=0;
  for ( MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.begin(); 
        i!= _mirrorObjectsMap.end(); 
        i++ )
    {
      j++;
    }
  return j;
}
/************************************/
bool DistributedController::isAMirror(const Name & name)
{
  if (_mirrorObjectsMap.find (name) !=  _mirrorObjectsMap.end ()) 
    return true;
  return false;
  
}
/*************************************/
vector<Name> DistributedController::getMirrorList()
{
  _publicMirrorObjectsVector.clear() ;
  for ( MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.begin();
        i!= _mirrorObjectsMap.end(); 
        i++ )
    {
      _publicMirrorObjectsVector.push_back( i->first) ;
    }

  return  _publicMirrorObjectsVector;
}
const ObjectDescriptor & DistributedController::getObjectDescriptorOfObject(const Name & objectName) 
{
  //no call to ancestor, because performer will catch the exception thrown in case of problems
  if (_simulationTree.findDescendantNamed(objectName) != NULL )
    {
      return *(_simulationTree.findDescendantNamed(objectName));
    }
  else 
    {
      //the object might have just been deleted : look for it in _deletedObjectDescriptors
      list <pair <Date, ObjectDescriptor *> >::iterator i = _deletedObjectDescriptors.begin() ;
      while ( i != _deletedObjectDescriptors.end() )
        {
          if (i->second->getName() == objectName )
            {
              return *i->second ;
            }
          ++i ;
        }
      UserException e("UnknownObject :") ; 
      e<<objectName ;
      throw e ;
    }
}

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

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


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

void DistributedController::dispatchEvent(Event * event) {
#ifdef _DEBUGEVT
  cerr<<"DistributedController::dispatchEvent pour "<<event->receiver<<endl;
#endif
  NameToPointerMap<ReferenceObjectHandle>::iterator i = _referenceObjectsMap.find(event->receiver);
  OMASSERTM(i!=_referenceObjectsMap.end(), "");
  (*i).second->receiveEvent( event );
#ifdef _DEBUGEVT
  cerr<<"DistributedController::dispatchEvent fin"<<endl;
#endif
} 

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

MirrorObjectHandle * DistributedController::createMirrorObject(ObjectDescriptor * objectDescription) 
{
  MirrorObjectHandle * result = NULL ;
  SimulatedObject * obj = createDescribedObject( objectDescription ) ;
  if ( obj == NULL )
    {
      cerr<<"Controller::createMirrorObject: unable to create "<<*objectDescription<<endl;
    }
  else
    {
      result = newOMKMirrorObjectHandle(*obj) ;
                 
      _mirrorObjectsMap.insert ( MirrorObjectsContainerType::value_type(objectDescription->getName (), result ) ) ;
    }
  return result ;   
}

//------------------------------------------------------------------------------
// void DistributedController::createControlledObjects(const ObjectDescriptor * subTree) 
// {
//   //go through the simulation tree to find all objects that have to be created
//   ObjectDescriptor::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 DistributedController::createControlledObjects(const ObjectDescriptor * subTree) 
{
  //go through the simulation tree to find all objects that have to be created
  ObjectDescriptor::SonsContainerType::const_iterator i = subTree->getSons()->begin() ;
  while ( i != subTree->getSons()->end() )
    {
      if ( (*i)->getProcess() == _processName ) 
        {
#ifdef _DEBUGEXEC
          cerr<<"Creating "<< (*i)->getName() << endl ;
#endif
          //create the object
          createReferenceObject ( (*i) ) ;
        }        
      else 
        {
#ifdef _DEBUGEXEC
          cerr<<"Not Creating "<< (*i)->getName() 
              <<" of process "<< (*i)->getProcess()
              <<endl ;
#endif
        }
      //create the subTree of that object
      createControlledObjects ( *i ) ;
      ++i ;
    }
}
void DistributedController::processNewObjectDeclaration ( ObjectDescriptor & declaration, const Date & declarationDate )
{
  //cerr<<"DistributedController::processNewObjectDeclaration "<<_processName<<" "<<declaration.getProcess()<<endl;
  if ( _processName == declaration.getProcess() ) 
    {
      Controller::processNewObjectDeclaration ( declaration, declarationDate ) ;
    }
  else
    {
      map<Name, list <Event *> >::iterator pendingEvents = _pendingEventsList.find( declaration.getName() ) ;
      if ( pendingEvents != _pendingEventsList.end() )
        {
#ifdef _DEBUGEXEC
          cerr<<"Found pending events for "<<declaration.getName()<<endl;
#endif
          for ( list <Event *>::iterator pendingEventsListIterator = pendingEvents->second.begin() ;
                pendingEventsListIterator != pendingEvents->second.end() ;
                ++pendingEventsListIterator)
            {
#ifdef _DEBUGEXEC
              cerr<<"sent "<<**pendingEventsListIterator<< "to "<<declaration.getName()<<endl;
#endif
              OMASSERTM ( getPointerToSimulatedObjectNamed(declaration.getName()) != NULL, "" ) ;
              getPointerToSimulatedObjectNamed(declaration.getName())->sendEvent(*pendingEventsListIterator) ; 
            }
          _pendingEventsList.erase ( pendingEvents ) ;
        }
    }
}

   
bool DistributedController::processEvent ( Event * event ) {
   // TDTD pour la mesure du temps de migration
   //static struct timeval start_timer, end_timer ;
   //static bool beginMigrationNotYetRegistred = true ;
   // fin TDTD
   bool result=false ;
   if ( event->eventId == SystemEventIdentifier::MaskRegisterForSignal ) {
      ValuedEvent<RegistrationData> * realEvent = dynamic_cast<ValuedEvent<RegistrationData> *>( event ) ;
      OMASSERTM (realEvent != NULL, "" ) ;
      
      
      _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<EventIdentifier, pair <Event *, Date> > >::iterator i = _broadcastedSignals.begin() ;
            i != _broadcastedSignals.end() ;
            ++i ) {
         if ( i->first == realEvent->value._sig ) {
            if ( i->second.second >= realEvent->date ) {
               Event * sentEvent = i->second.first->clone() ;
               sentEvent->eventId = realEvent->value._eventId ;
               sentEvent->receiver = realEvent->value._registrant ;
               sendEvent ( sentEvent ) ;
            }
         }
      }
   } else if ( event->eventId == SystemEventIdentifier::MaskCancelRegistrationForSignal ) {
      ValuedEvent<CancellationData> * realEvent = dynamic_cast<ValuedEvent<CancellationData> *>( event ) ;

      OMASSERTM (realEvent != NULL, "" ) ;

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

      OMASSERTM ( realEvent != NULL, "" ) ;

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

      if (objectDescriptor != NULL ) {
         deleteObject( objectDescriptor ) ;
      }
      result = Controller::processEvent ( event ) ;
   }
   else if ( event->eventId == SystemEventIdentifier::MaskNewLocalObject ) 
   {
      CreateObjectEvent * creationEvent = dynamic_cast< CreateObjectEvent* > ( event ) ;
         
      OMASSERTM (creationEvent != NULL, "" ) ;
      result = true ; // TDTD ajout ...
      // add the described object in the simulation tree : this is a declaration
      ObjectDescriptor * objectDescriptor = 
        _simulationTree.findDescendantNamed( creationEvent->value.getValue().first.getName() );
      if ( objectDescriptor == NULL ) {
         if ( (creationEvent->value.getValue().first.getProcess())==
              (getObjectDescriptor().getProcess()) ) {
            ObjectDescriptor * newObjectDescriptor = 
               new ObjectDescriptor(creationEvent->value.getValue().first) ;
              
            ObjectDescriptor * fathersDescription = 
               _simulationTree.findDescendantNamed ( creationEvent->value.getValue().second ) ;
              
            if (fathersDescription == NULL) {
               fathersDescription = & _simulationTree ;
                  //              ostringstream warningMessage ;
                  //              warningMessage<<"Attached new object named "
                  //                            <<newObjectDescriptor->getName()<<" to "<<getName()
                  //                            <<" because object "<<creationEvent->value.getValue().second
                  //                            <<"is unknown"<<endl;
                  //              warning ( warningMessage.str() , SomeWarnings ) ;
            }
            changeObjectsFather (newObjectDescriptor, fathersDescription) ;
              
            //create the described object
            processNewObjectDeclaration ( *newObjectDescriptor, event->date ) ;
              
            // notify other objects that an object has been created
            fireValuedSignal( SystemEventIdentifier::MaskObjectCreated,
                              creationEvent->value.getValue().first.getName() ) ;
         }
      } else {
          //      ostringstream warningMessage ;
          //      warningMessage<<"WARNING: an object of name "
          //                    <<creationEvent->value.getValue().first.getName()<<" already exists"<<endl;
          //      warning ( warningMessage.str() , SomeWarnings ) ;
      }
   } else if ( event->eventId == SystemEventIdentifier::MaskMetamorphoseMirToRef ) {
      //------- gestion de la migration (chadi)
//       if (beginMigrationNotYetRegistred) { // TDTD pour la mesure du temps de migration
//       gettimeofday(&start_timer, NULL);
//       //std::cerr << "temps de début pris à la date " << getSimulatedDate () << std::endl ;
//       beginMigrationNotYetRegistred = false ;
//       }
      MigrationObjectEvent * morphoseEvent = dynamic_cast< MigrationObjectEvent* > ( event ) ;
       
      OMASSERTM (morphoseEvent != NULL, "" ) ;
      result = true ; // TDTD ajout ...
       
      Name objectToMigrate = morphoseEvent->value.getValue().first ;
      Name destinationProcess = morphoseEvent->value.getValue().second ;
      exProcessName = getObjectDescriptorOfObject(objectToMigrate).getProcess();
      
      if (! (getObjectDescriptorOfObject(objectToMigrate).getProcess () == destinationProcess)) {
         //si egale ca veut dire ke le ref est deja 
         //sur le site destination, donc rien a faire ...
         //appeler emigrate() pour sauvegarder les valeurs internes de l'objet
         // getPointerToSimulatedObjectNamed(objectToMigrate)->emigrate() ;
         
         if (destinationProcess == _processName) {
            // ca veut dire ke g localise le site detenant le miroir elu pr etre ref
            MirrorObjectsContainerType::iterator i = 
               _mirrorObjectsMap.find (objectToMigrate) ;
            if (i != _mirrorObjectsMap.end ()) {                   
               MirrorObjectHandle * mirObjHandle =  i->second ;
               SimulatedObject * objectPtr = &(i->second->getSimulatedObject ()) ;
               mirObjHandle->cancelRegistrationToReferenceObject () ;
               mirObjHandle->setMorphosisPhaseTrue () ;
               
               deleteObjectHandle (mirObjHandle) ;
               
               ReferenceObjectHandle * refObjHandle = createReferenceObjectHandle (*objectPtr) ;
               _referenceObjectsMap.addObjectWithIndex (objectToMigrate, refObjHandle) ;
               _mirrorObjectsMap.erase (i) ;
               
               processStartEventAfterMorphose (refObjHandle) ;
               tableDesInitialises.addObjectWithIndex (refObjHandle->getSimulatedObject ().getName (), 
                                                       refObjHandle) ;
               scheduleObject (refObjHandle) ;
               
               ObjectDescriptor * descriptorOfObjectToMigrate = 
                  const_cast<ObjectDescriptor *> (&getObjectDescriptorOfObject (objectToMigrate)) ;
               descriptorOfObjectToMigrate->setProcess (destinationProcess) ;
               
               //maintenant il faut envoyer un event pour alerter les miroirs:
               //a la reception de cet event les miroirs doivent se deshabonner de 
               //l'ex ref et s'abonner au nouveau
               
        MigrationObjectEvent linkToNewRefEvent( 
          SystemEventIdentifier::MaskLinkToNewReferential,
          getSimulatedDate (),
          getName (),
          getName (),
          MigrationObjectType( MigrationObjectPrm( objectToMigrate, destinationProcess ) ) ) ;
               
               sendEvent (linkToNewRefEvent) ;
            }
         } else { //dans ce cas que les autres miroirs se desabonnent de leur ex-ref
            MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.find (objectToMigrate) ;
            if (i != _mirrorObjectsMap.end ())  {
               ObjectDescriptor * descriptorOfObjectToMigrate = 
                  const_cast<ObjectDescriptor *>
                  (&getObjectDescriptorOfObject (objectToMigrate)) ;
               descriptorOfObjectToMigrate->setProcess (destinationProcess) ;
               
               MirrorObjectHandle * moh =  (i->second) ;
               moh->cancelRegistrationToReferenceObject () ;
               moh->setMorphosisPhaseTrue () ;
            }
            // TDTD j'enlève les commentaires pour faire fonctionner la migration, en modifiant un peu...
            if (_referenceObjectsMap.find (objectToMigrate) != _referenceObjectsMap.end ()) {
               SimulatedObject * objectPtr =
                  &_referenceObjectsMap.getObjectOfIndex (objectToMigrate)->getSimulatedObject() ; 
               objectPtr->emigrate () ;
               ReferenceObjectHandle * refer =  
                  dynamic_cast<ReferenceObjectHandle* >
                  (_referenceObjectsMap.getObjectOfIndex(objectToMigrate));
               refer->setMorphosisPhaseTrue () ;
            }
         }
      }
   }
   else if (event->eventId == SystemEventIdentifier::MaskLinkToNewReferential)
   {
      MigrationObjectEvent * changeRefEvent = dynamic_cast< MigrationObjectEvent* >( event ) ;

      OMASSERTM (changeRefEvent != NULL, "" ) ;
      result = true ; // TDTD ajout ...
      Name objectToMigrate = changeRefEvent->value.getValue().first ;
      Name destinationProcess = changeRefEvent->value.getValue().second ;
      
      if (_processName != destinationProcess) 
      {
               if (_processName!=exProcessName) 
         {
                  //donc c'est un site ki a un miroir, alors brancher ce miroir
                  //sur son nouveau Ref
                  MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.find (objectToMigrate) ;
                  MirrorObjectHandle * moh = (i->second) ;
                  moh->linkToNewReferential(destinationProcess) ;
               } 
         else 
         {
                  //donc c le site ki a l'ex-ref il faut le transformer
                  //en miroir et le brancher sur le nouveau ref
                  MirrorObjectHandle * miroir = NULL ;
                  ReferenceObjectHandle * refe = _referenceObjectsMap.getObjectOfIndex (objectToMigrate) ;
                  SimulatedObject * objectPtr =  
                     &_referenceObjectsMap.getObjectOfIndex (objectToMigrate)
                     ->getSimulatedObject () ;      
                  ObjectDescriptor * descriptorOfObjectToMigrate = 
                     const_cast<ObjectDescriptor *>
                     (& _referenceObjectsMap.getObjectOfIndex (objectToMigrate)
                      ->getSimulatedObject ().getObjectDescriptor ()) ;
                  descriptorOfObjectToMigrate->setProcess (destinationProcess) ;
                  refe->setMigrationCaseToTrue () ;
                  _scheduler->unschedule (refe) ;
                  _scheduler->removeFromScheduable (refe) ;
                  _referenceObjectsMap.erase (objectToMigrate) ;
                  deleteObjectHandle (refe) ;
                  miroir = newOMKMirrorObjectHandle (*objectPtr) ;
                  _mirrorObjectsMap.insert 
                     (MirrorObjectsContainerType::value_type (objectPtr->getName (), miroir)) ;
                  miroir->linkToNewReferential (destinationProcess) ;
               }
               //gettimeofday (&end_timer, NULL) ;
      }
   } else if (event->eventId == "MaskSaveInternalValue") {
      result = true ; // TDTD ajout ...
      if (_referenceObjectsMap.find (event->sender) != _referenceObjectsMap.end ()) {
         SimulatedObject * objectPtr =  
            &_referenceObjectsMap.getObjectOfIndex (event->sender)->getSimulatedObject () ; 
         objectPtr->immigrate (event) ;
      } else if (_mirrorObjectsMap.find (event->sender) != _mirrorObjectsMap.end ()) {
         MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.find (event->sender) ;
         SimulatedObject * objectPtr = &(i->second->getSimulatedObject ()) ;
         objectPtr->immigrate (event) ;
      }
      //gettimeofday (&end_timer, NULL) ;
   // TDTD ajout pour mesurer le temps
//    } else if (event->eventId == "PrintMigrationDuration") {
//       result = true ;
//       double time_in_ms = (end_timer.tv_sec - start_timer.tv_sec) * 1000.0 +
//       (end_timer.tv_usec - start_timer.tv_usec) / 1000.0 ;
//       std::cout << "migration duration on process " << _processName << " = " << time_in_ms << std::endl ;
//       beginMigrationNotYetRegistred = true ;
   } else {
      result = Controller::processEvent ( event ) ;
   }
   return result ;
}
 


void DistributedController::deleteObject ( ObjectDescriptor * objectDescriptor )
{
  _deletedObjectDescriptors.push_back ( make_pair ( _date,objectDescriptor ) ) ;
  Controller::deleteObject ( objectDescriptor ) ;
}



void DistributedController::createObject(const ObjectDescriptor & newObjectDescription,
                                           const Name & fathersName)
{
  Name noProcess ;
  if ( newObjectDescription.getProcess() == noProcess )
    {
      ObjectDescriptor modifiableObjectDescription ( newObjectDescription ) ;
      modifiableObjectDescription.setProcess ( _processName ) ;
      Controller::createObject( modifiableObjectDescription, fathersName ) ;
    }
  else
    {
      Controller::createObject( newObjectDescription, fathersName ) ;
    }
}

void DistributedController::purgeMemoryFromOldEvents ( const Date & dateOfOldestKept )
{
  // purge object descriptors first
  bool disposableElements = !_deletedObjectDescriptors.empty() ;
  pair <Date, ObjectDescriptor *> examinedObjectDescriptor ;
  while ( disposableElements )
    {
      examinedObjectDescriptor = _deletedObjectDescriptors.front() ;
      if ( examinedObjectDescriptor.first < dateOfOldestKept )
        {
#ifdef _DEBUGEXEC
          cerr<<"DistributedController::purgeMemoryFromOldEvents: deleting "
              <<examinedObjectDescriptor.second->getName()<<endl;
#endif
          //only delete if it will not be deleted by the ancestor class : no object (nor object handle) was created
          if (  examinedObjectDescriptor.second->getProcess() != _processName )
            {
                     
              //if ( ) delete examinedObjectDescriptor.second ;
            }
          _deletedObjectDescriptors.pop_front() ;
          disposableElements = !_deletedObjectDescriptors.empty() ;
        }
      else 
        {
          disposableElements = false ;
        }
    }
   



  Controller::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<EventIdentifier, pair <Event *, Date> > examinedPair ;
  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 DistributedController::broadcastEventsForSignal ( Event & event, const EventIdentifier & sigId )
{
  Controller::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 DistributedController::receiveRegistrationForSignal(const EventIdentifier & sig,
                                                           const Name & registrant, 
                                                           const EventIdentifier & eventId)
{
  //   cerr << "DistributedController::receiveRegistrationForSignal " << sig << " | " << registrant << " | " << eventId << endl ;
  ValuedEvent<RegistrationData> * event ;
  event= new ValuedEvent<RegistrationData> (SystemEventIdentifier::MaskRegisterForSignal, _date, getName(), getName() ,RegistrationData (sig, registrant, eventId) ) ;
  sendEvent (event) ;
  return true ;
}


bool DistributedController::receiveCancellationForSignal ( const EventIdentifier & sigId , const Name & registrant ) {
  ValuedEvent<CancellationData> * event ;
  event= new ValuedEvent<CancellationData> (SystemEventIdentifier::MaskCancelRegistrationForSignal, _date, getName(), getName() ,CancellationData (sigId, registrant) ) ;
  sendEvent (event) ;
  return true ;
}

DistributedController::RegistrationData::RegistrationData (const EventIdentifier & sig,
                                                             const Name & registrant, 
                                                             const EventIdentifier & eventId) :
  _sig ( sig ),
  _registrant (registrant),
  _eventId (eventId)
{
}

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

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

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

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



PolatorNT * DistributedController::RegistrationData::createPolator() 
{
  return new Polator<RegistrationData>() ;
}
PolatorNT * DistributedController::CancellationData::createPolator() 
{
  return new Polator<CancellationData>() ;
}
DistributedController::CancellationData::CancellationData (const EventIdentifier & sigId,
                                                             const Name & registrant ) :
  _sigId ( sigId ),
  _registrant (registrant)
{
}

DistributedController::CancellationData::~CancellationData ()
{
}
void DistributedController::CancellationData::unpack (IncomingSynchronisationMessage & in ) 
{
  in>>_sigId>>_registrant;  
}

void DistributedController::CancellationData::pack (OutgoingSynchronisationMessage & out) const 
{
  out<<_sigId<<_registrant;
}

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

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

---