OMKPvmMirrorObjectHandle.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 "OMKTracer.h"
#include <cassert>
#include <OMKPvmMirrorObjectHandle.h>
#include <OMKSimulatedObject.h>
#include <OMKPvmController.h>
#include <OMKPvmSvmLink.h>
#include <OMKPvmMessage.h>
#include "OMKEvent.h"
#include "OMKObjectDescriptor.h"
#include "OMKSvm.h"
using namespace std ;
#ifndef _MSC_VER
#include <sys/time.h>
#endif
using namespace OMK ;

//-----------------------------------------------------------------------------
//recevoir la liste des outputs exportables

PvmMirrorObjectHandle::PvmMirrorObjectHandle (SimulatedObject & objetSimul) : 
   MirrorObjectHandle (objetSimul)
{
  Name processOfReferenceObject = 
    getSimulatedObject().getObjectDescriptor ().getProcess () ;
  
  _linkToReferencesProcess = 
    dynamic_cast<PvmController &>(getSimulatedObject().getController()).
    getDistributedVirtualMachine()->
    getLinkToProcessNamed (processOfReferenceObject) ;

  assert ( _linkToReferencesProcess != NULL ) ;
}

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

PvmMirrorObjectHandle::~PvmMirrorObjectHandle () {

}

void PvmMirrorObjectHandle::attributeRead () 
{
   ObjectHandle::attributeRead() ;
   if ( ! _registered )
      {
        //cerr<<"MirrorObjectHandle::attributeRead : new registration needed"<<endl;
        if ( !morphosisPhase )
          {
            registerToReferenceObject (true) ;
          }
        //registerToReferenceObject () ;
      }
}

//-----------------------------------------------------------------------------
// s'abonner Flot de Donnees aupres du referentiel

void PvmMirrorObjectHandle::registerToReferenceObject (bool needValues) 
{
   // should only be called once by the creator of the mirror 
   assert ( _registered == false ) ;
#ifdef _DEBUGPVMSYNCHRO
   cerr << "PvmMirrorObjectHandle::registerToReferenceObject: mirror registering to referential" << endl ;
#endif
   sendRequestToReferenceObject (Registration) ;
   _registered = true ;

   // until SGI Perfomer becomes compatible with exception handling, request initial values from the referential immediatly, and wait for answer
   PvmUnicastMessage * urgentRequest = new PvmUnicastMessage ( _linkToReferencesProcess->getTID() ) ;

   urgentRequest->insertTimeStamp( getSimulatedObject().getController().getSimulatedDate() ) ;

   getSimulatedObject().getName().pack ( *urgentRequest ) ;

   PvmController &  realController = dynamic_cast<PvmController & > ( _myObject.getController() ) ;

   realController.getProcessName ().pack ( *urgentRequest ) ;

   urgentRequest->send ( PvmMessage::MirrorNeedsInitialValues ) ;

//          struct timeval local_start_timer,local_end_timer ;
//          double time_in_ms;
//       gettimeofday (&local_start_timer, NULL) ;

      if (needValues) {
         realController.waitForAnswerToBlockingRequest(PvmMessage::InitialValuesForMirror) ;
      }
//       gettimeofday (&local_end_timer, NULL) ;
//       time_in_ms = (local_end_timer.tv_sec - local_start_timer.tv_sec) * 1000.0 +
//       (local_end_timer.tv_usec - local_start_timer.tv_usec) / 1000.0 ;
//       std::cout << "partial duration 8 = " << time_in_ms << std::endl ;

}

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

void  PvmMirrorObjectHandle::cancelRegistrationToReferenceObject () 
{
#ifdef _DEBUGPVMSYNCHRO
   cout << "PvmMirrorObjectHandle::cancelRegistrationToReferenceObject" << endl ;
#endif
   sendRequestToReferenceObject (CancelRegistration) ;
   _registered = false ;
}

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

void PvmMirrorObjectHandle::insertInStream (ostream & out) const {
   out << "PvmMirrorObjectHandle::insertInStream nothing to insert" << endl ;
}

//-----------------------------------------------------------------------------
void PvmMirrorObjectHandle::unpack (IncomingSynchronisationMessage & in) 
{
   RequestType typeMess ;
   int messageType ;

   //make sure the mirror is still needed
   if ( getAttributeRead() )
      {
         _dateOfLastUse = _myObject.getController().getSimulatedDate() ;
      }
   else
      {
         if ( _myObject.getController().getSimulatedDate() > _dateOfLastUse + 2 * _myObject.getController().getCyclePeriod() ) 
            { 
               cancelRegistrationToReferenceObject () ;
            }
      }

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

   switch ( typeMess )
      {
      case SynchronisationMessage:
         {
            _myObject.unpack ( in ) ;
         }
         break;
      case InitialValuesMessage:
         {
            _myObject.unpackAllValues ( in ) ;
         }
         break;
      default:
         cerr<<"PvmMirrorObjectHandle::unpack: " << _myObject.getName ()
             << " WARNING: uninterpreted message of type "<< typeMess << endl;
         break;
      }
}



void PvmMirrorObjectHandle::extract (istream & in) 
{
   assert (false) ; //use of extract deprecated
}

//-----------------------------------------------------------------------------
void PvmMirrorObjectHandle::receiveEvent (const Event & event) 
{
#ifdef _DEBUGPVMMESS
   cerr<<"PvmMirrorObjectHandle::receiveEvent (const Event & event) "<<endl;
#endif
   _linkToReferencesProcess->getOutgoingBuffer () << getSimulatedObject().getObjectDescriptor ().getName ()
                                                  << EventReceived
                                                  << event ;
}



void PvmMirrorObjectHandle::receiveEvent (Event * event) 
{
#ifdef _DEBUGPVMMESS
   cerr<<"PvmMirrorObjectHandle::receiveEvent (Event * event) "<<endl;
#endif

   _linkToReferencesProcess->getOutgoingBuffer () << getSimulatedObject().getObjectDescriptor ().getName () 
                                                  << EventReceived
                                                  << *event ;

   delete event ;
}


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

bool PvmMirrorObjectHandle::receiveRegistrationForSignal ( const EventIdentifier & sigId,
                                                           const Name & registrant, 
                                                           const EventIdentifier & eventId )
{
  OMTRACEID("DEBUGPVM", "Register : " << sigId << " " << " Name : "<< registrant <<" Ev : "<<  eventId );

   _linkToReferencesProcess->getOutgoingBuffer ()<< getSimulatedObject().getObjectDescriptor().getName () 
                                                 << (int) RegisterForSignal 
                                                 << sigId 
                                                 << registrant 
                                                 << eventId ;
   return true;
}
   
bool PvmMirrorObjectHandle::cancelRegistrationForSignal( const EventIdentifier & sigId , 
                                                            const Name & registrant ) 
{
  OMTRACEID("DEBUGPVM", "UN!!!Register : " << sigId << " Reg : "<< registrant );
  _linkToReferencesProcess->getOutgoingBuffer() << getSimulatedObject().getObjectDescriptor().getName ()
                                                << (int) CancelRegistrationForSignal  
                                                << sigId 
                                                << registrant ;
  return true  ;
}

void PvmMirrorObjectHandle::sendEventsForSignal( Event & event , const EventIdentifier & sigId ) 
{
   assert ( false ) ;
}

void PvmMirrorObjectHandle::sendRequestToReferenceObject (RequestType typeMess) 
{
   PvmOutgoingMessage * sendBuffer = & _linkToReferencesProcess->getOutgoingBuffer () ;

   // as no garanty can be made on the validity of the buffer, timestamp it
   if ( typeMess == CancelRegistration )
      {
         sendBuffer->insertTimeStamp ( OMK::Date(_myObject.getController().getSimulatedDate() + _myObject.getController().getPeriod()*1000) ) ;
      }
   // send the name of the object
   *sendBuffer << _myObject.getName ()  ;
   
   // send the request
   *sendBuffer << (int)typeMess ;
   
#ifdef _DEBGUPVMMESS
   std::cerr<<"PvmMirrorObjectHandle::sendRequestToReferenceObject adding "
            <<_myObject.getController ().getObjectDescriptor().getProcess ()
            <<" to the synchronisation message for object "
            <<_myObject.getName()
            <<std::endl;
#endif
   // send the requesting process
   *sendBuffer << _myObject.getController ().getObjectDescriptor().getProcess () ;
}




void PvmMirrorObjectHandle::linkToNewReferential (Name newProcessName) 
{
//          struct timeval local_start_timer,local_end_timer ;
//          double time_in_ms;

//       gettimeofday (&local_start_timer, NULL) ;

  _linkToReferencesProcess = dynamic_cast<PvmController &>(getSimulatedObject().getController()).getDistributedVirtualMachine()->getLinkToProcessNamed (newProcessName) ;

//       gettimeofday (&local_end_timer, NULL) ;
//       time_in_ms = (local_end_timer.tv_sec - local_start_timer.tv_sec) * 1000.0 +
//       (local_end_timer.tv_usec - local_start_timer.tv_usec) / 1000.0 ;
//       std::cout << "partial duration 6 = " << time_in_ms << std::endl ;
//       gettimeofday (&local_start_timer, NULL) ;

  assert ( _linkToReferencesProcess != NULL ) ;
// TDTD pour shunter PVM en cas de migration
  registerToReferenceObject (false) ;

//       gettimeofday (&local_end_timer, NULL) ;
//       time_in_ms = (local_end_timer.tv_sec - local_start_timer.tv_sec) * 1000.0 +
//       (local_end_timer.tv_usec - local_start_timer.tv_usec) / 1000.0 ;
//       std::cout << "partial duration 7 = " << time_in_ms << std::endl ;
}

void PvmMirrorObjectHandle::setMorphosisPhaseTrue ()
{
  morphosisPhase = true ;
  _migrationCase = true ;
}

---