---

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

#include "PsnReferenceObjectHandle.h"
#include "PsUnInitialisedAttributeException.h"
#include "PsSimulatedObject.h"
#include "PsController.h"
#include "unistd.h"

PsnMultiThreadedAsynchronousScheduler::PsnMultiThreadedAsynchronousScheduler(unsigned int numberOfSteps, 
                                                                                   unsigned int numberOfThreads) :
   PsnMultiThreadedScheduler(numberOfSteps, numberOfThreads,true),
   _running (false),
   _started (false),
   _nameOfAsynchronousObject("visu")
{
   cerr<<"Warning : using a experimental scheduler. UNSUPPORTED"<<endl;
   cerr<<"Only supports ONE asynchronous object"<<endl;
}

PsnMultiThreadedAsynchronousScheduler::~PsnMultiThreadedAsynchronousScheduler() {
}

void PsnMultiThreadedAsynchronousScheduler::addToScheduable (PsnReferenceObjectHandle * ref, unsigned int when) {
   if (ref->getSimulatedObject().getObjectDescriptor().getName() == _nameOfAsynchronousObject) {
      _asyncRef = ref ;
      setComputingState (ref,PsnReferenceObjectHandle::running ) ; 
      int ret = pthread_create(&_asynchronousThreadId,
                               0,
                               (void *(*)(void *))_asynchronousThreadContainer,
                               this) ;
       if (ret) {
         PsController::error("Couldn't create asynchronous thread") ;
      }
   }
   else {
      PsnMultiThreadedScheduler::addToScheduable ( ref , when );
   }
}



void PsnMultiThreadedAsynchronousScheduler::removeFromScheduable (PsnReferenceObjectHandle * ref) {
   if ( ref == _asyncRef ) {
      //nothing to do : the asynchronous thread has been stopped. destroying it would be to painfull code to write ! 
   }
   else {
      PsnMultiThreadedScheduler::removeFromScheduable ( ref );
   }
} ;



void PsnMultiThreadedAsynchronousScheduler::schedule(PsnReferenceObjectHandle * ref) {
   if ( ref == _asyncRef ) {
      _runDataAccess.protect() ;
      _running = true ;
      _runDataAccess.unprotect () ;
      _runCondition.signalChange() ;
   }
   else {
      PsnMultiThreadedScheduler::schedule ( ref );
   }
}



void PsnMultiThreadedAsynchronousScheduler::unschedule(PsnReferenceObjectHandle * ref) {
   if ( ref == _asyncRef ) {
      _runDataAccess.protect () ;
      _running = false ;
      _runDataAccess.unprotect () ;
      _runCondition.signalChange() ;
   }
   else {
      PsnMultiThreadedScheduler::unschedule ( ref );
   }
}

void PsnMultiThreadedAsynchronousScheduler::runStep (unsigned int which) {
   _runDataAccess.protect() ;
   if (!_started) {
      _started = true ;
      _runDataAccess.unprotect() ;
      _runCondition.signalChange() ;
   }
   else {
      _runDataAccess.unprotect() ;      
   }
   PsnMultiThreadedScheduler::runStep( which ) ;
}



void * PsnMultiThreadedAsynchronousScheduler::_asynchronousThreadContainer ( void * theScheduler) {
   PsnMultiThreadedAsynchronousScheduler * scheduler = (PsnMultiThreadedAsynchronousScheduler *) theScheduler ;

   scheduler->runAsynchronous() ;

   return scheduler ;
}



void PsnMultiThreadedAsynchronousScheduler::runAsynchronous() {
   bool init = false ;
   _runDataAccess.protect() ;
   while (!_started) {
         _runDataAccess.unprotect() ;
         _runCondition.waitForChange( _runDataAccess ) ;
   }
   
   _runDataAccess.unprotect() ;

   assert (false ) ;
   //_asyncRef->getSimulatedObject().init() ;
   
   while (true) {
      _runDataAccess.protect() ;

      while (!(_running && _started) ) {
         _runDataAccess.unprotect() ;
         _runCondition.waitForChange( _runDataAccess ) ;
         
      }

      _runDataAccess.unprotect() ;   

      try {

         assert (false) ;
         //_asyncRef->getSimulatedObject().compute() ;

      }
      catch (PsUnInitialisedAttributeException & e) {
         _runDataAccess.protect() ;
         _started = false ;
         _runDataAccess.unprotect() ;
         _runCondition.signalChange() ;
      }
   }
}

---