éJ J.

ª‚Ë@
 éJ £@Q®Ö ß YË@ éK QK@Qm.Ì '@ éK PñêÒm.Ì '@
àA‚ÒÊK - éJ ®J J.¢JË@ ÐñʪË@ ú¯ AJʪË@ éƒPYÖ Ï@
Higher School in Applied Sciences-Tlemcen (ESSAT)

Module : Système temps réel Filière : Électrotechnique

TD N◦ 3 : Exclusion mutuel à l’aide des moniteurs

Exercice 1 : Allocateur de ressources

— Ressource : N exemplaires/unités équivalents (ex : tampons en mémoire/sur disque, unités
de bandes magnétiques...)
— Chaque processus peut en acquérir une ou plusieurs ressources puis doit les libérer.
— Règles d’utilisation :
— une unité ne peut être allouée qu’à un processus à la fois
— une unité ne peut être allouée que si elle est libre
— une opération de libération s’applique toujours aux dernières ressources acquises par le
processus qui l’exécute
— une demande d’allocation est bloquante en cas d’échec

Exercice 2 : lecteurs / rédacteurs

Dans une base de données, afin de conserver une certaine cohérence, on ne peut pas :
— lire pendant une écriture
— écrire pendant une écriture
— écrire pendant une lecture
Les utilisateurs d’une base de données utiliseront les fonctions lecteur et ecrivain respectivement
pour lire et écrire dans la base de données.

lecteur( ){ ecrivain( ){
debut lire( ) ; debut ecrire( ) ;
lire(BD) ; ecrire(BD) ;
fin lire( ) ; fin ecrire( ) ;
} }

— Modifier les fonctions debut lire( ), fin lire( ), debut ecrire( ), fin ecrire( ) afin de donner la
priorité aux écrivains.

Exercice 3 : Problème des philosophes

N philosophes (ici 5) sont assis a une table circulaire, ils aimeraient manger leur plat de spa-
ghettis avec 2 fourchettes chacun mais il n’y a que N fourchettes. Evidemment ils ne pourront pas

Ghouti ABDELLAOUI, Lecturer

g.abdellaoui@essa-tlemcen.dz
ESSA-Tlemcen, Department of the second cycle -1- 8 janvier 2022
BP 165 RP Bel Horizon 13000 Tlemcen, Algerie
http://www.essa-tlemcen.dz/
 éJ J.ª‚Ë@
 éJ £@Q®Ö ß YË@ éK QK@Qm.Ì '@ éK PñêÒm.Ì '@
àA‚ÒÊK - éJ ®J J.¢JË@ ÐñʪË@ ú¯ AJʪË@ éƒPYÖ Ï@
Higher School in Applied Sciences-Tlemcen (ESSAT)

tous manger en même temps.

Utiliser les moniteurs comme un outil de synchronisation pour ce problème.

Ghouti ABDELLAOUI, Lecturer

g.abdellaoui@essa-tlemcen.dz
ESSA-Tlemcen, Department of the second cycle -2- 8 janvier 2022
BP 165 RP Bel Horizon 13000 Tlemcen, Algerie
http://www.essa-tlemcen.dz/
 Solution TD N°3 : Les moniteurs

Exercice 1
Moniteur : 2 procédures, demander et libérer
ps:ressource.demander(n); --demande de n unités
--attente si échec
<utiliser les ressources acquises>
ressource.libérer(n);
--libération des unités
• Condition de synchronisation : n =< nlibre

ressource : moniteur;
var nlibre : entier ;
disp : condition ;
procédure demander(n) ; procédure libérer(n) ;
début début
tantque n > nlibre faire nlibre := nlibre + n;
disp.attendre ; disp.signaler
disp.signaler fin ;
ftantque ; début
nlibre := nlibre – n; nlibre := N
fin ; fin
fin ressource

Exercice 2
Il s'agit donc d'implémenter les fonctions debut_lire, fin_lire, debut_ecrire et fin_ecrire
On utilise un moniteur comportant ces fonctions ainsi que les conditions :
cond f_lect , f_ecr
l'entier
int nb_lec
qui indique le nombre de lecteurs dans la base de données,
et enfin le booléen :
bool ecr
qui indique si quelqu'un est en train décrire dans la base de données ou non.

debut_lire( ){ fin_lire( ){
nb_lec ++; nb_lec - - ;
if (ecr){ //s'il y a un écrivain on attend if (nb_lec ==0){
f_lect.wait( );} f_ecr.signal( );
f_lect.signal( ); // si on peut lire alors tous ceux }
qui sont en attente aussi }
}

debut_ecrire( ){ fin_ecrire( ){
if (nb_lec > 0 || ecr){ ecr = false;
f_ecr.wait( ); if ( nb_lec > 0){ //priorité aux lecteurs : on
} regarde d'abord si il y en a qui veulent lire
ecr = true; f_lect.signal( );
} }
else {
f_ecr.signal( );}
}
On se place maintenant dans le cas où ce sont les écrivains qui ont la priorité On utilise un moniteur
comportant :

int nb_lec_base // compte le nombre de lecteurs dans la base de données

int nb_lec_att
// compte le nombre de lecteurs en attente d'une lecture dans la BD
int nb_ecr_att
// compte le nombre d'écrivains en attente d'écriture
bool ecr_base
// indique si on est en train d'écrire dans la base
cond f_lect , f_ecr
debut_lire( ){ nb_lec_base ++;
nb_lec_att ++; }
if (ecr_base || nb_ecr_att > 0){ //priorité aux fin_lire( ){
écrivains nb_lec_base --;
f_lect.wait( ); if (nb_lec_base == 0){ //on réveille 1 écrivain
} f_ecr.signal( );
nb_lec_att --; }
l_lect.signal( ); //pareil si on peut lire alors tous }
les autre en attente de lecture aussi

debut_ecrire( ){ fin_ecrire( ){
nb_ecr_att ++; ecr_base = false;
if (nb_lec_base > 0 || ecr_base){ if ( nb_ecr_att >0){
f_ecr.wait( ); f_ecr.signal( );
} }
ecr_base = true; elsif ( nb_lec_att > 0){
nb_ecr_att --; f_lec.signal( );
} }
}

Exercice 3
Etat = { PENSE , MANGE}
Etat Etat_Philo[ N ] = { PENSE , ................, PENSE}
cond file_privee [ N ];

prendre_fourchette ( int i ){ poser_fourchette ( int i ){

while ( Etat_Philo[ (i+1)%N ] == MANGE if ( Etat_Philo[ (i+1)%N ] == PENSE ) {
|| Etat_Philo[ (i-1+N)%N ] == MANGE ){ //si le philosophe de droite a
file_privee[ i ].wait( ); //l'opportunité de manger
} file_privee[ (i+1)%N ].signal( ); //on le réveille
Etat_Philo = MANGE; si éventuellement il
} // attend
}
if ( Etat_Philo[ (i-1+N)%N ] == PENSE ) { //si
le philosophe de gauche a
//l'opportunité de manger
file_privee[ (i-1+N)%N ].signal;
}
}