---

PsnMultiThreadedBenchmarkingScheduler.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 "PsnMultiThreadedBenchmarkingScheduler.h"

#include "PsnFrameScheduler.h"
#include "PsnBenchScheduler.h"
#include "PsnBarrier.h"
#include "PsController.h"
#include "PsDuplicatedObject.h"

#include "PsnNew.h"
#include "PsnDescriptorMemoryManager.h"
#include "PsnThreadMemoryManager.h"
#include "PsnSystemMemoryManager.h"

#include <unistd.h>

PsnMultiThreadedBenchmarkingScheduler::PsnMultiThreadedBenchmarkingScheduler (unsigned int numberOfSteps, 
                                                                              unsigned int numberOfThreads, 
                                                                              bool createThreadAndLocalSchedulers, 
                                                                              const int & sampleIndex, 
                                                                              unsigned int numberOfSamples,
                                                                              ostream & outputFile ) :
   PsnScheduler(numberOfSteps),
   _numberOfThreads(numberOfThreads),
   _currentStep ( 0 ),
   _nextThreadForScheduling ( 0 ),
   _sampleIndex ( sampleIndex ),
   _numberOfSamples( numberOfSamples ),
   _outputFile ( outputFile )

{
   assert ( _outputFile.good() ) ;

   _barrier = new PsnBarrier ( _numberOfThreads + 1) ;

   _threadIds = new pthread_t [ _numberOfThreads ] ;

   _threadData = new vector <pair<PsnScheduler *, unsigned int> * > ( _numberOfThreads ) ;

   for (int i = 0 ; i < _numberOfThreads ; i++ ) 
      {
         (*_threadData)[i] = new pair<PsnScheduler *, unsigned int> (this, i) ;
      }

   _localSchedulers = new vector <PsnScheduler *> ( _numberOfThreads ) ;

   int ret;

#ifdef _SGI
   //for better use of the cpus available
   pthread_setconcurrency(_numberOfThreads) ;
#endif

   if ( createThreadAndLocalSchedulers )
      {
         
         _duplicatedObjectScheduler = new PsnBenchScheduler( numberOfSteps, 
                                                             _sampleIndex, 
                                                             _numberOfSamples, 
                                                             _outputFile ) ;
         
         for (int i = 0 ; i < _numberOfThreads ; i++ ) 
            {
               (*_localSchedulers)[i] = new PsnBenchScheduler( numberOfSteps, 
                                                             _sampleIndex, 
                                                             _numberOfSamples, 
                                                             _outputFile ) ;
            }
            
         for (int i = 0 ; i < _numberOfThreads ; i++ ) 
            {
               ret = pthread_create( & (_threadIds [i]), 
                                     0,
                                     (void *(*)(void *))_threadContainer,
                                     (*_threadData)[i]);
               if (ret) 
                  {
                     PsController::error("Thread creation impossible") ;
                  }
               
            }
      }

   // create the data structures needed for benchmarking the waiting times
   _localWaitingTimes = new long * [ _numberOfThreads ] ;

   for (int i = 0 ; i < _numberOfThreads ; i++ ) 
      {
         _localWaitingTimes [ i ] = new long [ _numberOfSamples ] ;
      }
   
}


PsnMultiThreadedBenchmarkingScheduler::~PsnMultiThreadedBenchmarkingScheduler() 
{
   //first, print the scheduling data.
   long totalTime = 0 ;
   
   assert (_outputFile.good() ) ;
   
   for (int i = 0 ; i < _numberOfThreads ; i++ ) 
      {
         totalTime = 0 ;
         _outputFile <<"thread "<<i<<endl;
         for ( int j =0 ; j < _numberOfSamples ; j ++ ) 
            {
               totalTime += _localWaitingTimes [i] [j] ;
               _outputFile <<_localWaitingTimes [i] [j] <<" , ";
            }
         _outputFile << "average " <<totalTime/_numberOfSamples<<endl;
         
         delete _localWaitingTimes [ i ] ;
         
      }  
   
   delete [] _localWaitingTimes ;
   

   // then take care of the multi-threading data
   for (int i = 0 ; i < _numberOfThreads ; i++ ) 
      {
         // this will print the benchmarking data for each local scheduler
         delete (*_localSchedulers)[i] ;
         
         delete (*_threadData)[i] ;

   }

   delete _localSchedulers ;

   delete _barrier ;

   delete [] _threadIds ;

   delete _threadData ;

   delete _duplicatedObjectScheduler ;
}



void PsnMultiThreadedBenchmarkingScheduler::runStep (unsigned int which) 
{

   _currentStep = which ;

   _duplicatedObjectScheduler->runStep (which) ;

#if defined (_DEBUGSCHEDULER)   
   cerr<<"PsnMultiThreadedScheduler::runStep : Execution by block for debug "<<endl;
   for ( int i = 0 ; i < _numberOfThreads ; i++ ) {
      cerr<<"Block "<<i<<" ***********************************"<<endl;
      (*_localSchedulers)[ i ]->runStep (which) ;
   }
#else
   _barrier->Sync() ;

   _barrier->Sync() ;
   //let the controller do it's work

   //purge the memory manager from memory that couldn't be freed efficiently
   PsnThreadMemoryManager::freeLeakedMemoryBlocks() ;
#endif
}



void PsnMultiThreadedBenchmarkingScheduler::addToScheduable (PsnReferenceObjectHandle * ref, 
                                                 unsigned int when, 
                                                 unsigned int whichThread) 
{
   if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
      {
         _duplicatedObjectScheduler->addToScheduable ( ref , when ) ;
      }
   else 
      {
         (*_localSchedulers)[ whichThread ] -> addToScheduable( ref , when ) ;
      }
}



void PsnMultiThreadedBenchmarkingScheduler::addToScheduable (PsnReferenceObjectHandle * ref, 
                                                 unsigned int when) 
{

   if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
      {
         _duplicatedObjectScheduler->addToScheduable ( ref , when ) ;
      }
   else 
      {
         assert ( ref != NULL ) ;
         assert ( ref->getSimulatedObject().getFather () != NULL );
         
         //try and schedule an object on the same thread as it's father.
         map<PsnReferenceObjectHandle *, unsigned int>::iterator i = _whichThread.find((PsnReferenceObjectHandle *)ref->getSimulatedObject().getFather()->getObjectHandle() ) ;
         if ( i == _whichThread.end() )
            {
            
               (*_localSchedulers)[ _nextThreadForScheduling ] -> addToScheduable( ref , when ) ;
#ifdef _DEBUGSCHEDULER
               cerr<<ref->getSimulatedObject().getObjectDescriptor().getName()<< " goes to thread "<<_nextThreadForScheduling<<endl;
#endif
               _whichThread [ ref ] = _nextThreadForScheduling ;
               
               _nextThreadForScheduling = ( _nextThreadForScheduling + 1 ) % _numberOfThreads ;
               
            }
         else {//schedule on the same thread as ref's father
            
            (*_localSchedulers)[ (*i).second ] -> addToScheduable( ref , when ) ;
#ifdef _DEBUGSCHEDULER
            cerr<<ref->getSimulatedObject().getObjectDescriptor().getName()<< " goes to thread "<<(*i).second<<endl;
#endif
            
            _whichThread [ ref ] = (*i).second ;
            
      }
   }
}


 
void PsnMultiThreadedBenchmarkingScheduler::removeFromScheduable (PsnReferenceObjectHandle * ref) {

   if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
      {
         _duplicatedObjectScheduler->removeFromScheduable ( ref ) ;
      }
   else 
      {
         (*_localSchedulers) [ _whichThread [ ref ] ] ->removeFromScheduable (ref ) ;
      }
}



void PsnMultiThreadedBenchmarkingScheduler::schedule(PsnReferenceObjectHandle * ref) 
{
   if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
      {
         _duplicatedObjectScheduler->schedule ( ref ) ;
      }
   else 
      {
         (*_localSchedulers) [ _whichThread [ ref ] ] -> schedule (ref) ;
      }
}



void PsnMultiThreadedBenchmarkingScheduler::unschedule(PsnReferenceObjectHandle * ref) 
{
   if (dynamic_cast<const PsDuplicatedObject *>(&((PsnReferenceObjectHandle *)ref)->getSimulatedObject())) 
      {
         _duplicatedObjectScheduler->unschedule ( ref ) ;
      }
   else 
      {
         (*_localSchedulers) [ _whichThread [ ref ] ] -> unschedule (ref) ;
      }
}



void * PsnMultiThreadedBenchmarkingScheduler::_threadContainer (void * myThreadData) 
{
   // install the memory managers
   HeapStackTop systemMemoryManager ( HeapStackTop::getSystemMemoryManager() ) ;
  
   PsnMemoryManager * currentMemoryManager = HeapStackTop::getSystemMemoryManager() ;

   assert ( currentMemoryManager != 0 ) ;

   size_t initialAllocatatedMemory = 1024 * 1024 ;

   void * startMemory = currentMemoryManager->allocateSizeRemembered ( initialAllocatatedMemory ) ;

   PsnDescriptorMemoryManager * descriptorMemoryManager = new PsnDescriptorMemoryManager ( *currentMemoryManager ) ;

   descriptorMemoryManager->init() ;
   
   PsnThreadMemoryManager * memoryManagerForThisThread ;
   
   memoryManagerForThisThread = new PsnThreadMemoryManager ( startMemory, 
                                                             initialAllocatatedMemory,
                                                             *currentMemoryManager,
                                                             *descriptorMemoryManager ) ;
   memoryManagerForThisThread -> init() ;

   HeapStackTop allocationContextForThisThread ( memoryManagerForThisThread ) ;
   
   pair<PsnMultiThreadedBenchmarkingScheduler *, unsigned int> * threadData = ( pair<PsnMultiThreadedBenchmarkingScheduler *, unsigned int> * ) myThreadData ;

   ( * threadData ).first->run( ( * threadData ).second ) ;

   return threadData ;
}


void PsnMultiThreadedBenchmarkingScheduler::run( unsigned int whichFrameScheduler ) 
{
#ifdef _SGI
  timespec dateBeforeSync, dateAfterSync ;
  int counter = 0 ;
  while ( true ) 
     {
         
         //wait for the controller to be ready
         _barrier->Sync() ;
         
         (*_localSchedulers)[ whichFrameScheduler ]->runStep ( _currentStep ) ;
         
         clock_gettime (CLOCK_SGI_CYCLE, &dateBeforeSync);

         //wait for other local schdulers to be ready
         _barrier->Sync() ;

         clock_gettime (CLOCK_SGI_CYCLE, &dateAfterSync);

         if (dateAfterSync.tv_nsec >= dateBeforeSync.tv_nsec ) 
            {
               _localWaitingTimes [whichFrameScheduler] [ counter ] =  ( dateAfterSync.tv_nsec - dateBeforeSync.tv_nsec ) / 1000 ;
            }
         
         counter = ( counter + 1 ) % _numberOfSamples ;
   }

#else
   timeval dateBeforeSync ;
   timeval dateAfterSync ;
   int counter = 0 ;
   while ( true ) 
      {
         
         //wait for the controller to be ready
         _barrier->Sync() ;
         
         (*_localSchedulers)[ whichFrameScheduler ]->runStep ( _currentStep ) ;
         
         gettimeofday(&dateBeforeSync, NULL);

         //wait for other local schdulers to be ready
         _barrier->Sync() ;

         gettimeofday(&dateAfterSync, NULL);

         if (dateAfterSync.tv_usec >= dateBeforeSync.tv_usec ) 
            {
            _localWaitingTimes [whichFrameScheduler] [ counter ] =  dateAfterSync.tv_usec - dateBeforeSync.tv_usec ;
            }

         counter = ( counter + 1 ) % _numberOfSamples ;
   }
#endif
}

---