---

PsReactController.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
 *
 */
#ifdef _REACT
#include <PsReactController.h>
#include <PsReactGlobalController.h>
#include <PsnPthreadSemaphore.h>
#include <PsnDoubleListElement.h>
#include <PsnDoubleList.h>
#include "PsnReactFrameScheduler.h"

#define frs_abort(x) exit(x);

//--------------------------------------------------------

PsReactController::PsReactController(PsObjectDescriptor* arbreSimul, 
                                       int minorTim, 
                                       int nbMino,
                                       PsController * control,
                                       int cpuAutiliser,PsKernelObjectAbstractFactory * aKernelObjectFactory) : PsController(aKernelObjectFactory), barInit(2)
{
  cpu=cpuAutiliser;
  arbreObjets=arbreSimul;
  //Mise à jour de l'idObjet
  IdObjet(arbreSimul->get());
  arbreSimul->get()->setPointerToSimulatedObject(this);
  controleur=control;
  nbMinor=nbMino;
  _stepPeriod=minorTim;
// initialisations du controleur local
// a faire avant les init de objets de calcul...
  processNameessus= arbreSimul->get()->Nom();

// initialisation de l'état du controleur
  *_computeStatePointer=PsnReferenceObjectHandle::running;
#ifdef _DEBUG
  cout<<"creation du controleur React de nom "
      <<Nom()
      <<endl;
#endif
}

//--------------------------------------------------------

PsnSemaphore * PsReactController::newSemaphore(int i) {
#ifdef _DEBUG
  cout<<"PsReactController::newSemaphore("<<i<<") debut"<<endl;
#endif
  PsnSemaphore * ns=new PsnPthreadSemaphore(i);
  return ns;
}

//--------------------------------------------------------

PsReactController::~PsReactController() {
  pthread_attr_destroy(&attributs_pthread);
}

//--------------------------------------------------------

void PsReactController::reactToControlledObjectsSystemEvents() {
   int ret;
   PsnDoubleListElement * prec;
   PsEvenement courant;
   PsSimulatedObject * objetDest;
   PsObjectDescriptor * idObjetDest;
   listeEvtControleur->premier();
   while(!(listeEvtControleur->fin())) {
     courant=listeEvtControleur->get();
     //on recupère la référence sur l'objet
     objetDest=getPointerToSimulatedObjectNamed(courant.destinataire);
     idObjetDest=objetDest->IdObjet();
     //on le gère
     switch(courant.evt){
     case Mask_RESTART:
       if (idObjetDest->etat==PsnReferenceObjectHandle::stopped) {
         idObjetDest->etat=PsnReferenceObjectHandle::running;
         TraiterEvtObj(objetDest);
         _objectsNeedingActivationList[indiceFile]->remove(idObjetDest);
         objetDest->reInit();
         _scheduler->schedule((PsnReferenceObjectHandle *)objetDest->ObjectHandle());
       }//du test sur l'état
       break;
     case Mask_RESUME:
#ifdef _DEBUGEVT
       cout<<courant.destinataire<<" va être redémarré"<<endl;
#endif
       if (idObjetDest->etat==PsnReferenceObjectHandle::suspended) {
          idObjetDest->etat=PsnReferenceObjectHandle::running;
          TraiterEvtObj(objetDest);
          _objectsNeedingActivationList[indiceFile]->remove(idObjetDest);
          //on sait que c'est un référentiel 
          _scheduler->schedule((PsnReferenceObjectHandle *)objetDest->ObjectHandle());
       }
       break;
     case Mask_SUSPEND:
#ifdef _DEBUGEVT
        cout<<courant.destinataire<<" va être suspendu"<<endl;
#endif
        if(idObjetDest->etat==PsnReferenceObjectHandle::running) {
           idObjetDest->etat=PsnReferenceObjectHandle::suspended;
           TraiterEvtObj(objetDest);
           _scheduler->unschedule((PsnReferenceObjectHandle *)objetDest->ObjectHandle());
        }      
        break;
     case Mask_STOP:
        if(idObjetDest->etat==PsnReferenceObjectHandle::running) {
           idObjetDest->etat=PsnReferenceObjectHandle::stopped;
           TraiterEvtObj(objetDest);
           objetDest->fin();
           _scheduler->unschedule((PsnReferenceObjectHandle *)objetDest->ObjectHandle());
        }      
       break;
     case Mask_START:
        processStartEventOf(objetDest);
       break;
     case Mask_DELETE:
       if(idObjetDest->etat==PsnReferenceObjectHandle::stopped) {
         idObjetDest->etat=PsnReferenceObjectHandle::destroyed;
//  #ifdef _DYNOS
//       detruireDynOS(objetDest->Nom());
//  #endif
         cerr<<"WARNING:PsController::reactToControlledObjectsSystemEvents traitement incomplet de DELETE"<<endl;
         //il faut oter le descripteur d'objet de _objectsNeedingActivationList
       }
       break;
     default:
       cerr<<"WARNING:PsController::reactToControlledObjectsSystemEvents evenement système non géré"<<endl;
     }
     //on le supprime de la liste des événements à gérér.
     listeEvtControleur->supprimerDebut();
     listeEvtControleur->premier();
   }
}


//--------------------------------------------------------

frs_t * PsReactController::Frs() {
  return frs;
}

//--------------------------------------------------------

PsCalculus * PsReactController::createCalculus () {
  createControlledObjects();
  scheduleControlledObjects();
  nbModules=_referenceObjectsMap.size();
  cout<<"PsReactController : "
      <<processNameessus
      <<" createCalculus : nbModules à gérer detectés : "
      <<nbModules
      <<endl;
  // initialisation des signaux pour récupérer le signal underrun et le signal overrun.
  if (cpu==1) capture_signal(); //c'est une fonction statique : une seule execution suffit
  // calcul du pas de temps 
  PsFloat facUB = facSecUnite(UBASE);  
  _stepFrequency=_simulationTree.get()->Frequency();
  dt=  (PsDate) ( (1./_stepFrequency.getValue()) * facUB.getValue());
  
#if defined(_DEBUG)
  cdebug<< endl<<"freq controleur: " <<_stepFrequency<< " dt: " <<dt<< endl;
#endif
  return NULL;
}

//--------------------------------------------------------


void PsReactController::init() {
  //Creation du thread controleur
  // Le thread lancant le FRS doit avoir la porté d'un thread system : initialisation des attributs
  int ret=pthread_attr_init(&attributs_pthread);
  if (ret) {
    perror("impossible d'initialiser les attributs du thread");
  } 
  ret=pthread_attr_setscope(&attributs_pthread, PTHREAD_SCOPE_SYSTEM);
  if (ret) {
    perror("Impossible de créer des threads system");
  }
  // Mise en place du FRS
  ret = pthread_create(&id_pthread_controleur,
                       &attributs_pthread,
                       (void *(*)(void *)) Thread_controleur,
                       this);
  if (ret) {
    error("PsnControlLocal : run : impossible de créer le thread_controleur");
    frs_abort(1);
  }

  //synchronisation avec la fin de la creation de tous les threads
  barInit.Sync();
  //  PsController::init();
}

//--------------------------------------------------------

void *PsReactController::Thread_controleur(void *controleurv) {
  PsReactController * ceControleur=(PsReactController *)controleurv;
  ceControleur->threadControleur();
  return((void *)ceControleur);
}
 
//--------------------------------------------------------

PsSimulatedObject *
PsReactController::getPointerToSimulatedObjectNamed (const PsName & nom) 
{
  PsSimulatedObject * resultat;
  PsnReferenceObjectHandle * refRes;
  // hypothese : c'est un referentiels de ce controleur (recherche rapide)
  refRes=_referenceObjectsMap.refObjet(nom);

  resultat= ((PsnObjectHandle*)(_referenceObjectsMap.getObjectOfIndex(nom)) )->objetSimul();
  if (refRes==NULL) {//il faut chercher dans l'arbre des objets
     resultat=_simulationTree.find(nom)->getPointerToSimulatedObject();
  }
  else {
     resultat=((PsnObjectHandle*)refRes)->objetSimul();
  }
  if(resultat==NULL) {
     cout<<"WARNING : PsReactController::getPointerToSimulatedObjectNamed trouve NULL"<<endl;
  }
  return resultat;
}
 
//--------------------------------------------------------

void PsReactController::threadControleur() {
  PsNameToPointerMap<PsnReferenceObjectHandle>::iterator pTab;
  int ret;  
  int minor;
  int freq;
  pthread_attr_t attributs_pthread;

  ret=pthread_attr_init(&attributs_pthread);
  if (ret) {
    perror("PsnControlLocal : threadControleur : impossible d'initialiser les attributs du thread");
  } 
  ret=pthread_attr_setscope(&attributs_pthread, PTHREAD_SCOPE_SYSTEM);
  if (ret) {
    perror("PsnControlLocal : threadControleur : Impossible de créer des threads system");
  }
  /* 
   * Creation du frs si cpu = 1, il s'agit du frs maitre, sinon il s'agit d'un frs esclave.
   * cpu = cpu
   * source d'interruption = CCTIMER
   * nb de minor frames = nbminor
   * frs esclaves : controleur->nbFils-1
   * period = _stepPeriod [ms]
   */
  cout<<"PsReactController : threadControleur de "
      <<Nom()
      <<" : params de frs create master "
      <<_stepPeriod*1000
      <<" et "
      <<nbMinor
      <<" et "
      <<((PsReactGlobalController *)controleur)->NbFils()-1 
      <<" esclave(s) sur le cpu "
      <<cpu<<endl;
  if (cpu==1) {
    frs = frs_create_master(cpu,     //numero du CPU de APP (le frame sheduler)
                            FRS_INTRSOURCE_CCTIMER,
                            _stepPeriod*1000,
                            nbMinor,
                            ((PsReactGlobalController *)controleur)->NbFils()-1);
    PsReactGlobalController::frs=frs; 
  }
  else {
    frs = frs_create_slave(cpu,     //numero du CPU de APP (le frame sheduler)
                           PsReactGlobalController::frs);
  }
  if(frs==NULL) {
    perror("PsReactController : ThreadControleur : impossible de creer le frs");
    exit(0);
  }
  annulerSignalSIGRTMIN();
  cout <<"PsReactController : threadControleur : "
       <<Nom()
       <<" :frame scheduler créé"<<endl;
  
  //creation du thread Thread_time pour la gestion du temps
  ret=pthread_create(&(id_pthread_time),
                     &attributs_pthread,
                     Thread_Time,
                     (void *) this);
  if (ret) {
    perror("PsReactController : threadControleur : Impossible de creer le Thread Time");
    pthread_exit(0);
  }
#ifdef _DEBUG
  cout <<"PsReactController : threadControleur : "
       <<Nom()
       << "thread time crée "<<endl;
#endif
  //placement de ce thread en tête de toutes les files d'exécution
  for(minor=0;minor<nbMinor;minor++) {
    ret=frs_pthread_enqueue(frs,
                            id_pthread_time,
                            minor,
                            FRS_DISC_RT);
    if (ret) {
      perror("PsReactController : threadControleur : Impossible de mettre le Thread time dans la file d'execution");
      pthread_exit(0);
    }
  }
  //disc est la discipline qui permet a un thread de s'éxécuter en avance si il le peut
  //int disc= FRS_DISC_RT | FRS_DISC_UNDERRUNNABLE | FRS_DISC_OVERRUNNABLE | FRS_DISC_CONT;
  
  //pour tous les modules, creation du thread et placement sur les files d'éxécution.
  for (pTab= _referenceObjectsMap.begin(); pTab!= _referenceObjectsMap.end(); pTab++)
    {
      ret=pthread_create(&((*pTab).second->objetSimul()->id_pthread_calcul),
                         &attributs_pthread,
                         (*pTab).second->objetSimul()->Start_Thread,
                         (void *) (*pTab).second->objetSimul());
      
      if(ret) {
        error("PsReactController : threadControleur : creation d'un Thread calcul impossible");
        frs_abort(1);
      }
      //Placer les thread sur les files du controleur : c'est fait lors de la reception du Mask_START
    }
#ifdef _DEBUGPAR
  cdebug<<"Placement, sur le cpu "<<cpu<<" des objets suivants : "<<endl;
  for (pTab= _referenceObjectsMap.begin(); pTab!= _referenceObjectsMap.end(); pTab++)
     {    
        cdebug<<(*pTab).second->objetSimul()->Nom()<<endl;
     }
#endif
  PsController::init();
  advanceSimulatedDate(); 
  traiterEvt();
  reactToControlledObjectsSystemEvents();
  cout<<"PsReactController : threadControleur : date avant la BarInit : "<<date<<endl;
  barInit.Sync();
  ((PsReactGlobalController *)controleur)->barFrsStart->Sync();
  if (frs_start(frs)<0) {
    perror("PsReactController : threadControleur : démarrage du frs impossible ");
    exit(0);
  }
#ifdef _DEBUG
  cout<<"frame scheduler running"<<endl;
#endif
  if (ret=pthread_join(id_pthread_time,0)) {
    error("PsReactController : threadControleur : join thread_time failed");
  }
  else {
    cout<<"Thread_time terminé"<<endl;
  }
  for (pTab= _referenceObjectsMap.begin(); pTab!= _referenceObjectsMap.end(); pTab++) {
    if (ret=pthread_join((*pTab).second->objetSimul()->id_pthread_calcul,0)) {
      error("PsReactController : threadControleur : join des threads_calcul impossible");
    }
    cout <<"fini\n";
  }
  pthread_exit(0);
  
}

//--------------------------------------------------------

void PsReactController::threadTime() {
  int previous_minor; //permet de controler la réussite de frs_yield
  int localfin=TRUE;

  //On attend que tous les threads soient dans la file d'execution
  barStart->Sync(); 

  //On signale au frs qu'on est prêt
  if(frs_join(frs) < 0) {
    perror("PsController : Thread_time : pas réussi à joindre le Frame Scheduler");
    finObjetActif(0);
  }
#ifdef _DEBUG
  else {
    cout<<"join du thread_time réussi"<<endl;
  }
#endif
  do { //à chaque pas de simulation, compute la date.
    previous_minor=frs_yield();
    //on revient de cet appel de procedure seulement au prochain pas de simulation 
    if(previous_minor<0)  {
      if(!fin) {
        perror("PsReactController : Thread_time : frs_yield() a échoué");
        finObjetActif(0);
      }
    }
    processEventsOfSuspendedObjects();
    supprEvt();
    advanceSimulatedDate();
    traiterEvt();
    reactToControlledObjectsSystemEvents();
#ifdef _DEBUG
    cout<<"calcul du temps"<<endl;
#endif
    if (*_computeStatePointer==PsnReferenceObjectHandle::stopped
        ||*_computeStatePointer==PsnReferenceObjectHandle::destroyed) localfin=FALSE;
  } while(localfin);
#ifdef _DEBUG
  cout<<"Output du threadTime"<<endl;
#endif
  frs_stop(frs);
  frs_destroy(frs);
  finObjetActif(0);

}

//--------------------------------------------------------


void * PsReactController::Thread_Time(void *controleurv) {

  PsReactController *controleur=(PsReactController *)controleurv;
  controleur->threadTime();
  return (controleur); //ça evite des warnings
}


//--------------------------------------------------------



//  bool PsReactController::fin=FALSE;
//  PsnSemaphore PsReactController::sem_fin_clavier=PsnSemaphore(0);



//  void PsReactController::finFrs(void) {
//    frs_stop(frs);
//    frs_destroy(frs);
//  }

//--------------------------------------------------------

void PsReactController::capture_underrun (int i) {
  if((int)signal(SIGUSR1, capture_underrun)== -1) {
    error("PsReactController : capture_signal : impossible de mettre en place le signal underrun_error");
    frs_abort(1);
  }
  cout<<"PsReactController : Error underrun : un des modules n'a pu avoir le CPU alors qu'il aurait du";
  PsReactGlobalController::monError();
  frs_abort(2);
}

//--------------------------------------------------------

void PsReactController::capture_overrun (int i) {
  if((int)signal(SIGUSR1, capture_overrun)== -1) {
    error("PsReactController : capture_signal : impossible de mettre en place le signal overrun_error");
    frs_abort(1);
  }
  cout<<"PsReactController : Error overrrun : un des modules n'a pas relaché le CPU assez vite";
  PsReactGlobalController::monError();
  frs_abort(2);
}

//--------------------------------------------------------

void PsReactController::annulerSignalSIGRTMIN() {
  int error;
  frs_signal_info_t work;
  error=frs_pthread_getattr(frs,0,0,FRS_ATTR_SIGNALS,(void*)&work);
  if(!error)
    {
      work.sig_unframesched=-1;//0 serait la bonne valeur
      for(int i=0;i<nbMinor;i++) {
      error=frs_pthread_setattr(frs,i,0,FRS_ATTR_SIGNALS,(void*)&work);
      if(error) perror("PsReactController::annulerSignalSIGRTMIN:impossible d'annuler le signal");
      cout<<"PsReactController::annulerSignalSIGRTMIN::signal annulé"<<endl;
      }
    }
  else perror("PsReactController::annulerSignalSIGRTMIN ");
}

//--------------------------------------------------------

void PsReactController::capture_end(int i) {
  //l'utilisateur souhaite terminer la session. Le control n'est pas total on fait donc pour le mieux.
  PsReactGlobalController::monError();
  cout<<"c'est la fin";
}

//--------------------------------------------------------

void PsReactController::capture_signal() {
  if((int)signal(SIGUSR1, capture_underrun)== -1) {
    error("PsReactController : capture_signal : impossible de mettre en place le signal underrun_error");
    frs_abort(1);
  }

  if((int)signal(SIGUSR2, capture_overrun)== -1) {
    error("PsReactController : capture_signal : impossible de mettre en place le signal overrun_error");
    frs_abort(1);
  }
  if((int)signal(SIGINT, capture_end )== -1) {
    error("PsReactController : capture_signal : impossible de capturer les signaux de terminaison");
    frs_abort(1);
  }  
}

#endif

---