SCHEDULER RR FIFO

/*
  Université des sciences et de la technologie Houari Boumadiane(USTHB)                   
  Faculté d'Electronique & d'Informatique                                            
  Département informatique                                                                                 
  Spécialité : Master 1 Réseaux et système distribués
  Module : Système d'exploitation                                                   
  Auteur: ZERROUKI Boualam
  Date: 01/11/2011 00:00
  Description : Simulation de deux politiques 
                d'ordonnancements à savoir 
                FIFO et RR. 
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

/*Définition de pcb.*/
typedef struct element 
         {
              char *nomProcessus;
	          int pid;
	          int tempsArriver;
	          int tempsExecution;
	          int saveTempsExecution;
	          char *etatProcessus;
	      
              struct element *suivant;
         } pcb;
         
/*Fonctions de manupilation des processus*/         
void ajouterProcessus(pcb**,pcb**);	 
void triProcessus(pcb*);
void afficherProcessus(pcb*);
void modifierProcessus(pcb*,int);
void etatBloquerProcessus(pcb**,pcb**);
void fifoProcessus(pcb**,pcb**);
void rrProcessus(pcb**,pcb**,int);

/*Debut main*/
int main(void)
{  
 
  printf("                 *----------------------*\n");
  printf("                 *                      *\n");
  printf("                 *     ORDONNANCEUR     *\n");
  printf("                 *      FIFO && RR      *\n");
  printf("                 *                      *\n");
  printf("                 *----------------------*\n\n");
  
  printf("Construction de la file d'attente des processus prets.\n\n");
  
  pcb *tete=NULL,*queue=NULL,*p=NULL;
  char nMenu;

  int bool0=1,pid,quantum;
  char ouiNon;
  while(bool0 == 1)
  {
     ajouterProcessus(&tete,&queue);
     printf("\nVous voulez ajouter un processus dans la file d'attente pret (o/n) : ");scanf("%s",&ouiNon);;
     if( ouiNon != 'o' )bool0=0;
     printf("\n");        
  }
  
  printf("*----------------------*\n");
  printf("*                      *\n");
  printf("*  Menu :              *\n");
  printf("*                      *\n");
  printf("*    1 Modifier un prc *\n");
  printf("*    2 Affichage prc   *\n");
  printf("*    3 FIFO            *\n");
  printf("*    4 RR              *\n");
  printf("*    5 Quitter         *\n");
  printf("*                      *\n");
  printf("*----------------------*\n");
  
  m :
  printf("\n\nEntrez un numero de menu : ");scanf("%s",&nMenu);
  switch(nMenu)
  {
          case '1' : goto a;
                     break;
          case '2' : goto b;
                     break;
          case '3' : goto c;
                     break;
          case '4' : goto d;
                     break;
          case '5' : goto e;
                     break;
          default : printf("\nVous avez pas introduit un numero de menu...");
                    goto m;
  }
  
  a :
                  printf("\nEntrez le pid de processus que vous voulez modifier : ");scanf("%d",&pid);
                  printf("\n");
                  modifierProcessus(tete,pid);
                  goto m;
  b :
                  afficherProcessus(tete);
                  goto m;
  c:
                  fifoProcessus(&tete,&queue);
                  goto e;
  d :
                  printf("Entrez le quantum : ");scanf("%d",&quantum);
                  rrProcessus(&tete,&queue,quantum);
                  goto e;
  e :             
  return 0;
}
/*Fin main*/

/*Fonction pour ajouter les processus arrivent à la file d'attente des processus prêts*/
void ajouterProcessus(pcb**tete,pcb**queue)
{
     pcb *p;
     char nomProcessus[30],etatProcessus[30];
     
     p=(pcb*)malloc(sizeof(pcb));
     printf("Entrez le nom du processus : ");scanf("%s",nomProcessus);
     p->nomProcessus=(char*)malloc((strlen(nomProcessus)+1)*sizeof(char));
     strcpy(p->nomProcessus,nomProcessus);
     printf("Entrez le pid du processus : ");scanf("%d",&p->pid);
     printf("Entrez le temps d'arriver du processus : ");scanf("%d",&p->tempsArriver);
     printf("Entrez le temps d'execution du processus : ");scanf("%d",&p->tempsExecution);
     p->saveTempsExecution=p->tempsExecution;
     printf("Entrez l'etat du processus : ");scanf("%s",etatProcessus);
     p->etatProcessus=(char*)malloc((strlen(etatProcessus)+1)*sizeof(char));
     strcpy(p->etatProcessus,etatProcessus);
     p->suivant = NULL;
     
     if(*tete==NULL)*tete=p;
     else (*queue)->suivant=p;
     *queue=p;
}     
/*Fonction pour trier les processus selon le temps d'arrivé*/     
void triProcessus(pcb *tete)
{
  pcb *p;
  char *x1,*x5;
  int  i,x2,x3,x4,x6;
 
  i=0;
  while(i==0)
  {
        i=1;       
        for(p=tete;p->suivant!=NULL;p=p->suivant)
               if((p->tempsArriver)>(p->suivant->tempsArriver))
               {
                     x1=p->nomProcessus;
                     p->nomProcessus=p->suivant->nomProcessus;
                     p->suivant->nomProcessus=x1;
		     
		             x2=p->pid;
                     p->pid=p->suivant->pid;
                     p->suivant->pid=x2;
		     
		             x3=p->tempsArriver;
                     p->tempsArriver=p->suivant->tempsArriver;
                     p->suivant->tempsArriver=x3;
		     
		             x4=p->tempsExecution;
                     p->tempsExecution=p->suivant->tempsExecution;
                     p->suivant->tempsExecution=x4;
                     
                     x6=p->saveTempsExecution;
                     p->saveTempsExecution=p->suivant->saveTempsExecution;
                     p->suivant->saveTempsExecution=x6;
		     
		             x5=p->etatProcessus;
                     p->etatProcessus=p->suivant->etatProcessus;
                     p->suivant->etatProcessus=x5;
		     
                     i=0;
               }
   }
}

/*Fontion pour afficher les processus de la file d'attente prêt*/
void afficherProcessus(pcb *tete)
{   
  pcb *p;
         
  for(p=tete;p!=NULL;p=p->suivant)
  {
      printf("\n\n");
      printf("Processus\t");
      printf("%s\t",p->nomProcessus);
      printf("%d\t",p->pid);
      printf("%d\t",p->tempsArriver);
      printf("%d\t",p->tempsExecution);
      printf("%s\t",p->etatProcessus);
  }
}

/*Fonction pour modifier un processus, la reconnaissance du processus à modifier se fait par le pid de processus*/
void modifierProcessus(pcb *tete,int pid)
{
  pcb *p;
  char nomProcessus[30],etatProcessus[30];
         
  for(p=tete;p!=NULL;p=p->suivant)
  {
     if(p->pid == pid)
     { 
        free(p->nomProcessus);
        printf("Entrez le nom de processus : ");scanf("%s",nomProcessus);
        p->nomProcessus=(char*)malloc((strlen(nomProcessus)+1)*sizeof(char));
        strcpy(p->nomProcessus,nomProcessus);
        printf("Entrez le pid de processus : ");scanf("%d",&p->pid);
        printf("Entrez le temps d'arriver de processus : ");scanf("%d",&p->tempsArriver);
        printf("Entrez le temps d'execution de processus : ");scanf("%d",&p->tempsExecution);
        p->saveTempsExecution=p->tempsExecution;
        free(p->etatProcessus);
        printf("Entrez l'etat de processus : ");scanf("%s",etatProcessus);
        p->etatProcessus=(char *)malloc((strlen(etatProcessus)+1)*sizeof(char));
        strcpy(p->etatProcessus,etatProcessus);
               
        return;
     }  
  }
}

/*Fonction pour mettre un processus dans la queue de la file d'attente des processus prêts
  s'il est bloqué et puis la rendre active*/	 
void etatBloquerProcessus(pcb**tete,pcb**queue)
{
     pcb *p;
     
     if(strcmp((*tete)->etatProcessus,"bloquer")==0 && (*tete)->suivant!=NULL)
     {
         p=*tete;
         *tete=(*tete)->suivant;
         free(p->etatProcessus);
         p->etatProcessus=(char *)malloc((strlen("active")+1)*sizeof(char));
         strcpy(p->etatProcessus,"active");
         p->suivant=NULL;
         (*queue)->suivant=p;
         *queue=p;    
     }
}

/*Fonction qui fait l'allocation de processeur selon la politique FIFO*/
void fifoProcessus(pcb**tete,pcb**queue)
{
    pcb *p;
    int nbProcessus=0,temps=0,bool=1;
    float tempsMoyenSejour=0,tempsMoyenAttente=0;
     
    triProcessus(*tete);
    while(*tete!=NULL)
    {  
       etatBloquerProcessus(tete,queue);
       p=*tete;
       if(bool == 1)
       {
               temps=p->tempsArriver;
               bool=0;
       }
       temps=temps+p->tempsExecution;
       tempsMoyenSejour=tempsMoyenSejour+(temps-p->tempsArriver);
       tempsMoyenAttente=tempsMoyenAttente+(temps-p->tempsArriver-p->tempsExecution);
       
       *tete=(*tete)->suivant;
       free(p->nomProcessus);
       free(p->etatProcessus);
       free(p);
       p=NULL;
       
       nbProcessus++;
       
    }
    *queue=NULL;
    tempsMoyenSejour=tempsMoyenSejour/nbProcessus;
    tempsMoyenAttente=tempsMoyenAttente/nbProcessus;
    
    printf("\n\n");
    printf("Temps moyen de sejour est %f\n",tempsMoyenSejour);
    printf("Temps moyen d'attente est %f\n",tempsMoyenAttente);
    
} 

/*Fonction qui fait l'allocation de processeur selon la politique RR*/
void rrProcessus(pcb**tete,pcb**queue,int quantum)
{ 
     pcb *p;
     int nbProcessus=0,temps=0,bool=1;
     float tempsMoyenSejour=0,tempsMoyenAttente=0;
     
     triProcessus(*tete);
     while(*tete!=NULL)
     {
         etatBloquerProcessus(tete,queue);
         p=*tete;
         if(bool == 1)
         {
               temps=p->tempsArriver;
               bool=0;
         }
         if(p->tempsExecution<quantum)temps=temps+p->tempsExecution;
         else temps=temps+quantum;
         
         p->tempsExecution=p->tempsExecution-quantum;
         
         if(p->tempsExecution<=0)
         {
               tempsMoyenSejour=tempsMoyenSejour+(temps-p->tempsArriver);
               tempsMoyenAttente=tempsMoyenAttente+(temps-p->tempsArriver-p->saveTempsExecution);
               
               *tete=(*tete)->suivant;
               free(p->nomProcessus);
               free(p->etatProcessus);
               free(p);
               p=NULL;
               nbProcessus++;
         }
         else
         {
              if((*tete)->suivant!=NULL)
              {
                    *tete=(*tete)->suivant;
                    p->suivant=NULL;
                    (*queue)->suivant=p;
                    *queue=p; 
              }    
         }
     }
     
     tempsMoyenSejour=tempsMoyenSejour/nbProcessus;
     tempsMoyenAttente=tempsMoyenAttente/nbProcessus; 
     printf("\n\n");
     printf("Temps moyen de sejour est %f\n",tempsMoyenSejour);
     printf("Temps moyen d'attente est %f\n",tempsMoyenAttente);    
}