OMKPvmController.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 <cassert>
#include <OMKPvmController.h>
#include "OMKSynchronisationMessage.h"

#include <OMKPvmSvm.h>
#include <OMKSvmLink.h>
#include "OMKPvmUnicastMessage.h"

#include <OMKObjectDescriptor.h>
#include <OMKSimulatedObject.h>
#include <OMKProcess.h>
#include "OMKParametersAccessor.h"
#include "OMKParametersAccessor.inl"
#include <OMKPvmMirrorObjectHandle.h>
#include <OMKPvmReferenceObjectHandle.h>
#include <OMKPvmDuplicatedObjectHandle.h>

//-------------chadi ajout 1/2 -------------
#include <OMKPvmLocalObjectHandle.h>
//---------------fin 1/2 -------------------

#include <OMKDoubleListElement.h>
#include <OMKDoubleList.h>
#include "OMKSystemEventIdentifier.h"
#include "OMKMultipleConfigurationParameter.h"

#include "OMKPvmException.h"
#include <pvm3.h>

using namespace std;
using namespace OMK ;

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

PvmController::PvmController (ObjectDescriptor & initialObjects,
                                    const Date & initialDate,
                                    int argc,
                                    char * argv [])
                                    : DistributedController (initialObjects, initialDate),
                                    _finishing ( false ) 
{

  Date latence = 20 ;
  Date timeOut = 10 ;
  std::string synchro ("strong") ;
  int deadReckoning = 70 ;
  bool yieldNeeded = false ;
  NameToPointerMap<Process> * processTable = new NameToPointerMap<Process>() ;
  receiveAndProcessMessages = &PvmController::synchronizedReceiveAndProcessMessages ;

  MultipleConfigurationParameter * schedulingParameters = getSchedulingParametersOfObject( initialObjects ) ;
  if ( schedulingParameters != NULL)
  {
    ConfigurationParameterDescriptor * param = schedulingParameters->getSubDescriptorByName("Latency") ;
    if (param != NULL)
    {
      latence = atoi (param->getAssociatedString().c_str()) ;
    }
    std::cerr << "Latency : " << latence << std::endl ;

    synchro = "strong" ;
    if( ParametersAccessor::get( schedulingParameters, "Synchronization", synchro ) 
      && ( synchro == "relaxed" ) )
    {
      receiveAndProcessMessages = &PvmController::relaxedReceiveAndProcessMessages ;
    }
    std::cerr << "Synchronization : " << synchro << std::endl ;

    ParametersAccessor::get( schedulingParameters, "YieldNeeded", yieldNeeded ) ;
    std::cerr << "YieldNeeded : " << yieldNeeded << std::endl ;

    const ConfigurationParameterDescriptor * timeOutParamDescriptor = 
      schedulingParameters->getSubDescriptorByName ("TimeOut") ;
    if (timeOutParamDescriptor != NULL) {
      timeOut = atoi (timeOutParamDescriptor->getAssociatedString().c_str()) ;
    }
    std::cerr << "TimeOut : " << timeOut << std::endl ;

    const ConfigurationParameterDescriptor * deadReckoningParamDescriptor = 
      schedulingParameters->getSubDescriptorByName ("DeadReckoningStepInterval") ;
    if (deadReckoningParamDescriptor != NULL) {
      deadReckoning = atoi (deadReckoningParamDescriptor->getAssociatedString().c_str()) ;
    }
    std::cerr << "DeadReckoningStepInterval : " << deadReckoning << std::endl ;

    param = schedulingParameters->getSubDescriptorByName("Machines") ;
    MultipleConfigurationParameter * describedMachines = dynamic_cast<MultipleConfigurationParameter *>(param);
    if (describedMachines != NULL)
    {
      int numberOfMachines = describedMachines->getNumberOfSubItems () ;
      for (int machineNumber = 0 ;
        machineNumber != numberOfMachines ;
        ++machineNumber )
      {
        param = describedMachines->getSubDescriptorByPosition ( machineNumber ) ;
        processTable->addObjectWithIndex ( describedMachines->getNameOfSubDescriptor (machineNumber),
          new Process ( describedMachines->getNameOfSubDescriptor (machineNumber),
          param->getAssociatedString() )
          ) ;
      }
    }
  }

  // virtual member functions aren't initiallised in constructor
  // therefore, recreate the correct objectHandle
  delete _objectHandle ;

  _objectHandle = NULL ;

  DuplicatedObjectHandle * localObjectHandle = newOMKDuplicatedObjectHandle( *this ) ;
  _objectHandle = localObjectHandle ;
  // TDTD ajout pour fixer bug mémoire : comme le _objectHandle a été effacé, ça ne marche plus...
  _computeStatePointer = const_cast<ReferenceObjectHandle::SimulatedObjectComputingState *>(&(dynamic_cast<DuplicatedObjectHandle *>(_objectHandle)->getComputingState () )) ;

  for (NameToPointerMap<Process>::const_iterator i = processTable->begin() ;
    i != processTable->end () ;
    ++i) 
  {
    localObjectHandle->addProcessOfDuplicate ( (*i).second ) ;
  }


  _distributedVirtualMachine = new PvmSvm (processTable, latence, timeOut, deadReckoning, yieldNeeded, argc, argv) ;

  _distributedVirtualMachine->init (initialDate ) ;

  _processName = _distributedVirtualMachine->getSiteName () ;

  setProcessOfDescriptor ( initialObjects, _processName ) ;

  cout << "PvmController::PvmController (...)" 
    << "of process: " << _distributedVirtualMachine->getSiteName () << endl ;

  // initialisation de l'état du controleur
  // TDTD suite ajout pour fixer bug mémoire : comme le _objectHandle a été effacé, ça ne marche plus...
  assert ( _computeStatePointer != NULL ) ;
  *_computeStatePointer = ReferenceObjectHandle::initial ;


  //rewritten 2001/12/5 by D. Margery
  list < ObjectDescriptor *> * descriptorList = _simulationTree.getDescendants() ;
  for (list < ObjectDescriptor *>::iterator descriptorIterator = descriptorList->begin() ;
    descriptorIterator != descriptorList->end() ;
    ++ descriptorIterator )
  {
    Frequency currentFreq = (*descriptorIterator)->getFrequency() ;
    Name currentProcess = (*descriptorIterator)->getProcess() ;
    Process * currentProcessDescriptor = processTable->getObjectOfIndex( currentProcess ) ;
    if ( currentProcessDescriptor != NULL )
      // the process could have been removed by the svm
    {
      if ( currentFreq > currentProcessDescriptor->getMaxFrequencyOfHostedObjects () ) 
      {
        currentProcessDescriptor->setMaxHostedFrequency (currentFreq) ;
      }
      currentProcessDescriptor->setFrequency ( Controller::lcm(currentFreq, currentProcessDescriptor->getFrequency() ) ) ;
    }
  }
  delete descriptorList ;

  //subscribe to system signals to receive notification on what is happening on other controllers
  registerForSignalBy(SystemEventIdentifier::MaskObjectDestroyed, getName()) ;

}

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

PvmController::~PvmController () 
{
  // deconnexion de la machine virtuelle
#ifdef _DEBUGEXECPVM
  cout << "PvmController::~PvmController : " << endl;
#endif
  _distributedVirtualMachine->disconnectFromDistributedSimulation ( getSimulatedDate () ) ;
  delete _distributedVirtualMachine ;   
}


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

void PvmController::run()
{
  if ( pvm_parent() != PvmNoParent )
  {
    DistributedController::run() ;

    // the simulation is locally finished, so notify all the controllers before exiting 
    Date lastDate = _date + 2 * _stepPeriod + _distributedVirtualMachine->getSynchronisationLatency() ;

    while (_date < lastDate )
    {
#ifdef _DEBUGPVMMESS
      cerr<<"PvmController::run(): trying a clean exit"<<endl;
#endif
      ReferenceObjectHandle * objectHandle = dynamic_cast<ReferenceObjectHandle *> ( _objectHandle ) ;

      assert ( objectHandle != NULL ) ;

      //the controller has to process residual system events adressed to itself
      objectHandle->processEvents() ;

      //send enought empty signals to enable other controllers to finish their job
      makeSynchronisationMessage( _referenceObjectsMap ) ;

      // send the synchronisation messages
      _distributedVirtualMachine->sendCurrentBuffersWithTag (PvmMessage::SynchronisationMessage) ; 

      //wait a little, to try and get clean exit
#ifdef _MSC_VER
      Sleep( 1000 ) ;
#else
      sleep(1) ;
#endif

      // for cleanup, read any arrived messages
      _distributedVirtualMachine->processReceivedMessages (*this, PvmMessage::SynchronisationMessage) ;

      advanceSimulatedDate() ;
    } 
  }

}



MirrorObjectHandle * PvmController::createMirrorObject (ObjectDescriptor * objectDescription) 
{
  MirrorObjectHandle * mirror =  DistributedController::createMirrorObject( objectDescription ) ;

  // Register the mirror to the reference object for regular updates of outputs
  mirror->registerToReferenceObject (true) ;

  return mirror ;
}


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

const Name & PvmController::getProcessName () const 
{
  return (_distributedVirtualMachine->getSiteName ()) ;
}

//------------------------------------------------------------------------------
void PvmController::advanceSimulatedDate () 
{
#ifdef _DEBUGEXECPVM
  cerr << "PvmController::advanceSimulatedDate () from " <<_date<<endl;
#endif
  //send any messages collected during init
  if (_date < initialSimulationDate )
  {
    _distributedVirtualMachine->sendCurrentBuffersWithTag (PvmMessage::SynchronisationMessage) ;  
  }

  DistributedController::advanceSimulatedDate () ;

  // prepare buffers to receive any message generate during this simulation step
  _distributedVirtualMachine->timestampCurrentSendBuffers (_date) ;   
}


// void PvmController::computeNextSimulationStep () {
// #ifdef _DEBUGEXECPVM
//    cerr << "PvmController::computeNextSimulation : computing yet another simulation step for " 
//      <<notreProcessus()<< endl;
// #endif

//    // compute the simulation step
//    DistributedController::computeNextSimulationStep () ;

//    // compute the synchronisation messages
//    makeSynchronisationMessage ( _referenceObjectsMap ) ;

//    // send the synchronisation messages
//    _distributedVirtualMachine->sendCurrentBuffersWithTag (PvmMessage::SynchronisationMessage) ;  

//    // proceed with a relaxed synchronisation
//    _distributedVirtualMachine->synchroniseReceiveAndProcessMessages (*this, PvmMessage::SynchronisationMessage) ; 


//    //added by chadi to test if a new process has been added dynamically
//    _distributedVirtualMachine->testIfNewProcessAdded () ;

// }

void PvmController::computeNextSimulationStep () {

#ifdef _DEBUGEXECPVM
  cerr << "PvmController::computeNextSimulation : computing yet another simulation step for " 
    <<notreProcessus()<< endl;
#endif

  // compute the simulation step
  DistributedController::computeNextSimulationStep () ;

  // compute the synchronisation messages
  makeSynchronisationMessage ( _referenceObjectsMap ) ;

  // send the synchronisation messages
  _distributedVirtualMachine->sendCurrentBuffersWithTag (PvmMessage::SynchronisationMessage) ;  

  // TDTD : pour un fonctionnement en synchro ou relaxed
  (this->*receiveAndProcessMessages) () ;
  //synchronizedReceiveAndProcessMessages () ;
  // TDTD : en cas de desynchro, il faut régler le pb du flush des messages inutiles... ::: à peu près réalisé...

  //added by chadi to test if a new process has been added dynamically
  // TDTD : à remettre plus tard
  //_distributedVirtualMachine->testIfNewProcessAdded () ;
  /*
  if (testIfTroubleOccured())
  {
  bool tico = _distributedVirtualMachine->reconnexionEstablished() ;
  }
  */

  //    {
  //     cout<<"bien bien bien"<<endl;
  // makeSynchronisationMessage ( _referenceObjectsMap ) ;       
  // _distributedVirtualMachine->sendCurrentBuffersWithTag (PvmMessage::SynchronisationMessage) ;  
  //   }

  //  if (testIfTroubleOccured())
  //        {
  //     _distributedVirtualMachine->sendPingMessage() ;
  //        }



  //  if ( testIfTroubleOccured() )
  //        {
  //     NameToPointerMap<ReferenceObjectHandle>::iterator pTabRef ;
  //     for (pTabRef = _referenceObjectsMap.begin () ;
  //          pTabRef != _referenceObjectsMap.end () ;
  //          pTabRef ++) 
  //       {

  //         PvmReferenceObjectHandle * pvmObjectHandle = dynamic_cast<PvmReferenceObjectHandle *> ( (*pTabRef).second ) ; 
  //         if ( pvmObjectHandle != NULL )
  //           {
  //             pvmObjectHandle->flushDisconnectedSitesOutgoingBuffer() ;
  //           }

  //       }

  //        }

}

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

void PvmController::synchronizedReceiveAndProcessMessages (void) {
  _distributedVirtualMachine->synchroniseReceiveAndProcessMessages (*this, PvmMessage::SynchronisationMessage) ;
}

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

void PvmController::relaxedReceiveAndProcessMessages (void) {
  _distributedVirtualMachine->relaxedSynchroniseReceiveAndProcessMessages (*this, PvmMessage::SynchronisationMessage) ;
}

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

void PvmController::makeSynchronisationMessage (NameToPointerMap<ReferenceObjectHandle> & referenceObjects ) 
{
  static Name endMessage ("_OpenMASKEndOfSynchronisationMessage") ;

#ifdef _DEBUGPVMMESS
  cerr<<"PvmController::makeSynchronisationMessage for "<<referenceObjects.size() <<" objects "<<endl;
#endif

  NameToPointerMap<ReferenceObjectHandle>::iterator pTabRef ;
  // ask all referentials to contribute to the synchronisation message
  for (pTabRef = referenceObjects.begin () ;
    pTabRef != referenceObjects.end () ;
    pTabRef ++) 
  {
#ifdef _DEBUGPVMMESS
    cerr<<"PvmController::makeSynchronisationMessage for object " <<(*pTabRef).second->getSimulatedObject().getName()<<endl;
#endif

    PvmReferenceObjectHandle * pvmObjectHandle = dynamic_cast<PvmReferenceObjectHandle *> ( (*pTabRef).second ) ; 
    if ( pvmObjectHandle != NULL )
    {
      pvmObjectHandle->makeSynchronisationMessage ( _date ) ;
    }
    else
    {
#ifdef _DEBUGPVMMESS
      cerr<<"No synchronisation message for "<<(*pTabRef).second->getSimulatedObject().getName()<<endl;
#endif      
    }
#ifdef _DEBUGPVMMESS
    cerr<<"PvmController::makeSynchronisationMessage of " <<(*pTabRef).second->getSimulatedObject().getName()<<" done"<<endl;
#endif
  } 
#ifdef _DEBUGPVMMESS
  cerr<<"PvmController::makeSynchronisationMessage done"<<endl;
#endif
}


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

void PvmController::parseSynchronisationMessage (PvmIncomingMessage * message) 
{

  ReferenceObjectHandle * refer ; // Referentiel de l'objet destinataire
  MirrorObjectHandle * miroir ; // Miroir de l'objet destinataire
  Name nomObj ; // Nom du miroir destinataire
  bool stillMessagesToParse = true ;

#ifdef _DEBUGPVMMESS
  cerr << "PvmController::parseSynchronisationMessage at "<<getSimulatedDate()<<":"<< endl ;
#endif


  while ( stillMessagesToParse ) 
  {
    // get the message recepient
    nomObj.unpack ( *message ) ;


#ifdef _DEBUGPVMMESS
    cerr << "PvmController::parseSynchronisationMessage: message received for " << nomObj << endl;
#endif
    if ( nomObj == SynchronisationMessage::endOfSynchronisationFragment )
      // the synchronisation message has been completely parsed
    {
      stillMessagesToParse = false ;
    }
    else 
    {
      MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.find ( nomObj ) ;
      if (i != _mirrorObjectsMap.end ()) 
      {
        // On lui transmet le message
#ifdef _DEBUGPVMMESS
        cout << "PvmController::parseSynchronisationMessage: for miror" << endl ;
#endif
        miroir = i->second ;
        miroir->unpack ( *message ) ;
      } 
      else if (_referenceObjectsMap.find (nomObj) != _referenceObjectsMap.end ()) 
      {
        // On lui transmet le message
#ifdef _DEBUGPVMMESS
        std::cout << "PvmController::parseSynchronisationMessage : for referential : " << nomObj <<std::endl ;
        //std::cout << "message : " << *message << std::endl ;
#endif
        refer = dynamic_cast<PvmReferenceObjectHandle *>(_referenceObjectsMap.getObjectOfIndex (nomObj) ) ;
        if ( refer != NULL )
        {
          refer->unpack (*message)  ;
        }
        else
        {
          dynamic_cast<PvmDuplicatedObjectHandle *>(_referenceObjectsMap.getObjectOfIndex (nomObj) )->unpack ( *message ) ;
        }
      } 
      else if (nomObj == "") 
      {
#ifdef _DEBUGPVMMESS
        cout << "PvmController::parseSynchronisationMessage :CL : message vide d'abonnement ... pour synchro" << endl ;
#endif
      } 
      else 
      {
#ifdef _DEBUGPVMMESS
        cerr << "PvmController::parseSynchronisationMessage: "<< endl ;
        cerr << "for unknown object: <" << nomObj << "> (was probably destroyed)" << endl ;
        error ("PvmController::parseSynchronisationMessage : Objet ni miroir ni referentiel") ;
#endif
        //probably a request for an object that was destroyed
        int typeMess ;
        *message >> typeMess ;
        // hope it is a registration for a just destroyed referential, and interprete it
        if ( typeMess == Registration )
        {
          Name processName ;
          *message >> processName ;     
        }
        else if ( typeMess == EventReceived )
        {
          Event * event ;
          Name classToCreate ;
          EventIdentifier eventId;
          Date eventDate;
          Name sender, receiver ;
          *message >> classToCreate >> eventId>> eventDate>>sender>>receiver ;
          event = EventCreator::createEvent (classToCreate, eventId, eventDate, sender, receiver ) ;
          event->unpack ( *message ) ;
          //cerr << "PvmController::parseSynchronisationMessage event "<<*event<<" undelivered"<<endl;
          delete event ;
        }
      }
    }
  }
#ifdef _DEBUGPVMMESS
  cerr << "PvmController::parseSynchronisationMessage : message parsed"<< endl ;
#endif
}






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

void PvmController::init () 
{

  if ( pvm_parent() != PvmNoParent )
  {
    //on tente l'initialisation normale : pour chaque init, cette initialisation appelle initObjetReferentiel 
#ifdef _DEBUGDISTRIBUTEDINIT
    cerr<<"PvmController::init preparing the outgoing message buffers "<<endl;
#endif   
    _distributedVirtualMachine->timestampCurrentSendBuffers ( _date ) ;

    // try a classic initialisation
    Controller::init () ;

    //initialisation shouldn't fail
    assert ( tableDesNonInitialises.empty () ) ;

    //here, as advanceSimulatedDate has been called to restore the initial simulation date, no need to timestamp messages

#ifdef _DEBUGDISTRIBUTEDINIT
    cerr<<"PvmController::init : classic initialisation tried"<<endl;
#endif
    // send all registrations
    _distributedVirtualMachine->sendCurrentBuffersWithTag (PvmMessage::SynchronisationMessage) ;

    // broadcast a empty message signalling our initialisation is finished, and wait for all processes
    _distributedVirtualMachine->synchronizeOn ( *this, PvmMessage::LocalInitSuccessfull ) ;


    //restore state to the supposed state resulting of a call to the ancestor init
    _distributedVirtualMachine->timestampCurrentSendBuffers (_date) ;
  }

}

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

int PvmController::getOutputHistorySize(void) {
  // Taille d'une file d'une output pour un controleur local
  // nbMinor * 4 --> pour guarantir la recuperation d'au plus 4 valeurs dans la file
  // 1 ?? surete ??
  int nbrValeurPendantLatence = 1 ;//la latence minimal est un pas de simulation au sens controleur
  nbrValeurPendantLatence+=_distributedVirtualMachine->getSynchronisationLatency()/_stepPeriod;
  return DistributedController::getOutputHistorySize()+nbrValeurPendantLatence;
}  



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

ObjectHandle * 
PvmController::removeObjectFromDataStructures(const Name & nom) 
{

  ObjectHandle * result = NULL ;

  if (_referenceObjectsMap.find (nom) != _referenceObjectsMap.end ()) 
  {
    result = Controller::removeObjectFromDataStructures(nom);
  } 
  else 

  {
    MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.find (nom) ;
    if (i != _mirrorObjectsMap.end ()) 
    {
      MirrorObjectHandle * miroir = i->second ;
      _mirrorObjectsMap.erase( i );
      result = miroir;
    }
    else if (_duplicatedObjectsMap.find (nom) != _duplicatedObjectsMap.end()) 
    {
      //a duplicated object is a referential present in the duplicated objects table
      _duplicatedObjectsMap.erase(nom);
    }  
  } 

  return result ; 
}


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

MirrorObjectHandle * PvmController::newOMKMirrorObjectHandle (SimulatedObject & obj) 
{
  return new PvmMirrorObjectHandle(obj);
}


DuplicatedObjectHandle * PvmController::newOMKDuplicatedObjectHandle (SimulatedObject & obj) 
{
  return new PvmDuplicatedObjectHandle( obj, *this );
}


//---------chadi ajout 2/2 ------
LocalObjectHandle * PvmController::newOMKLocalObjectHandle (SimulatedObject & obj) 
{
  return new PvmLocalObjectHandle( obj, *this );
}

//-------------- --------
vector<Name> PvmController::getIsolatedMirrorList()
{

  for ( MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.begin(); i!= _mirrorObjectsMap.end(); i++ )
  {
    Name referentialProcess = i->second->getSimulatedObject().getObjectDescriptor().getProcess();
    if ( _distributedVirtualMachine->disconnectedProcess( referentialProcess ) )
    {
      _publicIsolatedMirrorObjectsVector.push_back( i->first) ;
    }
  }

  return  _publicIsolatedMirrorObjectsVector;
}
//********************************************************
vector<Name> PvmController::getNonIsolatedMirrorList()
{

  if (_distributedVirtualMachine->disconnectedTableIsEmpty())
  {
    _publicIsolatedMirrorObjectsVector.clear();
    return _publicIsolatedMirrorObjectsVector;
  }
  else
  {

    for ( MirrorObjectsContainerType::iterator i = _mirrorObjectsMap.begin(); i!= _mirrorObjectsMap.end(); i++ )
    {
      Name referentialProcess = i->second->getSimulatedObject().getObjectDescriptor().getProcess();
      if ( _distributedVirtualMachine->disconnectedProcess( referentialProcess ) )
      {

      }
      else
      {
        _publicNonIsolatedMirrorObjectsVector.push_back( i->first) ;
      }
    }

    return  _publicNonIsolatedMirrorObjectsVector;
  }
}
//**********************************************************

bool PvmController::testIfTroubleOccured ()
{
  //  if (_distributedVirtualMachine->getTroubleFlag() )
  if (_distributedVirtualMachine->disconnectedTableIsEmpty() )
  {
    return false;
  }
  else
    return true ;
  // dans le cas ou il y a plusieurs sites > 2 , si 2 sites sont deconnectes puis un des 2 s'est retabli alors
  // le troubleFlag est Faux par contre on a tjrs un site deconnecte donc le trouble existe encore ....
  /*  else if (_distributedVirtualMachine->disconnectedTableIsEmpty() )
  {
  return false;
  }
  return true;
  */
}
//*********************************************************
void PvmController::createNewSite ( const Date & date)
{
  _distributedVirtualMachine->addNewSiteRequest (date);
}


//****************** fin ***********************************


ReferenceObjectHandle * PvmController::newOMKReferenceObjectHandle(SimulatedObject & object, 
                                                                         Controller & controller,
                                                                         SignalDispatcher * signalDispatcher)
{
  return new PvmReferenceObjectHandle(object, controller, signalDispatcher );
}

Svm * PvmController::getDistributedVirtualMachine ()
{
  return _distributedVirtualMachine;
}

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


void PvmController::sendInitialValuesToMirror(PvmIncomingMessage & message)
{
  if ( ! _finishing )
  {
    // first find out the name of the objects whose initial values are needed
    Name referentialName ;
    referentialName.unpack ( message ) ;


#ifdef _DEBUGEXECPVM
    cerr<<"Looking for initial values of "<<referentialName<<endl;
#endif

    //then find the corresponding referential
    NameToPointerMap<ReferenceObjectHandle>::iterator i = _referenceObjectsMap.find ( referentialName ) ;

    PvmReferenceObjectHandle * referential = NULL ;
    if ( i != _referenceObjectsMap.end() ) 
    {
      referential = dynamic_cast<PvmReferenceObjectHandle *> (i->second) ;
    }
    else
    {
      //the referential might have been destroyed: look for it in the list of deleted object handles
      list <pair <Date, ObjectHandle *> >::iterator i = _deletedObjectHandles.begin() ;
      while ( i != _deletedObjectHandles.end() )
      {
        if ( i->second->getSimulatedObject().getName() == referentialName )
        {
          referential = dynamic_cast<PvmReferenceObjectHandle *> ( i->second );
          i = _deletedObjectHandles.end() ;
        }
        else
        {
          ++ i ;
        }
      }
    }

    assert ( referential != NULL ) ;


    //find the name of the requesting process
    Name mirrorProcessName ;
    mirrorProcessName.unpack( message ) ;

    //then find the link to the corresponding process
    SvmLink * process = getDistributedVirtualMachine()->getLinkToProcessNamed ( mirrorProcessName ) ;

    assert ( process != NULL ) ;

    //build the answer
    PvmUnicastMessage * urgentAnswer = new PvmUnicastMessage ( process->getTID() ) ;

    urgentAnswer->insertTimeStamp( _date ) ;

    referential->packInitialValues ( * urgentAnswer ) ;

    SynchronisationMessage::endOfSynchronisationFragment.pack ( * urgentAnswer ) ;  

    // and send it
    urgentAnswer->send ( PvmMessage::InitialValuesForMirror ) ;
  }
}


void PvmController::waitForAnswerToBlockingRequest (PvmMessage::MessageTag tag)
{
  if ( ! _finishing )
    // avoid blocking the controller while terminating, because other controllers could have exited
  {
    _distributedVirtualMachine->waitForAnswerToBlockingRequest ( *this, tag ) ;      
  }
}

void PvmController::finish()
{
  _finishing = true ;
  DistributedController::finish() ;
}


Date PvmController::getPurgeDate () 
{
  //in the worst case we could reveive message from an object whose simulation date is current date - _latency -stepPeriod ;
  // make sure by doubling latency
  return DistributedController::getPurgeDate() - 2 * _distributedVirtualMachine->getSynchronisationLatency() ;
}


std::list<Name> PvmController::getDisconnectedProcessusList () {
  return _distributedVirtualMachine->getDisconnectedProcessusList () ;
}

std::map<Name, int> PvmController::getDisconnectedProcessusMap () {
  return _distributedVirtualMachine->getDisconnectedProcessusMap () ;
}

---