Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

PsPvmBenchController< APvmController > Class Template Reference

A PVM controller that produces bench information on the cost of some controller operations, as well as a the bench results produced by a PsBenchController. More...

#include <PsPvmBenchController.h>

Inheritance diagram for PsPvmBenchController< APvmController >:

Inheritance graph
[legend]
Collaboration diagram for PsPvmBenchController< APvmController >:

Collaboration graph
[legend]
List of all members.

Public Methods

 PsPvmBenchController (PsObjectDescriptor &scenario, const PsDate &initialSimulationDate, int argc, char *argv[])
 constructor

virtual ~PsPvmBenchController ()
virtual void computeNextSimulationStep ()
 compute the next simulation step

virtual void compute ()
 redefine compute so that time is mesured

virtual PsnScheduler * createScheduler ()
 create a scheduler than can bench stuff

virtual void parseSynchronisationMessage (PsnPvmIncomingMessage *message)

Protected Attributes

long dureePartielleRecep
vector< long > _stepDurationTab
 a table recording the time it took to calculated each simulation step

vector< long > _completeDurationTab
vector< long > _networkReceiveDurationTab
vector< long > _demarshallingDurationTab
vector< long > _networkSendDurationTab
vector< long > _marshallingDurationTab

Detailed Description

template<class APvmController>
class PsPvmBenchController< APvmController >

A PVM controller that produces bench information on the cost of some controller operations, as well as a the bench results produced by a PsBenchController.

Author:
David Margery
Version:
1.0

Definition at line 30 of file PsPvmBenchController.h.

Constructor & Destructor Documentation

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

constructor

Definition at line 73 of file PsPvmBenchController.h.

References PsDate. 

00078    : PsBenchController<APvmController>(scenario,initialSimulationDate,argc,argv)
00079 {

template<class APvmController>
PsPvmBenchController< APvmController >::~PsPvmBenchController (    )  [virtual]
 

Definition at line 82 of file PsPvmBenchController.h.

References PsPvmBenchController< APvmController >::_completeDurationTab, PsPvmBenchController< APvmController >::_demarshallingDurationTab, PsBenchController< APvmController >::_file, PsPvmBenchController< APvmController >::_marshallingDurationTab, PsPvmBenchController< APvmController >::_networkReceiveDurationTab, PsPvmBenchController< APvmController >::_networkSendDurationTab, PsBenchController< APvmController >::_numberOfSamples, and PsPvmBenchController< APvmController >::_stepDurationTab. 

00084 {
00085    ostream * out ;
00086    if ( _file != NULL )
00087       {
00088          out = _file ;
00089       }
00090    else
00091       {
00092          out = & cout ;
00093       }
00094    long moyenne, moyenneGlobale,moyenneAttente,moyenneDecodage,moyenneTransmission, moyenneCreation;
00095    int nbValeurs,nbValeursGlobale,nbValeursAttente,nbValeursDecodage,nbValeursTransmission,nbValeursCreation;
00096    long duree, dureeGlobale,dureeAttente,dureeDecodage,dureeTransmission,dureeCreation;
00097 #ifdef _SGI
00098    timespec resolutionHorloge;
00099    clock_getres(CLOCK_SGI_CYCLE,&resolutionHorloge);   
00100    *out<<"Resolution of the timer in seconds: "<<resolutionHorloge.tv_sec<<endl;
00101    *out<<"Resolution of the timer in nanoseconds : "<<resolutionHorloge.tv_nsec<<endl;
00102 #endif
00103    moyenne=0;
00104    moyenneGlobale=0;
00105    moyenneAttente=0;
00106    moyenneDecodage=0;
00107    moyenneTransmission=0;
00108    moyenneCreation=0;
00109    nbValeursGlobale=0;
00110    nbValeurs=0;
00111    nbValeursAttente=0;
00112    nbValeursDecodage=0;
00113    nbValeursTransmission=0;
00114    nbValeursCreation=0;
00115 #ifdef _PRINTCOMPLETESAMPLE
00116    *out<<"Duree globale, duree sans PVM, temps attente, temps décodage,temps de transmission, temps de creation des messages"<<endl;
00117 #endif
00118    for(int i=0;i<_numberOfSamples;i++) 
00119       {
00120          dureeGlobale = _completeDurationTab [i] ;
00121 #ifdef _PRINTCOMPLETESAMPLE
00122          *out<<dureeGlobale<<" , ";
00123 #endif
00124          if (dureeGlobale>=0) 
00125             {
00126                moyenneGlobale = moyenneGlobale + dureeGlobale ;
00127                nbValeursGlobale++;
00128             }
00129          duree=_stepDurationTab[i];
00130 #ifdef _PRINTCOMPLETESAMPLE
00131          *out<<duree<<" , "; 
00132 #endif
00133          if (duree>=0) 
00134             {
00135                moyenne = moyenne + duree;
00136                nbValeurs++;
00137             }
00138          dureeAttente=_networkReceiveDurationTab[i];
00139 #ifdef _PRINTCOMPLETESAMPLE
00140          *out<<dureeAttente<<" , "; 
00141 #endif
00142          if (dureeAttente>=0) 
00143             {
00144                moyenneAttente = moyenneAttente + dureeAttente ;
00145                assert ( moyenneAttente >= 0 ) ;
00146                nbValeursAttente++;
00147             }
00148          dureeDecodage=_demarshallingDurationTab[i];
00149 #ifdef _PRINTCOMPLETESAMPLE
00150          *out<<dureeDecodage<<" , ";
00151 #endif
00152          if (dureeDecodage>=0) 
00153             {
00154                moyenneDecodage = moyenneDecodage + dureeDecodage ;
00155                assert ( moyenneDecodage >= 0 ) ;
00156                nbValeursDecodage++;
00157             }
00158          dureeTransmission=_networkSendDurationTab[i];
00159 #ifdef _PRINTCOMPLETESAMPLE
00160          *out<<dureeTransmission<<" , "; 
00161 #endif
00162          if (dureeTransmission>=0) 
00163             {
00164                moyenneTransmission = moyenneTransmission + dureeTransmission ;
00165                nbValeursTransmission++;
00166             }
00167          dureeCreation=_marshallingDurationTab[i];
00168 #ifdef _PRINTCOMPLETESAMPLE
00169          *out<<dureeCreation<<endl; 
00170 #endif
00171          if (dureeCreation>=0) 
00172             {
00173                moyenneCreation = moyenneCreation + dureeCreation ;
00174                nbValeursCreation++;
00175             }
00176       }
00177    *out<<"Therefore, the average "<<endl
00178        <<" - time needed to compute a simulation step is: "<<moyenneGlobale/nbValeursGlobale<<endl
00179        <<" - time used by computations: "<<moyenne/nbValeurs<<endl
00180        <<" - time used synchronizing: "<<moyenneAttente/nbValeursAttente<<endl
00181        <<" - time used demarshalling: "<<moyenneDecodage/nbValeursDecodage<<endl
00182        <<" - time used transmitting: "<<moyenneTransmission/nbValeursTransmission<<endl
00183        <<" - time used marshalling: "<<moyenneCreation/nbValeursCreation<<endl; 
00184

Member Function Documentation

template<class APvmController>
void PsPvmBenchController< APvmController >::compute (    )  [virtual]
 

redefine compute so that time is mesured

Reimplemented from PsBenchController< APvmController >.

Definition at line 247 of file PsPvmBenchController.h.

References PsPvmBenchController< APvmController >::_completeDurationTab, PsController::_date, PsBenchController< APvmController >::_endSamplingDate, PsBenchController< APvmController >::_numberOfSamples, PsBenchController< APvmController >::_sampleIndex, PsBenchController< APvmController >::_startSamplingDate, and PsBenchController< BenchedController >::compute(). 

00249 {
00250    //initialisation des compteurs du pas de calcul
00251    if ( ( _startSamplingDate <= _date ) &&
00252         ( _date <= _endSamplingDate )) 
00253       {
00254          assert ( _sampleIndex < _numberOfSamples ) ;
00255          assert ( _sampleIndex >= 0 ) ;
00256 #ifdef _SGI
00257          timespec before, after;
00258          clock_gettime(CLOCK_SGI_CYCLE, &before);
00259          PsBenchController<APvmController>::compute ();
00260          clock_gettime(CLOCK_SGI_CYCLE, &after);
00261          long duration = ( after.tv_nsec - before.tv_nsec ) / 1000 ;
00262          _completeDurationTab[_sampleIndex] = duration ;         
00263 #else
00264          timeval before, after;
00265          gettimeofday ( &before, NULL ) ;
00266          PsBenchController<APvmController>::compute ();
00267          gettimeofday ( &after, NULL ) ;
00268          long duration = after.tv_usec - before.tv_usec ;
00269          _completeDurationTab[_sampleIndex] = duration ;
00270 #endif
00271       }
00272    else 
00273       {
00274          PsBenchController<APvmController>::compute ();
00275       }

template<class APvmController>
void PsPvmBenchController< APvmController >::computeNextSimulationStep (    )  [virtual]
 

compute the next simulation step

Reimplemented from PsController.

Definition at line 279 of file PsPvmBenchController.h.

References PsPvmBenchController< APvmController >::_demarshallingDurationTab, PsPvmBenchController< APvmController >::_marshallingDurationTab, PsPvmBenchController< APvmController >::_networkReceiveDurationTab, PsPvmBenchController< APvmController >::_networkSendDurationTab, PsController::_referenceObjectsMap, PsBenchController< APvmController >::_sampleIndex, PsPvmBenchController< APvmController >::_stepDurationTab, PsController::computeNextSimulationStep(), PsPvmBenchController< APvmController >::dureePartielleRecep, and PsnPvmMessage::SynchronisationMessage. 

00281 {
00282 #ifdef _SGI
00283    timespec avantG;
00284    timespec avant, apres;
00285    //Le pas de simulation standard
00286    clock_gettime(CLOCK_SGI_CYCLE, &avantG);
00287 
00288    // get directly to the distributed controller, a we are redoing what the pvm controller is doing
00289    PsDistributedController::computeNextSimulationStep() ;
00290 
00291    //fin du pas de simulation standard
00292 
00293    clock_gettime(CLOCK_SGI_CYCLE, &avant);
00294 
00295    if(_sampleIndex>=0) _stepDurationTab[_sampleIndex] = ( avant.tv_nsec - avantG.tv_nsec ) / 1000 ;
00296    makeSynchronisationMessage (_referenceObjectsMap ) ;
00297    clock_gettime(CLOCK_SGI_CYCLE, &apres);
00298 
00299    if(_sampleIndex>=0) _marshallingDurationTab[_sampleIndex] = ( apres.tv_nsec-avant.tv_nsec ) / 1000;
00300    _distributedVirtualMachine->sendCurrentBuffersWithTag (PsnPvmMessage::SynchronisationMessage) ;  
00301 
00302    clock_gettime(CLOCK_SGI_CYCLE, &avant );
00303 
00304    if(_sampleIndex>=0) _networkSendDurationTab[_sampleIndex]= ( avant.tv_nsec-apres.tv_nsec ) / 1000 ;
00305 
00306    dureePartielleRecep=0;
00307    _distributedVirtualMachine->synchroniseReceiveAndProcessMessages (*this, PsnPvmMessage::SynchronisationMessage) ; 
00308 
00309    clock_gettime(CLOCK_SGI_CYCLE, &apres);
00310 
00311    if(_sampleIndex>=0) _demarshallingDurationTab[_sampleIndex] = dureePartielleRecep;
00312 
00313    if(_sampleIndex>=0) _networkReceiveDurationTab[_sampleIndex]= ( apres.tv_nsec-avant.tv_nsec ) / 1000 - dureePartielleRecep;
00314 #else
00315    timeval dateBefore, dateAfter ;
00316 
00317    //take the date before calling equivalent ancestor method
00318    gettimeofday(&dateAfter, NULL );
00319 
00320    // get directly to the distributed controller, a we are redoing what the pvm controller is doing
00321    PsDistributedController::computeNextSimulationStep () ;
00322 
00323    gettimeofday(&dateBefore, NULL );
00324 
00325    if(_sampleIndex>=0) _stepDurationTab[_sampleIndex] = dateBefore.tv_usec - dateAfter.tv_usec;
00326 
00327    makeSynchronisationMessage (_referenceObjectsMap ) ;
00328 
00329    gettimeofday(&dateAfter, NULL );
00330 
00331    if(_sampleIndex>=0) _marshallingDurationTab[_sampleIndex] = dateAfter.tv_usec - dateBefore.tv_usec;
00332 
00333    _distributedVirtualMachine->sendCurrentBuffersWithTag (PsnPvmMessage::SynchronisationMessage) ;  
00334 
00335    gettimeofday(&dateBefore, NULL );
00336 
00337    if(_sampleIndex>=0) _networkSendDurationTab[_sampleIndex] = dateBefore.tv_usec - dateAfter.tv_usec;
00338 
00339    dureePartielleRecep = 0;
00340 
00341    _distributedVirtualMachine->synchroniseReceiveAndProcessMessages (*this, PsnPvmMessage::SynchronisationMessage) ; 
00342 
00343    gettimeofday(&dateAfter, NULL );
00344 
00345    if(_sampleIndex>=0) _demarshallingDurationTab[_sampleIndex] = dureePartielleRecep;
00346 
00347    if(_sampleIndex>=0) _networkReceiveDurationTab[_sampleIndex] = dateAfter.tv_usec - dateBefore.tv_usec - dureePartielleRecep;
00348 #endif

template<class APvmController>
PsnScheduler * PsPvmBenchController< APvmController >::createScheduler (    )  [virtual]
 

create a scheduler than can bench stuff

Reimplemented from PsBenchController< APvmController >.

Reimplemented in PsMultiThreadedPvmBenchmarkingController.

Definition at line 188 of file PsPvmBenchController.h.

References PsPvmBenchController< APvmController >::_completeDurationTab, PsPvmBenchController< APvmController >::_demarshallingDurationTab, PsPvmBenchController< APvmController >::_marshallingDurationTab, PsPvmBenchController< APvmController >::_networkReceiveDurationTab, PsPvmBenchController< APvmController >::_networkSendDurationTab, PsBenchController< APvmController >::_numberOfSamples, PsPvmBenchController< APvmController >::_stepDurationTab, PsBenchController< BenchedController >::createScheduler(), and vector< long >::resize(). 

00190 {
00191    PsnScheduler * res ;
00192 
00193    res = PsBenchController<APvmController>::createScheduler() ;
00194 
00195    _stepDurationTab.resize(_numberOfSamples) ;
00196 
00197    _completeDurationTab.resize(_numberOfSamples) ;
00198 
00199    _networkReceiveDurationTab.resize(_numberOfSamples) ;
00200 
00201    _networkSendDurationTab.resize(_numberOfSamples) ;
00202 
00203    _demarshallingDurationTab.resize(_numberOfSamples) ;
00204 
00205    _marshallingDurationTab.resize(_numberOfSamples) ;
00206 
00207    return res ;

template<class APvmController>
void PsPvmBenchController< APvmController >::parseSynchronisationMessage (  PsnPvmIncomingMessage *    message )  [virtual]
 

Definition at line 211 of file PsPvmBenchController.h.

References PsPvmBenchController< APvmController >::dureePartielleRecep. 

00213 {
00214    //Here, multiple calls have to be benched and accumulated
00215 #ifdef _SGI
00216    timespec before, after;
00217 
00218    clock_gettime(CLOCK_SGI_CYCLE, &before);
00219 
00220 
00221    PsBenchController<APvmController>::parseSynchronisationMessage(message);
00222 
00223    clock_gettime(CLOCK_SGI_CYCLE, &after);
00224 
00225    long duration = ( after.tv_nsec - before.tv_nsec ) / 1000 ;
00226 
00227    if (duration > 0) dureePartielleRecep += duration ;
00228 
00229    assert ( dureePartielleRecep >= 0 ) ;
00230 #else
00231    timeval before, after ;
00232 
00233    gettimeofday ( &before, NULL ) ;
00234    
00235    PsBenchController<APvmController>::parseSynchronisationMessage(message);
00236 
00237    gettimeofday ( &after, NULL ) ;
00238 
00239    long duration = after.tv_usec - before.tv_usec;
00240 
00241    if (duration > 0) dureePartielleRecep += duration ;
00242 #endif

Member Data Documentation

template<class APvmController>
vector<long> PsPvmBenchController< APvmController >::_completeDurationTab [protected]
 

Definition at line 47 of file PsPvmBenchController.h.

Referenced by PsPvmBenchController< APvmController >::compute(), PsPvmBenchController< APvmController >::createScheduler(), and PsPvmBenchController< APvmController >::~PsPvmBenchController().

template<class APvmController>
vector<long> PsPvmBenchController< APvmController >::_demarshallingDurationTab [protected]
 

Definition at line 49 of file PsPvmBenchController.h.

Referenced by PsPvmBenchController< APvmController >::computeNextSimulationStep(), PsPvmBenchController< APvmController >::createScheduler(), and PsPvmBenchController< APvmController >::~PsPvmBenchController().

template<class APvmController>
vector<long> PsPvmBenchController< APvmController >::_marshallingDurationTab [protected]
 

Definition at line 51 of file PsPvmBenchController.h.

Referenced by PsPvmBenchController< APvmController >::computeNextSimulationStep(), PsPvmBenchController< APvmController >::createScheduler(), and PsPvmBenchController< APvmController >::~PsPvmBenchController().

template<class APvmController>
vector<long> PsPvmBenchController< APvmController >::_networkReceiveDurationTab [protected]
 

Definition at line 48 of file PsPvmBenchController.h.

Referenced by PsPvmBenchController< APvmController >::computeNextSimulationStep(), PsPvmBenchController< APvmController >::createScheduler(), and PsPvmBenchController< APvmController >::~PsPvmBenchController().

template<class APvmController>
vector<long> PsPvmBenchController< APvmController >::_networkSendDurationTab [protected]
 

Definition at line 50 of file PsPvmBenchController.h.

Referenced by PsPvmBenchController< APvmController >::computeNextSimulationStep(), PsPvmBenchController< APvmController >::createScheduler(), and PsPvmBenchController< APvmController >::~PsPvmBenchController().

template<class APvmController>
vector<long> PsPvmBenchController< APvmController >::_stepDurationTab [protected]
 

a table recording the time it took to calculated each simulation step

Reimplemented from PsBenchController< APvmController >.

Definition at line 46 of file PsPvmBenchController.h.

Referenced by PsPvmBenchController< APvmController >::computeNextSimulationStep(), PsPvmBenchController< APvmController >::createScheduler(), and PsPvmBenchController< APvmController >::~PsPvmBenchController().

template<class APvmController>
long PsPvmBenchController< APvmController >::dureePartielleRecep [protected]
 

Definition at line 45 of file PsPvmBenchController.h.

Referenced by PsPvmBenchController< APvmController >::computeNextSimulationStep(), and PsPvmBenchController< APvmController >::parseSynchronisationMessage().

The documentation for this class was generated from the following file:
logo OpenMask

Documentation generated on Mon Nov 25 15:26:20 2002

Generated with doxygen 1.2.12 by Dimitri van Heesch ,   1997-2001