Paralllisme Et Algorithmique Rparrtie
Paralllisme Et Algorithmique Rparrtie
Paralllisme Et Algorithmique Rparrtie
Parallélisme et Algorithmique
Réparrtie
Réferences Biblio :
M.chel Raynal
parallélisme → Dunod
KOTLIN
Rq :
var val:INTEGER;
process Crediteur(c : INTEGER);
Begin
val := val+c;
End;
process Debiteur (d : INTEGER);
Begin
if val < d then
write ("..decouvrent..");
val := val-d;
End;
.
.
.
.
→entre_en_section_critique
→sortie_section_crituqe
.
.
.
Exercice:
Correction :
Initialisation des ressources :
1. process prod
2. process cons
Begin
loop
P(Sem_CP);
prelever(T, msgc);
V(Sem_CV);
consommer(msgc);
end loop;
end;
1. Process Prod
Begin
loop
produire(msgp);
P(Sem_CV);
T[ip]:=msgp;
ip:=ip+1 mod N;
V(Sem_CP);
end loop;
end;
2. Process cons
1. Process prod
Begin
loop
produire(msgp);
P(Sem_CV);
P(MUTEXP);
T[ip]:=msgp;
ip:=ip+1 mod N;
V(MUTEXP);
V(Sem_CP);
end loop;
end;
2.Process cons
Begin
loop
P(Sem_CP);
P(MUTEXC);
msgc:=T[ic];
ic:=ic+1 mod N;
V(MUTEXC);
V(Sem_CV);
consommer(msgc);
end loop;
end;
Exercice :
Solution :
Sem_Fich : Semaphore
#Process Lect
begin
loop
P(Sem_Fich);
<Lecture>
V(Sem_Fich);
end loop;
end
Sem_Fich : Semaphore
#Process Réd
begin
loop
P(Sem_Fich);
<Ecriture>
V(Sem_Fich);
end loop;
end
Process lect
Begin
loop
P(Sem_lect);
if(cpt_lect == 0):
then: P(Sel_Fich);
Sem_Fich : Semaphore
#Process Réd
begin
loop
P(Sem_Fich);
<Ecriture>
V(Sem_Fich);
end loop;
end
Exercice :
Process N
begin
A1N
(*)
A2N
end;
(*) :
MUTEX : Semaphore; := 1
Sem_RDZ : Semaphore; :=0
P(MUTEX);
cpt++;
Les Moniteurs
Moniteur Nom Moniteur;
var /$ Déclaration de variables globales $/
c: condition;
procedure op1 [(...)];
begin
(...)
end;
(...)
procedure opN[(...)]
begin
(...)
end;
begin /*Initialisation*/
end;
Wait (c) : Le process à l'origine de cet appel est bloqué en attente dans la file
"f_wait(c)"
Signal(c) : Le process à l'origine de cet aooek déblqiue un process (selon FIFO) de
la file "f_wait(c)" et il est mis en attente dans la file "f_signal(c)" . Si la file
"f_wait(c)" est vide alors cet appelé signal(c) est une instruction vide.
Les process bloqués dans la file f_signal(c) sont dit signaleurs.
Ils sont prioritaires par rapport aux autres moniteurs.
Exemple :
Gestion d'accés à une ressource unique
Moniteur Gest_Acces_Ress;
var occup : boolean;
libre : condition;
procedure Allouer;
begin
end;
procedure liberer;
begin
occup := false;
signal(libre);
end;
begin /*Initialisation*/
oocuup := false;
end;
process Pi
begin
(...)
Gest_Acces_Ress.Allouer;
<Usage_de_la_ress>;
Gest_Acces_Ress.Liberer;
Exercice :
Reprenez la synchronisation d'accès au fichier commun aux lecteurs et rédacteurs
en utilisant le concept moniteur, la lecture simultanée est autorisée et à la fin
d'écriture un process rédacteur débloque en priorité un lecteur.
Process Lect
Moniteur Gest_Fich;
var ecriture : boolean;
cpt_lect : integer;
libre_lect, libre_ecrit : condition;
procedure Demande_Lecture;
begin
cpt_lect++;
if ecriture then wait(libre_lect);
end;
procedure Fin_lecture;
begin
cpt_lect--;
if cpt_lect == 0 then signal(libre_ectit);
end;
procedure Fin_Ecriture;
begin
ecriture = false;
if cpt_lect > 0 then signal (libre_lect);
else signal (libre_ecrit);
end;
begin /*Initialisation*/
cpt_lect = 0;
ecriture = false;
end;
Exercice :
Reprenez le code du moniteur Gest_Fich en introduisant une priorité de déblocage
en fin d'écriture à tour de rôle entre process Lecteurs et Rédacteurs. On fixera cette
priorité à une valeur maximale MAX_PRIO.
Process Lect
Moniteur Gest_Fich;
var ecriture : boolean;
cpt_lect : integer;
libre_lect, libre_ecrit : condition;
prio_lect, prio_ecrit : integer
procedure Demande_Lecture;
begin
cpt_lect++;
if ecriture then wait(libre_lect);
end;
procedure Fin_lecture;
begin
cpt_lect--;
if cpt_lect == 0 then signal(libre_ectit);
end;
procedure Demande_Ecriture;
begin
if(ecriture or cpt_lect > 0) then wait(libre_ecrit);
ecriture := true;
procedure Fin_Ecriture;
begin
ecriture = false;
if (cpt_lect > 0 and cpt_red == 0) then signal (libre_lect);
else if(cpt_red > 0 and cpt_lect == 0 ) then signal (libre_red);
else:
if(prio_lect > 0) then signal(libre_lect)
prio_lect--;
if(prio_lect == 0) then prio_red ) MAX-PRIO;
else signal(libre_écri);
if(prio_red==0) then prio_lect = MAX_PRIO;
end;
begin /*Initialisation*/
cpt_lect = 0;
ecriture = false;
prio_lect = MAX_PRIO;
prio_red = 0;
end;
Exercice :
Donnez le code d'un moniteur Gest_RdZ qui permet d'assurer le rendez-vous de N
process.
process Pj
begin
A1j
(*) Gest_RdA.check_RdZ;
A2j
end;
(*):
Moniteur Gest_RdZ;
var cpt : integer;
start_rdz : condition;
procedure check_RdZ
begin
cpt ++;
if(cpt<N) then wait(start_rdz);
signal(start_rdz)
end;
begin/*Initialisation*/
cpt :=0;
Exercice :
Moniteur Gest_Ress_Multiple
var cpt_disp : integer;
libre_ress : condition;
begin /*Initialisation*/
cpt_disp := M;
end;
Exercice:
Donnez le code d'un moniteur Gest_Access_TAMPON qui permet d'assuer la
synchronisation d'accès à un tampon T à N entre process producteurs et
consommateurs. La consommation s'effectue en FIFO.
Moniteur Gest_Ress_TAMPON
var
begin /*Initialisation*/
end;