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

PsnMultiThreadedBenchedScheduler Class Reference

class PsnMultiThreadedBenchScheduler : use threads to schedule the different simulation objects calculation time of objects is benchmarked More...

#include <PsnMultiThreadedBenchedScheduler.h>

Inheritance diagram for PsnMultiThreadedBenchedScheduler:

Inheritance graph
[legend]
Collaboration diagram for PsnMultiThreadedBenchedScheduler:

Collaboration graph
[legend]
List of all members.

Public Methods

 PsnMultiThreadedBenchedScheduler (unsigned int numberOfSteps, unsigned int numberOfThreads)
 constructor : redefine to create bench schedulers instead of frame schedulers

virtual ~PsnMultiThreadedBenchedScheduler ()
 destructor

virtual void runStep (unsigned int which)
 redefine to increment benchmarking sample

virtual void run (unsigned int whichFrameScheduler)
 redefing to mesure waiting times


Static Protected Methods

void * _threadContainer (void *)
 the function called at the start of the thread


Protected Attributes

long _indexOfBenchmarkingSample
 index of the current banchmarking sample

long ** _localWaitingTimes
 used to bench waiting times

int _numberOfSamples
 number of benchmarking samples to take

Detailed Description

class PsnMultiThreadedBenchScheduler : use threads to schedule the different simulation objects calculation time of objects is benchmarked

Author:
David Margery
Version:
:

Definition at line 33 of file PsnMultiThreadedBenchedScheduler.h.

Constructor & Destructor Documentation

PsnMultiThreadedBenchedScheduler::PsnMultiThreadedBenchedScheduler (  unsigned int    numberOfSteps,
unsigned int    numberOfThreads
) 
 

constructor : redefine to create bench schedulers instead of frame schedulers

Definition at line 30 of file PsnMultiThreadedBenchedScheduler.cxx.

References PsnMultiThreadedScheduler::_duplicatedObjectScheduler, _indexOfBenchmarkingSample, _localWaitingTimes, _numberOfSamples, PsnMultiThreadedScheduler::_numberOfThreads, _threadContainer(), PsnMultiThreadedScheduler::_threadData, PsnMultiThreadedScheduler::_threadIds, and PsController::error(). 

00030                                                                                                                             :
00031    PsnMultiThreadedScheduler(numberOfSteps, numberOfThreads, false),
00032    _indexOfBenchmarkingSample ( 0 ),
00033    _numberOfSamples ( 350 )
00034 {
00035 
00036    _localWaitingTimes = new long * [ _numberOfThreads ] ;
00037    
00038    for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00039       {
00040          _localWaitingTimes [ i ] = new long [ _numberOfSamples ] ;
00041       }
00042    
00043    _duplicatedObjectScheduler = new PsnBenchScheduler( numberOfSteps, _indexOfBenchmarkingSample , _numberOfSamples , cout ) ;
00044 
00045    for (int i = 0 ; i < _numberOfThreads ; i++ )
00046       {
00047          (*_localSchedulers)[i] = new PsnBenchScheduler( numberOfSteps, _indexOfBenchmarkingSample, _numberOfSamples , cout ) ;
00048       }
00049    
00050    int ret;
00051    for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00052       {
00053       
00054          ret = pthread_create( & (_threadIds [i]), 
00055                                0,
00056                                (void *(*)(void *))_threadContainer,
00057                                (*_threadData)[i]);
00058          if (ret) 
00059          {
00060             PsController::error("Thread creation impossible") ;
00061          }
00062          
00063       }
00064 
00065 }

PsnMultiThreadedBenchedScheduler::~PsnMultiThreadedBenchedScheduler (    )  [virtual]
 

destructor

Definition at line 69 of file PsnMultiThreadedBenchedScheduler.cxx.

References _localWaitingTimes, _numberOfSamples, and PsnMultiThreadedScheduler::_numberOfThreads. 

00069                                                                     {
00070    long totalTime = 0 ;
00071    
00072    for (int i = 0 ; i < _numberOfThreads ; i++ ) 
00073       {
00074          totalTime = 0 ;
00075          cout <<"thread "<<i<<endl;
00076          for ( int j =0 ; j < _numberOfSamples ; j ++ ) 
00077             {
00078                totalTime+=_localWaitingTimes [i] [j] ;
00079                cout<<_localWaitingTimes [i] [j] <<" , ";
00080             }
00081          cout<< "average " <<totalTime/_numberOfSamples<<endl;
00082          
00083          delete _localWaitingTimes [ i ] ;
00084          
00085       }  
00086    
00087    delete [] _localWaitingTimes ;
00088 }

Member Function Documentation

void * PsnMultiThreadedBenchedScheduler::_threadContainer (  void *    )  [static, protected]
 

the function called at the start of the thread

Reimplemented from PsnMultiThreadedScheduler.

Definition at line 103 of file PsnMultiThreadedBenchedScheduler.cxx.

Referenced by PsnMultiThreadedBenchedScheduler(). 

00103                                                                               {
00104    
00105    pair<PsnMultiThreadedBenchedScheduler *, unsigned int> * threadData = ( pair<PsnMultiThreadedBenchedScheduler *, unsigned int> * ) myThreadData ;
00106 
00107    ( * threadData ).first->run( ( * threadData ).second ) ;
00108 
00109    return threadData ;
00110 }

void PsnMultiThreadedBenchedScheduler::run (  unsigned int    whichFrameScheduler )  [virtual]
 

redefing to mesure waiting times

Reimplemented from PsnMultiThreadedScheduler.

Definition at line 113 of file PsnMultiThreadedBenchedScheduler.cxx.

References PsnMultiThreadedScheduler::_barrier, PsnMultiThreadedScheduler::_currentStep, _localWaitingTimes, _numberOfSamples, and PsnBarrier::Sync(). 

00114 {
00115    timeval _dateReelleDebut ;
00116    timeval _dateReelleFin ;
00117    int counter = 0 ;
00118 
00119    while ( true ) {
00120       
00121       _barrier->Sync() ;
00122       
00123 
00124       (*_localSchedulers)[ whichFrameScheduler ]->runStep ( _currentStep ) ;
00125 
00126       gettimeofday(&_dateReelleDebut, NULL);
00127 
00128       _barrier->Sync() ;
00129 
00130       gettimeofday(&_dateReelleFin, NULL);
00131       if (_dateReelleFin.tv_usec > _dateReelleDebut.tv_usec ) 
00132       {
00133          _localWaitingTimes [whichFrameScheduler] [ counter ] = _dateReelleFin.tv_usec - _dateReelleDebut.tv_usec ;
00134       }
00135 
00136       counter = ( counter + 1 ) % _numberOfSamples ;
00137 
00138    }
00139 }

void PsnMultiThreadedBenchedScheduler::runStep (  unsigned int    which )  [virtual]
 

redefine to increment benchmarking sample

Reimplemented from PsnMultiThreadedScheduler.

Definition at line 92 of file PsnMultiThreadedBenchedScheduler.cxx.

References _indexOfBenchmarkingSample, _numberOfSamples, and PsnMultiThreadedScheduler::runStep(). 

00092                                                                   {
00093 
00094    _indexOfBenchmarkingSample = (_indexOfBenchmarkingSample + 1) % _numberOfSamples ;
00095    
00096    PsnMultiThreadedScheduler::runStep ( which ) ; 
00097 
00098 }

Member Data Documentation

long PsnMultiThreadedBenchedScheduler::_indexOfBenchmarkingSample [protected]
 

index of the current banchmarking sample

Definition at line 51 of file PsnMultiThreadedBenchedScheduler.h.

Referenced by PsnMultiThreadedBenchedScheduler(), and runStep().

long* * PsnMultiThreadedBenchedScheduler::_localWaitingTimes [protected]
 

used to bench waiting times

Reimplemented from PsnMultiThreadedScheduler.

Definition at line 54 of file PsnMultiThreadedBenchedScheduler.h.

Referenced by PsnMultiThreadedBenchedScheduler(), run(), and ~PsnMultiThreadedBenchedScheduler().

int PsnMultiThreadedBenchedScheduler::_numberOfSamples [protected]
 

number of benchmarking samples to take

Reimplemented from PsnMultiThreadedScheduler.

Definition at line 57 of file PsnMultiThreadedBenchedScheduler.h.

Referenced by PsnMultiThreadedBenchedScheduler(), run(), runStep(), and ~PsnMultiThreadedBenchedScheduler().

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

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

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