---

PsReactGlobalController.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 <PsReactGlobalController.h>
#include <PsReactController.h>
#include <PsArbreSimul.h>
#include <PsSimulatedObject.h>
#include <PsCalculus.h>
#include <vector>

PsReactGlobalController * PsReactGlobalController::controleurUnique =NULL;
frs_t * PsReactGlobalController::frs =NULL;

// PsnControlLocal::PsnControlLocal
//--------------------------------------------------------
PsReactGlobalController::PsReactGlobalController(const PsName & processName, PsObjectDescriptor* scenario,PsKernelObjectAbstractFactory * aFactory) : PsController(aFactory)
{
  PsReactGlobalController::controleurUnique=this;
  PsController::stop=monError;  
  arbreObjets= scenario;
  nbFils=atoi(processName.getCString());
  idObjet=_simulationTree.find(PSNOMRAC);
  idObjet->setPointerToSimulatedObject(this);
  controleur=this;
  // initialisations du controleur global
  // a faire avant les init de objets de calcul...
  processNameessus="ControleurReactGlobal";
  
  // initialisation de l'état du controleur
  *_computeStatePointer=PsnReferenceObjectHandle::running;
    
}

class AgregatTriable {
public:
  PsObjectDescriptor * arbreSimul;
  int poids;
  AgregatTriable() {};
  AgregatTriable(PsObjectDescriptor * id) {
    arbreSimul=id;
    poids=id->getNbDescendants()+1; //pas de modules de poids nul.
  }
  friend int operator < (const AgregatTriable &Source1,const AgregatTriable &Source2) {
      return Source1.poids>Source2.poids;
  }
  friend istream &operator >> (istream &flot, AgregatTriable at) {
    return flot;
  };
  friend ostream & operator<< (ostream & flot, const AgregatTriable at) {
     flot<<at.arbreSimul->get()->Nom()<<" de poids "<<at.poids<<endl;
    return flot;
  }
};


PsCalculus * PsReactGlobalController::createCalculus () {

  /* Partition de l'arbre de simulation entre les différents processus
   * L'algorithme est le suivant :
   * On obtient une liste des modules et des sous-arbres pouvant être calculé en parallèle toutesLesSeq
   * On associe un poids à chacun (le nombre des descendants + 1)
   * On trie la liste obtenue par ordre décroissant de poids
   * On maintient à jour une liste des poids par processus (tabPoids)
   * On affecte le module ou le sousarbre de plus grand poids non-encore affecté à un processus au processus ayant le moins de poids.
   */

  PsString processus("ProcCtrlReact"); //pour fabriquer des noms de processus des controleurs fils
  PsString nomObjet("ObjCtrlReact");//pour fabriquer les noms des controleurs fils
  char cpt('0'); //pour construire des noms uniques
  PsString unique;//idem
  PsString tmp1;
  PsObjectDescriptor * idTmp;//pour construire les identifiants des controleurs fils
  PsObjectDescriptor * arbreTmp;//pour construire les arbre des controleurs fils
  vector <PsObjectDescriptor * > * lesFils;//La liste des fils de la racine


  //initialisation des structures de données utilisées.
  lesFils=new vector<PsObjectDescriptor *>;
  int tabPoids[nbFils];              //la table des poids qu'il faut maintenir
  for(int i=0;i<nbFils;i++) {
    tabPoids[i]=0;
    idTmp=new PsObjectDescriptor((nomObjet+((char)(cpt+i))),
                         "ControleurReactLocal",
                         processus+((char)(cpt+i)),
                         0,
                         0,
                         FALSE);
#ifdef _DEBUG
    cout<<"nom généré : "<<idTmp->Nom()<<endl;
#endif
    arbreTmp=new PsObjectDescriptor(idTmp);
    lesFils->push_back(arbreTmp);
  }

  //construction de la liste des modules et des sous-arbres parallèles
  PsList <PsObjectDescriptor *> * toutesLesSeq=_simulationTree.listeUniteSequentielles();
  PsList <PsObjectDescriptor *>::iterator itrl;
  PsList <AgregatTriable> * listeSeq;//La liste trie selon leur poids des modules et des sous-arbres parallèles
  listeSeq = new PsList <AgregatTriable>;
  for (itrl=toutesLesSeq->begin();itrl!=toutesLesSeq->end();itrl++) {
    AgregatTriable * temp;
    temp=new AgregatTriable(*itrl);
    listeSeq->insert(*temp);
  }
  listeSeq->sort();
#ifdef _DEBUGPAR
  cout<<"Liste des poids "<<endl;
  listeSeq->afficher();
#endif
  //L'affectation aux processeurs
  for (PsList <AgregatTriable>::iterator elemCour=listeSeq->begin();
       elemCour!=listeSeq->end();
       elemCour++) {
    int indicePlusFaiblePoids=0;
    int plusFaiblePoids=tabPoids[0];
    for (i=1;i<nbFils;i++) {
      if (tabPoids[i]<plusFaiblePoids) indicePlusFaiblePoids=i;
    }
    tabPoids[indicePlusFaiblePoids]+=elemCour->poids;

//      unique=(char)cpt+indicePlusFaiblePoids;
//      tmp1=process+unique;
    if(elemCour->arbreSimul->el->Sequence()) {
      elemCour->arbreSimul->ChangerProcessusSousArbre((*lesFils)[indicePlusFaiblePoids]->el->Nom());
    }
    else {
      elemCour->arbreSimul->ChangerProcessus((*lesFils)[indicePlusFaiblePoids]->el->Nom());
    }
  }

  //rebranchement de l'arbre de simulation
  //les fils de la racine deviennent les controleurs react locaux
  vector <PsObjectDescriptor * > * listeftmp=_simulationTree.echangerFils(lesFils);
  vector <PsObjectDescriptor * >::iterator iter; 
  for(iter=lesFils->begin();iter!=lesFils->end();iter++) {
    (*iter)->echangerFils(listeftmp); //les fils des controleurs sont les anciens fils de la racine
  }

  /* calcul de la frequency du controleur (lcm des freqs de ref.)
   * Obtention de la liste des modules
   * Calcul de _cycleFrequency, _stepFrequency et surtout _stepPeriod, nbMinor
   */
  PsList<PsFrequency> * listeFreq= new PsList<PsFrequency>;
  _simulationTree.listeToutesFrequencys(listeFreq);
#ifdef _DEBUG
  listeFreq->afficher();
#endif
  PsList<PsFrequency>::iterator pListe;
  PsFloat facUB = facSecUnite(UBASE);  
  int freq;
  _stepFrequency= 1;
  _cycleFrequency=0;
  for (pListe= listeFreq->begin();
       pListe != listeFreq->end(); 
       pListe++)
    {
      freq=pListe->getValue();
      if (freq!=0) {//si freq=0, c'est la frequency non initialisé d'un des controleurs
        _cycleFrequency=gcd(freq,_cycleFrequency);
        _stepFrequency=(int)((freq*_stepFrequency.getValue())/gcd(freq,_stepFrequency.getValue()));  //lcm(freq,_stepFrequency);
      }
    }
  _stepPeriod= int(1000./_stepFrequency);
  nbMinor= _stepFrequency/_cycleFrequency;
  // calcul du pas de temps 
  dt=  (PsDate) ( (1./_stepFrequency) * facUB);   
  /* Creation des PsncontroleurReactLocal
   * createCalculus
   */
  for (i=0;i<nbFils;i++) {
    PsObjectDescriptor * arbreTmp;
    arbreTmp=(*lesFils)[i];
    arbreTmp->get()->frequency=_stepFrequency;
    PsReactController * tmp=new PsReactController(arbreTmp,_stepPeriod,nbMinor,this,i+1,kernelObjectFactory);
    arbreTmp->get()->setPointerToSimulatedObject(tmp);
    tmp->createCalculus();
  }
  return NULL;
}



//----------------------------------------------------------
// desctructeur

PsReactGlobalController::~PsReactGlobalController() {
  delete barStart;
  delete barFrsStart;
}

void PsReactGlobalController::init() {
  PsObjectDescriptor::iterator i;
  int nbDesc=_simulationTree.getNbDescendants();
  nbDesc=(int)((nbDesc-nbFils)/nbFils);
  barFrsStart=new PsnBarrier(nbFils+1);
  barStart=new PsnBarrier(nbDesc+nbFils+1);
#ifdef _DEBUG
  cout<<"nombres de threads attendus à la barriere de synchro : "
      <<nbDesc+nbFils+1
      <<endl;
#endif
  for (i=_simulationTree.begin();
       i!=_simulationTree.end();
       i++) {
    //initialisation de l'alias sur barStart
    ((PsReactController *)(*i)->get()->getPointerToSimulatedObject())->barStart=barStart;
    (*i)->get()->getPointerToSimulatedObject()->traiterEvt();
    (*i)->get()->getPointerToSimulatedObject()->init();
  }
}
void PsReactGlobalController::run() {
   advanceSimulatedDate();
   compute();
}

void PsReactGlobalController::compute() {
  PsObjectDescriptor::iterator i;
  int ret;
  barFrsStart->Sync();
#ifdef _DEBUG
  cout<<"PsReactGlobalController::compute::passage de barFrsStart"<<endl;
#endif
  barStart->Sync();
#ifdef _DEBUG
  cout<<"PsReactGlobalController::compute::passage de barStart"<<endl;
#endif
  for (i=_simulationTree.begin();
       i!=_simulationTree.end();
       i++) {
     ret=pthread_join(((PsReactController *)(*i)->get()->getPointerToSimulatedObject())->id_pthread_controleur,0);
     if (ret)
        {
           error("PsnControlLocal : run : join failed");
        }
     else {
        cout<<"thread controleur terminé"<<endl;
     }
  }
}

int  PsReactGlobalController::NbFils() {
  return nbFils;
}
const PsEvenement & PsReactGlobalController::nouvelEvt (const PsEvenement & evenement) {
  switch(evenement.evt) {
  case Mask_STOP:
  case Mask_DELETE:
  case Mask_SUSPEND:
    monError();
    break;
  default:
    error("événement système non géré");
  }
  return evenement;
}

void PsReactGlobalController::monError() {
   //un seul frs_stop est nécessaire
   //frs_destroy sur le controleur maitre doit être fait en dernier
  PsObjectDescriptor::iterator i;
  frs_stop(frs);//arrêt de la simulation
  frs_t * frsneedsDelete;
  for (i=controleurUnique->_simulationTree.begin();
       i!=controleurUnique->_simulationTree.end();
       i++) {
    ((PsReactController *)(*i)->get()->getPointerToSimulatedObject())->*_computeStatePointer=PsnReferenceObjectHandle::stopped;
    frsneedsDelete=((PsReactController *)(*i)->get()->getPointerToSimulatedObject())->frs;
    if(frsneedsDelete!=frs) {
       frs_destroy(frsneedsDelete);
    }
  }
  frs_destroy(frs); //on détruit le FRS maitre en dernier
  exit(1);
}

//  #ifdef _REACT
//  #define frs_abort(x) exit(x)
//  bool PsReactGlobalController::fin=FALSE;
//  PsnSemaphore PsReactGlobalController::sem_fin_clavier=PsnSemaphore(0);
//  frs_t * PsReactGlobalController::frs=NULL;

//  void PsnControlLocal::run()
//  {
//    // Phase de preparation de la simulation
//    //======================================
//    //mise en place de la barrière de synchro qui permet d'attendre que tous les threads soient placés sur leur file d'exécution avant le démarrage, c'est a dire tous les modules plus le temps, le time la gui et le controleur
//  #ifdef _PSGUI1
//    bar=new PsnBarrier(nb_modules+4);
//  #else
//    bar=new PsnBarrier(nb_modules+3);
//  #endif
//  #ifdef _PSGUI1 //dans le cas des processus légers
  
//    // attente de l'ordre utilisateur de demarrage de la simulation
//    while(*_computeStatePointer==PsnReferenceObjectHandle::initial){ 
//      // gestion des demandes de l'utilisateur au niveau controle
//      appliIlv->gestEvtUI();
//      // pour tous les referentiels gestion de l'interface utilisateur
//      PsnListeModuleElem * pListe;
//      for (pListe= _referenceObjectsList->superListBegin(); pListe!=NULL ; pListe=superListNext(pListe)){
//        (*pListe).listeElem->objetSimul()->Calcul()->runUserInterfaceDuringInit();
//      }
//    }
//  #endif
//  #ifdef _SPROC
//    id_thread_controleur=sproc(Thread_controleur,PR_SALL, (void *)this);
//    if(id_thread_controleur== -1) {
//      perror("PsnControlLocal :: run :: impossible de créer le thread controleur");
//      exit(1);
//    }
//  #else //pas de visu donc utilisation des threads posix
//    // 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);
//    }
//  #endif //cas react - gui
//    cout << "PsnControlLocal : run : fin de l'initialisation"<<endl;
//  #endif

//  #ifdef _REACT
//  #ifdef _SPROC
//    int ret=1;
//  #ifdef _DEBUG
//    int pid=0;
//    cout<<"PsnControlLocal::run::on va attendre"<<endl;
//    pid=wait(&ret);
//    cout<<"PsnControlLocal::run::on a termin'e avec le thread controleur "<<pid<<endl;
//  #else
//    wait(&ret);
//  #endif
//    if (ret == -1) { 
//      perror("PsnControlLocal :: run :: impossible d'attendre la fin du controleur ");
//    }
//  #else
//    if (ret=pthread_join(id_pthread_controleur,0)) {
//      error("PsnControlLocal : run : join failed");
//    }
//  #endif
//    cout<<"PsnControlLocal : run : fin de la simulation"<<endl;
//    sem_fin_clavier.V(); //gestion du SIGINT
//  } //run

//  //  void PsnControlLocal::computeNextSimulationStepGUI() {
//  //  #ifdef _REACT
//  //    if (pause) {
//  //      frs_stop(frs);
//  //      do {
//  //        runUserInterface();
//  //      }
//  //      while(pause);
//  //      frs_resume(frs);
//  //    }
//  //  #else
//  //    if (pause==FALSE){
//  //      computeNextSimulationStep();
//  //    }
//  //  #endif
//  //  }

//  // Le corps du thread chargé de gérer le FRS et d'initialiser tout.
//  #ifdef _SPROC
//  void PsnControlLocal::Thread_controleur(void *controleurv) {
//  #else
//  void *PsnControlLocal::Thread_controleur(void *controleurv) {
//  #endif
//    PsNameToPointerMap<PsnReferenceObjectHandle>::iterator pTab;
//    int ret;  
//    int minor;
//    int freq;
//  #ifndef _SPROC
//    pthread_attr_t attributs_pthread;
//  #endif
//    PsnControlLocal *controleur=(PsnControlLocal *)controleurv;
//  #ifndef _SPROC
//    ret=pthread_attr_init(&attributs_pthread);
//    if (ret) {
//      perror("PsnControlLocal : Thread_controleur : impossible d'initialiser les attributs du thread");
//    } 
//    ret=pthread_attr_setscope(&attributs_pthread, PTHREAD_SCOPE_SYSTEM);
//    if (ret) {
//      perror("PsnControlLocal : Thread_controleur : Impossible de créer des threads system");
//    }
//  #endif
//      /* 
//       * Creation du frs controleur maitre
//       * cpu = 1
//       * source d'interruption = CCTIMER
//       * nb de minor frames = nbminor
//       * frs esclaves : aucun
//       * period = _stepPeriod [ms]
//       */
//    cout<<"PsnControlLocal : Thread_controleur : params de frs create master "<<controleur->_stepPeriod*1000<<" et "<<controleur->nbMinor<<endl;
//    controleur->frs = frs_create_master(3,     //numero du CPU de APP (le frame sheduler)
//                                    FRS_INTRSOURCE_CCTIMER,
//                                    controleur->_stepPeriod*1000,
//                                    controleur->nbMinor,
//                                    0);
//    if(controleur->frs==NULL) {
//      perror("PsnControlLocal : ThreadControleur : impossible de creer le frs");
//      exit(0);
//    }
//    cout <<"PsnControlLocal : Thread_controleur : frame scheduler crée"<<endl;


//  #ifdef _SPROC
//    controleur->id_thread_time=sproc(Thread_Time,PR_SALL,(void *) controleur);
//    if(controleur->id_thread_time==-1) {
//      controleur->finFrs();
//      perror("PsnControlLocal :: Thread_Controleur :: Impossible de creer le thread time");
//      exit(0);
//    }  
//  #ifdef _DEBUG
//    cout <<"PsnControlLocal : Thread_controleur : thread time crée "<<endl;
//  #endif
//    for(minor=0;minor<controleur->nbMinor;minor++) {
//      ret=frs_enqueue(controleur->frs,
//                  controleur->id_thread_time,
//                  minor,
//                  FRS_DISC_RT);
//      //cout<<"PsnControlLocal : Thread_controleur : mise en file Thread_Time"<<endl;
//      if (ret) {
//        perror("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread time dans la file d'execution");
//        exit(0);
//      }
//    }
//  #else
//    //creation du thread Thread_time pour la gestion du temps
//    ret=pthread_create(&(controleur->id_pthread_time),
//                   &attributs_pthread,
//                   Thread_Time,
//                   (void *) controleur);
//    if (ret) {
//      perror("PsnControlLocal : Thread_controleur : Impossible de creer le Thread Time");
//      pthread_exit(0);
//    }
//  #ifdef _DEBUG
//    cout <<"PsnControlLocal : Thread_controleur : thread time crée "<<endl;
//  #endif
//    //placement de ce thread en tête de toutes les files d'exécution
//    for(minor=0;minor<controleur->nbMinor;minor++) {
//      ret=frs_pthread_enqueue(controleur->frs,
//                          controleur->id_pthread_time,
//                          minor,
//                          FRS_DISC_RT);
//      //cout<<"PsnControlLocal : Thread_controleur : mise en file Thread_Time"<<endl;
//      if (ret) {
//        perror("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread time dans la file d'execution");
//        pthread_exit(0);
//      }
//    }
//  #endif
//    //creation du thread Thread_fin gérant la fin de la simulation
//  #ifdef _SPROC
//    controleur->id_thread_fin=sproc(Thread_Fin,PR_SALL,(void *) controleur);
//    if(controleur->id_thread_fin==-1) {
//      controleur->finFrs();
//      perror("PsnControlLocal : Thread_controleur : creation du Thread_Fin impossible");
//      frs_abort(1);
//    }
//  #ifdef _DEBUG
//    cout <<"PsnControlLocal : Thread_controleur : thread fin crée avec l'id "<<controleur->id_thread_controleur<<endl;
//  #endif
//    //placement de ce thread un fois par frame majeure
//    //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;
//    for(minor=0;minor<controleur->nbMinor-1;minor++) {
//      ret=frs_enqueue(controleur->frs,
//                  controleur->id_thread_fin,
//                  minor,
//                  disc);
//      if (ret) {
//        controleur->finFrs();
//        perror("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread fin dans la file d'execution");
//        exit(0);
//      }
//    }
//    ret=frs_enqueue(controleur->frs,
//                controleur->id_thread_fin,
//                controleur->nbMinor-1,
//                FRS_DISC_RT);
//    //cout<<"PsnControlLocal : Thread_controleur : mise en file Thread_Fin rt"<<endl;
//    if (ret) {
//      controleur->finFrs();
//      perror("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread_Fin dans la file d'execution");
//      exit(0);
//    }
//  #else
//    ret=pthread_create(&(controleur->id_pthread_fin),
//                   &attributs_pthread,
//                   Thread_Fin,
//     (void *) controleur);
//    if(ret) {
//      error("PsnControlLocal : Thread_controleur : creation du Thread_Fin impossible");
//      frs_abort(1);
//    }
//  #ifdef _DEBUG
//    cout <<"PsnControlLocal : Thread_controleur : thread fin crée avec l'id "<<id_pthread<<endl;
//  #endif
//    //placement de ce thread un fois par frame majeure
//    //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;
//    for(minor=0;minor<controleur->nbMinor-1;minor++) {
//      ret=frs_pthread_enqueue(controleur->frs,
//                          controleur->id_pthread_fin,
//                          minor,
//                          disc);
//      //      cout<<"PsnControlLocal : Thread_controleur : mise en file Thread_fin  disc"<<endl;
//      if (ret) {
//        error("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread fin dans la file d'execution");
//        pthread_exit(0);
//      }
//    }
//    ret=frs_pthread_enqueue(controleur->frs,
//                        controleur->id_pthread_fin,
//                        controleur->nbMinor-1,
//                        FRS_DISC_RT);
//    //cout<<"PsnControlLocal : Thread_controleur : mise en file Thread_Fin rt"<<endl;
//    if (ret) {
//      error("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread_Fin dans la file d'execution");
//      pthread_exit(0);
//    }
//  #endif  
//    //pour tous les modules, creation du thread et placement sur les files d'éxécution.
//    for (pTab= controleur->_referenceObjectsMap.begin(); pTab!= controleur->_referenceObjectsMap.end(); pTab++)
//    {
//      cout<<"Mise en file de : "<<(*pTab).second->objetSimul()->Nom().getCString()<<endl;
//  #ifdef _SPROC
//      (*pTab).second->objetSimul()->id_thread_calcul=sproc((*pTab).second->objetSimul()->Start_Thread,
//                                                       PR_SALL,
//                                                       (void *) (*pTab).second->objetSimul());
//      if((*pTab).second->objetSimul()->id_thread_calcul == -1) {
//        error("PsnControlLocal : Thread_controleur : creation d'un Thread calcul impossible");
//        frs_abort(1);
//      }
//      freq=(*pTab).second->objetSimul()->getObjectDescriptor().Frequency();
//      int nbExecParMajor=int(controleur->_stepFrequency/freq);
//      for(minor=0;minor<controleur->nbMinor;minor++) {
//        if (minor%nbExecParMajor==nbExecParMajor-1) {//il faut une execution temps réel
//      ret=frs_enqueue(controleur->frs,
//                      (*pTab).second->objetSimul()->id_thread_calcul,
//                      minor,
//                      FRS_DISC_RT);
//      //cout<<"PsnContrlLocal mise en file calcul rt"<<endl;
//      if (ret) {
//        error("Impossible de mettre un Thread calcul dans la file d'execution");
//        exit(0);
//      }
//        }
//        else {
//      ret=frs_enqueue(controleur->frs,
//                      (*pTab).second->objetSimul()->id_thread_calcul,
//                      minor,
//                      disc);
//      //cout<<"PsnControlLocal : Thread_controleur : mise en file calcul disc"<<endl;
//              if (ret) {
//        error("Impossible de mettre un Thread calcul dans la file d'execution");
//        exit(0);
//      }//if (ret)
//        }//else
//      }//for minor
//  #else
//      ret=pthread_create(&((*pTab).second->objetSimul()->id_pthread_calcul),
//                     &attributs_pthread,
//                         (*pTab).second->objetSimul()->Start_Thread,
//                         (void *) (*pTab).second->objetSimul());

//      if(ret) {
//        error("PsnControlLocal : Thread_controleur : creation d'un Thread calcul impossible");
//        frs_abort(1);
//      }
//      freq=(*pTab).second->objetSimul()->getObjectDescriptor().Frequency();
//      int nbExecParMajor=int(controleur->_stepFrequency/freq);
//      for(minor=0;minor<controleur->nbMinor;minor++) {
//        if (minor%nbExecParMajor==nbExecParMajor-1) {//il faut une execution temps réel
//      ret=frs_pthread_enqueue(controleur->frs,
//                              (*pTab).second->objetSimul()->id_pthread_calcul,
//                              minor,
//                              FRS_DISC_RT);
//      //cout<<"PsnContrlLocal mise en file calcul rt"<<endl;
//      if (ret) {
//        error("Impossible de mettre un Thread calcul dans la file d'execution");
//        pthread_exit(0);
//      }
//        }
//        else {
//      ret=frs_pthread_enqueue(controleur->frs,
//                              (*pTab).second->objetSimul()->id_pthread_calcul,
//                              minor,
//                              disc);
//      //cout<<"PsnControlLocal : Thread_controleur : mise en file calcul disc"<<endl;
//              if (ret) {
//        error("Impossible de mettre un Thread calcul dans la file d'execution");
//        pthread_exit(0);
//      }//if (ret)
//        }//else
//      }//for minor
//  #endif
//    }//for tous les objets de simulation
//  #ifdef _PSGUI1
//  #ifdef _SPROC
//    controleur->id_thread_gui=sproc(Thread_Gui,PR_SALL,(void *) controleur);
//    if(controleur->id_thread_gui==-1) {
//      controleur->finFrs();
//      perror("PsnControlLocal :: Thread_Controleur :: Impossible de creer le thread gui");
//      exit(0);
//    }  
//  #ifdef _DEBUG
//    cout <<"PsnControlLocal : Thread_controleur : thread gui crée "<<endl;
//  #endif
//  //    for(minor=0;minor<controleur->nbMinor;minor++) {
//  //      ret=frs_enqueue(controleur->frs,
//  //                      controleur->id_thread_gui,
//  //                      minor,
//  //                      FRS_DISC_BACKGROUND);
//  //      //cout<<"PsnControlLocal : Thread_controleur : mise en file Thread_Time"<<endl;
//  //      if (ret) {
//  //        perror("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread time dans la file d'execution");
//  //        exit(0);
//  //      }
//  //    }
//  #else
//    //creation du thread Thread_time pour la gestion du temps
//    ret=pthread_create(&(controleur->id_pthread_gui),
//                   &attributs_pthread,
//                   Thread_Gui,
//                   (void *) controleur);
//    if (ret) {
//      perror("PsnControlLocal : Thread_controleur : Impossible de creer le Thread Time");
//      pthread_exit(0);
//    }
//  #ifdef _DEBUG
//    cout <<"PsnControlLocal : Thread_controleur : thread gui crée "<<endl;
//  #endif
//    ///On ne place pas ce thread sur le frame scheduler pour qu'il puisse l'arreter et surtout pour le redémarrer. D'où commentaire des 14 lignes suivantes.

//  //placement de ce thread en tête de toutes les files d'exécution
//  //    for(minor=0;minor<controleur->nbMinor;minor++) {
//  //      ret=frs_pthread_enqueue(controleur->frs,
//  //                              controleur->id_pthread_gui,
//  //                              minor,
//  //                              FRS_DISC_BACKGROUND);
//  //      //cout<<"PsnControlLocal : Thread_controleur : mise en file Thread_Time"<<endl;
//  //      if (ret) {
//  //        perror("PsnControlLocal : Thread_controleur : Impossible de mettre le Thread gui dans la file d'execution");
//  //        pthread_exit(0);
//  //      }
//  //    }
//  #endif //creation du controleur de gui
//  #endif


//    //on démarre le frs
//  #ifdef _DEBUG
//    cout<<"PsnControlLocal : Thread_controleur : synchro normale de mise en file"<<endl;
//  #endif
//    controleur->bar->Sync();
//    cout<<"frame scheduler running\n";
//    if (frs_start(controleur->frs)<0) {
//      perror("PsnControlLocal : Thread_controleur : démarrage du frs impossible ");
//      exit(0);
//    }
//  #ifdef _SPROC
//    wait(&ret); 
//    cout <<"PsnControlLocal :: Tread_controleur :: on n'attend rien"<<endl; 
//    if (ret == -1) {
//      perror("PsnControlLocal :: Thread_controleur :: impossible d'attendre la fin de tous les fils");
//    }
//    wait(&ret); 
//    if (ret == -1) {
//      perror("PsnControlLocal :: Thread_controleur :: impossible d'attendre la fin de tous les fils");
//    }
//    for (pTab= controleur->_referenceObjectsMap.begin(); pTab!= controleur->_referenceObjectsMap.end(); pTab++) {
//      wait(&ret);  
//      if (ret == -1) {
//        perror("PsnControlLocal :: Thread_controleur :: impossible d'attendre la fin de tous les fils");
//      }
//      cout <<"fini\n";
//    }
//    exit(0);
//  #else
//    if (ret=pthread_join(controleur->id_pthread_fin,0)) {
//      error("PsnControlLocal : thread_controleur : join thread_fin failed");
//    }
//    if (ret=pthread_join(controleur->id_pthread_time,0)) {
//      error("PsnControlLocal : thread_controleur : join thread_time failed");
//    }
//    for (pTab= controleur->_referenceObjectsMap.begin(); pTab!= controleur->_referenceObjectsMap.end(); pTab++) {
//      if (ret=pthread_join((*pTab).second->objetSimul()->id_pthread_calcul,0)) {
//        error("PsnControlLocal : thread_controleur : join des threads_calcul impossible");
//      }
//      cout <<"fini\n";
//    }
//    pthread_exit(0);
//    return((void *)controleur);
//  #endif    
//  }//Thread_Controleur

//  // Le corps du thread chargé de gérer la date de la simulation.
//  // Ce thread doit être le premier à être exécuté dans chaque minor frame sur chaque Frame scheduler
//  #ifdef _SPROC
//  void PsnControlLocal::Thread_Time(void *controleurv) {
//  #else
//  void *PsnControlLocal::Thread_Time(void *controleurv) {
//  #endif
//    int previous_minor; //permet de controler la réussite de frs_yield
//    int localfin=TRUE;
//    PsnControlLocal *controleur=(PsnControlLocal *)controleurv;
//    //On attend que tous les threads soient dans la file d'execution
//  #ifdef _DEBUG
//    cout<<"Thread Time :: synchronisation normale"<<endl;
//  #endif
//    controleur->bar->Sync(); 
//   //On signale au frs qu'on est prêt
//    if(frs_join(controleur->frs) < 0) {
//      //si on arrive jusqu'ici, c'est mal parti
//      perror("PsnControlLocal : Thread_time : pas réussi à joindre le Frame Scheduler");
//      quitterThread(0);
//    }
//    do { //à chaque pas de simulation, compute la date.
//  #ifdef _DEBUG
//      cout<<"calcul du temps"<<endl;
//  #endif
//      controleur->_numberOfSimulatedSteps++;
//      controleur->date=controleur->date + controleur->dt;  
//      previous_minor=frs_yield();
//      if(previous_minor<0)  {
//        //on revient de cet appel de procedure seulement au prochain pas de simulation 
//        if(!fin) {
//      perror("PsnControlLocal : Thread_time : frs_yield() a échoué");
//      quitterThread(0);
//        }
//      }
//      if (fin) localfin=FALSE;
//    } while(localfin);
//  #ifdef _DEBUG
//    cout<<"Output du thread time"<<endl;
//  #endif
//    quitterThread(0);
//  #ifndef _SPROC
//    return (controleur); //ça evite des warnings
//  #endif
//  }


//   //Le thread charge de gérer la gui si elle existe
//  #ifdef _SPROC
//   void PsnControlLocal::Thread_Gui(void *controleurv) {
//  #else
//   void *PsnControlLocal::Thread_Gui(void *controleurv) {
//  #endif
//  #ifdef _PSGUI1
//     int previous_minor;
//    PsnControlLocal *controleur=(PsnControlLocal *)controleurv;
//    //on attend que tous les threads soient dans leurs files d'execution
//    controleur->bar->Sync();

//    //on se join au frame scheduler (cette stratégie est discutable)
//  //    if(frs_join(controleur->frs) < 0) {
//  //      //si on arrive jusqu'ici, c'est mal parti
//  //      cout<<"PsnControlLocal : Thread_Gui : pas réussi à joindre le Frame Scheduler : je continue en solo"<<endl;
//  //    }
//    do {
//  //      if((previous_minor=frs_yield())<0)  {    
//  //        //on revient de cet appel de procedure seulement au prochain pas de simulation 
//  //        perror("PsnControlLocal : Thread_Gui : frs_yield() a échoué");
//  //      }
//      // gestion des demandes de l'utilisateur au niveau controle
//      controleur->computeNextSimulationStepGUI(); //anc :exec_GUI();
//      controleur->runUserInterface();
//    } while(!(fin&&controleur->fini));
//    fin=TRUE;
  
//  #ifndef _SPROC
//    return((void *)controleur);
//  #endif
//  #endif //de _PSGUI1  
//  }

//  // Le thread charge de gérer la terminaison.
//  #ifdef _SPROC
//  void PsnControlLocal::Thread_Fin(void *controleurv) {
//  #else
//  void *PsnControlLocal::Thread_Fin(void *controleurv) {
//  #endif
//    int previous_minor;  //permet de controler la réussite de frs_yield
//    PsnControlLocal *controleur=(PsnControlLocal *)controleurv;
//    //on attend que tous les threads soient dans la file d'execution
//  #ifdef _DEBUG
//    cout<<"synchronisation normale pour le thread_Fin"<<endl;
//  #endif
//    controleur->bar->Sync();
//    //cout<<"PsnControlLocal : Thread_Fin avant join"<<endl;
//    if(frs_join(controleur->frs) < 0) {
//      //si on arrive jusqu'ici, c'est mal parti
//      error("PsnControlLocal : Thread_Fin : pas réussi à joindre le Frame Scheduler");
//      frs_destroy(controleur->frs);
//      exit(0);//seul lui peut arreter : si il plante il faut tout arreter avant que ce soit impossible
//    }
//    do {
//  #ifdef _DEBUG
//      cout<<"controle de la fin"<<endl;
//  #endif
//      previous_minor=frs_yield();
//      if(previous_minor<0)  {    
//        //on revient de cet appel de procedure seulement au prochain pas de simulation 
//        perror("PsnControlLocal : Thread_Fin : frs_yield() a échoué");
//        exit(0);//seul lui peut arreter : si il plante il faut tout arreter
//      }
//      if (controleur->fini) {fin=TRUE;};
//    } while(!fin);
//    //arrivé ici, il faut terminer la simulation...  
//    cout<<"PsnControlLocal : Thread_fin : on termine la simulation"<<endl;
//    frs_stop(controleur->frs);
//    frs_destroy(controleur->frs);
//    controleur->Output();
//    quitterThread(0);
//  #ifndef _SPROC
//    return((void *)controleur);
//  #endif
//  }



#endif

---