Page principale   Liste par ordre alphabétique   Liste des composants   Liste des fichiers   Composants   Déclarations  

fifo.c

Aller à la documentation de ce fichier.
00001 /**
00002  * \file fifo.c
00003  * Source definissant toutes les fonctions utiles pour manipuler une pile FIFO.
00004  * Et notament pour gerer la liste de processus actifs et l'ordonnancement de leur execution.
00005  */
00006 #include "fifo.h"
00007 
00008 /**************************************************************************************
00009  Entierement fait par Martin Ludovic
00010 **************************************************************************************/
00011 
00012 /**
00013  * Initialise une pile
00014  * \param liste : la pile a initialiser
00015  * \return rien
00016  */
00017 void liste_init (l_fifo* liste) {
00018   liste->tete = NULL;
00019 }
00020 
00021 /**
00022  * Ajoute un nouveau processus a la pile
00023  * \param liste : la pile ds laquelle il faut ajouter un processus
00024  * \param pid : le num du processus a ajouter
00025  * \return rien
00026  */
00027 void liste_add_pid (l_fifo* liste, int pid) {
00028   struct cellule *p_cel; 
00029   struct cellule *p_tmp; 
00030 
00031   // Initialisation de la cellule
00032   p_cel = malloc(sizeof(struct cellule));
00033   p_cel->pid = pid;
00034   p_cel->temps = 0;
00035   p_cel->suivant = NULL;
00036   // Cas de la liste vide
00037   if (liste->tete == NULL) {
00038     liste->tete = p_cel;
00039   }
00040   else { // Liste non vide
00041     p_tmp = liste->tete;
00042     while (p_tmp->suivant) {
00043       p_tmp = p_tmp->suivant;
00044     }
00045     p_tmp->suivant = p_cel;
00046   }
00047 }
00048 
00049 /**
00050  * Retourne le num du processus dont il faut executer une instruction
00051  * \param liste : la pile contenant la liste des proc en cour d'exec
00052  * \return
00053  * - -1 en cas de pile vide
00054  * - le num du processus sinon
00055  */
00056 int liste_next_pid (l_fifo* liste){
00057   struct cellule *p_tmp; 
00058 
00059   // Cas de la liste vide
00060   if (liste->tete == NULL) {
00061     fprintf(stderr,"Impossible de determiner le num du prochain processus : la liste est vide\n");
00062     return -1;
00063   }
00064   else{
00065     // Un processus passe la main
00066     if (liste->tete->temps >= quantum) {
00067       liste->tete->temps = 0;
00068       p_tmp = liste->tete;
00069       while (p_tmp->suivant) {
00070         p_tmp = p_tmp->suivant;
00071       }
00072       p_tmp->suivant = liste->tete;
00073       liste->tete = liste->tete->suivant;
00074       p_tmp->suivant->suivant = NULL;
00075     }
00076     liste->tete->temps ++;
00077     return liste->tete->pid;
00078   }
00079 }
00080 
00081 /**
00082  * Supprime un processus de la pile
00083  * \param liste : la pile contenant la liste des proc en cour d'exec
00084  * \param pid : le num du processus a supprimer
00085  * \return 
00086  * - -1 en cas de pile vide
00087  * - -2 si il n'y a pas de processus de num pid
00088  * -  0 sinon
00089  */
00090 int liste_supp_pid (l_fifo* liste, int pid) {
00091   struct cellule *p_tmp; 
00092   struct cellule *p_clr; 
00093 
00094   // Cas de la liste vide
00095   if (liste->tete == NULL) {
00096     fprintf(stderr,"Impossible de supprimer un element d'une liste vide\n");
00097     return -1;
00098   }
00099   else{
00100     if (liste->tete->pid == pid) {
00101       p_clr = liste->tete;
00102       liste->tete =  liste->tete->suivant;
00103       free (p_clr);
00104       return 0;
00105     }
00106     p_tmp = liste->tete;
00107     while (p_tmp->suivant) {
00108       if (p_tmp->suivant->pid == pid) {
00109         p_clr = p_tmp->suivant;
00110         p_tmp->suivant = p_tmp->suivant->suivant;
00111         free(p_clr);
00112         return 0;
00113       }
00114       p_tmp = p_tmp->suivant;
00115     }
00116     return -2; // Le processus n'a pas ete trouve
00117   }
00118 }    
00119 
00120 /**
00121  * Ajoute une nouvelle page a la pile.
00122  * \param liste : la pile ds laquelle il faut ajouter une page
00123  * \param page : le num de la page a ajouter
00124  * \return rien
00125  */
00126 void liste_add_page (l_fifo* liste, int page) {
00127   struct cellule *p_cel; 
00128   struct cellule *p_tmp; 
00129 
00130   // Initialisation de la cellule
00131   p_cel = malloc(sizeof(struct cellule));
00132   p_cel->page = page;
00133   p_cel->suivant = NULL;
00134   // Cas de la liste vide
00135   if (liste->tete == NULL) {
00136     liste->tete = p_cel;
00137   }
00138   else { // Liste non vide
00139     p_tmp = liste->tete;
00140     while (p_tmp->suivant) {
00141       p_tmp = p_tmp->suivant;
00142     }
00143     p_tmp->suivant = p_cel;
00144   }
00145 }
00146 
00147 /**
00148  * Retourne le num de la plus vielle page
00149  * \param liste : la pile contenant la liste des pages physiques de la  memoire principale
00150  * \return
00151  * - -1 en cas d'erreur
00152  * - Le num de la plus vielle page
00153  */
00154 int liste_old_page (l_fifo* liste) {
00155   // Cas de la liste vide
00156   if (liste->tete == NULL) {
00157     fprintf(stderr,"Impossible de determiner le num de la plus vielle page : la liste est vide\n");
00158     return -1;
00159   }
00160   else // Liste non vide
00161     return liste->tete->page;
00162 }
00163 
00164 /**
00165  * Quand on accede a une page, elle devient la page la plus 'jeune'. Cette fonction permet 
00166  * d'actualiser l'age de cette page. En fait, on deplace cette page au fond de la pile.
00167  * \param liste : la pile contenant la liste des pages physiques de la  memoire principale
00168  * \param page : le num de la page a deplacer
00169  * \return 
00170  * - -1 en cas de pile vide
00171  * - -2 si il n'y a pas de page de num page
00172  * -  0 sinon
00173  */
00174 int liste_acces_page (l_fifo* liste, int page) {
00175   switch (liste_supp_page(liste,page)) {
00176   case -1:
00177     return -1;
00178   case -2:
00179     return -2;
00180   default:
00181     // La page 'page' a ete trouvee et supprimee
00182     // Il faut la rajouter a la fin de la liste
00183     liste_add_page(liste,page);
00184     return 0;
00185   }
00186 }
00187 
00188 /**
00189  * Supprime une page de la pile.
00190  * \param liste : la pile contenant la liste des pages physiques de la  memoire principale
00191  * \param page : le num de la page a supprimer
00192  * \return 
00193  * - -1 en cas de pile vide
00194  * - -2 si il n'y a pas de page de num page
00195  * -  0 sinon
00196  */
00197 int liste_supp_page (l_fifo* liste, int page) {
00198   struct cellule *p_tmp; 
00199   struct cellule *p_clr; 
00200 
00201   if (liste->tete == NULL) {  // Cas de la liste vide
00202     fprintf(stderr,"Impossible de supprimer un element d'une liste vide\n");
00203     return -1;
00204   }
00205   if (liste->tete->page == page) {
00206     p_clr = liste->tete;
00207     liste->tete =  liste->tete->suivant;
00208     free (p_clr);
00209     return 0;
00210   }
00211   p_tmp = liste->tete;
00212   while (p_tmp->suivant) {
00213     if (p_tmp->suivant->page == page) {
00214       p_clr = p_tmp->suivant;
00215       p_tmp->suivant = p_tmp->suivant->suivant;
00216       free(p_clr);
00217       return 0;
00218     }
00219     p_tmp = p_tmp->suivant;
00220   }
00221   return -2; // La page n'a pas ete trouvee
00222 }
00223 
00224 /**
00225  * Retourne la taille de la liste
00226  * \param liste : la pile contenant la liste des proc en cour d'execution
00227  * \return 
00228  * La taille de la liste
00229  */
00230 int liste_taille (l_fifo* liste) {
00231   struct cellule *p_tmp; 
00232   int taille;
00233 
00234   taille = 0;
00235   p_tmp = liste->tete;
00236   while (p_tmp != NULL) {
00237     taille ++;
00238     p_tmp = p_tmp->suivant;
00239   }
00240   return taille;
00241 }
00242 
00243 /**
00244  * Retourne un tableau d'entiers representant la liste des processus en cours d'utilisation
00245  * \param liste : la pile contenant la liste des proc en cour d'execution
00246  * \return 
00247  * Un pointeur sur un tableau d'entiers representant la liste passee en parametre.
00248  */
00249 int *liste_enum_pid (l_fifo* liste) {
00250   struct cellule *p_tmp; 
00251   int * tab;
00252   int taille;
00253   int i;
00254 
00255   taille = liste_taille(liste);
00256   tab = malloc(taille * sizeof(int));
00257   p_tmp = liste->tete;
00258   for (i=0 ; i<taille ; i++) {
00259     tab[i] = p_tmp->pid;
00260     p_tmp = p_tmp->suivant;
00261   }
00262   return tab;
00263 }

Généré le Sun Sep 29 22:47:21 2002 pour KSInu par doxygen1.2.16