---

PsSoftRealTimeController.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 <PsBenchController.h>
#include <sys/time.h>
#ifdef _SGI
#include <sys/syssgi.h>
#endif
#include <unistd.h>
#include <PsnDoubleListElement.h>
#include <PsnDoubleList.h>
#include "PsnBenchScheduler.h"
#include "PsConfigurationParameterDescriptor.h"

PsBenchController::PsBenchController(PsObjectDescriptor & scenario, const PsDate & initialDate ) 
   :  PsController(scenario, initialDate),
      _file (NULL ),
      _startSamplingDate ( initialDate ),
      _endSamplingDate ( initialDate+1000 )       
{

   if (getConfigurationParameters() != NULL )
      {
         const PsConfigurationParameterDescriptor * param = getConfigurationParameters()->getSubDescriptorByName("TimeFrom") ;
         if ( param != NULL )
            {
               _startSamplingDate=atoi(param->getAssociatedString().c_str() ) ;
            }

         param = getConfigurationParameters()->getSubDescriptorByName("TimeUntil") ;
         if ( param != NULL )
            {
               _endSamplingDate = atoi(param->getAssociatedString().c_str()  ) ;
            }
         param = getConfigurationParameters()->getSubDescriptorByName("BenchResultFile") ;
         if ( param != NULL )
            {
               _resultFilename = param->getAssociatedString() ;
               _file = new ofstream ( _resultFilename.getCString() );
            }
      }

   if (_startSamplingDate>_endSamplingDate) 
      {
         cout<<"PsBenchController::WARNING : sampling dates dont make an interval"<<endl;
         cout<<"PsBenchController::WARNING : default sampling dates used "<<endl; 
         _startSamplingDate=PsController::initialSimulationDate;
         _endSamplingDate=PsController::initialSimulationDate+1000;            
      }
}


void 
PsBenchController::flushResults() 
{
   if(_file == NULL) 
      {
         printToStream(cout);
      }
   else 
      {
         printToStream(*_file);
      }
}



PsBenchController::~PsBenchController() 
{
   if (_date<_endSamplingDate) flushResults();
   delete [] _stepDurationTab;
   delete [] _slowedDownStepDurationTab;
}

void PsBenchController::init() 
{
   PsController::init() ;

   if (_startSamplingDate<PsController::initialSimulationDate) 
      {
         _startSamplingDate=PsController::initialSimulationDate;
         cout<<"PsBenchController::WARNING : no values PsController::initialSimulationDate ("
             <<PsController::initialSimulationDate<<")"<<endl;
      }

   _numberOfSamples = (_endSamplingDate-_startSamplingDate)/_stepPeriod + 1;

   _sampleIndex=0;

   _stepDurationTab = new long[_numberOfSamples];
   _slowedDownStepDurationTab = new long[_numberOfSamples];
}

PsnScheduler * PsBenchController::createScheduler() {
   PsnScheduler * res ;
   cout<<"Benchmarking between "<<_startSamplingDate<<" and "<<_endSamplingDate << endl;
   if ( _file != NULL ) {
      res = new PsnBenchScheduler(nbMinor, _sampleIndex, _numberOfSamples,*_file) ;
   }
   else {
      res = new PsnBenchScheduler(nbMinor, _sampleIndex, _numberOfSamples, cout ) ;
   }
   //res = new PsnFrameScheduler(_nbStepsByCycle) ;
   return res ;
}

void PsBenchController::compute (){
   static long avance = 0 ;
   //initialisation des compteurs du pas de calcul
   if ((_startSamplingDate<=_date)&&(_date<=_endSamplingDate)) {
      static timespec avant, apres;
      clock_gettime(CLOCK_SGI_CYCLE, &avant);
      PsController::compute ();
      //lecture des compteurs du pas de calcul
      clock_gettime(CLOCK_SGI_CYCLE, &apres);
      //remplissage de la table globale
      long duree = apres.tv_nsec - avant.tv_nsec ;
      if (duree < 0 ) duree =  apres.tv_nsec + ( LONG_MAX/2 - avant.tv_nsec ) ;
      _stepDurationTab[_sampleIndex] = duree ;
      _sampleIndex++;
      //Les 4 lignes qui suivent sont une tentative primitive d'atteinte du temps réel
      avance += _stepPeriod * 1000  - duree / 1000 ;
      if (avance > 10000) {
         usleep( avance );
         clock_gettime(CLOCK_SGI_CYCLE, &apres);
         if (apres.tv_nsec > avant.tv_nsec) {
            avance = avance - (apres.tv_nsec - avant.tv_nsec) / 1000 ;
         }
         else {
            avance =  avance - (( LONG_MAX/2 - avant.tv_nsec ) + apres.tv_nsec ) / 1000 ;
         }
      }
      _slowedDownStepDurationTab[_numberOfSimulatedSteps%_numberOfSamples] = apres.tv_nsec - avant.tv_nsec ;
      if (_slowedDownStepDurationTab[_numberOfSimulatedSteps%_numberOfSamples] < 0) {
         _slowedDownStepDurationTab[_numberOfSimulatedSteps%_numberOfSamples] = ( LONG_MAX/2 - avant.tv_nsec ) + apres.tv_nsec ;
      }
      if (_date==_endSamplingDate) {
         flushResults();
         _sampleIndex=-1;
      }
   }
   else {
      PsController::compute ();
   }
}

void PsBenchController::printToStream(ostream & out) {
   timespec resolutionHorloge;
   long moyenne;
   long averageTimeSlowed = 0 ;
   int nbValeurs;
   long duree;
   out<<syssgi(SGI_CYCLECNTR_SIZE) ;
   clock_getres(CLOCK_SGI_CYCLE,&resolutionHorloge);   
   out<<"resolution de l'horloge en secondes : "<<resolutionHorloge.tv_sec<<endl;
   out<<"resolution de l'horloge en nanosecondes : "<<resolutionHorloge.tv_nsec<<endl;
   moyenne=0;
   nbValeurs=0;
   for(int i=0;i<_numberOfSamples;i++) {
      duree=_stepDurationTab[i];
      out<<duree/1000<<" "<<_slowedDownStepDurationTab[i]/1000<<endl;
          if (duree>=0) {
             moyenne = moyenne+(duree/1000);
             averageTimeSlowed = averageTimeSlowed + (_slowedDownStepDurationTab[i]/1000);
             nbValeurs++;
          }
   }
   out<<"Soit une moyenne corrigée de : "<<moyenne/nbValeurs<<" microsecondes"<<endl; 
   out<<"Soit une moyenne ralentie de : "<<averageTimeSlowed/(1000*nbValeurs)<<" millisecondes "<<_stepPeriod<<endl; 
}

---