---

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

PsnSharedMemoryManager * PsMomeController::STLSharedMemoryManager=NULL;
PsnRelaxedMemoryManager * PsMomeController::outputDataSharedMemoryManager=NULL;
PsnCoherantMemoryManager * PsMomeController::controlersDataSharedMemoryManager=NULL;
PsnCoherantMemoryManager * PsMomeController::strictMemoryManager=NULL;
PsnRelaxedMemoryManager * PsMomeController::weakMemoryManager=NULL;
char * PsMomeController::nomExecutable="none" ;
#ifdef _MOME
#include <unistd.h>
#include <sys/mman.h>
#include <malloc.h>
typedef unsigned char TpProcessorNumber;
typedef unsigned char TpGroupeNumber;
#include <MomeDsm.h>
#include <PsnCoherantMemoryManager.h>
#include <PsnRelaxedMemoryManager.h>
#include <PsnOutputOffsetTable.h>
#include <PsnOutputSharedData.h>
#include <PsnUniqueCreator.h>
#include <PsClassicalNameServer.h>
#include <mySharedAllocator.h>
#include <PsnMomeMirrorObjectHandle.h>
#include <PsnMomeReferenceObjectHandle.h>
#include <PsnNew.h>
#include <glib.h>
#endif

void PsMomeController::SigSegvExceptionThrower(void *) {
   cerr<<"PsMomeController::SigSegvExceptionThrower"<<endl;
   exit(0);
}

PsMomeController::PsMomeController(PsObjectDescriptor & initialObjects, const PsDate & initialDate) : 
   PsDistributedController(initialObjects, initialDate) 
{
#ifdef _MOME
   chdir(g_dirname(nomExecutable));
   cout<<"I am controler "<<MomeMe<<"(named "<<getObjectDescriptor().getName()<<") of "<<MomeNumberOfProcessors<<" of thread "<<pthread_self()<<endl;
   _tailleAlloueParSegment = 4*1024*MomePageSize;
   int numSeg = MomeAllocateSharedSegment(2*_tailleAlloueParSegment);
   //cout<<"Me suis alloué un segment partagé"<<endl;
   void * zone = memalign(4096,2*_tailleAlloueParSegment);
   //cout<<"Me suis alloué la mémoire correspondante"<<endl;
   void * buffer = MomeMapMemory(zone,2*_tailleAlloueParSegment,MomeWrite,MAP_FIXED,numSeg,0);

   _zoneCoherenceForte = (int *) buffer ;

   if (MomeMe!=0) {
      MomeBarrier();
      cerr<<"passage de la barrière****************************************"<<endl;
   }

   cerr<<"gestion des adresses depuis "<<buffer<<" et jusqu'à "<<(void *)((unsigned int)buffer+2*_tailleAlloueParSegment)<<endl;
   //sleep(3);

   strictMemoryManager = new PsnCoherantMemoryManager(buffer,_tailleAlloueParSegment, MomePageSize );

   cerr<<"Mémoire cohérante crée"<<endl;

   STLSharedMemoryManager = strictMemoryManager;
   controlersDataSharedMemoryManager = strictMemoryManager;

   cerr<<"Initialisation des données partagées"<<endl;
   _sharedObjectFactory = new PsnUniqueCreator(controlersDataSharedMemoryManager);

   //si MomeMe == 0, on sait qu'on est déjà en exclusion 
   cerr<<"Unique creator créé "<<endl;

   /* on initialise le gestionnaire de broadcast avant le gestionnaire de noms pour obtenir un bon verrou */
   cerr<<"initialisation du broadcastManager"<<endl;
   
   _myBroadcastManager = new PsnBroadcastManager(*_sharedObjectFactory);

   //Feinte : rendu ici, sur tous les noeuds, le PsNameServer doit être le même, au niveau contenu
   //On le recopie donc dans un PsNameServer partagé, et on vérifie
   cerr<<"Nouveau serveur de nom a créer "<<endl;

   PsMomeNameServer * unAutreServeur = _sharedObjectFactory->newPsNameServer(MomeMe+1);
   PsNameServer * oldNameServer = PsName::getNameServer() ;
   cerr<<"nouveau serveur de nom créé"<<endl;
   PsName::setNameServer ( unAutreServeur ) ;   
   delete oldNameServer ;


   myOutputOffsetTable = _sharedObjectFactory->newPsnOutputOffsetTable();

   assert(myOutputOffsetTable != NULL ) ;

   if(MomeMe==0) {
      cerr<<"Arrivé à la barrière de fin d'initialisation"<<endl;
      MomeBarrier();
      cerr<<"Passage de la barrière****************************************"<<endl;
   }
   //gestion des SIGSEGV
   // MomeSIGSEGVHandler( & PsMomeController::SigSegvExceptionThrower );

#endif
}

PsMomeController::~PsMomeController() {
#ifdef _MOME
   cout<<"PsMomeController::~PsMomeController()"<<endl;
   PsClassicalNameServer * unAutreServeur = new PsClassicalNameServer(PsName::getNameServer()->getCanonicalRepresentation());
   PsNameServer * oldNameServer = PsName::getNameServer() ;
   PsName::setNameServer(unAutreServeur);
   MomeBarrier(); //tout le monde doit avoir sa copie du serveur de nom avant la destruction
   if (MomeMe==0) delete oldNameServer ;
   cout<<"destruction du Serveur de nom spécifique Mome"<<endl;
   destroyControlledObjects();
   cout<<"PsMomeController::~PsMomeController() Les objets controlés ont été détruits"<<endl;
   MomeBarrier() ;
   delete weakMemoryManager ;
   //if (MomeMe==0) delete myOutputOffsetTable;
   MomeFinalize(0);
#endif
}


void PsMomeController::init() {
#ifdef _MOME
   MomeBarrier();  
   cerr<<"PsMomeController::init() classique tentée "<<_stepPeriod<<endl;
   PsDistributedController::init();
   cerr<<"PsMomeController::init() : frequency locale : "<<_stepPeriod<<endl;
   while (! tableDesNonInitialises.empty ()) {
      cerr<<"Nouvelle initialisation des objets dont l'init a échouée"<<endl; 
      weakMemoryManager->strongSynchronizeRegion(0,_tailleAlloueParSegment);
      //syncAttributesAndEvents();
      PsNameToPointerMap<PsSimulatedObject> aInitialiser = tableDesNonInitialises ;
      tableDesNonInitialises.clear () ;
      PsNameToPointerMap<PsSimulatedObject>::iterator pNI ;
      //cout<<"*"<<endl;
      for (pNI = aInitialiser.begin () ;
           pNI != aInitialiser.end () ;
           pNI ++) {
         cout<<pNI->second->getName()<<" " ;
         initObjetReferentiel (pNI->second) ;
         cout<<".";
      }
      cout<<endl;
   }
   cerr<<"PsMomeController::init Synchronisation ";
   weakMemoryManager->strongSync();   
   cerr<<"efffective"<<endl;
#endif
}

PsnSharedMemoryManager * PsMomeController::whichSharedMemoryManager(void * ptr) {
#ifdef _MOME
   if(strictMemoryManager!=NULL) {
      if(strictMemoryManager->inAdressSpace(ptr)) return strictMemoryManager;
   }
   if (weakMemoryManager!=NULL) {
      if(weakMemoryManager->inAdressSpace(ptr)) return weakMemoryManager;
   }
   return 0 ;
#else
   return 0 ;
#endif
}

PsnOutputSharedData * PsMomeController::creerDonneesOutput (const PsName & object, const PsName & name) {
#ifdef _MOME
   PsnOutputSharedData * res;
#ifdef _DEBUGCREATIONOUTPUT
   cerr<<"on cherche "<<object<<","<<name<<endl;
#endif
   pair<bool,unsigned int> present = myOutputOffsetTable->getOutputOffset(object,name);
   if (present.first) {
#ifdef _DEBUGCREATIONOUTPUT
      cerr<<"on a retrouvé la output "<<object<<","<<name<<endl;
#endif
      res = (PsnOutputSharedData * )outputDataSharedMemoryManager->localAddressToGlobal(present.second);
   }
   else {
      myOutputOffsetTable->lock();
#ifdef _DEBUGCREATIONOUTPUT
      cerr<<"On va déclarer la output "<<object<<","<<name<<endl;
#endif
      res = new PsnOutputSharedData();
#ifdef _DEBUGCREATIONOUTPUT
      cerr<<"On a déclaré la structure de donnée"<<endl;
#endif
      myOutputOffsetTable->declareOutput(object,
                                         name,
                                         outputDataSharedMemoryManager->globalAddressToLocal(res));
#ifdef _DEBUGCREATIONOUTPUT
      cerr<<"On a déclaré la output "<<object<<","<<name<<endl;
#endif
      myOutputOffsetTable->unlock();
   }
   return res;
#else
   return 0 ;
#endif
}

void PsMomeController::invalidateOutput(const PsName & object, const PsName & name) {
#ifdef _MOME
   //cerr<<"PsMomeController::invalidateOutput("<<object<<","<<name<<")"<<endl;
   myOutputOffsetTable->lock();
   myOutputOffsetTable->invalidateOutput(object,name);
   myOutputOffsetTable->unlock();
   //cerr<<"PsMomeController::invalidateOutput done"<<endl;
#endif
}

#include <PsOutputNT.h>
#include <PsControlParameter.h>
#include <PsnMirrorObjectHandle.h>

void PsMomeController::syncAttributesAndEvents( void ) 
{
#ifdef _MOME
    //Synchroniser les données partagées avec les données locales
//     PsNameToPointerMap<PsnMirrorObjectHandle>::iterator i;
//     PsNameToPointerMap<PsOutputNT> * tableDesOutputs;
//     PsNameToPointerMap<PsOutputNT>::iterator ii;
//     PsNameToPointerMap<PsControlParameterNT> * tableDesParametres;
//     PsNameToPointerMap<PsControlParameterNT>::iterator iii;
//     for(i=_mirrorObjectsMap.begin();i!=_mirrorObjectsMap.end();i++){
//        tableDesOutputs=((*i).second)->objetSimul()->TabOutputs();
//        for(ii=tableDesOutputs->begin();ii!=tableDesOutputs->end();ii++) {
//       (*ii).second->extract();
//       //cout<<(*ii).first<<" : "<<*((*ii).second)<<endl;
//        }
//        tableDesParametres=((*i).second)->objetSimul()->TabParams();
//        for(iii=tableDesParametres->begin();iii!=tableDesParametres->end();iii++) {
//       (*iii).second->extract();
//       //cout<<(*ii).first<<" : "<<*((*ii).second)<<endl;
//        }      
//     }
   _myBroadcastManager->sync();
#endif
}  

void PsMomeController::computeNextSimulationStep() {
#ifdef _MOME
#ifdef _DEBUGEXEC
   cerr<<"PsMomeController::computeNextSimulationStep synchronisation de la mémoire "<<endl;
#endif
   weakMemoryManager->sync();      
#ifdef _DEBUGEXEC
   cerr<<"PsMomeController::computeNextSimulationStep synchronisation des messages et des événements "<<endl;
#endif
      
#ifdef _DEBUGEXEC
   cerr<<"PsMomeController::computeNextSimulationStep appel de la méthode ancêtre "<<endl;
#endif
   PsDistributedController::computeNextSimulationStep();
#ifdef _DEBUGEXEC
   cerr<<"PsMomeController::computeNextSimulationStep fait"<<endl; 
#endif
#endif
}

PsnMirrorObjectHandle * PsMomeController::newPsnMirrorObjectHandle (PsSimulatedObject & obj) {
#ifdef _MOME
   return new PsnMomeMirrorObjectHandle(obj, *_myBroadcastManager, *strictMemoryManager);
#else
   return 0 ;
#endif
}

PsnReferenceObjectHandle * PsMomeController::newPsnReferenceObjectHandle (PsSimulatedObject & object, 
                                                                          PsController & controller,
                                                                          PsnSignalDispatcher * signalDispatcher) 
{
#ifdef _MOME
   return new PsnMomeReferenceObjectHandle(obj, controller, signalDispatcher) ; 
#else
   return 0 ;
#endif
}

void PsMomeController::prepareEventProcessing ( list <PsEvent *> & myList ) {
#ifdef _MOME
   syncAttributesAndEvents();
#ifdef _DEBUGEVT
   cerr<<"PsMomeController::prepareEventProcessing de "<<getObjectDescriptor().Processus()<<endl;
#endif
   //dispatch events received from the broadcast manager
   _myBroadcastManager->dispatchEventsOfList(*this);
#ifdef _DEBUGEVT
   cerr<<"PsMomeController::traiterEvt : events dispatched"<<endl;
#endif
#endif
}


void PsMomeController::actOnSystemEvent( PsEvent * evt ) {
#ifdef _MOME
#ifdef _DEBUGEVT
   cerr<<"PsMomeController::actOnSystemEvent"<<evt<<endl;
#endif
   if(evt->receiver == getName()) {//il faut diffuser l'évenement
      HeapStackTop toto(controlersDataSharedMemoryManager);
      _myBroadcastManager->broadcastEvent(controlersDataSharedMemoryManager->globalAddressToLocal(evt->clone()));
   }
   else {
      PsDistributedController::actOnSystemEvent ( evt ) ;
   }
#else
   PsDistributedController::actOnSystemEvent ( evt ) ;
#endif
}

int PsMomeController::getOutputHistorySize(void) {
   //on aligne sur un multiple de nbMinor 
   int resul = PsDistributedController::getOutputHistorySize() ;
   if (resul % _nbStepsByCycle != 0) {
      resul = (resul / _nbStepsByCycle + 1) * _nbStepsByCycle ;
   }
   return 2 * resul;
}  

void PsMomeController::createControlledObjects( const PsObjectDescriptor * subTree ) 
{
#ifdef _MOME
   cerr<<"PsMomeController::createControlledObjects"<<endl;
   weakMemoryManager = new PsnRelaxedMemoryManager((int *)(((int)_zoneCoherenceForte)+_tailleAlloueParSegment),
                                                   _tailleAlloueParSegment, 
                                                   MomePageSize, 
                                                   _sharedObjectFactory,
                                                   getOutputHistorySize() );  

   outputDataSharedMemoryManager = weakMemoryManager;
  
   cerr<<"PsMomeController::createControlledObjects appel ancetre"<<endl;
   PsDistributedController::createControlledObjects( subTree ) ;
   cerr<<"PsMomeController::createControlledObjects fait"<<endl;
#endif
}
void PsMomeController::broadcast (const PsName & nomDestinataire, const PsString & message) {
   assert (false) ; // non implementé
}

---