---

PsnPvmReferenceObjectHandle.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 <PsnPvmReferenceObjectHandle.h>
#include <PsSimulatedObject.h>
#include <PsnPvmMessage.h>
#include <PsObjectDescriptor.h>
#include <PsnSvmLink.h>
#include <PsnProcess.h>
#include <PsController.h>
#ifdef _PVM
#include <PsPvmController.h>
#endif
#include "PsnSvm.h"
#include <typeinfo>
#include "PsEventListener.h"
#include "PsIncomingSynchronisationMessage.h"
//-----------------------------------------------------------------------------

PsnPvmReferenceObjectHandle::PsnPvmReferenceObjectHandle (PsSimulatedObject & object, 
                                                          PsController & controller)
   : PsnReferenceObjectHandle ( object, controller)
{
}

PsnPvmReferenceObjectHandle::PsnPvmReferenceObjectHandle (PsSimulatedObject & object, 
                                                          PsController & controller, 
                                                          PsnSignalDispatcher * signalDispatcher)
   : PsnReferenceObjectHandle ( object, controller, signalDispatcher)
{
}

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

PsnPvmReferenceObjectHandle::~PsnPvmReferenceObjectHandle () 
{
}


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

void PsnPvmReferenceObjectHandle::emettreValAttributs (PsnPvmOutgoingMessage *messFD,
                                                       PsnPvmOutgoingMessage *messEV) 
{

}


void PsnPvmReferenceObjectHandle::insertInStream (ostream & out) const 
{
   PsController::error ("On utilise l'insert du referentiel") ;
}

//-----------------------------------------------------------------------------
void PsnPvmReferenceObjectHandle::unpack (PsIncomingSynchronisationMessage & in) 
{
#if defined (_DEBUGPVMMESS)
   cerr << "PsnPvmReferenceObjectHandle::unpack"<<endl;
#endif
   // Frequency max des refs du pss distant
   PsFrequency freqPssDist ;
   // Frequency de ce pss
   PsFrequency freqLocale ;
   // Frequency de communication
   PsFrequency  freqComm ;

   PsnRequestType typeMess ;
   int messageType ;

   in >> messageType ;
   typeMess = static_cast <PsnRequestType> (messageType) ;

#if defined (_DEBUGPVMMESS)
   cerr << "PsnPvmReferenceObjectHandle::unpack: received a message of type " <<typeMess<<" "<<Registration
        <<" at date "<<getSimulatedObject().getSimulatedDate()
        <<endl;
#endif
 
   if (typeMess == Registration) 
      {
         // name of the process sending the message
         PsName processName ;
         
         processName.unpack ( in ) ;
#ifdef _DEBUGPVMMESS
         cout << "PsnPvmReferenceObjectHandle::unpack " << processName << " registering a mirror "<< endl ;
#endif
         PsnSvmLink * canal = dynamic_cast<PsPvmController &>(_controller).getDistributedVirtualMachine()->getLinkToProcessNamed (processName) ;

         PsnProcess * processDescriptor = dynamic_cast<PsPvmController &>(_controller).getDistributedVirtualMachine()->getProcessDescriptorNamed (processName) ;
         
         //the registering process needs a complete version of the outputs of the object in the next synchronisation message
         _needAllOutputValues.insert ( make_pair(processName, canal) ) ;

//       // On recupere la frequency max des refs du pss distant
//       freqPssDist = processDescriptor->getMaxFrequencyOfHostedObjects () ;
//       // On recupere la frequency locale
//       freqLocale = _myObject. getObjectDescriptor ().getFrequency () ;
//       // On calcule la frequency de communication
//  #ifdef _DEBUGPVMMESS
//       cout << "freqLocale : " << freqLocale << endl ;
//       cout << "freqPssDist : " << freqPssDist << endl ;
//  #endif
//       if (freqLocale > freqPssDist) 
//          {
//             freqComm = plusPetitSSMultSup(freqLocale,
//                                            freqPssDist) ;
//  #ifdef _DEBUGPVMMESS
//             cout << "freqComm : " << freqComm << endl ;
//  #endif
//          } 
//       else 
//          {
//             freqComm = freqLocale ;
//  #ifdef _DEBUGPVMMESS
//             cout << "freqComm  : " << freqComm << endl ;
//  #endif
//          }
//       // On la stocke
//       _processFrequencies.insert (ProcessFrequenciesType::value_type(processName, freqComm)) ;
      } 
   else if (typeMess == CancelRegistration) 
      {
         // name of the process sending the message
         PsName processName ;
         processName.unpack ( in ) ;

         _needUpdateOutputValues.erase (processName) ; 
         //_processFrequencies.erase ( processName ) ;
         _needAllOutputValues.erase ( processName ) ;
      } 
   else if (typeMess == EventReceived) 
      {
#if ( defined (_DEBUGPVMMESS) || defined (_DEBUGPVMEVENTS ) )
         cerr << "PsnPvmReferenceObjectHandle::unpack: received an event relayed from an mirror" << endl ;
#endif
         PsEvent * event ;
         PsName classToCreate ;
         PsEventIdentifier eventId;
         PsDate eventDate;
         PsName sender, receiver ;
         in >> classToCreate >> eventId>> eventDate>>sender>>receiver ;
         event = PsEventCreator::createEvent (classToCreate, eventId, eventDate, sender, receiver ) ;
         event->unpack ( in ) ;
         PsnReferenceObjectHandle::receiveEvent ( event ) ;
      } 
   else if (typeMess == RegisterForSignal) 
      {
#ifdef _DEBUGPVMMESS
         cout << "PsnPvmReferenceObjectHandle::unpack: RegisterForSignal" << endl ;
#endif
      PsName sigId ;
      PsName registrant ;
      PsName eventId ;
      in >> sigId >> registrant >> eventId ;
      receiveRegistrationForSignal (sigId, registrant, eventId );
   } 
   else if (typeMess == CancelRegistrationForSignal) 
      {
#ifdef _DEBUGPVMMESS
         cout << "PsnPvmReferenceObjectHandle::unpack: CancelRegistrationForSignal" << endl ;
#endif
         PsName sigId ;
         PsName registrant ;
         in >> sigId >> registrant ;
         cancelRegistrationForSignal (sigId, registrant) ;
      }
   else 
      {
         cerr<<"PsnPvmReferenceObjectHandle::unpack : unknown request"<<endl; ;
      }

#if defined (_DEBUGPVMMESS)
   cerr << "PsnPvmReferenceObjectHandle::unpack finished" <<endl;
#endif
}
   


void PsnPvmReferenceObjectHandle::extract (istream & in) {
#if defined (_DEBUGPVMMESS)
   cerr << "PsnPvmReferenceObjectHandle::extract:"<<endl;
#endif
   // Type de message
   PsString typeMess ;
   // Nom du processus ou se trouve le miroir (cas de l'EV)
   PsName processName ;
   
   in >> typeMess ;
   cerr << "PsnPvmReferenceObjectHandle::extract: received a message of type " <<typeMess<<endl;
   if (typeMess == "EV") 
      {
         int typeEv ;
         in >> typeEv ;
         cerr << "PsnPvmReferenceObjectHandle::extract: received an event message of type " <<typeEv<<endl;
         if (typeEv == Registration) 
            {
               // Frequency max des refs du pss distant
               PsFrequency freqPssDist ;
               // Frequency de ce pss
               PsFrequency freqLocale ;
               // Frequency de communication
               PsFrequency  freqComm ;

               // On recupere le nom du processus associe
               in >> processName ;
#ifdef _DEBUGPVMMESS
               cout << "PsnPvmReferenceObjectHandle::extract "<<processName << " registred a mirror "<< endl ;
#endif
               // On recupere le processus associe
               PsnSvmLink * canal = dynamic_cast<PsPvmController &>(_controller).getDistributedVirtualMachine()->getLinkToProcessNamed (processName) ;
               
               PsnProcess * processDescriptor = dynamic_cast<PsPvmController &>(_controller).getDistributedVirtualMachine()->getProcessDescriptorNamed (processName) ;
               
               //the registering process needs a complete version of the outputs of the object in the next synchronisation message
               _needAllOutputValues.insert ( make_pair (processName,canal) ) ;

//          // On recupere la frequency max des refs du pss distant
//          freqPssDist = processDescriptor->getMaxFrequencyOfHostedObjects () ;
//          // On recupere la frequency locale
//          freqLocale = _myObject. getObjectDescriptor ().getFrequency () ;
//          // On calcule la frequency de communication
//  #ifdef _DEBUGPVMMESS
//          cout << "freqLocale : " << freqLocale << endl ;
//          cout << "freqPssDist : " << freqPssDist << endl ;
//  #endif
//          if (freqLocale > freqPssDist) {
//             freqComm = plusPetitSSMultSup(freqLocale,
//                                            freqPssDist) ;
//  #ifdef _DEBUGPVMMESS
//             cout << "freqComm : " << freqComm << endl ;
//  #endif
//          } else {
//          freqComm = freqLocale ;
//  #ifdef _DEBUGPVMMESS
//          cout << "freqComm  : " << freqComm << endl ;
//  #endif
//          }
//       // On la stocke
//          _processFrequencies.insert(ProcessFrequenciesType::value_type(processName, freqComm)) ;
         } 
         else if (typeEv == CancelRegistration) {
            cout << "On se desabonne" << endl ;
         } 
         else if (typeEv == EventReceived) {
#ifdef DEBUG
         cerr << "On recoit un evenement en provenance d'un miroir" << endl ;
#endif
         assert ( false ) ;
         //PsEvent evt ( in ) ;
         //in >> evt ;
         //receiveReallyEvent (evt) ;
      } 
         else if (typeEv == RegisterForSignal) 
            {
#ifdef DEBUG
      cout << "On recoit un signal en provenance d'un miroir" << endl ;
#endif
      PsName sigId ;
      PsName abonne ;
      PsName eventId ;
      in >> sigId >> abonne >> eventId ;
      receiveRegistrationForSignal (sigId, abonne, eventId );
      } 
      else {
         cerr<<"PsnPvmReferenceObjectHandle::extract : Type d'evenement incorrect"<<endl ;
      }
   }
   else {
      cerr<<"PsnPvmReferenceObjectHandle::extract : Type d'evenement incorrect" <<endl ;
   }
}


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

void PsnPvmReferenceObjectHandle::makeSynchronisationMessage ( const PsDate & date ) 
{
#if defined (_DEBUGEXECPVM) || defined (_DEBUGPVMMESS) 
   cerr<<"PsnPvmReferenceObjectHandle::makeSynchronisationMessage ( const PsDate & "<<date<< ")"<<endl;
#endif
   PsnPvmOutgoingMessage * message ;

   if ( _dateOfLastActivation == date )
      // only send a synchronisation message if the handled object has been activated
      {
         PsNameToPointerMap<PsnSvmLink>::iterator pCanal ; // iterateur
//       ProcessFrequenciesType::iterator pFreq ; // iterateur
//       PsDate dtComm ;
//       PsFrequency freqComm ;
#ifdef _DEBUGPVMMESS
         cout<<"makeSynchronisationMessages of "<<getSimulatedObject().getName()<<endl;
#endif
         // On initialise l'iterateur sur la frequency
         //pFreq = _processFrequencies.begin () ;
         //Pour tous les abonnes
         for (pCanal = _needUpdateOutputValues.begin () ;
              pCanal != _needUpdateOutputValues.end ();
              pCanal ++) 
            {
               // On calcule le pas de temps de la communication
//             freqComm = (*pFreq).second ;
//             dtComm = 1000 / freqComm ;
#ifdef _DEBUGPVMMESS
               cout << "dtComm : " << dtComm << endl ;
#endif
               // On verifie qu'il faut reellement emettre
               // devrait maintenant etre inutile a cause des Frames majeures et mineures
//             if (_controller.getSimulatedDate () % dtComm == 0) 
//                {
                     // On recupere le message ou stocker les donnees
                     message = &(*pCanal).second->getOutgoingBuffer () ;  
#ifdef _DEBUGPVMMESS
                     cout <<"PsnPvmReferenceObjectHandle::makeSynchronisationMessage writing to the buffer: " <<message<< endl ;
#endif
          // On va construire le message
          // On ajoute le destinataire, puis le type du message puis les outputs
          *message << _myObject.getName ()  
                   << static_cast<int> (SynchronisationMessage) 
                   <<  _myObject ;
  
#ifdef _DEBUGDISTRIBUTEDINIT
          cerr<<"PsnPvmReferenceObjectHandle::makeSynchronisationMessage : sending a message to ";
          (*pCanal).second->printDebuggingInformation();
          cerr<<" for object "<<_myObject.getName()<<endl;
#endif
        }
        // On passe a la frequency suivante
//      pFreq ++ ;
//        }
    }
  else
    {
#ifdef _DEBUGPVMMESS
      cerr <<"PsnPvmReferenceObjectHandle::makeSynchronisationMessage : No synchronisation needed at " << date 
           <<", last activation : "<<_dateOfLastActivation<<endl ;
#endif
    }
   // send complete values to the processes needing a complete list of the values with their associated production date.
   // this is done after updating, because processes in that list are then automatically inserted in the list of process needing only updates
   for (map<PsName, PsnSvmLink *>::iterator i = _needAllOutputValues.begin() ;
        i != _needAllOutputValues.end() ;
        ++i)
      {
         packInitialValues ( (i->second)->getOutgoingBuffer () ) ; 

         _needUpdateOutputValues.insert ( *i ) ;
      }
   _needAllOutputValues.clear() ;
#ifdef _DEBUGPVMMESS
   cerr <<"PsnPvmReferenceObjectHandle::makeSynchronisationMessage end" <<endl ;
#endif
}

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

int PsnPvmReferenceObjectHandle::plusPetitSSMultSup (const int A, const int B) {
   // Fournit le plus petit sous-multiple de A plus grand que B
   int i = B ; // Valeur testee
   // Valeur max au dela de laquelle pas ss-multiple
   int valMax = div (A, 2).quot ; 
   bool ssMult = false ; // i ss-multiple de A ???

#ifdef DEBUG
   cout << "plusPetitSSMultSup***************************************" << endl ;
   cout << "A : " << A << ", B : " << B << endl ;
   cout << "valMax : " << valMax << endl ;
#endif
  
   // On verifie si i ss-multiple de A
   ssMult = (div (A, i).rem == 0) ;
   while ((! ssMult) && (i <= valMax)) {
      i++ ;
      // On verifie si i ss-multiple de A
      ssMult = (div (A, i).rem == 0) ;
   }
   if (i > valMax) {
#ifdef DEBUG
      cout << "res : " << A << endl ;
      cout << "Fin de plusPetitSSMultSup***************************************" << endl;
#endif  
      return A ;
   } else {
#ifdef DEBUG
      cout << "res : " << i << endl ;
      cout << "Fin de plusPetitSSMultSup***************************************" << endl;
#endif  
      return i ;
   }
}


void PsnPvmReferenceObjectHandle::packInitialValues ( PsnPvmOutgoingMessage & message ) 
{
   _myObject.getName ().pack ( message ) ; 
   message << static_cast<int> (InitialValuesMessage) ;
   _myObject.packAllValues ( message ) ;
}

---