Simulation de l'exécution des processus

Commenter

Contenu du snippet

ce programme simule l'exécution des processus suivant les algorithmes FIFO, LIFO,
PAR PRIORITE et PAR QUANTUM DE TEMPS

Source / Exemple : 


#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;

}

Conclusion :


ce programme est développé dans le cadre d'un mini_projet lors de mes études.
j'attends toutes vos remarques ou suggestions.
:)

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.