---

PsPvmBenchController.h

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 
 *
 */
#ifndef PsPvmBenchControllerHEADER
#define PsPvmBenchControllerHEADER

#include <PsPvmController.h>
#include <PsBenchController.h>
#include <fstream>

template <class APvmController>
class PsPvmBenchController : public PsBenchController<APvmController> 
{
public :
   PsPvmBenchController (PsObjectDescriptor & scenario,
                         const PsDate & initialSimulationDate,
                         int argc,
                         char * argv []);
   virtual ~PsPvmBenchController () ;
   virtual void computeNextSimulationStep();
   virtual void compute();
   virtual PsnScheduler * createScheduler() ; 
   virtual void parseSynchronisationMessage (PsnPvmIncomingMessage * message) ;
protected :
   long dureePartielleRecep;
   vector<long> _stepDurationTab ;
   vector<long> _completeDurationTab ;
   vector<long> _networkReceiveDurationTab ;
   vector<long> _demarshallingDurationTab ;
   vector<long> _networkSendDurationTab ;
   vector<long> _marshallingDurationTab ;
} ; // PsPvmBenchController


#include <PsDuplicatedObject.h>
#include <sys/time.h>
#include <unistd.h>
#include <limits.h>
#include <fstream>
#include <iostream>
#include <iomanip>

#include "PsConfigurationParameterDescriptor.h"
#include "PsnSvm.h"

#include "PsSynchronisationMessage.h"
#include "PsnMirrorObjectHandle.h"
#include "PsnPvmReferenceObjectHandle.h"
#include "PsnPvmDuplicatedObjectHandle.h"

#include <assert.h>

template <class APvmController>
PsPvmBenchController<APvmController>::PsPvmBenchController (PsObjectDescriptor & scenario,
                                            const PsDate & initialSimulationDate,
                                            int argc,
                                            char * argv []) 
   : PsBenchController<APvmController>(scenario,initialSimulationDate,argc,argv)
{
}

template <class APvmController>
PsPvmBenchController<APvmController>::~PsPvmBenchController () 
{
   ostream * out ;
   if ( _file != NULL )
      {
         out = _file ;
      }
   else
      {
         out = & cout ;
      }
   long moyenne, moyenneGlobale,moyenneAttente,moyenneDecodage,moyenneTransmission, moyenneCreation;
   int nbValeurs,nbValeursGlobale,nbValeursAttente,nbValeursDecodage,nbValeursTransmission,nbValeursCreation;
   long duree, dureeGlobale,dureeAttente,dureeDecodage,dureeTransmission,dureeCreation;
#ifdef _SGI
   timespec resolutionHorloge;
   clock_getres(CLOCK_SGI_CYCLE,&resolutionHorloge);   
   *out<<"Resolution of the timer in seconds: "<<resolutionHorloge.tv_sec<<endl;
   *out<<"Resolution of the timer in nanoseconds : "<<resolutionHorloge.tv_nsec<<endl;
#endif
   moyenne=0;
   moyenneGlobale=0;
   moyenneAttente=0;
   moyenneDecodage=0;
   moyenneTransmission=0;
   moyenneCreation=0;
   nbValeursGlobale=0;
   nbValeurs=0;
   nbValeursAttente=0;
   nbValeursDecodage=0;
   nbValeursTransmission=0;
   nbValeursCreation=0;
#ifdef _PRINTCOMPLETESAMPLE
   *out<<"Duree globale, duree sans PVM, temps attente, temps décodage,temps de transmission, temps de creation des messages"<<endl;
#endif
   for(int i=0;i<_numberOfSamples;i++) 
      {
         dureeGlobale = _completeDurationTab [i] ;
#ifdef _PRINTCOMPLETESAMPLE
         *out<<dureeGlobale<<" , ";
#endif
         if (dureeGlobale>=0) 
            {
               moyenneGlobale = moyenneGlobale + dureeGlobale ;
               nbValeursGlobale++;
            }
         duree=_stepDurationTab[i];
#ifdef _PRINTCOMPLETESAMPLE
         *out<<duree<<" , "; 
#endif
         if (duree>=0) 
            {
               moyenne = moyenne + duree;
               nbValeurs++;
            }
         dureeAttente=_networkReceiveDurationTab[i];
#ifdef _PRINTCOMPLETESAMPLE
         *out<<dureeAttente<<" , "; 
#endif
         if (dureeAttente>=0) 
            {
               moyenneAttente = moyenneAttente + dureeAttente ;
               assert ( moyenneAttente >= 0 ) ;
               nbValeursAttente++;
            }
         dureeDecodage=_demarshallingDurationTab[i];
#ifdef _PRINTCOMPLETESAMPLE
         *out<<dureeDecodage<<" , ";
#endif
         if (dureeDecodage>=0) 
            {
               moyenneDecodage = moyenneDecodage + dureeDecodage ;
               assert ( moyenneDecodage >= 0 ) ;
               nbValeursDecodage++;
            }
         dureeTransmission=_networkSendDurationTab[i];
#ifdef _PRINTCOMPLETESAMPLE
         *out<<dureeTransmission<<" , "; 
#endif
         if (dureeTransmission>=0) 
            {
               moyenneTransmission = moyenneTransmission + dureeTransmission ;
               nbValeursTransmission++;
            }
         dureeCreation=_marshallingDurationTab[i];
#ifdef _PRINTCOMPLETESAMPLE
         *out<<dureeCreation<<endl; 
#endif
         if (dureeCreation>=0) 
            {
               moyenneCreation = moyenneCreation + dureeCreation ;
               nbValeursCreation++;
            }
      }
   *out<<"Therefore, the average "<<endl
       <<" - time needed to compute a simulation step is: "<<moyenneGlobale/nbValeursGlobale<<endl
       <<" - time used by computations: "<<moyenne/nbValeurs<<endl
       <<" - time used synchronizing: "<<moyenneAttente/nbValeursAttente<<endl
       <<" - time used demarshalling: "<<moyenneDecodage/nbValeursDecodage<<endl
       <<" - time used transmitting: "<<moyenneTransmission/nbValeursTransmission<<endl
       <<" - time used marshalling: "<<moyenneCreation/nbValeursCreation<<endl; 

}


template <class APvmController>
PsnScheduler * PsPvmBenchController<APvmController>::createScheduler()
{
   PsnScheduler * res ;

   res = PsBenchController<APvmController>::createScheduler() ;

   _stepDurationTab.resize(_numberOfSamples) ;

   _completeDurationTab.resize(_numberOfSamples) ;

   _networkReceiveDurationTab.resize(_numberOfSamples) ;

   _networkSendDurationTab.resize(_numberOfSamples) ;

   _demarshallingDurationTab.resize(_numberOfSamples) ;

   _marshallingDurationTab.resize(_numberOfSamples) ;

   return res ;
}


template <class APvmController>
void PsPvmBenchController<APvmController>::parseSynchronisationMessage (PsnPvmIncomingMessage * message) 
{
   //Here, multiple calls have to be benched and accumulated
#ifdef _SGI
   timespec before, after;

   clock_gettime(CLOCK_SGI_CYCLE, &before);


   PsBenchController<APvmController>::parseSynchronisationMessage(message);

   clock_gettime(CLOCK_SGI_CYCLE, &after);

   long duration = ( after.tv_nsec - before.tv_nsec ) / 1000 ;

   if (duration > 0) dureePartielleRecep += duration ;

   assert ( dureePartielleRecep >= 0 ) ;
#else
   timeval before, after ;

   gettimeofday ( &before, NULL ) ;
   
   PsBenchController<APvmController>::parseSynchronisationMessage(message);

   gettimeofday ( &after, NULL ) ;

   long duration = after.tv_usec - before.tv_usec;

   if (duration > 0) dureePartielleRecep += duration ;
#endif
}



template <class APvmController>
void PsPvmBenchController<APvmController>::compute ()
{
   //initialisation des compteurs du pas de calcul
   if ( ( _startSamplingDate <= _date ) &&
        ( _date <= _endSamplingDate )) 
      {
         assert ( _sampleIndex < _numberOfSamples ) ;
         assert ( _sampleIndex >= 0 ) ;
#ifdef _SGI
         timespec before, after;
         clock_gettime(CLOCK_SGI_CYCLE, &before);
         PsBenchController<APvmController>::compute ();
         clock_gettime(CLOCK_SGI_CYCLE, &after);
         long duration = ( after.tv_nsec - before.tv_nsec ) / 1000 ;
         _completeDurationTab[_sampleIndex] = duration ;         
#else
         timeval before, after;
         gettimeofday ( &before, NULL ) ;
         PsBenchController<APvmController>::compute ();
         gettimeofday ( &after, NULL ) ;
         long duration = after.tv_usec - before.tv_usec ;
         _completeDurationTab[_sampleIndex] = duration ;
#endif
      }
   else 
      {
         PsBenchController<APvmController>::compute ();
      }
}


template <class APvmController>
void PsPvmBenchController<APvmController>::computeNextSimulationStep() 
{
#ifdef _SGI
   timespec avantG;
   timespec avant, apres;
   //Le pas de simulation standard
   clock_gettime(CLOCK_SGI_CYCLE, &avantG);

   // get directly to the distributed controller, a we are redoing what the pvm controller is doing
   PsDistributedController::computeNextSimulationStep() ;

   //fin du pas de simulation standard

   clock_gettime(CLOCK_SGI_CYCLE, &avant);

   if(_sampleIndex>=0) _stepDurationTab[_sampleIndex] = ( avant.tv_nsec - avantG.tv_nsec ) / 1000 ;
   makeSynchronisationMessage (_referenceObjectsMap ) ;
   clock_gettime(CLOCK_SGI_CYCLE, &apres);

   if(_sampleIndex>=0) _marshallingDurationTab[_sampleIndex] = ( apres.tv_nsec-avant.tv_nsec ) / 1000;
   _distributedVirtualMachine->sendCurrentBuffersWithTag (PsnPvmMessage::SynchronisationMessage) ;  

   clock_gettime(CLOCK_SGI_CYCLE, &avant );

   if(_sampleIndex>=0) _networkSendDurationTab[_sampleIndex]= ( avant.tv_nsec-apres.tv_nsec ) / 1000 ;

   dureePartielleRecep=0;
   _distributedVirtualMachine->synchroniseReceiveAndProcessMessages (*this, PsnPvmMessage::SynchronisationMessage) ; 

   clock_gettime(CLOCK_SGI_CYCLE, &apres);

   if(_sampleIndex>=0) _demarshallingDurationTab[_sampleIndex] = dureePartielleRecep;

   if(_sampleIndex>=0) _networkReceiveDurationTab[_sampleIndex]= ( apres.tv_nsec-avant.tv_nsec ) / 1000 - dureePartielleRecep;
#else
   timeval dateBefore, dateAfter ;

   //take the date before calling equivalent ancestor method
   gettimeofday(&dateAfter, NULL );

   // get directly to the distributed controller, a we are redoing what the pvm controller is doing
   PsDistributedController::computeNextSimulationStep () ;

   gettimeofday(&dateBefore, NULL );

   if(_sampleIndex>=0) _stepDurationTab[_sampleIndex] = dateBefore.tv_usec - dateAfter.tv_usec;

   makeSynchronisationMessage (_referenceObjectsMap ) ;

   gettimeofday(&dateAfter, NULL );

   if(_sampleIndex>=0) _marshallingDurationTab[_sampleIndex] = dateAfter.tv_usec - dateBefore.tv_usec;

   _distributedVirtualMachine->sendCurrentBuffersWithTag (PsnPvmMessage::SynchronisationMessage) ;  

   gettimeofday(&dateBefore, NULL );

   if(_sampleIndex>=0) _networkSendDurationTab[_sampleIndex] = dateBefore.tv_usec - dateAfter.tv_usec;

   dureePartielleRecep = 0;

   _distributedVirtualMachine->synchroniseReceiveAndProcessMessages (*this, PsnPvmMessage::SynchronisationMessage) ; 

   gettimeofday(&dateAfter, NULL );

   if(_sampleIndex>=0) _demarshallingDurationTab[_sampleIndex] = dureePartielleRecep;

   if(_sampleIndex>=0) _networkReceiveDurationTab[_sampleIndex] = dateAfter.tv_usec - dateBefore.tv_usec - dureePartielleRecep;
#endif
}

#endif

---