condition.c

Aller à la documentation de ce fichier.

 
#include <manux/condition.h>
#include <manux/memoire.h>   // NULL
#include <manux/debug.h>     // assert
#if defined(MANUX_CONDITION_AUDIT) && defined(MANUX_KMALLOC)
#   include <manux/kmalloc.h>
#   include <manux/listetaches.h>
#endif
 
#if defined(MANUX_CONDITION_AUDIT) && defined(MANUX_KMALLOC)
 
typedef struct _CelluleCondition {
   Condition                * condition;
   struct _CelluleCondition * suivant;
} CelluleCondition;
  
typedef struct _ListeConditions {
   CelluleCondition * tete;
   CelluleCondition * queue;
} ListeConditions;
 
static
ListeConditions * listeConditionsCreer(void)
{
   ListeConditions * result;
 
   result = (ListeConditions *) kmalloc(sizeof(ListeConditions));
 
   result->tete = NULL;
   result->queue = NULL;
 
   return result;
}
 
static
void listeConditionsInserer(ListeConditions * l, Condition * c)
{
   CelluleCondition * cell = (CelluleCondition *) kmalloc(sizeof(CelluleCondition));
   
   assert(l != NULL);
   assert(c != NULL);
 
   if (cell != NULL) {
      cell->condition = c;
      cell->suivant = NULL;
      if (l->queue != NULL) {
         l->queue->suivant = cell;
      }
      l->queue = cell;
      if (l->tete  == NULL) {
    l->tete = cell;
      }
   }
}
 
static ListeConditions * listeConditions = NULL;
 
void conditionsAfficherEtat(void)
{
   CelluleCondition * cell;
   CelluleTache * cellT;
 
   printk("\nEtat des variables de condition sur le systeme :\n\n");
   printk("Cond    |    s |    d | Attente\n");
   printk("--------+------+------+--------\n");
 
   if (listeConditions != NULL) {
      for (cell = listeConditions->tete; cell != NULL; cell = cell->suivant){
         printk("0x%x | %4d | %4d | ",
        cell->condition,
        cell->condition->nbSignaler,
        cell->condition->nbDiffuser);
         for (cellT = cell->condition->tachesEnAttente.tete ;
          cellT != NULL; cellT = cellT->suivant){
            printk("%d ", cellT->tache->numero);
         }
         printk("\n");
      }
   }
   printk("--------+------+------+--------\n");
}
 
#endif //  defined(MANUX_CONDITION_AUDIT) && defined(MANUX_KMALLOC)
 
 
void conditionInitialiser(Condition * cond)
{
   initialiserListeTache((&cond->tachesEnAttente));
 
#if defined(MANUX_CONDITION_AUDIT)
   cond->nbSignaler = 0;
   cond->nbDiffuser = 0;
 
   if (listeConditions == NULL) {
      listeConditions = listeConditionsCreer();
   }
   if (listeConditions != NULL) {
      listeConditionsInserer(listeConditions, cond);
   }
#endif
}
 
void conditionAttendre(Condition * cond, ExclusionMutuelle * em)
{
   // On se place dans la liste des tâches en attente de la condition
   // que l'on peut manipuler sans risque car on est protégé par
   // l'exclusion mutuelle 
   insererCelluleTache(&(cond->tachesEnAttente),
                       tacheEnCours,
                       (CelluleTache*)tacheEnCours+sizeof(Tache));
   
   // On doit libérer l'exclusion mutuelle et se placer dans l'état
   // bloqué, on va se rendre non préemptible pour faire ça afin de ne
   // pas se retrouvée bloquée après avoir été préemptée par une tâche
   // qui signale la condition !
   tacheEnCoursInterdirePreemption();
   
   exclusionMutuelleSortir(em);
   tacheEnCours->etat = Tache_Bloquee;
   
   tacheEnCoursAutoriserPreemption();
 
   // On est bloquée et préemptible, on peut rendre la main
   ordonnanceur();
 
   // Il nous faut ré-acquérir l'exclusion mutuelle
   exclusionMutuelleEntrer(em);
}
 
void conditionSignaler(Condition * cond)
{
   Tache * ta;
 
   // Si on trouve une tâche en attente de cette condition
   // on la réveille.
   if ((ta = extraireTache(&(cond->tachesEnAttente))) != NULL) {
      ta->etat = Tache_Prete;
      insererCelluleTache(&listeTachesPretes,
                          ta,
                          (CelluleTache*)ta+sizeof(Tache));
   }
#if defined(MANUX_CONDITION_AUDIT)
   cond->nbSignaler++;
#endif
}
 
void conditionDiffuser(Condition * cond)
{
   Tache * ta;
 
   // Si on trouve une tâche en attente de cette condition
   // on la réveille.
   while ((ta = extraireTache(&(cond->tachesEnAttente))) != NULL) {
      ta->etat = Tache_Prete;
      insererCelluleTache(&listeTachesPretes,
                          ta,
                          (CelluleTache*)ta+sizeof(Tache));
   }
#if defined(MANUX_CONDITION_AUDIT)
   cond->nbDiffuser++;
#endif
}