OMKSvm.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 <OMKSvm.h>
#include <OMKSvmLink.h>
#include "OMKSynchronisationMessage.h"
#include <OMKPvmMessage.h>
#include <OMKPvmMulticastMessage.h>
#include <OMKPvmUnicastMessage.h>
#include <OMKProcess.h>
#include <OMKPvmController.h>
#include "OMKPvmNameServer.h"
#include "OMKPvmCentralNameServer.h"
#include <pvm3.h>
#include "OMKPvmSvm.h"
#ifndef _MSC_VER
#include <sys/time.h>
#endif
#include "OMKTracer.h"

using namespace std;
using namespace OMK ;

std::string Svm::_slaveGroupName = "spawnedControllers";
std::string Svm::_masterSiteName = "OpenMaskMasterDistributedSite" ;

#ifdef _MSC_VER
int
gettimeofday(struct timeval *t, struct timezone *tzp)
{
        struct _timeb timebuffer;

        /* this calls the time and returns sec ** msec */
        _ftime( &timebuffer );

        t->tv_sec=timebuffer.time;
        t->tv_usec=timebuffer.millitm*1000;
        return 1;
}
#endif

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

Svm::Svm (NameToPointerMap<Process> * tab, const Date & latence, const Date & timeOut,
                const int deadReckoningInterval, const bool yieldNeeded) : 
//   _processTable ( tab ),
//   _activeProcessTable (tab ),
   _troubleFlag ( false ),
   _simStep ( 0 ),
   _siteId ( -1 ), //negative values indicates an error
   _numberOfSlaves ( 0 ),
   _synchronisationLatency (latence),
   _synchronisationTimeOut (timeOut),
   _deadReckoningInterval (deadReckoningInterval),
   _yieldNeeded (yieldNeeded)
{
_processTable = new NameToPointerMap<Process>();
   for ( NameToPointerMap<Process>::iterator processIterator = tab->begin () ;
            processIterator != tab->end () ;
            ++processIterator 
            )
        {
          _processTable->addObjectWithIndex(processIterator->first, processIterator->second );
 
        }

//--------------chadi ajout 1/6 ------------------------
  _temporaryTable = new  NameToPointerMap<Process>();
  _disconnectedTable = new  NameToPointerMap<Process>();
  _activeProcessTable = new  NameToPointerMap<Process>();
  _disconnectedTable->clear();
   for ( NameToPointerMap<Process>::iterator processIterator = _processTable->begin () ;
            processIterator != _processTable->end () ;
            ++processIterator 
            )
        {
          _activeProcessTable->addObjectWithIndex(processIterator->first, processIterator->second );
 
        }
  
   firstTime = true;
 aRecevoir.clear();
//--------------fin chadi ajout 1/6 ------------------------
// TDTD ajout pour simuler des défaillances réseau
#ifdef _MSC_VER
        srand( getpid() ) ;
#else
        srandom (getpid ()) ;
#endif
}


Svm::~Svm () 
{
}


const Date & Svm::getSynchronisationLatency() 
{
  return _synchronisationLatency;
}



void Svm::init (const Date & initialSimulationDate) 
{
   if ( getParentSiteId () == 0 )  // wasn't created by a spawn
     {
       createDistributedSimulation ( initialSimulationDate ) ;
     }
   else
     {
       connectToDistributedSimulation () ;
     }
}


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

//***********************  chadi *****************************

void Svm::addNewSiteToSimulation (const Date & date)
{
  dateVar = date ;

 Process * theNewProcessToAdd = new Process ( "visualProcessC", "maxipes.irisa.fr" );


 
 // addNewWorkstation ( "barbux.irisa.fr" ) ;
 addNewWorkstation ( theNewProcessToAdd->getHostMachineName () ) ;
 
 _processTable->addObjectWithIndex ("visualProcessC", theNewProcessToAdd ) ;
 
 
 int adrLoc ;
 
 int processSiteId ;

 cout<<"New Process will be Spawned .....///"<<endl;
 cout<<"theNewProcessToAdd is named : "<<theNewProcessToAdd->getProcessName()<<endl;
 
 // spawn a new process on the specified workstation
 adrLoc = spawnProcess (theNewProcessToAdd) ;

 cout<<"New Process Spawned .....valeur de spawn est egale a : "<<adrLoc<<endl;
 
 // create a SvmLink, add it to processInfo
 theNewProcessToAdd->setSvmLink (createSvmLink (adrLoc)) ; 
 
 _idToProcessTable.insert ( make_pair ( adrLoc,theNewProcessToAdd ) ) ;
 
 theNewProcessToAdd->getSvmLink ()->getOutgoingBuffer().insertTimeStamp ( date ) ;

 
 // send the name of the process (in the Svm) to the created process
 theNewProcessToAdd->getSvmLink ()->getOutgoingBuffer()<<theNewProcessToAdd->getProcessName() ;
 
 theNewProcessToAdd->getSvmLink ()->getOutgoingBuffer().send (PvmMessage::SiteName) ;
 
 //prepare processSiteIds for the next step
 processSiteId =  theNewProcessToAdd->getSvmLink ()->getTID()  ;      
// processSiteIds.push_back ( theNewProcessToAdd->getSvmLink ()->getTID() ) ;  
 
  
 // Encodage des attributs Svm de chaque processus
 PvmUnicastMessage nameToIdMessage ( processSiteId ) ;
 nameToIdMessage.insertTimeStamp ( date ) ;

 NameToPointerMap<Process>::iterator i ;
 for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
   {
     nameToIdMessage << *((*i).second) ;
   }
 
 // Transfert des adresses vers le controleur local du process ajouté
 nameToIdMessage.send ( PvmMessage::ProcessTable ) ;
 
 
 // envoyer le processTable Update a tt le monde
 PvmMulticastMessage updateProcessTableMessage ( processSiteIds ) ;
 updateProcessTableMessage.insertTimeStamp ( date ) ;

 updateProcessTableMessage << *theNewProcessToAdd ;
// updateProcessTableMessage << (theNewProcessToAdd->getProcessName()) ;
 cout<<" theNewProcessToAdd->getProcessName() = "<<theNewProcessToAdd->getProcessName()<<endl;

 updateProcessTableMessage.send ( PvmMessage::updateProcessTable ) ;
 

 processSiteIds.push_back ( theNewProcessToAdd->getSvmLink ()->getTID() ) ; 
 cout<<"Finishing method addNewSiteToSimulation"<<endl;

}

void Svm::testIfNewProcessAdded () 
{
 PvmIncomingMessage * message = NULL ;
 message =  _linkToCentralSite->testIfRequestUpdateProcessTable (PvmMessage::updateProcessTable) ;
 if ( message != NULL )
   {  
     Name zico ;
    // *message>>zico ;
    // cout<<"le nom de process recu est :  "<<zico<<endl; 
     Process* p = new Process  ( "visualProcessC", "maxipes.irisa.fr" ); 

    // Process *p ;             
    // *message>> *p ;
     _processTable->addObjectWithIndex(p->getProcessName(),p ) ;
     ++_numberOfSlaves ;
    
    // Process * p = (*i).second ;
     // creation d'un canal sans destinataire 
     p->setSvmLink (createSvmLink ()) ;
     // maj du destinataire ?????????????????????????????????
     *npp  >> *p ;
     
     _idToProcessTable.insert ( make_pair ( p->getSvmLink()->getTID(),p ) ) ;
     
     PvmUnicastMessage initSucMessage ( p->getSvmLink()->getTID() ) ;
     initSucMessage.insertTimeStamp ( dateVar ) ;
     initSucMessage.send ( PvmMessage::LocalInitSuccessfull ) ;
     
     NameToPointerMap<Process>::iterator i ;
     for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
        {
          cout<<"_processTable contient: "<<(*i).second->getProcessName()<<endl; 
        }

     syncDistributedSites();  
   }
}



//****
//************************************************************

/*
void Svm::createDistributedSimulation(const Date & initialSimulationDate )
{
  Process * miaou = new Process ( "visualProcessTest", "barbux.irisa.fr" );
 _processTable->addObjectWithIndex ("visualProcessTest", miaou ) ;


#ifdef _DEBUGPVMEXEC
   cerr << "Svm::createDistributedSimulation : creating the distributed simulation" << endl ;
#endif
   _siteName = _masterSiteName ;

     
     NameToPointerMap<Process>::iterator i ;
     
     for (i = _processTable->begin () ; i != _processTable->end () ; ++i ) 
       {
         addNewWorkstation ( (*i).second->getHostMachineName () ) ;
       }

  //   Process * miaou = new Process ( "visualProcessTest", "barbux.irisa.fr" );
                
  //   addNewWorkstation ( "barbux.irisa.fr" ) ;

  //   _processTable->addObjectWithIndex ("visualProcessTest", miaou ) ;

 for ( NameToPointerMap<Process>::iterator pi = _processTable->begin () ;
               pi != _processTable->end () ;
               ++pi 
               )
            {
              
              cout<<"pour s'assurer ke le proc est ajoute koi (createDistributedSimulation) : "<<endl;
              cout<<"nom de proc est: "<< pi->second->getProcessName()<<" nom de host machine est: "<<pi->second->getHostMachineName()<<endl;
            }

     // creation des processus locaux
#ifdef _DEBUGPVMEXEC
     cerr << "Creation des processus locaux..................." << endl ;
#endif
     Process * processInfo ;
     int adrLoc ;

     std::vector<int> processSiteIds ;
     
     for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
       {
         processInfo = (*i).second ;
         
         // spawn a new process on the specified workstation
         adrLoc = spawnProcess (processInfo) ;
         
         // create a SvmLink, add it to processInfo
         processInfo->setSvmLink (createSvmLink (adrLoc)) ; 
         
         _idToProcessTable.insert ( make_pair ( adrLoc,processInfo ) ) ;

         processInfo->getSvmLink ()->getOutgoingBuffer().insertTimeStamp ( initialSimulationDate ) ;

         // send the name of the process (in the Svm) to the created process
         processInfo->getSvmLink ()->getOutgoingBuffer()<<(*i).first ;
         
         processInfo->getSvmLink ()->getOutgoingBuffer().send (PvmMessage::SiteName) ;

         //prepare processSiteIds for the next step
         processSiteIds.push_back ( processInfo->getSvmLink ()->getTID() ) ;

#ifdef _DEBUGPVMMESS
         cerr<<typeid((*i).first).name()<<endl;
         cerr<<(*i).first<<" of id "<<processInfo->getSvmLink ()->getTID()<<endl;
#endif
       }
     

     // Encodage des attributs Svm de chaque processus
     PvmMulticastMessage nameToIdMessage ( processSiteIds ) ;
     nameToIdMessage.insertTimeStamp ( initialSimulationDate ) ;
     
     for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
       {
         nameToIdMessage << *((*i).second) ;
       }
     
     // Transfert des adresses vers chaque controleur local
     nameToIdMessage.send ( PvmMessage::ProcessTable ) ;
     
     serveNameRequestsUntilEnd () ;

}

*/


// aspects fonctionnement secondaire
//****************************************************
// RK 1302 : Suppression du nom du pss

void Svm::createDistributedSimulation(const Date & initialSimulationDate )
{
#ifdef _DEBUGPVMEXEC
   cerr << "Svm::createDistributedSimulation : creating the distributed simulation" << endl ;
#endif
   _siteName = _masterSiteName ;

     
     NameToPointerMap<Process>::iterator i ;
     
     for (i = _processTable->begin () ; i != _processTable->end () ; ++i ) 
       {
         addNewWorkstation ( (*i).second->getHostMachineName () ) ;
       }

     
     // creation des processus locaux
#ifdef _DEBUGPVMEXEC
     cerr << "Creation des processus locaux..................." << endl ;
#endif
     Process * processInfo ;
     int adrLoc ;

     //   std::vector<int> processSiteIds ;
     
     for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
       {
         processInfo = (*i).second ;
         
         // spawn a new process on the specified workstation
         adrLoc = spawnProcess (processInfo) ;

         cout<<"my TID is : "<<adrLoc<<endl ;
         
         // create a SvmLink, add it to processInfo
         processInfo->setSvmLink (createSvmLink (adrLoc)) ; 
         
         _idToProcessTable.insert ( make_pair ( adrLoc,processInfo ) ) ;

         processInfo->getSvmLink ()->getOutgoingBuffer().insertTimeStamp ( initialSimulationDate ) ;

         // send the name of the process (in the Svm) to the created process
         processInfo->getSvmLink ()->getOutgoingBuffer()<<(*i).first ;
         
         processInfo->getSvmLink ()->getOutgoingBuffer().send (PvmMessage::SiteName) ;

         //prepare processSiteIds for the next step
         processSiteIds.push_back ( processInfo->getSvmLink ()->getTID() ) ;

#ifdef _DEBUGPVMMESS
         cerr<<typeid((*i).first).name()<<endl;
         cerr<<(*i).first<<" of id "<<processInfo->getSvmLink ()->getTID()<<endl;
#endif
       }
     

     // Encodage des attributs Svm de chaque processus
     PvmMulticastMessage nameToIdMessage ( processSiteIds ) ;
     nameToIdMessage.insertTimeStamp ( initialSimulationDate ) ;
     
     for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
       {
         nameToIdMessage << *((*i).second) ;
       }
     
     // Transfert des adresses vers chaque controleur local
     nameToIdMessage.send ( PvmMessage::ProcessTable ) ;
     
     serveNameRequestsUntilEnd () ;

}



void Svm::serveNameRequestsUntilEnd (void) 
{
  bool serving = true ;

  //convert the actual name Server to a PvmCentralNameServer
  PvmCentralNameServer * nameServer = new PvmCentralNameServer ( *Name::getNameServer() ) ;
  Name::setNameServer (nameServer ) ;


  PvmIncomingMessage receiveBuffer ;
  std::pair<PvmMessage::MessageTag,  int> receivedRequest ;  

  while ( serving )
    {

      receivedRequest = waitForAnyRequests ( receiveBuffer ) ;

      switch (receivedRequest.first)
        {
        case PvmMessage::EndOfSimulation :
           {
              const Date & endDate (receiveBuffer.getMessageDate() );
              Name endedProcess ;
              receiveBuffer>>endedProcess ;
              cerr<<endedProcess<<" finished at "<<endDate<<endl;
              _processTable->erase ( endedProcess ) ;
              if ( _processTable->size() == 0 ) 
                 {  
                    disconnectFromDistributedSimulation ( endDate ) ;
                    serving = false ;
                 }
           }
           break;
        case PvmMessage::NameServiceGetId :
          {
            int stringLength ;
            receiveBuffer>>stringLength ;
            char * stringId = new char[stringLength] ;
            receiveBuffer>>stringId ;
            assert ( stringId [stringLength - 1] == 0 ) ;
            OMTRACEID("PVMSVM",
          "Requested id for string "<<stringId<<"| of length "<<stringLength
                <<" from "<< hex << receivedRequest.second << dec);
            if ( stringLength ==1)
      {
        OMTRACE ("Ask for Id of " << stringId <<"|");
        Name::idType id = nameServer->getIdentifier( stringId ) ;
        OMTRACE ("id=" << id  <<"|");
        OMTRACE ("StringAssociatedTo=  " << nameServer->getStringAssociatedTo (id) <<"|");
      }
      Name::idType id = nameServer->getIdentifier( stringId ) ;
            OMTRACEID("PVMSVM"," sending "<<id<< "|");
            delete [] stringId ;
            pvm_initsend( PvmSvm::pvmDataEncoding ) ;
            pvm_pklong (&id, 1, 1);
            pvm_send (receivedRequest.second,PvmMessage::NameServiceReturnId) ;  
          }
          break;
        case PvmMessage::NameServiceGetString:
          {
            Name::idType id ;
            receiveBuffer>>id ;
            OMTRACEID("PVMSVM",
            "Requested String for id "<<id
                <<"| from "<< hex << receivedRequest.second<< dec );
      std::string resultingString( nameServer->getStringAssociatedTo (id) ) ;
            OMTRACEID("PVMSVM"," sending "<<resultingString<<"|");
            pvm_initsend( PvmSvm::pvmDataEncoding ) ;
            pvm_pkstr( const_cast<char *>( resultingString.c_str() ) ) ;
            pvm_send (receivedRequest.second,PvmMessage::NameServiceReturnString) ;  
          }
          break;
        case PvmMessage::NameServiceVerifyLocalNameServer:
          {
            nameServer->verifyCompatibilityWithLocalNameServer (receivedRequest.second, receiveBuffer) ;
          }
          break;
          //added by Chadi
        case PvmMessage::addNewSite:
          {
            addNewSiteToSimulation(receiveBuffer.getMessageDate());
          }
          break;
          //end added
        default:
            OMTRACEID("PVMSVM","Svm::serveNameRequestsUntilEnd() : unexpected request "
                                              <<receivedRequest.first);
          //an unexpected request is received
//        switch (Controller::warningLevel)
//          {
//          case Controller::AllWarnings :
//            cerr<<"Svm::serveNameRequestsUntilEnd() : unexpected request "
//                <<receivedRequest.first<<endl;
//            break ;
//          case Controller::FatalWarnings :
//            cerr<<"Svm::serveNameRequestsUntilEnd() : unexpected request"
//                <<receivedRequest.first<<endl;
//            exit (2) ;              
//            break;
//          default://nothing to do
//            break;
//          }
          break;
        }
    }
}
void Svm::addNewSiteRequest (const Date & date)
{
  PvmUnicastMessage mess ( getParentSiteId () ) ;
  mess.insertTimeStamp ( date ) ;
  mess.send ( PvmMessage::addNewSite ) ;
}


void Svm::connectToDistributedSimulation () 
{
//TDTD
//#ifdef _DEBUGPVMEXEC
  cerr<<"Svm::connectToDistributedSimulation (): connecting to the distributed simulation"<<endl;
//#endif

   PvmIncomingMessage * np = NULL ;

   // connect to the global controller
   _linkToCentralSite = createSvmLink ( getParentSiteId () ) ;
 
   // join the group of slave processes
   joinSvmGroup (_slaveGroupName) ;
 
   // create a distributed version of the nameServer
   PvmNameServer * pvmNameServer = new PvmNameServer ( getParentSiteId() , *Name::getNameServer() ) ; 
 
   Name::setNameServer ( pvmNameServer ) ; 
 
   // find out the name of this site
   np = & _linkToCentralSite->waitForMessage (PvmMessage::SiteName) ;
   *np >> _siteName ;
   npp = np ;

//    cout<<"my site name is _siteName: "<<_siteName<<endl;
//    NameToPointerMap<Process>::iterator j ;
//    for (j = _processTable->begin () ; j != _processTable->end () ; j ++) 
//      {
//        cout<<"connect: _processTable contient: "<<(*j).second->getProcessName()<<endl; 
//      }
   

 
   // find out the adresses of the other sites 
   // - extract the timestamp of the communication
   _linkToCentralSite->waitForMessage (PvmMessage::ProcessTable) ;

   // - extract, for each process, it's adress in the virtual machine and create a link
   NameToPointerMap<Process>::iterator i ;
   for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
     {
       ++_numberOfSlaves ; //we add ourselves, but as _numberOfSlaves is initialised to 0, it's ok

      // Remarque : creer un canal sur soi-meme n'est pas genant,
      // on met juste a jour les tids dans la table des pss

      Process * p = (*i).second ;

      // creation d'un canal sans destinataire 
      p->setSvmLink (createSvmLink ()) ;

      // maj du destinataire
      *np  >> *p ;

      _idToProcessTable.insert ( make_pair ( p->getSvmLink()->getTID(),p ) ) ;

      cout<<"le TID du process ajoute est : "<< p->getSvmLink()->getTID()<<" et son nom est :"<<p->getProcessName()<<endl; 
   }


   //wait for all other sites to be connected to the distributed simulation.
   //avoids sending messages to sites still connected or worse, not yet connected
   syncDistributedSites () ;
   cout<<"EEEE"<<endl;
}

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

void Svm::disconnectFromDistributedSimulation (const Date & endOfSimulationDate ) 
{
#ifdef _DEBUGPVMEXEC
   cout <<"Svm::disconnectFromDistributedSimulation"<< endl ;
#endif
   int recepient = getParentSiteId () ;

   if ( recepient != 0 )
      // a local PvmController has finished. Notify the central controller
      {
         PvmUnicastMessage endMessage (recepient) ;
         
         endMessage.insertTimeStamp ( endOfSimulationDate ) ;
 
         endMessage << getSiteName () ;

         endMessage.send ( PvmMessage::EndOfSimulation ) ;
      }
   else
      //the central controller is deconnecting. Notify all local controllers
      {
         std::vector<int> processSiteIds ;
         for (NameToPointerMap<Process>::iterator i = _processTable->begin () ; 
              i != _processTable-> end () ; 
              i ++) 
            {
               processSiteIds.push_back ( (i->second)->getSvmLink ()->getTID() ) ;
            }
         PvmMulticastMessage endOfSimulationMessage ( processSiteIds ) ;             

         endOfSimulationMessage.insertTimeStamp ( endOfSimulationDate ) ;

         endOfSimulationMessage << getSiteName () ;

         endOfSimulationMessage.send ( PvmMessage::EndOfSimulation ) ;
      }
}


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


void Svm::broadcast (PvmMessage::MessageTag tag, PvmMulticastMessage * mess)
{
  //the first implementation, commented, dies in pvm with an unexpected error
  //I haven't had time to trace the problem, so the second implementation is used

  /* first implementation
  initBeforeMessagePacking () ;
  
  if ( mess != NULL )
    {
      mess->packMessage() ;
    }
  else
    {
      mess = new PvmOutgoingMessage () ;
      mess->insertTimeStamp(0) ;
      *mess << "dummy";
      mess->packMessage() ;
    }
  
  broadcastToGroup ( slaveGroup, tag ) ;
  */

#ifdef _DEBUGPVMMESS
  cerr<<"Svm::broadcast ("<<tag<<","<<mess<<") ; "<<endl;
#endif

  NameToPointerMap<Process>::iterator processIter ; 
  
  if (mess == NULL )
    {
      std::vector<int> distantRecepients ;
      for (processIter = _processTable->begin () ; processIter != _processTable->end () ; ++processIter) 
        {
          if (_siteName != (*processIter).second->getProcessName ()) 
            {
              // On connait alors le canal a observer
              distantRecepients.push_back ( (*processIter).second->getSvmLink ()->getTID () ) ;
            }
        }

      mess = new PvmMulticastMessage ( distantRecepients ) ;
      mess->insertTimeStamp(0) ;
    }

  mess -> send ( tag ) ;

}



void Svm::synchronizeOn ( PvmController & parsingController, PvmMessage::MessageTag tag )
{
  broadcast ( tag ) ;
#ifdef _DEBUGPVMSYNCHRO
  cerr<< "Svm::waitForAllProcesses("<<tag<<") "<<_numberOfSlaves <<endl;
  usleep(1000000) ;
#endif

  int numberOfReadyProcesses = 1 ; //this process has entered the barrier
  
  while ( numberOfReadyProcesses != _numberOfSlaves )
     {

        // here, we ignore the results, because we suppose one process will only send tag once during synchronization
        waitForAnswerToBlockingRequest ( parsingController, tag ) ;

        numberOfReadyProcesses++ ;

#ifdef _DEBUGPVMMESS
  cerr<< "Svm::exitSoftBarrier numberToEnterBarrier: "<<numberOfReadyProcesses<<endl;
  usleep(1000000) ;
#endif

     }
}

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

void Svm::syncDistributedSites()
{
  groupBarrier( _slaveGroupName, _numberOfSlaves ) ;
}

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

SvmLink * Svm::getLinkToProcessNamed( const Name & processName )
{
  // check that we know this process
  if( _processTable->find( processName ) != _processTable->end() )
  {
    Process *pss = _processTable->getObjectOfIndex( processName ) ;
    return pss->getSvmLink() ;
  }
  else
  {
// #ifdef _USESSTREAM
//     ostringstream o ;
//     o << "Svm::getLinkToProcessNamed : Impossible de trouver le processus "
//       << processName << " afin de recuperer son canal !" ;
//     Controller::warning (o.str(), Controller::SomeWarnings ) ;
// #else
//     ostrstream o ;
//     o << "Svm::getLinkToProcessNamed : Impossible de trouver le processus "
//       << processName << " afin de recuperer son canal !" ;
//     o.put ('\0') ;
//     Controller::warning (o.str(), Controller::SomeWarnings ) ;
//     delete o.str() ;
// #endif
    return 0 ;
  }
}

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

Process * Svm::getProcessDescriptorNamed( const Name & processName )
{
  // check that we know this process
  if( _processTable->find( processName ) != _processTable->end() )
  {
    Process *pss = _processTable->getObjectOfIndex( processName ) ;
    return pss ;
  }
  else 
  {
// #ifdef _USESSTREAM
//     ostringstream o  ;
//     o << "Svm::getProcessDescriptorNamed: process " << processName << " unknown !" ;
//     Controller::warning (o.str(), Controller::SomeWarnings ) ;
// #else
//     ostrstream o  ;
//     o << "Svm::getProcessDescriptorNamed: process " << processName << " unknown !" ;
//     o.put('\0') ;
//     Controller::warning (o.str(), Controller::SomeWarnings ) ;
//     delete o.str() ;
// #endif
    return 0 ;
  }
}

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


//-----------------chadi ajout 2/6---------------------------

// on cherche dans la liste des deconnectes si le processus existe ou pas

Process * Svm::testIfDisconnectedProcessNamed( const Name & processName )
{
  // check that we know this process as a deconnected process
  if( _disconnectedTable->find( processName ) != _disconnectedTable->end() )
  {
    Process *pss = _disconnectedTable->getObjectOfIndex( processName ) ;
    return pss ;
  }
  else 
  {
    return 0 ;
  }
}

//-------------------fin chadi ajout 2/6--------------------------






void Svm::processReceivedMessages (PvmController & parsingController, const PvmMessage::MessageTag tag) 
{
#ifdef _DEBUGPVMMESS
   cerr << "Svm::processReceivedMessages"<<endl;
#endif
   NameToPointerMap<Process>::iterator pOMKs ; // Iterateur pour parcours tableau
   SvmLink * canal ; // Canal vers le precedent processus
   PvmIncomingMessage * messageRecu = NULL ;
   for (pOMKs = _processTable->begin () ; 
        pOMKs != _processTable->end () ; 
        pOMKs ++) 
      {
         if (_siteName != (*pOMKs).second->getProcessName ()) 
            {
               // On connait alors le canal a observer
               canal = (*pOMKs).second->getSvmLink () ;
#ifdef _DEBUGPVMMESS
               cout << "Svm::processReceivedMessages from "
                    << (*pOMKs).second->getProcessName () << " tag : "
                    << tag << endl ;
               //canal->affiche () ;
#endif
               // On fait une reception non bloquante
               messageRecu = canal->testForMessage (tag) ;
               while ( messageRecu->hasMessage () ) 
                  {
#ifdef _DEBUGPVMMESS
                     cerr << "Svm::processReceivedMessages : message received of size " <<messageRecu->getSize()<< endl;
#endif        
#ifdef _DEBUGPVMMESS
                     cerr << "Svm::processReceivedMessages: extracted emission date: " <<messageRecu->getMessageDate()<< endl;
#endif        
                     //cerr << "Svm::processReceivedMessages : date " << dateEmission << endl ;
                     // On envoie le message et l'objet au controleur local
                     parsingController.parseSynchronisationMessage (messageRecu) ;
                     messageRecu = canal->testForMessage (tag) ;
                  }
            }
      }
}

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

void Svm::waitAndProcessMessages (PvmController & parsingController, 
                                     const PvmMessage::MessageTag tag) 
{
#ifdef _DEBUGPVMMESS
   cerr<<"Svm::waitAndProcessMessages tag "<<tag<<endl<<"Processus : "<<endl;
   NameToPointerMap<Process>::iterator pOMK ;
   for (pOMK = _processTable->begin () ; pOMK != _processTable->end () ; pOMK ++) {
      cerr<<(*pOMK).second->getProcessName ();
   }
   cerr<<endl;
#endif
   NameToPointerMap<Process>::iterator pOMKs ; // Iterateur pour parcours tableau
   SvmLink * canal ; // Canal vers le precedent processus
   PvmIncomingMessage * messageRecu ;
#ifdef _DEBUGPVMMESS
   cerr<<"Svm::waitAndProcessMessages écoute de tous les processus"<<endl;
#endif
   for (pOMKs = _processTable->begin () ; pOMKs!= _processTable->end () ; pOMKs ++) {
#ifdef _DEBUGPVMMESS
      cerr<<"Svm::waitAndProcessMessages écoute d'un de plus : "<<(*pOMKs).second->getProcessName ()<<endl;
#endif
      if (_siteName != (*pOMKs).second->getProcessName ()) {
         // On connait alors le canal a observer
         canal = (*pOMKs).second->getSvmLink () ;
#ifdef _DEBUGPVMMESS
         cout << "OMKmSvm::waitAndProcessMessages sur "
              << (*pOMKs).second->getProcessName () << " tag : "
              << tag << endl ;
         canal->printDebuggingInformation () ;
#endif
         // On recoit le message en bloquant
         messageRecu = & canal->waitForMessage (tag) ;
#ifdef _DEBUGPVMMESS
         cerr << "Svm::waitAndProcessMessages : message received"<< endl ;
#endif
         // On envoie le message et l'objet au controleur local
         parsingController.parseSynchronisationMessage (messageRecu) ;
      }
   }
}

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

void Svm::waitForMessage (PvmController & parsingController, const PvmMessage::MessageTag tag) 
{
   NameToPointerMap<Process>::iterator pOMKs ; // Iterateur pour parcours tableau
   SvmLink * canal ; // Canal vers le precedent processus
   PvmIncomingMessage * messageRecu = NULL ;
   bool rienRecu=true;
   while (rienRecu) {//on ne teste pas la nullite du message, 
      //car en cas de message ne contenant que la date, on le vide !
      for (pOMKs = _processTable->begin () ; pOMKs!= _processTable->end () ; pOMKs ++) {
         if (_siteName != (*pOMKs).second->getProcessName ()) {
            // On connait alors le canal a observer
            canal = (*pOMKs).second->getSvmLink () ;
#ifdef _DEBUGPVMMESS
            cout << "OMKmSvm::waitForMessage sur "
                 << (*pOMKs).second->getProcessName () << " tag : "
                 << tag << endl ;
            canal->printDebuggingInformation () ;
#endif
            // On recoit le message en bloquant
            messageRecu = canal->testForMessage (tag) ;
            // On envoie le message et l'objet au controleur local
            if (messageRecu->hasMessage() ) 
               {
#ifdef _DEBUGPVMMESS
               cerr << "Svm::waitForMessage : message received" << endl ;
#endif
               parsingController.parseSynchronisationMessage (messageRecu) ;
               rienRecu=false;
            }
         }
      }
      messageRecu = _linkToCentralSite->testForMessage (tag) ;
      //cerr << "Svm::waitForMessage : message recu : " << *messageRecu << endl ;
      if (messageRecu->hasMessage() ) 
         {
#ifdef _DEBUGPVMMESS
         cerr << "Svm::waitForMessage : message received" << endl ;
#endif
         parsingController.parseSynchronisationMessage (messageRecu) ;
         rienRecu=false;
      }
   }
}

//------------------------------------------------------
/*
void Svm::flushDisconnectedSitesOutgoingBuffer()
{
  for ( NameToPointerMap<Process>::iterator prIt = _disconnectedTable->begin () ;
        prIt != _disconnectedTable->end () ;
        ++prIt 
        )
    {
      prIt->second->getSvmLink ()->getOutgoingBuffer().flushCurrentBuffer();    
    }
}
*/
//------------------------------------------------------



// void Svm::synchroniseReceiveAndProcessMessages (PvmController & parsingController, const PvmMessage::MessageTag tag) 
// {
//   NameToPointerMap<Process> aRecevoir ;
//   static int _mostAncientDate = 10000 ;
  
//   //First make a list of processes that we need to receive values from
//   for (   NameToPointerMap<Process>::iterator pOMKsE = _processTable->begin () ; 
//        pOMKsE != _processTable->end () ; 
//        pOMKsE ++) 
//     {
//       if ( (pOMKsE->first != _siteName) &&
//         ( pOMKsE->second->getDateOfLastMessage () +
//           pOMKsE->second->getPeriod () +
//           _synchronisationLatency < parsingController.getSimulatedDate ()))
//      {
//        if (pOMKsE->second->getDateOfLastMessage () < _mostAncientDate)
//          {
//            _mostAncientDate = pOMKsE->second->getDateOfLastMessage ();
//          }
//        _disconnectedTable->addObjectWithIndex (pOMKsE->first, pOMKsE->second) ;
// #ifdef _DEBUGPVMMESS
//        cerr << "Svm::synchroniseReceiveAndProcessMessages: trying reception from: "
//             << pOMKsE->first << endl ;
// #endif
//      }
//     }
  
//   PvmIncomingMessage receiveBuffer ;
//   PvmMessage::MessageTag receivedRequest ;  
//   Process * receivingProcess ;
  
//   struct timeval start_timer,end_timer;
//   gettimeofday(&start_timer, NULL);
//   int time_in_ms = 0;
//   int _simDate =  parsingController.getSimulatedDate () ;
//   while ( _mostAncientDate + time_in_ms  < _simDate ) 
//     { 
//       for ( NameToPointerMap<Process>::iterator processIterator = _disconnectedTable->begin () ;
//          processIterator != _disconnectedTable->end () ;
//          ++processIterator 
//          )
//      {
          
//        //this new implementation doesn't do blocking receives, as some processes could send urgent requests
//        receivingProcess = processIterator->second ;
         
//        receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
         
//        if ( receiveBuffer.hasMessage() )
//          {
              
//            switch (receivedRequest)
//              {
//              case PvmMessage::SynchronisationMessage :
//                {
                    
//                              //have the controller process the message
//                      parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                        
//                      receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ;
                        
//                              //an additionnal test could be performed here to make sure correct date of last message has happened
//                      _disconnectedTable->erase ( receivingProcess->getProcessName() ) ;
//                  //  }
                    
//                }
//              break ;
//              case PvmMessage::MirrorNeedsInitialValues :
//                {
//                  parsingController.sendInitialValuesToMirror ( receiveBuffer ) ;      
//                }
//              break ;
//              case PvmMessage::InitialValuesForMirror :
//                {
//                  //have the controller process the message
//                  parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                    
//                }
//              break ;
//              case PvmMessage::LocalInitSuccessfull :
//              case PvmMessage::ProcessTable :
//              case PvmMessage::EndOfSimulation :
//              case PvmMessage::EnterBarrier :
//              case PvmMessage::SiteName :
//              case PvmMessage::ExitBarrier :
//              case PvmMessage::NameServiceGetId :
//              case PvmMessage::NameServiceGetString :
//              case PvmMessage::NameServiceReturnId :
//              case PvmMessage::NameServiceReturnString :
//              case PvmMessage::NameServiceVerifyLocalNameServer :
//              case PvmMessage::NameServiceVerifyResult :
//              default:
//                {
//                  Controller::warning ("Svm::waitForAnswerToBlockingRequest(): received unexpected message",
//                                         Controller::AllWarnings ) ;
//                }
//              }
//          }     
          
          
//      } //end for
      
//       gettimeofday(&end_timer, NULL);
      
//       time_in_ms = ( (end_timer.tv_sec-start_timer.tv_sec) * 1000000 +
//                   (end_timer.tv_usec-start_timer.tv_usec) )/1000 ;
      
//   //    cout<<"la valeur de dif en millisec : "<<time_in_ms<<endl;
//       //      cout<<"la valeur de start est : "<<start<<endl;
//       //      cout<<"la valeur de end est : "<<end<<endl;
      
//     }  //end while
  
// }




void Svm::relaxedSynchroniseReceiveAndProcessMessages (PvmController & parsingController, const PvmMessage::MessageTag tag) {

   PvmIncomingMessage receiveBuffer ;
   PvmMessage::MessageTag receivedRequest ;  
   Process * receivingProcess ;
   static Name visualProcessA ("visualProcessA") ;
   static Name visualProcessB ("visualProcessB") ;
   static Name visualProcessC ("visualProcessC") ;
   static Name visualProcessD ("visualProcessD") ;

   //std::cerr <<"Svm:: le controleur est sur le processus : " << _siteName << std::endl ;
//    if (_siteName == visualProcessB) { // simulation d'un pb de latence réseau
//       int sommeil = random () % 15000 ;
//       usleep (sommeil) ;
//       //std::cerr <<"ralentissement de : " << sommeil << std::endl ;
//    } else if (_siteName == visualProcessC) { // simulation d'un pb de latence réseau
//       int sommeil = random () % 30000 ;
//       usleep (sommeil) ;
//       //std::cerr <<"ralentissement de : " << sommeil << std::endl ;
//    } else if (_siteName == visualProcessD) { // simulation d'un pb de latence réseau
//       int sommeil = random () % 45000 ;
//       usleep (sommeil) ;
//       //std::cerr <<"ralentissement de : " << sommeil << std::endl ;
//    }


//  if (! _disconnectedTable->empty ()) {

   // first, we try only once to receive something from the disconnected processes
   NameToPointerMap<Process> copyOfDisconnected ;
   for (NameToPointerMap<Process>::iterator prIt = _disconnectedTable->begin () ;
        prIt != _disconnectedTable->end () ;
        ++ prIt) {
      copyOfDisconnected.addObjectWithIndex (prIt->first, prIt->second) ;
   }
   for (NameToPointerMap<Process>::iterator prIt = copyOfDisconnected.begin () ;
        prIt != copyOfDisconnected.end () ;
        ++ prIt) {
      if (prIt->first != _siteName) {
         receivingProcess = prIt->second ;       
         receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage (receiveBuffer) ;  
         if (receiveBuffer.hasMessage ()) {
            // this process has become active again, we put it in the list of processes that we need to receive values from
            // TDTD ajout de trace pour debug
            //std::cerr << " 1 buffer reçu : " << receivedRequest << " à date " << receiveBuffer.getMessageDate ()<< " de " << receivingProcess->getProcessName() << std::endl ;
            // TDTD essai de mise en commentaire pour voir... c'est normalement fait plus loin, avec un test...
            //_activeProcessTable->addObjectWithIndex (prIt->first, prIt->second) ;
            // fin TDTD
            // TDTD : essai pour voir...
            _activeProcessTable->addObjectWithIndex (prIt->first, prIt->second) ;
            _disconnectedTable->erase (prIt->second->getProcessName ()) ;
//TDTDTD enlever le processus de la map _disconnectedProcessusMap
            _disconnectedProcessusMap.erase (prIt->first) ;

            // fin TDTD
            switch (receivedRequest) {
            case PvmMessage::SynchronisationMessage : {
               // cout<<"parsingController.getSimulatedDate() = "<<parsingController.getSimulatedDate()<<endl;
               parsingController.parseSynchronisationMessage (&receiveBuffer) ;
               receivingProcess->setDateOfLastMessage (receiveBuffer.getMessageDate ()) ;
            }
               break ;
            case PvmMessage::MirrorNeedsInitialValues : {
               parsingController.sendInitialValuesToMirror (receiveBuffer) ;      
            }
               break ;
            case PvmMessage::InitialValuesForMirror : {
               //have the controller process the message
               parsingController.parseSynchronisationMessage (&receiveBuffer) ;
            }
               break ;
            case PvmMessage::LocalInitSuccessfull :
               //  case PvmMessage::pingMessage :
//                    {
//                      cout<<"i got the ping message"<<endl;
//                      _activeProcessTable->addObjectWithIndex(prIt->first, processIterator->second) ;
//                      _disconnectedTable->erase( prIt->second->getProcessName() );
//                    }
               break;
            case PvmMessage::ProcessTable :
            case PvmMessage::EndOfSimulation :
            case PvmMessage::EnterBarrier :
            case PvmMessage::SiteName :
            case PvmMessage::ExitBarrier :
            case PvmMessage::NameServiceGetId :
            case PvmMessage::NameServiceGetString :
            case PvmMessage::NameServiceReturnId :
            case PvmMessage::NameServiceReturnString :
            case PvmMessage::NameServiceVerifyLocalNameServer :
            case PvmMessage::NameServiceVerifyResult :
            default: {
               std::cerr << "Svm::waitForAnswerToBlockingRequest(): received unexpected message" << std::endl ;
            }
            } //end switch
         } else {
            // TDTD
            // if the proces was declared active, it is now declared inactive, not to send to him datas that will cost time to read
            // so that it will still be late...
            if (_activeProcessTable->find (prIt->second->getProcessName ()) != _activeProcessTable->end ()) {
               _activeProcessTable->erase (prIt->second->getProcessName ()) ;
            }
            // fin TDTD
         }                    
      }
   } //end for
   //     cout<<"size of _activeProcessTable  : "<<_activeProcessTable->size()<<endl;
//    }
   //second, make a list of processes that we need to receive values from
   for (NameToPointerMap<Process>::iterator pOMKsE = _activeProcessTable->begin () ; 
        pOMKsE != _activeProcessTable->end () ; 
        pOMKsE ++) {
      if ((pOMKsE->first != _siteName) &&
          (pOMKsE->second->getDateOfLastMessage () +
           pOMKsE->second->getPeriod () +
           _synchronisationLatency < parsingController.getSimulatedDate ())) {
         aRecevoir.addObjectWithIndex (pOMKsE->first, pOMKsE->second) ;
#ifdef _DEBUGPVMMESS
         cerr << "Svm::synchroniseReceiveAndProcessMessages: trying reception from: "
              << pOMKsE->first << endl ;
#endif
      }
   }
  
    struct timeval start_timer,end_timer;
    gettimeofday(&start_timer, NULL);
    double time_in_ms = 0;

   // third, try to receive something from the active processes
   // valeur initiale proposée par Chadi : 200 ms
   while ((time_in_ms < _synchronisationTimeOut) && ! aRecevoir.empty ()) { // TDTD : valeur délicate à estimer pour le cas multi processus sur une seule machine
// TDTD : ici je remplace processTable par activeProcesstable
//       for (NameToPointerMap<Process>::iterator processIterator = _processTable->begin () ;
//         processIterator != _processTable->end () ;
//         ++processIterator) {
      for (NameToPointerMap<Process>::iterator processIterator = _activeProcessTable->begin () ;
           processIterator != _activeProcessTable->end () ;
           ++processIterator) {
// fin TDTD
         //this new implementation doesn't do blocking receives, as some processes could send urgent requests
         receivingProcess = processIterator->second ;
         receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage (receiveBuffer) ;
         if (receiveBuffer.hasMessage ()) {
            // TDTD ajout de trace pour debug
            //std::cerr << " 2 buffer reçu : " << receivedRequest << " à date " << receiveBuffer.getMessageDate ()<< " de " << receivingProcess->getProcessName() << std::endl ;
            //---------------------------chadi ajout 4/6 ---------------------
            //  aRecevoir.erase ( receivingProcess->getProcessName() ) ;
            // start = clock();

            //  Date dlm = receivingProcess->getDateOfLastMessage();
//            receivingProcess->setDateOfLastMessage( receiveBuffer.getMessageDate()) ;
//            cout<<"date of last message est = "<<dlm<<" et le message ke je viens de recevoir est daté: "<<receivingProcess->getDateOfLastMessage()<<"donc la difference est de l'ordre de :"<<receivingProcess->getDateOfLastMessage()-dlm<<endl;
// TDTD : je mets ce code plus haut
//          if (_disconnectedTable->find (processIterator->second->getProcessName ()) != _disconnectedTable->end ()) {
//             _activeProcessTable->addObjectWithIndex (processIterator->first, processIterator->second) ;
//             _disconnectedTable->erase (processIterator->second->getProcessName ()) ;
//             //std::cout<<" j'enleve de la liste de deconnecte le processus suivant: "<<processIterator->first<<std::endl;
//             _simStep = 0 ;
//          }
// fin TDTD
            //-----------------------fin chadi ajout 4/6 -------------------------
//            if (receiveBuffer.getMessageDate()+90 < parsingController.getSimulatedDate())
//              { }
//            else {
            switch (receivedRequest) {
            case PvmMessage::SynchronisationMessage : {
               // cout<<"parsingController.getSimulatedDate() = "<<parsingController.getSimulatedDate()<<endl;
               // To filter ancient synchro messages
               parsingController.parseSynchronisationMessage (&receiveBuffer) ;
               receivingProcess->setDateOfLastMessage (receiveBuffer.getMessageDate ()) ;
               if (parsingController.getSimulatedDate () < receiveBuffer.getMessageDate () + 30) {
                  // on a déjà reçu des messages assez récents de ce processus, on n'en demande pas d'autres
                  aRecevoir.erase (receivingProcess->getProcessName ()) ;
               }
            }
               break ;
            case PvmMessage::MirrorNeedsInitialValues : {
               parsingController.sendInitialValuesToMirror (receiveBuffer) ;      
            } break ;
            case PvmMessage::InitialValuesForMirror : {
               //have the controller process the message
               parsingController.parseSynchronisationMessage (&receiveBuffer) ;
            } break ;
            case PvmMessage::LocalInitSuccessfull :
               //  case PvmMessage::pingMessage :
//                  {
//                    cout<<"i got the ping message"<<endl;
//                    _activeProcessTable->addObjectWithIndex(processIterator->first, processIterator->second) ;
//                    _disconnectedTable->erase( processIterator->second->getProcessName() );
//                  }
               break ;
            case PvmMessage::ProcessTable :
            case PvmMessage::EndOfSimulation :
            case PvmMessage::EnterBarrier :
            case PvmMessage::SiteName :
            case PvmMessage::ExitBarrier :
            case PvmMessage::NameServiceGetId :
            case PvmMessage::NameServiceGetString :
            case PvmMessage::NameServiceReturnId :
            case PvmMessage::NameServiceReturnString :
            case PvmMessage::NameServiceVerifyLocalNameServer :
            case PvmMessage::NameServiceVerifyResult :
            default: {
               std::cerr << "Svm::waitForAnswerToBlockingRequest(): received unexpected message" << std::endl ;
            }
            } //end switch
         }                
      } //end for
      
      gettimeofday (&end_timer, NULL) ;
      time_in_ms = (end_timer.tv_sec-start_timer.tv_sec) * 1000.0 +
         (end_timer.tv_usec-start_timer.tv_usec) /1000.0 ;

      // TDTD : ajout d'un arrêt pour pouvoir travailler avec PVM sur une seule machine et plusieurs process
      if (_yieldNeeded) {
#ifdef _MSC_VER
                  Sleep( 0 ) ;
#else
         usleep (0) ;
#endif
      }
   }  //end while

   // fourth, remove the inactive processes from the _activeProcessTable and place them in the _disconnectedTable
   if  (! aRecevoir.empty ()) {
      for (NameToPointerMap<Process>::iterator processIterator = aRecevoir.begin () ;
           processIterator != aRecevoir.end () ;
           ++ processIterator) {
         _disconnectedTable->addObjectWithIndex (processIterator->first, processIterator->second) ;
// TDTDTD ajouter le nom du processus dans la map _disconnectedProcessusMap avec la dernière date simulée arrivée
           _disconnectedProcessusMap.insert (std::pair<Name, Type::IntType> (processIterator->first,
                                                                             (int)processIterator->second->getDateOfLastMessage ())) ;
         // TDTD : je ne comprends pas trop pourquoi mais ici les lignes suivantes doivent être commentéee...
//       if (_activeProcessTable->find (processIterator->second->getProcessName ()) != _disconnectedTable->end ()) {
//          _activeProcessTable->erase (processIterator->second->getProcessName ()) ;
//       }
         // fin TDTD : en fait c'était à cause de l'envoi aux seuls non inactifs (et non pas non en retard), voir la méthode send...withTag...
         //std::cout << "je rajoute le processus suivant a la table des deconnectes " << processIterator->second->getProcessName () << std::endl ;
      }
      aRecevoir.clear () ;
      removeProcessProlog () ;
   }
// TDTD ajout trace pour debug
   //std::cout<<"longueur de la table des deconnectés : "<<_disconnectedTable->size ()<<std::endl;
#ifdef _DEBUGPVMMESS
   cerr << "Svm::synchroniseReceiveAndProcessMessages : on n'est pas bloque la " << endl ;
#endif

}




 /* TDTD : version intermédiaire de sauvegarde
void Svm::relaxedSynchroniseReceiveAndProcessMessages (PvmController & parsingController, const PvmMessage::MessageTag tag) 
{
 //  if (firstTime) {
//     firstTime = false;
//     synchroniseReceiveAndProcessMessages( parsingController,tag);
//       }
//   else {
 // NameToPointerMap<Process> aRecevoir ;


  PvmIncomingMessage receiveBuffer ;
  PvmMessage::MessageTag receivedRequest ;  
  Process * receivingProcess ;
  
 


  if (!_disconnectedTable->empty())
    {
      
      for ( NameToPointerMap<Process>::iterator prIt = _disconnectedTable->begin () ;
            prIt != _disconnectedTable->end () ;
            ++prIt 
            )
        {
          if (prIt->first != _siteName)
            {
              receivingProcess = prIt->second ;  
              receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;   
              if ( receiveBuffer.hasMessage() )
                {
                     // TDTD ajout de trace pour debug
                   //std::cerr << " 1 buffer reçu : " << receivedRequest << " à date " << receiveBuffer.getMessageDate ()<< " de " << receivingProcess->getProcessName() << std::endl ;
                   //cout<<"TRUC BIDULE"<<endl;
                  _activeProcessTable->addObjectWithIndex(prIt->first, prIt->second) ;
                   aRecevoir.addObjectWithIndex (prIt->first, prIt->second) ;
        //         _disconnectedTable->erase( prIt->second->getProcessName() );

                   //cout<<"DEBUT: je rajoute a la liste des ACTIVES le processus suivant: "<<prIt->first<<endl;
                   //TDTD : à vérifier avec l'algorithme...


        //        cout<<"DEBUT: j'enleve de la liste de deconnecte le processus suivant: "<<prIt->first<<endl;
                  switch (receivedRequest)
                    {
                    case PvmMessage::SynchronisationMessage :
                      {
                        // To filter ancient synchro messages
                //      if (receiveBuffer.getMessageDate()+90 < parsingController.getSimulatedDate())
                //        { receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ; }
                //      else {
                          
                                //have the controller process the message
                          parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                          
                          receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ;
                          
                                //an additionnal test could be performed here to make sure correct date of last message has happened
                //        aRecevoir.erase ( receivingProcess->getProcessName() ) ;
                //      }
                        
                      }
                    break ;
                    case PvmMessage::MirrorNeedsInitialValues :
                      {
                        parsingController.sendInitialValuesToMirror ( receiveBuffer ) ;      
                      }
                    break ;
                    case PvmMessage::InitialValuesForMirror :
                      {
                        //have the controller process the message
                        parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                        
                      }
                    break ;
                    case PvmMessage::LocalInitSuccessfull :
                   //  case PvmMessage::pingMessage :
//                    {
//                      cout<<"i got the ping message"<<endl;
//                      _activeProcessTable->addObjectWithIndex(prIt->first, processIterator->second) ;
//                      _disconnectedTable->erase( prIt->second->getProcessName() );
//                    }
                    break;
                    case PvmMessage::ProcessTable :
                    case PvmMessage::EndOfSimulation :
                    case PvmMessage::EnterBarrier :
                    case PvmMessage::SiteName :
                    case PvmMessage::ExitBarrier :
                    case PvmMessage::NameServiceGetId :
                    case PvmMessage::NameServiceGetString :
                    case PvmMessage::NameServiceReturnId :
                    case PvmMessage::NameServiceReturnString :
                    case PvmMessage::NameServiceVerifyLocalNameServer :
                    case PvmMessage::NameServiceVerifyResult :
                    default:
                      {
                         std::cerr << "Svm::waitForAnswerToBlockingRequest(): received unexpected message" << std::endl ;
                      }
                    } //end switch
                  
                  
                  //  aRecevoir.addObjectWithIndex(prIt->first, prIt->second) ;
                  //  _disconnectedTable->erase( prIt->second->getProcessName() );
        //        cout<<"je rajoute a la liste des actives le processus suivant: "<<prIt->first<<endl;
                  //       Date dlm = receivingProcess->getDateOfLastMessage();
                  //      receivingProcess->setDateOfLastMessage( receiveBuffer.getMessageDate()) ;
                  //        cout<<"date of last message est = "<<dlm<<" et le message ke je viens de recevoir est daté: "<<receivingProcess->getDateOfLastMessage()<<"donc la difference est de l'ordre de :"<<receivingProcess->getDateOfLastMessage()-dlm<<endl;
                  //  while ( dlm+50 < receivingProcess->getDateOfLastMessage() && receiveBuffer.hasMessage() )
                  //                {
                  //                  receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
                  //                  if (receiveBuffer.hasMessage())
                  //                    {
                  //                      receivingProcess->setDateOfLastMessage( receiveBuffer.getMessageDate()) ;
                  //                      dlm = receivingProcess->getDateOfLastMessage();
                  //                    }
                   //                 receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
                  //                }
                }         
              
            }
        } //end for
      
    }


  
  
  //      cout<<"size of _activeProcessTable  : "<<_activeProcessTable->size()<<endl;
  
  //First make a list of processes that we need to receive values from
  for (   NameToPointerMap<Process>::iterator pOMKsE = _activeProcessTable->begin () ; 
          pOMKsE != _activeProcessTable->end () ; 
          pOMKsE ++) 
    {
      if ( (pOMKsE->first != _siteName) &&
           ( pOMKsE->second->getDateOfLastMessage () +
             pOMKsE->second->getPeriod () +
             _synchronisationLatency < parsingController.getSimulatedDate ()))
        {
          aRecevoir.addObjectWithIndex (pOMKsE->first, pOMKsE->second) ;
#ifdef _DEBUGPVMMESS
          cerr << "Svm::synchroniseReceiveAndProcessMessages: trying reception from: "
               << pOMKsE->first << endl ;
#endif
        }
    }
  
  struct timeval start_timer,end_timer;
  gettimeofday(&start_timer, NULL);
  double time_in_ms = 0;
  
  
  while ( (time_in_ms < 200) && !aRecevoir.empty() ) 
    { 
      for ( NameToPointerMap<Process>::iterator processIterator = _processTable->begin () ;
            processIterator != _processTable->end () ;
            ++processIterator 
            )
        {
          
          //this new implementation doesn't do blocking receives, as some processes could send urgent requests
          receivingProcess = processIterator->second ;
          
          receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
          
          if ( receiveBuffer.hasMessage() )
            {
                     // TDTD ajout de trace pour debug
               //std::cerr << " 2 buffer reçu : " << receivedRequest << " à date " << receiveBuffer.getMessageDate ()<< " de " << receivingProcess->getProcessName() << std::endl ;
              //---------------------------chadi ajout 4/6 ---------------------
              //  aRecevoir.erase ( receivingProcess->getProcessName() ) ;
              // start = clock();

             //  Date dlm = receivingProcess->getDateOfLastMessage();
//            receivingProcess->setDateOfLastMessage( receiveBuffer.getMessageDate()) ;
//            cout<<"date of last message est = "<<dlm<<" et le message ke je viens de recevoir est daté: "<<receivingProcess->getDateOfLastMessage()<<"donc la difference est de l'ordre de :"<<receivingProcess->getDateOfLastMessage()-dlm<<endl;

              if (_disconnectedTable->find(processIterator->second->getProcessName())!=_disconnectedTable->end())
                {
                  _activeProcessTable->addObjectWithIndex(processIterator->first, processIterator->second) ;
                  _disconnectedTable->erase( processIterator->second->getProcessName() );
                //  cout<<" j'enleve de la liste de deconnecte le processus suivant: "<<processIterator->first<<endl;
                   _simStep = 0 ;
                }
              //-----------------------fin chadi ajout 4/6 -------------------------
//            if (receiveBuffer.getMessageDate()+90 < parsingController.getSimulatedDate())
//              { }
//            else {
                switch (receivedRequest)
                  {
                  case PvmMessage::SynchronisationMessage :
                    {
                     // cout<<"parsingController.getSimulatedDate() = "<<parsingController.getSimulatedDate()<<endl;
                      // To filter ancient synchro messages
                       if (receiveBuffer.getMessageDate()+30 < parsingController.getSimulatedDate())
                         { //cout<<"receiveBuffer.getMessageDate()+90 < parsingController.getSimulatedDate()"<<endl; //receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ; }

                            // TDTD : ajout d'un manque cruel : le traitement du message en retard...
                        parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                            // fin TDTD
                       receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ; }
 
                      else {
                        
                                //have the controller process the message
                        parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                        
                        receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ;
                        
                                //an additionnal test could be performed here to make sure correct date of last message has happened
                        aRecevoir.erase ( receivingProcess->getProcessName() ) ;
                //      cout<<"Je viens d'effacer le process de aRecevoir ..."<<endl;
                      }
                      
                    }
                  break ;
                  case PvmMessage::MirrorNeedsInitialValues :
                    {
                      parsingController.sendInitialValuesToMirror ( receiveBuffer ) ;      
                    }
                  break ;
                  case PvmMessage::InitialValuesForMirror :
                    {
                      //have the controller process the message
                      parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                      
                    }
                  break ;
                  case PvmMessage::LocalInitSuccessfull :
                 //  case PvmMessage::pingMessage :
//                  {
//                    cout<<"i got the ping message"<<endl;
//                    _activeProcessTable->addObjectWithIndex(processIterator->first, processIterator->second) ;
//                    _disconnectedTable->erase( processIterator->second->getProcessName() );
//                  }
                  break;
                  case PvmMessage::ProcessTable :
                  case PvmMessage::EndOfSimulation :
                  case PvmMessage::EnterBarrier :
                  case PvmMessage::SiteName :
                  case PvmMessage::ExitBarrier :
                  case PvmMessage::NameServiceGetId :
                  case PvmMessage::NameServiceGetString :
                  case PvmMessage::NameServiceReturnId :
                  case PvmMessage::NameServiceReturnString :
                  case PvmMessage::NameServiceVerifyLocalNameServer :
                  case PvmMessage::NameServiceVerifyResult :
                  default:
                    {
                       std::cerr << "Svm::waitForAnswerToBlockingRequest(): received unexpected message" << std::endl ;
                    }
                  } //end switch
//            }
        //     receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
            }     
          
          
        } //end for
      
      gettimeofday(&end_timer, NULL);
      
      time_in_ms =  (end_timer.tv_sec-start_timer.tv_sec) * 1000.0 +
                     (end_timer.tv_usec-start_timer.tv_usec) /1000.0 ;
      // TDTD : ajout d'un arrêt pour pouvoir travailler avec PVM sur une seule machine et plusieurs process
      usleep (1) ;

    }  //end while
  
  if  ( !aRecevoir.empty() )  
    {
      for ( NameToPointerMap<Process>::iterator processIterator = aRecevoir.begin () ;
            processIterator != aRecevoir.end () ;
            ++processIterator 
            )
        {
          _disconnectedTable->addObjectWithIndex(processIterator->first, processIterator->second );

//        _temporaryTable->addObjectWithIndex(processIterator->first, processIterator->second );

//        aRecevoir.erase ( processIterator->first ) ;
//        _activeProcessTable->erase( processIterator->first ) ;
        
          std::cout<<"je rajoute le processus suivant a la table des deconnectes "<<processIterator->second->getProcessName()<<std::endl;
        }
      aRecevoir.clear();
      removeProcessProlog () ;
    }
// TDTD ajout trace pour debug
          std::cout<<"longueur de la table des deconnectés : "<<_disconnectedTable->size ()<<std::endl;

  
#ifdef _DEBUGPVMMESS
  cerr << "Svm::synchroniseReceiveAndProcessMessages : on n'est pas bloque la " << endl ;
#endif
  
//  } //else firsttime

}
*/

void Svm::removeProcessProlog ()
{ 
  _simStep++ ;
  //cout<<"_simStep est egale :"<<_simStep<<endl;
  if (_simStep == 2) { 
    removeProcessFromActiveTable() ; 
   // cout<<"_simStep est egale (2) :"<<_simStep<<endl;
    _simStep = 0 ;
  }
}

void Svm::removeProcessFromActiveTable()
{
for ( NameToPointerMap<Process>::iterator processIterator = _disconnectedTable->begin () ;
            processIterator != _disconnectedTable->end () ;
            ++processIterator 
            )
        {
          _activeProcessTable->erase( processIterator->first ) ;
         // cout<<"le process "<<processIterator->first<<" a ete vire de la liste active"<<endl;
        }
// _temporaryTable->clear() ;
// _simStep = 0 ;
}



// void Svm::synchroniseReceiveAndProcessMessages (PvmController & parsingController, const PvmMessage::MessageTag tag) 
// {
//   NameToPointerMap<Process> aRecevoir ;
  
  
//   //First make a list of processes that we need to receive values from//   //First make a list of processes that we need to receive values from

//   for (   NameToPointerMap<Process>::iterator pOMKsE = _processTable->begin () ; 
//        pOMKsE != _processTable->end () ; 
//        pOMKsE ++) 
//     {
//       if ( (pOMKsE->first != _siteName) &&
//         ( pOMKsE->second->getDateOfLastMessage () +
//           pOMKsE->second->getPeriod () +
//           _synchronisationLatency < parsingController.getSimulatedDate ()))
//      {
//        aRecevoir.addObjectWithIndex (pOMKsE->first, pOMKsE->second) ;
// #ifdef _DEBUGPVMMESS
//        cerr << "Svm::synchroniseReceiveAndProcessMessages: trying reception from: "
//             << pOMKsE->first << endl ;
// #endif
//      }
//     }
  
//   PvmIncomingMessage receiveBuffer ;
//   PvmMessage::MessageTag receivedRequest ;  
//   Process * receivingProcess ;
  
//   struct timeval start_timer,end_timer;
//   gettimeofday(&start_timer, NULL);
//   int time_in_ms = 0;
//   while ( (time_in_ms < 100) && !aRecevoir.empty() ) 
//     { 
//       for ( NameToPointerMap<Process>::iterator processIterator = aRecevoir.begin () ;
//          processIterator != aRecevoir.end () ;
//          ++processIterator 
//          )
//      {
          
//        //this new implementation doesn't do blocking receives, as some processes could send urgent requests
//        receivingProcess = processIterator->second ;
         
//        receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
         
//        if ( receiveBuffer.hasMessage() )
//          {
              
//            //---------------------------chadi ajout 4/6 ---------------------
//            //  aRecevoir.erase ( receivingProcess->getProcessName() ) ;
//            // start = clock();
              
//            if (_disconnectedTable->find(processIterator->second->getProcessName())!=_disconnectedTable->end())
//              {
//                //    removeFromDisconnectedTable(processIterator);
//                _disconnectedTable->erase( processIterator->second->getProcessName() );
//                cout<<" j'enleve de la liste de deconnecte le processus suivant: "<<processIterator->first<<endl;
//              }
//            //-----------------------fin chadi ajout 4/6 -------------------------
//  if (receiveBuffer.getMessageDate()+90 < parsingController.getSimulatedDate())
//    { }
//  else {
//             switch (receivedRequest)
//              {
//              case PvmMessage::SynchronisationMessage :
//                {
//                  // To filter ancient synchro messages
//                   if (receiveBuffer.getMessageDate()+50 < parsingController.getSimulatedDate())
//                     { }
//                   else {

//                                      //have the controller process the message
//                      parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                        
//                      receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ;
                        
//                              //an additionnal test could be performed here to make sure correct date of last message has happened
//                      aRecevoir.erase ( receivingProcess->getProcessName() ) ;
//                    }
                    
//                }
//              break ;
//              case PvmMessage::MirrorNeedsInitialValues :
//                {
//                  parsingController.sendInitialValuesToMirror ( receiveBuffer ) ;      
//                }
//              break ;
//              case PvmMessage::InitialValuesForMirror :
//                {
//                  //have the controller process the message
//                  parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                    
//                }
//              break ;
//              case PvmMessage::LocalInitSuccessfull :
//              case PvmMessage::ProcessTable :
//              case PvmMessage::EndOfSimulation :
//              case PvmMessage::EnterBarrier :
//              case PvmMessage::SiteName :
//              case PvmMessage::ExitBarrier :
//              case PvmMessage::NameServiceGetId :
//              case PvmMessage::NameServiceGetString :
//              case PvmMessage::NameServiceReturnId :
//              case PvmMessage::NameServiceReturnString :
//              case PvmMessage::NameServiceVerifyLocalNameServer :
//              case PvmMessage::NameServiceVerifyResult :
//              default:
//                {
//                  Controller::warning ("Svm::waitForAnswerToBlockingRequest(): received unexpected message",
//                                         Controller::AllWarnings ) ;
//                }
//              } //end switch
//    }
//          }     
          
          
//      } //end for
      
//       gettimeofday(&end_timer, NULL);
      
//       time_in_ms = ( (end_timer.tv_sec-start_timer.tv_sec) * 1000000 +
//                   (end_timer.tv_usec-start_timer.tv_usec) )/1000 ;
      
//   //    cout<<"la valeur de dif en millisec : "<<time_in_ms<<endl;
//       //      cout<<"la valeur de start est : "<<start<<endl;
//       //      cout<<"la valeur de end est : "<<end<<endl;
      
//     }  //end while
  
//   if (!aRecevoir.empty())   
//     {
//       for ( NameToPointerMap<Process>::iterator processIterator = aRecevoir.begin () ;
//          processIterator != aRecevoir.end () ;
//          ++processIterator 
//          )
//      {
//        _disconnectedTable->addObjectWithIndex(processIterator->first, processIterator->second );
//        aRecevoir.erase ( processIterator->first ) ;
//        cout<<"je rajoute le processus suivant a la table des deconnectes "<<processIterator->second->getProcessName()<<endl;
//      }        
//     }
  
// #ifdef _DEBUGPVMMESS
//   cerr << "Svm::synchroniseReceiveAndProcessMessages : on n'est pas bloque la " << endl ;
// #endif
// }






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

// void Svm::synchroniseReceiveAndProcessMessages (PvmController & parsingController, const PvmMessage::MessageTag tag) 
// {
//    NameToPointerMap<Process> aRecevoir ;


//    //First make a list of processes that we need to receive values from
//    for (   NameToPointerMap<Process>::iterator pOMKsE = _processTable->begin () ; 
//         pOMKsE != _processTable->end () ; 
//         pOMKsE ++) 
//       {
//       if ( (pOMKsE->first != _siteName) &&
//            ( pOMKsE->second->getDateOfLastMessage () +
//              pOMKsE->second->getPeriod () +
//               _synchronisationLatency < parsingController.getSimulatedDate ())) // || (pOMKsE->second->getIterationFlag()>=1000) )) 
// //------- chadi ajout 3/6-------)&&  !(disconnectedProcess(pOMKsE)))
//          {
//             aRecevoir.addObjectWithIndex (pOMKsE->first, pOMKsE->second) ;
// #ifdef _DEBUGPVMMESS
//             cerr << "Svm::synchroniseReceiveAndProcessMessages: trying reception from: "
//                  << pOMKsE->first << endl ;
// #endif
//          }
//       }

   
//    PvmIncomingMessage receiveBuffer ;
//    PvmMessage::MessageTag receivedRequest ;  
//    Process * receivingProcess ;
   
//    while (! aRecevoir.empty () ) 
//       { 

//       for ( NameToPointerMap<Process>::iterator processIterator = aRecevoir.begin () ;
//             processIterator != aRecevoir.end () ;
//             ++processIterator 
//             )
//          {
//            //*****************chadi: faux deconnexion d'un site *****************
//            //  if ( processIterator->second->getProcessName()== "visualProcessC" )
//            //     {
//               //  addToDisconnectedTable( processIterator );
//            // _disconnectedTable->addObjectWithIndex(processIterator->first,processIterator->second  );
//            //     }
//            //*************************************************************
//             //this new implementation doesn't do blocking receives, as some processes could send urgent requests
//             receivingProcess = processIterator->second ;

//             receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
               
//             if ( receiveBuffer.hasMessage() )
//                {

// //---------------------------chadi ajout 4/6 ---------------------
                   
//      //          cout<<"parsingController.getSimulatedDate = "<<parsingController.getSimulatedDate()<<endl;
//      //          cout<<"receiveBuffer.getMessageDate = "<<receiveBuffer.getMessageDate()<<" en provenance du processus: "<<processIterator->second->getProcessName()<<endl;
//      //          cout<<"_synchronisationLatency = "<<_synchronisationLatency<<endl;
//      //          cout<<"la periode de "<<processIterator->second->getProcessName()<<" est egale a "<< processIterator->second->getPeriod()<<endl;

//              //    cout<<"difference de temps ou pas : "<<receiveBuffer.getMessageDate() - receiveBuffer.getDateOfLastMessage()<<endl;

//      //          cout<<"iterateur->first : " <<processIterator->first<<" iterateur->second : "<<processIterator->second<<endl;
                    
//                  if (_disconnectedTable->find(processIterator->second->getProcessName())!=_disconnectedTable->end())
//                    {
//                      processIterator->second->resetIterationFlag();
//                   // aRecevoir.addObjectWithIndex (processIterator->first, processIterator->second) ;
//                      cout<<"j'enleve de la liste des deconnectes le processus suivant: "<<processIterator->second->getProcessName()<<endl;
//                      removeFromDisconnectedTable(processIterator);
//                    }

                     
// //-----------------------fin chadi ajout 4/6 -------------------------
                     
//                   switch (receivedRequest)
//                      {
//                      case PvmMessage::SynchronisationMessage :
//                        {

//                           if (receiveBuffer.getMessageDate()+90 < parsingController.getSimulatedDate())
//                          {
//                          //cout<<"c pas un bon signe ..."<<endl;
//                          }
//                          else
//                           {

//                              //have the controller process the message
//                              parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                              
//                              receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ;
                              
//                              //an additionnal test could be performed here to make sure correct date of last message has happened
//                              aRecevoir.erase ( receivingProcess->getProcessName() ) ;
//                             }
//                        }
//                      break ;
//                      case PvmMessage::MirrorNeedsInitialValues :
//                         {
//                            parsingController.sendInitialValuesToMirror ( receiveBuffer ) ;      
//                         }
//                      break ;
//                      case PvmMessage::InitialValuesForMirror :
//                         {
//                            //have the controller process the message
//                            parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                              
//                         }
//                      break ;
//              //      case PvmMessage::updateProcessTable :
//                        {
//                          cout<<"ProcessTable Will be Updated ....."<<endl;
//                          _processTable->addObjectWithIndex("visualProcessC", new Process ( "visualProcessTest", "maxipes.irisa.fr" )) ;
//                          cout<<"ProcessTable Updated Succeffully ....."<<endl;
//                          ++_numberOfSlaves ;
//                        }
//                      break ;
//                      case PvmMessage::LocalInitSuccessfull :
//                      case PvmMessage::ProcessTable :
//                      case PvmMessage::EndOfSimulation :
//                      case PvmMessage::EnterBarrier :
//                      case PvmMessage::SiteName :
//                      case PvmMessage::ExitBarrier :
//                      case PvmMessage::NameServiceGetId :
//                      case PvmMessage::NameServiceGetString :
//                      case PvmMessage::NameServiceReturnId :
//                      case PvmMessage::NameServiceReturnString :
//                      case PvmMessage::NameServiceVerifyLocalNameServer :
//                      case PvmMessage::NameServiceVerifyResult :
//                      case PvmMessage::updateProcessTable :
//                      case PvmMessage::addNewSite :
                
//                      default:
//                         {
//                            Controller::warning ("Svm::waitForAnswerToBlockingRequest(): received unexpected message",
//                                                   Controller::AllWarnings ) ;
//                         }
//                      }
                  
//                }
// //-------------------------------chadi ajout 5/6 ----------------------

//             else

//                  {
//                    //   cout<<"nb iteration avant inc = "<<processIterator->second->getIterationFlag()<<endl;
                      
//                    processIterator->second->incrementeIterationFlag();
                      
//                    //   cout<<"nb iteration apres inc = "<<processIterator->second->getIterationFlag()<<endl;
                      
//                    // if ( processIterator->second->disconnectedProcess())
//                    if ( processIterator->second->getIterationFlag() >= 200000)

//                  //  if (receivingProcess->getDateOfLastMessage()+50 < parsingController.getSimulatedDate())
//                      {
//                      //  addToDisconnectedTable( processIterator );
//                        _disconnectedTable->addObjectWithIndex(processIterator->first,processIterator->second  );
//                        aRecevoir.erase( processIterator->second->getProcessName());
//                       // cout<<"je rajoute le processus suivant a la table des deconnectes "<<processIterator->second->getProcessName()<<" car processIterator->second->getIterationFlag()="<<processIterator->second->getIterationFlag()<<endl;
//                      //  cout<<"getDateOfLastMessage()+50 = "<< receivingProcess->getDateOfLastMessage()+50<<" tandis ke parsingController.getSimulatedDate = "<<parsingController.getSimulatedDate()<<endl;
//                      //  cout<<"processIterator->second->getIterationFlag() ="<<processIterator->second->getIterationFlag()<<endl;
//                      }
//                  }
               
// //-----------------------------fin chadi ajout 5/6 -----------------------
               
//          } //end for
//       }  //end while
   
   
// #ifdef _DEBUGPVMMESS
//    cerr << "Svm::synchroniseReceiveAndProcessMessages : on n'est pas bloque la " << endl ;
// #endif
// }


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


//----------------------- The Original One ------------------------------------------------

void Svm::synchroniseReceiveAndProcessMessages (PvmController & parsingController, const PvmMessage::MessageTag tag) 
{
   //cout<<"GGGGG"<<endl;
   NameToPointerMap<Process> aRecevoir ;

   //First make a list of processes that we need to receive values from
   for (   NameToPointerMap<Process>::iterator pOMKsE = _processTable->begin () ; 
           pOMKsE != _processTable->end () ; 
           pOMKsE ++) 
      {
         if ( (pOMKsE->first != _siteName) &&
              ( pOMKsE->second->getDateOfLastMessage () +
                pOMKsE->second->getPeriod () +
                _synchronisationLatency < parsingController.getSimulatedDate () ) ) 
            {
               aRecevoir.addObjectWithIndex (pOMKsE->first, pOMKsE->second) ;
#ifdef _DEBUGPVMMESS
               cerr << "Svm::synchroniseReceiveAndProcessMessages: trying reception from: "
                    << pOMKsE->first << endl ;
#endif
            }
      }

   
   PvmIncomingMessage receiveBuffer ;
   PvmMessage::MessageTag receivedRequest ;  
   Process * receivingProcess ;
   
   while (! aRecevoir.empty () ) 
      { 
         for ( NameToPointerMap<Process>::iterator processIterator = _processTable->begin () ;
               processIterator != _processTable->end () ;
               ++processIterator 
               )
            {
               //this new implementation doesn't do blocking receives, as some processes could send urgent requests
               receivingProcess = processIterator->second ;

               receivedRequest = receivingProcess->getSvmLink ()->testForAnyMessage ( receiveBuffer ) ;
               
               if ( receiveBuffer.hasMessage() )
                  {
                     // TDTD ajout de trace pour debug
                     //std::cerr << "buffer reçu : " << receivedRequest << " à date " << receiveBuffer.getMessageDate ()
                     //       << " de " << receivingProcess->getProcessName() << std::endl ;
                     switch (receivedRequest)
                        {
                        case PvmMessage::SynchronisationMessage :
                           {
                              //have the controller process the message
                              parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                              
                              receivingProcess->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ;
                              
                              //an additionnal test could be performed here to make sure correct date of last message has happened
                              aRecevoir.erase ( receivingProcess->getProcessName() ) ;
                           }
                        break ;
                        case PvmMessage::MirrorNeedsInitialValues :
                           {
                              parsingController.sendInitialValuesToMirror ( receiveBuffer ) ;      
                           }
                        break ;
                        case PvmMessage::InitialValuesForMirror :
                           {
                              //have the controller process the message
                              parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
                              
                           }
                        break ;
                        case PvmMessage::LocalInitSuccessfull :
                        case PvmMessage::ProcessTable :
                        case PvmMessage::EndOfSimulation :
                        case PvmMessage::EnterBarrier :
                        case PvmMessage::SiteName :
                        case PvmMessage::ExitBarrier :
                        case PvmMessage::NameServiceGetId :
                        case PvmMessage::NameServiceGetString :
                        case PvmMessage::NameServiceReturnId :
                        case PvmMessage::NameServiceReturnString :
                        case PvmMessage::NameServiceVerifyLocalNameServer :
                        case PvmMessage::NameServiceVerifyResult :
                        default:
                           {
                              std::cerr << "Svm::waitForAnswerToBlockingRequest(): received unexpected message" << std::endl ;
                              /* END CHADI */
                           }
                        }
                  }
            }
         // TDTD : ajout d'un arrêt pour pouvoir travailler avec PVM sur une seule machine et plusieurs process
         if (_yieldNeeded) {
#ifdef _MSC_VER
                 Sleep( 0 ) ;
#else
            usleep (0) ;
#endif
         }
      }
         
   
#ifdef _DEBUGPVMMESS
   cerr << "Svm::synchroniseReceiveAndProcessMessages : on n'est pas bloque la " << endl ;
#endif
}


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



void Svm::sendCurrentBuffersWithTag(const PvmMessage::MessageTag tag) 
{
   NameToPointerMap<Process>::iterator pOMKs ; // Iterateur pour parcours tableau
   SvmLink * canal ; // Canal vers le precedent processus
   static int nbSteps = 1 ;
#ifdef _DEBUGPVMMESS
   cerr<<"Svm::sendCurrentBufferWithTag tag "<<tag<<endl<<"Processus : "<<endl;
   NameToPointerMap<Process>::iterator pOMK ;
   for (pOMK = _processTable->begin () ; pOMK != _processTable->end () ; pOMK ++) 
     {
       cerr<<(*pOMK).second->getProcessName ();
     }
   cerr<<endl;
#endif

   if (_deadReckoningInterval > 0) {
      nbSteps = (nbSteps + 1) % _deadReckoningInterval ;
   }

   // TDTD on envoie seulement les synchros aux actifs...
   for (pOMKs = _processTable->begin () ; pOMKs != _processTable->end () ; pOMKs ++) 
      //for (pOMKs = _activeProcessTable->begin () ; pOMKs != _activeProcessTable->end () ; pOMKs ++) 
// fin TDTD
     {
#ifdef _DEBUGPVMMESS
       cerr<<"Traitement des emissions vers "<<(*pOMKs).second->getProcessName ()<<endl;
#endif
       if (_siteName != (*pOMKs).second->getProcessName ()) 
         {

           // On connait alors le canal a observer
           canal = (*pOMKs).second->getSvmLink () ;

           if ( tag == PvmMessage::SynchronisationMessage ) 
             {
                (*pOMKs).second->getSvmLink ()->getOutgoingBuffer()<<SynchronisationMessage::endOfSynchronisationFragment ;
              
             }

           // On transmet le message du canal

// TDTD ajout pour purger les envois aux inactifs
           //std::cerr << "sur site : " << _siteName << " : " ;
           if (_activeProcessTable->find ((*pOMKs).second->getProcessName ()) != _activeProcessTable->end ()) {
              //std::cerr << "envoi de syncho à actif : " << (*pOMKs).second->getProcessName () ;
              canal->sendOutgoingBuffer ( tag ) ;
           } else {
              if (nbSteps == 0) { // un coup de dead-reckoning ?
                 //std::cerr << "envoi de syncho à inactif : " << (*pOMKs).second->getProcessName () ;
                 canal->sendOutgoingBuffer ( tag ) ;             
              } else {
                 canal->getOutgoingBuffer().flushCurrentBuffer () ;
                 //std::cerr << "pas d'envoi de syncho à inactif : " << (*pOMKs).second->getProcessName () ;
              }
               }
           //std::cerr << endl ;
// fin TDTD
#ifdef _DEBUGPVMMESS
           cerr << "OMKmSvm::transmission avec tag : "
                << tag << endl ;
#endif
         }
#ifdef _DEBUGPVMMESS
       else 
         {
           cerr << "Rien à faire "<<endl ;
           //canal->affiche () ;
         }
#endif
     }
}

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

void Svm::waitForMessageFrom (PvmController & parsingController,
                                 const Name & processName,
                                 const PvmMessage::MessageTag tag) 
{
   SvmLink * canal ; // Canal vers le precedent processus
   PvmIncomingMessage * messageRecu = NULL ;
   
   // On recupere le canal a observer
   canal = getLinkToProcessNamed (processName) ; 
#ifdef _DEBUGPVMMESS
   cout << "OMKmSvm::waitForMessageFrom sur "
        << processName << " tag : "
        << tag << endl ;
   canal->printDebuggingInformation() ;
#endif
   // On recoit le message en bloquant
   messageRecu = & canal->waitForMessage (tag) ;
   // On envoie le message et l'objet au controleur local
   parsingController.parseSynchronisationMessage (messageRecu) ;
   // On libere le message ???
   //delete messageRecu;
}


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

void Svm::timestampCurrentSendBuffers (const Date & date) 
{
   NameToPointerMap<Process>::iterator i ;
   for (i = _processTable->begin () ; i != _processTable->end () ; i ++) 
     {
        if (_siteName != (*i).second->getProcessName ())
           { 
              i->second->getSvmLink ()->getOutgoingBuffer ().insertTimeStamp ( date ) ;
           }
     }
}


const Name & Svm::getSiteName() const
{
   return _siteName;
}

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

Process * Svm::waitForAnswerToBlockingRequest (PvmController & parsingController, PvmMessage::MessageTag tag)
{
   // this implementation assumes that only one thread at a time will enter this function
   // numberOfThread is an unsafe method to test this
   static int numberOfThreads = 0 ;
   ++numberOfThreads ;
   assert ( numberOfThreads == 1) ;

   Process * result ;

   PvmIncomingMessage receiveBuffer ;
   std::pair<PvmMessage::MessageTag,  int> receivedRequest ;  
   
   bool serving = true ;

   while ( serving ) 
      {

      receivedRequest = waitForAnyRequests ( receiveBuffer ) ;

      //find the sender process (result of this member function)
      map<int,Process *>::iterator i = _idToProcessTable.find ( receivedRequest.second ) ;
      
   //   cout<<"receivedRequest.second est egale : "<<receivedRequest.second<<endl;
   //   cout<<"receivedRequest.first est egale : "<<receivedRequest.first<<endl;
      // the message should come from a known process
      assert ( i != _idToProcessTable.end() ) ;
      
      result = i->second ;
      
      switch (receivedRequest.first)
        {
        case PvmMessage::SynchronisationMessage :
          {
            //have the controller process the message
            parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
            
            assert ( result != NULL ) ;
            
            result->setDateOfLastMessage ( receiveBuffer.getMessageDate () ) ;
          }
        break ;
        case PvmMessage::MirrorNeedsInitialValues :
          {
            parsingController.sendInitialValuesToMirror ( receiveBuffer ) ;      
          }
        break ;
        case PvmMessage::InitialValuesForMirror :
          {
            //have the controller process the message
            parsingController.parseSynchronisationMessage ( &receiveBuffer ) ;
            
          }
        break ;
        case PvmMessage::LocalInitSuccessfull :
        case PvmMessage::ProcessTable :
        case PvmMessage::EndOfSimulation :
        case PvmMessage::EnterBarrier :
        case PvmMessage::SiteName :
        case PvmMessage::ExitBarrier :
        case PvmMessage::NameServiceGetId :
        case PvmMessage::NameServiceGetString :
        case PvmMessage::NameServiceReturnId :
        case PvmMessage::NameServiceReturnString :
        case PvmMessage::NameServiceVerifyLocalNameServer :
        case PvmMessage::NameServiceVerifyResult :
        case PvmMessage::updateProcessTable :
        case PvmMessage::addNewSite :
        default:
          {
          }
        }
      
      serving = ( receivedRequest.first != tag ) ;
      
      }
   
   --numberOfThreads ;

   return result ;
}

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

//----------------chadi ajout 6/6--------------------------------------------------------

void Svm::addToDisconnectedTable( Name& nameOfProcess , Process* pointerToTheProcess )
  
{
//***************************
//  if ( processIterator->second->getProcessName()== "visualProcessC" )
//    { }
//  else {
//****************************


  _disconnectedTable->addObjectWithIndex(nameOfProcess, pointerToTheProcess );
 // _everybodyTable->erase(processIterator->second->getProcessName());
// }
  _troubleFlag = true ;
}

void Svm::removeFromDisconnectedTable( NameToPointerMap<Process>::iterator processIterator )
 {
//***************************
//  if ( processIterator->second->getProcessName()== "visualProcessC" )
//    { }
//  else {
//****************************
//   _everybodyTable->addObjectWithIndex(processIterator->first,processIterator->second  );
  
   _disconnectedTable->erase( processIterator->second->getProcessName() );
// }
   _troubleFlag = false ;
  }

//-----------------------fin chadi ajout 6/6 ---------------------------------------------


bool Svm::disconnectedProcess(Name& zico)
{
  if (_disconnectedTable->find(zico)!=_disconnectedTable->end())
    { return true;}
  else
    return false;
}

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

bool Svm::getTroubleFlag ()
{
  if (_troubleFlag == true)
    { return true; }
  return false;
}

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

bool Svm::disconnectedTableIsEmpty ()
{
  if ( _disconnectedTable->empty() )
    {
      return true;
    }
  return false;
}

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

bool Svm::reconnexionEstablished ()
{
 NameToPointerMap<Process>::iterator prIt = _disconnectedTable->begin () ;
          
//       if ( testIfSiteRecovered( (*prIt).second->getHostMachineName() ) )
 if ( testIfSiteRecovered( (*prIt).second ) )
         {
          // cout<<" Svm::reconnexionEstablished OK"<<endl;
           return true ;
         }
        
 else 
   {
    // cout<<" Svm::reconnexionEstablished NOTOK"<<endl;
     return false ;
   }
         
}

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

void Svm::sendPingMessage ()
{
 for ( NameToPointerMap<Process>::iterator prIt = _disconnectedTable->begin () ;
            prIt != _disconnectedTable->end () ;
            ++prIt 
            )
        {
          ((*prIt).second)->getSvmLink()->getOutgoingBuffer()<<"ping" ;
          ((*prIt).second)->getSvmLink()->getOutgoingBuffer().send(PvmMessage::pingMessage) ;
          cout<<"message ping est fait "<<endl;
        }
}

//-----------------------------------------------------------------
// ajouts TDTD pour gestion plus précise des déconnectés
//-----------------------------------------------------------------

std::list<Name> Svm::getDisconnectedProcessusList () {
   _disconnectedProcessusList.clear () ;
   for (NameToPointerMap<Process>::iterator prIt = _disconnectedTable->begin () ;
        prIt != _disconnectedTable->end () ;
        prIt ++) {
      _disconnectedProcessusList.push_back ((*prIt).first) ;
   }
   return _disconnectedProcessusList ;
}

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

std::map<Name, int> Svm::getDisconnectedProcessusMap () {
   return _disconnectedProcessusMap ;
}

//----------------------fin chadi ajout 2/3 --------------------------

---