---

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

#include "PsnMultiThreadedAsynchronousScheduler.h"
#include "PsnMultiThreadedScheduler.h"
#include "PsConfigurationParameterDescriptor.h"
#include "PsMultipleConfigurationParameter.h"
#include "PsNoRefCountingNameServer.h"
#include "PsnDescriptorMemoryManager.h"
#include "PsnThreadMemoryManager.h"
#include "PsnSystemMemoryManager.h"


PsMultiThreadedPvmController::PsMultiThreadedPvmController (PsObjectDescriptor & initialObjects,
                                                            const PsDate & initialDate,
                                                            int argc,
                                                            char * argv []) : 
   PsPvmController(initialObjects,
                   initialDate,
                   argc,
                   argv),
   _numberOfThreads (2),
   _accessingThread ( 0 )
{
   assert ( _accessingThread != pthread_self() ) ;
   
   if ( getObjectDescriptor().getSchedulingParameters() != NULL )
      {
         const PsConfigurationParameterDescriptor * param = getObjectDescriptor().getSchedulingParameters()->getSubDescriptorByName("NumberOfThreads") ;
         if (param != NULL )
            {
               // if the sheduling parameter named NumberOfThreads if a uniqueConfigurationParameter, then all processes should be spawned with the same number of threads,
               //otherwise read  the number of threads from the appriate subdescriptor (the one with the name of the process, or default
               const PsMultipleConfigurationParameter * complexParam ;
               complexParam = dynamic_cast< const PsMultipleConfigurationParameter *> (param) ;
               if ( complexParam != NULL )
                  {
                     // a multithreading value could by defined for each process

                     //find the value for this process
                     param = complexParam->getSubDescriptorByName (getObjectDescriptor().getProcess().getCString() ) ;

                     if (param == NULL)
                        { //no value has been defined for this process
                           param = complexParam->getSubDescriptorByName ("default") ;

                           if (param == NULL)
                              {//no default value has been defined
                                 _numberOfThreads = 2 ;
                              }
                           else
                              {// a default value has been defined
                                 _numberOfThreads = atoi (param->getAssociatedString().c_str() ) ; 
                              }
                        }
                     else
                        {// a value has been defined for this process
                           _numberOfThreads = atoi (param->getAssociatedString().c_str() ) ; 
                        }
                  }
               else 
                  {// all processes use the same number of threads
                     _numberOfThreads = atoi (param->getAssociatedString().c_str() ) ; 
                  }
            }
      }
   
}

PsMultiThreadedPvmController::~PsMultiThreadedPvmController() {

}

PsnScheduler * PsMultiThreadedPvmController::createScheduler() 
{
   return new PsnMultiThreadedScheduler( _nbStepsByCycle , _numberOfThreads, true ) ;
}

void PsMultiThreadedPvmController::run ()
{
    PsnMemoryManager * currentMemoryManager = HeapStackTop::getSystemMemoryManager() ;

   assert ( currentMemoryManager != 0 ) ;

   // commented out because a thread memory manager doesn't seem performant : confirmed : our implementation performs very poorly compared to the malloc implementation on the demarshalling phase

   //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 ) ;
  
   PsPvmController::run() ;
}


PsSimulatedObject * PsMultiThreadedPvmController::getPointerToSimulatedObjectNamed (const PsName & objectName )
{

   PsSimulatedObject * result ;

   map<PsName, PsSimulatedObject * >::iterator i = _pointerToObjectCache.find ( objectName ) ;
   if ( i != _pointerToObjectCache.end() )
      {
         result = i->second ;
      }
   else
      {
         _dataLock.protect() ;
         i = _addToCache.find (objectName) ;
         if ( i != _addToCache.end() )
            {
               result = i->second ;
               _dataLock.unprotect() ;
            }
         else 
            {
               if ( _accessingThread == pthread_self() ) 
                  {
                     _dataLock.unprotect() ;
                     result = PsPvmController::getPointerToSimulatedObjectNamed ( objectName ) ;               
                  }
               else if ( _accessingThread == 0 )
                  {
                     _accessingThread = pthread_self() ;
                     _dataLock.unprotect() ;
                     
                     result = PsPvmController::getPointerToSimulatedObjectNamed ( objectName ) ;               
                     
                     _dataLock.protect() ;
                     _accessingThread = 0 ;
                     _dataLock.unprotect() ;
                     _accessCondition.signalChange() ;
                  }      
               else 
                  { //other thread is accessing: wait
                     _accessCondition.waitForChange ( _dataLock ) ; 
                     
                     _dataLock.unprotect() ;

                     result = getPointerToSimulatedObjectNamed ( objectName ) ; 
                  }
               _dataLock.protect() ;
               _addToCache.insert ( make_pair(objectName,result) ) ;
               _dataLock.unprotect() ;
            }
      }
   return result ;
}


void PsMultiThreadedPvmController::computeNextSimulationStep () 
{
   _pointerToObjectCache.insert (_addToCache.begin() , _addToCache.end() ) ;
   _addToCache.clear() ;
   PsPvmController::computeNextSimulationStep () ;
}

---