SIMULATION DE L'EXÉCUTION DES PROCESSUS

#include<iostream.h>
#include<dos.h>
#include<conio.h>
#include<stdlib.h>


const int maxc=100;
const int maxtaches=100;
const int maxcar=10;

char ch[maxtaches][maxcar];//pour sauvegarder les codes saisis
int nb=0;//nbre d elts dans ch

class processus;

 class ordonnanceur
{
processus *p;
public:
ordonnanceur();
~ordonnanceur();
void ajouter_proc(char*,char*,int,int,int);
void desactiver_proc(processus*);
void activer_proc(processus*);
void ordonner_proc_fifo();
void ordonner_proc_lifo();
void ordonner_proc_prio();
void fifo();
void lifo();
void priorite();
void quantum();
void executer_proc();
void executer_proc_quantum();
void modifier();
processus* selectionner_proc(char*);
processus* processus_non_execute();
void affichage_tout_proc();
};



class processus
{

char code[maxcar];
int prio;
char nom[maxcar];
bool actif;
int  inst_ar,t_ex,t_cons;
processus* suiv;

public:
friend void ordonnanceur::ajouter_proc(char*,char*,int,int,int);
processus();
processus(char*,char*,int,int,int);
void affichage_proc_coursd_execution();
void affichage_proc_coursd_execution_quantum(int);
void affichage_donnees_proc();
void modifie_proc();
char* getcode(){return code;}
char* getnom(){return nom;}
int& getprio(){return prio;}
int& getinst_ar(){return inst_ar;}
int& gett_ex(){return t_ex;}
int& gett_cons(){return t_cons;}
bool& getactif(){return actif;}
processus* getsuiv(){return suiv;}

};





processus::processus()
{
strcpy(code,"\0");
prio=0;
strcpy(nom,"\0");
actif=false;
inst_ar=0;
t_ex=0;
t_cons=0;
suiv=NULL;
}

processus::processus(char*cod,char* n,int priorite,int temps_ex,int inst_arriv)
{
strcpy(code,cod);
strcpy(nom,n);
prio=priorite;
t_ex=temps_ex;
t_cons=0;;
inst_ar=inst_arriv;
suiv=NULL;
actif=false;
}


ordonnanceur::ordonnanceur()
{
p=NULL;
}


ordonnanceur::~ordonnanceur()
{
processus* q;
while(p!=NULL)
{
 q=p;
 p=p->getsuiv();
 delete q;
}
}

void ordonnanceur::ajouter_proc(char* cod,char* n,int priorite,
                                int temps_ex,int inst_arriv)
{
static processus* dernier_proc;

if(p==NULL)//insertion du 1er processus
{
 p=new processus(cod,n,priorite,temps_ex,inst_arriv);
 dernier_proc=p;
}
else
{
 dernier_proc->suiv=new processus( cod,n,priorite,temps_ex,inst_arriv);
 dernier_proc=dernier_proc->suiv;
}
}


bool existe_deja(char* cod)
{

int k=0;
while((k<nb)&&strcmp(cod,ch[k]))
 k++;
return(k!=nb);
}


char* saisie_code()
{
int i=0;
static char cod[maxc];
do
 {
 i++;
 if(i==1)
 cout<<"donner un code"<<endl;//si c'est la 1ere fois
 else
 if(strlen(cod)>9)
 cout<<"donner un code de longueur <10"<<endl;
 else
 cout<<"ce code existe deja, donnez un autre"<<endl;
 cin>>cod;
 }
while(existe_deja(cod)||strlen(cod)>9);
strcpy(ch[nb],cod);
nb++;
return(cod);
}

char* saisie_nom()
{
 int j=0;
 static char n[maxc];
 do
 {
 j++;
 if(j==1)
 cout<<"donner un nom"<<endl;
 else
 cout<<"donner un nom de longueur <10"<<endl;
 cin>>n;
 }
 while(strlen(n)>9);
 return(n);
 }

void saisir_donnees_proc(int i,char* cod,char* n,int& priorite,
                         int& temps_ex,int& inst_arriv)
{
 cout<<"\t\tla saisie du processus "<<(i+1)<<endl<<endl;

 strcpy(n,saisie_nom());
 strcpy(cod,saisie_code());
 do
 {
 cout<<"donner la priorite"<<endl;
 cin>>priorite;
 }
 while(priorite<1);
 do
 {
 cout<<"donner l instant d arrivee"<<endl;
 cin>>inst_arriv;
 }
 while(inst_arriv<1);
 do
 {
 cout<<"donner le temps d execution"<<endl;
 cin>>temps_ex;
 }
 while(temps_ex<1);

}

void permuter(processus* j,processus* q) //permuter 2 processus
{
 char ch[maxcar];
 int aux;
 strcpy(ch,j->getcode());
 strcpy(j->getcode(),q->getcode());
 strcpy(q->getcode(),ch);
  strcpy(ch,j->getnom());
 strcpy(j->getnom(),q->getnom());
 strcpy(q->getnom(),ch);
 aux=j->getprio();
 j->getprio()=q->getprio();
 q->getprio()=aux;
  aux=j->getinst_ar();
 j->getinst_ar()=q->getinst_ar();
 q->getinst_ar()=aux;
  aux=j->gett_ex();
 j->gett_ex()=q->gett_ex();
 q->gett_ex()=aux;
  aux=j->gett_cons();
 j->gett_cons()=q->gett_cons();
 q->gett_cons()=aux;
  aux=j->getactif();
 j->getactif()=q->getactif();
 q->getactif()=aux;
}





void ordonnanceur::ordonner_proc_fifo()
{
processus* j;
processus* q=p;

while(q->getsuiv())
{
 j=q->getsuiv();
 while(j)
 {
 if(j->getinst_ar()<q->getinst_ar())
  permuter(j,q) ;
 j=j->getsuiv();
 }
 q=q->getsuiv();
}
}


void ordonnanceur::ordonner_proc_lifo()
{
 processus* j;
processus* q=p;

while(q->getsuiv())
{
 j=q->getsuiv();
 while(j)
 {
 if(j->getinst_ar()>q->getinst_ar())
  permuter(j,q) ;
 j=j->getsuiv();
 }
 q=q->getsuiv();
}
}



void ordonnanceur::ordonner_proc_prio()
{
processus* j;
processus* q=p;

while(q->getsuiv())
{
 j=q->getsuiv();
 while(j)
 {
 if(j->getprio()>q->getprio())
  permuter(j,q) ;
 j=j->getsuiv();
 }
 q=q->getsuiv();
}
}

void ordonnanceur::desactiver_proc(processus* q)
{
q->getactif()=false;
}


void processus::affichage_proc_coursd_execution()
{
t_cons=0;//au cas ou on reexecute le processus

gotoxy(1,wherey());
cout<<code;
gotoxy(11,wherey());
cout<<nom;
gotoxy(22,wherey());
cout<<inst_ar;
gotoxy(37,wherey());
cout<<prio;
gotoxy(49,wherey());
cout<<t_ex;
gotoxy(60,wherey());
cout<<t_cons;
gotoxy(73,wherey());
cout<<actif;

while(t_cons<t_ex)
{
sleep(1);
t_cons++;
gotoxy(60,wherey());
cout<<t_cons;
}
gotoxy(73,wherey());
cout<<0;
cout<<endl<<endl;
}


void ordonnanceur::activer_proc(processus* q)
{
q->getactif()=true;
}

void affichage_entete()
{
cout<<"code";
gotoxy(11,wherey());
cout<<"nom";
gotoxy(20,wherey());
cout<<"t_arrivee";
gotoxy(35,wherey());
cout<<"priorite";
gotoxy(49,wherey());
cout<<"t_ex";
gotoxy(59,wherey());
cout<<"t_cons";
gotoxy(71,wherey());
cout<<"actif";
cout<<endl<<endl;
}
void ordonnanceur::executer_proc()
{
processus* q=p;
affichage_entete();
while(q)
{
activer_proc(q);
q->affichage_proc_coursd_execution();
desactiver_proc(q);
q=q->getsuiv();
}
}


processus* ordonnanceur::processus_non_execute()
{
processus* q=p;
while((q)&&(q->gett_cons()==q->gett_ex()))
q=q->getsuiv();
return q;
}

void processus::affichage_proc_coursd_execution_quantum(int quant)
{

int compt=0;
if(t_cons<t_ex)
{

gotoxy(1,wherey());
cout<<code;
gotoxy(11,wherey());
cout<<nom;
gotoxy(22,wherey());
cout<<inst_ar;                     
gotoxy(37,wherey());
cout<<prio;
gotoxy(49,wherey());
cout<<t_ex;
gotoxy(60,wherey());
cout<<t_cons;
gotoxy(73,wherey());
cout<<actif;

while((t_cons<t_ex)&&(compt<quant))
{
 sleep(1);
 t_cons++;
 compt++;
 gotoxy(60,wherey());
 cout<<t_cons;
}

gotoxy(73,wherey());
cout<<0;
cout<<endl<<endl;

}
}


void ordonnanceur::executer_proc_quantum()
{
processus* q=p;
int quant;

do
{
cout<<"donner le quantum"<<endl;
cin>>quant;
}
while(quant<1);
affichage_entete();

while(q)
{
q->gett_cons()=0;
q=q->getsuiv();
}

while(processus_non_execute())
{
 q=processus_non_execute();
 while(q)
 {
  activer_proc(q);
  q->affichage_proc_coursd_execution_quantum(quant);
  desactiver_proc(q);
  q=q->getsuiv();
 }
}
}

void ordonnanceur::fifo()
{
clrscr();
cout<<endl;
cout<<"execution des processus suivant l algo FIFO:"<<endl;
cout<<"-------------------------------------------"<<endl<<endl<<endl;
ordonner_proc_fifo();
executer_proc();
cout<<"tapez sur une touche pour continuer"<<endl;
getch();
}



void ordonnanceur::lifo()
{
clrscr();
cout<<endl;
cout<<"execution des processus suivant l algo LIFO:"<<endl;
cout<<"-------------------------------------------"<<endl<<endl<<endl;
ordonner_proc_lifo();
executer_proc();
cout<<"tapez sur une touche pour continuer"<<endl;
getch();
}


void ordonnanceur::priorite()
{
clrscr();
cout<<endl;
cout<<"execution des processus suivant l algo base sur la priorite:"<<endl;
cout<<"-----------------------------------------------------------"<<endl<<endl<<endl;
ordonner_proc_prio();
executer_proc();
cout<<"tapez sur une touche pour continuer"<<endl;
getch();
}



void ordonnanceur::quantum()
{
clrscr();
cout<<endl;
cout<<"execution des processus suivant l algo ROUND ROBIN:"<<endl;
cout<<"--------------------------------------------------"<<endl<<endl<<endl;
ordonner_proc_fifo();
executer_proc_quantum();
cout<<"tapez sur une touche pour continuer"<<endl;
getch();
}

processus* ordonnanceur::selectionner_proc(char* cod)
{
processus* q=p;
while((q!=NULL)&&strcmp(q->getcode(),cod))
q=q->getsuiv();
return q;
}

void supprimecod_ch(char* cod)
{
int i=0;
while(strcmp(cod,ch[i]))
i++;
while(i<nb-1)
{
strcpy(ch[i],ch[i+1]);
i++;
}
nb--;
}


void processus::modifie_proc()
{
clrscr();
int choix;
char cod[maxcar];
cout<<"que voulez_vous changer ?"<<endl<<endl;
cout<<"1- changer le nom"<<endl;
cout<<"2- changer le code"<<endl;
cout<<"3- changer la priorite"<<endl;
cout<<"4- l instant d arrivee"<<endl;
cout<<"5- le temps d execution demande"<<endl<<endl;
do
{
cout<<"tapez le numero correspondant a votre demande: ";
cin>>choix;
}
while((choix<1)||(choix>5));
cout<<endl;
switch(choix)
{
case 1: strcpy(nom,saisie_nom());
        break;
case 2: strcpy(cod,code);
        strcpy(code,saisie_code());
        supprimecod_ch(cod);
        break;
case 3: do
		  {
        cout<<"donner la priorite"<<endl;
		  cin>>prio;
        }
        while(prio<1);
        break;
case 4: do
        {
        cout<<"donner l instant d arrivee"<<endl;
		  cin>>inst_ar;
        }
        while(inst_ar<1);
        break;
case 5: do
        {
        cout<<"donner le temps d execution"<<endl;
		  cin>>t_ex;
        }
        while(t_ex<1);
        break;
}


t_cons=0;
}


void processus::affichage_donnees_proc()
{
cout<<"nom="<<nom<<"  code="<<code<<"  priorite="<<prio<<"  inst_ar="<<inst_ar;
cout<<"  t_ex="<<t_ex<<"  t_cons="<<t_cons<<"  actif="<<actif<<endl<<endl;
}


void ordonnanceur::affichage_tout_proc()
{
processus* q=p;
cout<<"affichage des processus:"<<endl;
cout<<"************************"<<endl<<endl<<endl;
while(q)
{
q->affichage_donnees_proc();
q=q->getsuiv();
}
}




void ordonnanceur::modifier()
{
char cod[maxc];
int i=0;
do
{
if(i==0)
cout<<"donner le code du processus a modifier"<<endl;
else
cout<<"ce code n existe pas, donnez un autre"<<endl;
cin>>cod;
i++;
}
while(existe_deja(cod)==false);
processus*q=selectionner_proc(cod);
q->modifie_proc();
cout<<endl<<endl<<"apres modification, le processus devient:"<<endl<<endl;
q->affichage_donnees_proc();
cout<<endl<<"tapez sur une touche pour continuer";
getch();
}


void main()
{
int nb_tache,i,choix;
ordonnanceur o;
char cod[maxcar],n[maxcar];
int priorite,temps_ex,inst_arriv;
do
{
 cout<<"donner le nombre de taches presentes"<<endl;
 cin>>nb_tache;
}
while((nb_tache<=0)||(nb_tache>maxtaches));

for(i=0;i<nb_tache;i++)
{
 saisir_donnees_proc(i,cod,n,priorite,temps_ex,inst_arriv);
 o.ajouter_proc(cod,n,priorite,temps_ex,inst_arriv);
}
clrscr();
cout<<endl;
o.affichage_tout_proc();
cout<<endl<<endl<<"tapez sur une touche pour continuer";
getch();
debut:
;

clrscr();
cout<<endl;
cout<<"voici les differentes taches possibles:"<<endl;
cout<<"***************************************"<<endl<<endl;
cout<<"1- affichage de tous les processus"<<endl;
cout<<"2- modifier les donnees d un processus"<<endl;
cout<<"3- voir l execution des processus suivant l algo FIFO"<<endl;
cout<<"4- voir l execution des processus suivant l algo LIFO"<<endl;
cout<<"5- voir l execution des processus suivant l algo base sur la priorite"<<endl;
cout<<"6- voir l execution des processus suivant l algo ROUND ROBIN"<<endl;
cout<<"7- quitter"<<endl<<endl<<endl;
do
{
cout<<"tapez le numero correspondant a votre demande "<<endl;
cin>>choix;
}
while((choix<1)||(choix>7));
clrscr();
switch(choix)
{
case 1: o.affichage_tout_proc();
        cout<<"tapez sur une touche pour continuer"<<endl;
        getch();
        break;
case 2: o.modifier();
        break;
case 3: o.fifo();
        break;
case 4: o.lifo();
        break;
case 5: o.priorite();
        break;
case 6: o.quantum();
        break;
case 7: exit(1);
        break;
}

goto debut;

}