🎫

Parallélisme et Algorithmique
Réparrtie
Réferences Biblio :
M.chel Raynal

parallélisme → Dunod

Systémes Répartis → Eyroles

Distributed systems → Spinger

KRAKOWIAK → Systémes d'éxploitation (proces) → MASSON

TANNEBAUM → Systemes d'exploitation centralisés et répartis → inter-editions

Email du prof : naja.inpt@gmail.com

Cas des systèmes centralisés:

On parle du pseudo-parallelisme → temps partagé (time sharing)

Si on execute un processus (qui a des instructions i1, i2,....,in,in+1,...), s'il y a

intéruption sur l'instruction 'in', une sauvegarde sera effectuée avant de passer à
l'instrcution "in+1".

Rq : Le parralelisme dans les langages

FORTRAN → FORTRAN 90
MODULA (Task)
PASCAL → Version avec parallelisme (Task)
JAVA (Thread)

Parallélisme et Algorithmique Réparrtie 1

 C# (Thread)
PYTHON (Thread)

KOTLIN
Rq :

CISC → RISC → pipeline

chercher pour le symbole d'entrelacement

Exemple : Compte bancaire

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;

Hyp : Les instructions 1, 2, 3 et 4 sont atomiques

Cela nous donne une execution séquentielle de p1 et p2: p1 ={(2),(3),(4)} ; p2 = {(2),(3),
(4)}

p1 Même chose pour un autre processus Pj

.
.

.
.

→entre_en_section_critique

Parallélisme et Algorithmique Réparrtie 2

 Sec ^
Crit ^

→sortie_section_crituqe
.

.
.

Rq : risque d'interblocage ( retour au cours du premiere annee)

Exercice:

On considére des process producteurs et consommateurs ayant un tampon de N

cases en commun.
Font message produit et mémorisé dans ce tompon, ne doit étre écrasé avant
consommation par un autre message et il ne sera consommée qu'une seule fois
synchroniser l'accés à ce tampon pour les cas suivants:

1. Un seul producteur et un seul consommateur

2. Avec consommation selon le FIFO

3. Pour plusieurs producteurs et consommateurs

Correction :
Initialisation des ressources :

Sem_CV := N ; Sem_CP := 0 : Semaphore; [CV = cases vides; CN = cases

pleines]

1)- Avec un seul producteur et un seul consommateur

1. process prod

Parallélisme et Algorithmique Réparrtie 3

 Begin
loop
produire(msgp);
p(Sem_CV);
deposer(T,msgp);
V(Sem_CP);
end loop;
end;

2. process cons

Begin
loop
P(Sem_CP);
prelever(T, msgc);
V(Sem_CV);
consommer(msgc);
end loop;
end;

2)- Avec consommation selon le FIFO

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

Parallélisme et Algorithmique Réparrtie 4

 Begin
loop
P(Sem_CP);
msgc:=T[ic];
ic:=ic+1 mod N;
V(Sem_CV);
consommer(msgc);
end loop;
end;

3)- Pour plusieurs producteurs et consomamtuers :

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 :

Parallélisme et Algorithmique Réparrtie 5

 On considère un fichier commun à plusieurs process lecteurs et rédacteurs. Utilisez
le concept sémaphore pour synchroniser l'accès à ce fichier. La lecture simultanée
étant autorisée.

a. Un process lecteur et un process rédacteur

b. plusieurs lecteurs et rédacteurs sans FIFO

c. plusieurs lecteurs et rédacteurs avec FIFO

Solution :

a. Un process lecteur et un process rédacteur

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

b. Plusieurs lecteurs et rédacteurs sans FIFO

var cpt_lect : integer;

sem_lect : Semaphore;

Process lect
Begin
loop
P(Sem_lect);
if(cpt_lect == 0):
then: P(Sel_Fich);

Parallélisme et Algorithmique Réparrtie 6

 cpt_lect := cpt_lect + 1;
V(Sem_Lect);
<Lecyure>
P(Sem_Lect);
cpt_lect = cpt_lect - 1;
if cpt_lect == 0 then V(Sem_Fich);
V(Sem_Lect);
end loop;
end;

Sem_Fich : Semaphore
#Process Réd
begin
loop
P(Sem_Fich);
<Ecriture>
V(Sem_Fich);
end loop;
end

c. Plusieurs lecteurs et rédacteurs avec FIFO

Exercice :

On considère N process qui peuvent executer en parallèle des instructions données

et se mettre en rendez-vous avant de continuer l'execution de leurs second blocs
d'instructions.

Utilisez les sémaphores pour réaliser ce rendez-vous.

Process N
begin
A1N
(*)
A2N
end;

(*) :

MUTEX : Semaphore; := 1
Sem_RDZ : Semaphore; :=0

P(MUTEX);
cpt++;

Parallélisme et Algorithmique Réparrtie 7

 if cpt < N then V(MUTEX);
P(Sem_RDZ);
else V(MUTEX);
V(Sem_RDZ);

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

Parallélisme et Algorithmique Réparrtie 8

 if occup then wait(libre);
occup := true;

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;

Parallélisme et Algorithmique Réparrtie 9

 procedure Demande_Ecriture;
begin
if(ecriture or cpt_lect > 0) then wait(libre_ecrit);
ecriture := true;
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;

Parallélisme et Algorithmique Réparrtie 10

 end;

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 :

Parallélisme et Algorithmique Réparrtie 11

 On considère une ressource que existe en n (n>>1) exemplaires. Donnez le code
d'un moniteur Gest_Ress_Multiple qui permet à un process quelconque d'allouer n
exemplaires (n<<M) qu'il libére après usage. (On choisira à la libération
d'exemplaires de cette ressource l'activation de tous les processus en attente pour
en satisfaire le maximum d'entre eux).

Moniteur Gest_Ress_Multiple
var cpt_disp : integer;
libre_ress : condition;

procedure Allouer (var n integer)

begin
while(cpt<n) do wait(libre_ress);
signal(libre_ress);
cpt_disp := cpt_disp - n;
end;

procedure Liberer (var n integer)

begin
cpt_dsip = cpt_n;
signal(libre_ress);
end;

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

procedure deposer(var msgp : type_msg)

begin
end;

procedure prelever(var msgc : type_msg)

begin
end;

begin /*Initialisation*/
end;

Parallélisme et Algorithmique Réparrtie 12

Parallélisme et Algorithmique Réparrtie 13