Td6 : synchronisation des processus avec des moniteurs - tél

Ce document universitaire propose une correction détaillée du TD6, axé sur la synchronisation des processus à l'aide des moniteurs. Il est principalement destiné aux étudiants en Systèmes d'Exploitation Avancés, notamment ceux en première année d'ingénierie, afin d'approfondir leurs connaissances en matière de gestion des processus.

Le contenu couvre les notions fondamentales suivantes :

• La définition, la structure et la sémantique des moniteurs.
• L'implémentation de l'exclusion mutuelle et la gestion des conditions d'attente.
• L'utilisation des variables de condition et des primitives associées (wait, signal).
• Des exercices d'application pour illustrer les concepts.

Systèmes d’Exploitation : TD6 : Synchronisation des processus avec des Moniteurs

Télécharger PDF

Synchronisation des processus avec des Moniteurs

Définition

Les moniteurs offrent une solution de "haut niveau" pour la protection de données partagées, une approche introduite par Hoare en 1974. Ils visent à simplifier la mise en place de sections critiques, c'est-à-dire des blocs de code où un seul processus peut s'exécuter à la fois pour éviter les conflits d'accès aux ressources partagées.

Un moniteur est défini par les composants suivants :

• Des données internes (également appelées variables d'état), qui sont les ressources partagées que le moniteur protège.
• Des primitives d'accès aux moniteurs (points d'entrée), qui sont les procédures publiques que les processus peuvent appeler pour interagir avec les données internes.
• Des primitives internes, uniquement accessibles depuis l'intérieur du moniteur, utilisées pour sa gestion.
• Une ou plusieurs files d'attente, pour gérer les processus qui ne peuvent pas entrer immédiatement ou qui se bloquent à l'intérieur du moniteur.

Structure d'un moniteur

La structure conceptuelle d'un moniteur peut être représentée par le pseudo-code suivant :

• Type m = moniteur
• Début
• Déclaration des variables locales (ressources partagées) ;
• Déclaration et corps des procédures du moniteur (points d’entrée) ;
• Initialisation des variables locales ;
• Fin

Cette structure encapsule les données et les opérations qui les manipulent, garantissant un accès contrôlé.

Sémantique des moniteurs

La sémantique des moniteurs repose sur des principes stricts pour assurer la synchronisation et l'exclusion mutuelle :

• Seul un processus (ou tâche, ou thread) peut être actif à un moment donné à l'intérieur du moniteur. Cette règle est fondamentale et garantit l'exclusion mutuelle.
• La demande d'entrée dans un moniteur (ou d'exécution d'une primitive du moniteur) sera bloquante tant qu'il y aura un processus actif à l'intérieur du moniteur. L'accès à un moniteur construit donc implicitement une exclusion mutuelle.
• Lorsqu'un processus actif au sein d'un moniteur ne peut progresser dans son travail (parce qu'une certaine condition n'est pas remplie, par exemple, un buffer est vide pour un consommateur), il libère l'accès au moniteur avant de se bloquer.
• Lorsque des variables internes du moniteur ont changé, le moniteur doit pouvoir réveiller un processus bloqué qui attend que ces conditions soient remplies.
• Pour cela, il existe deux types de primitives de synchronisation :
  • wait : cette primitive libère l'accès au moniteur, puis bloque le processus appelant sur une condition spécifique. Le processus attendra d'être réveillé.
  • signal : cette primitive réveille sur une condition un des processus en attente à l'intérieur du moniteur (un processus qui a exécuté précédemment un wait sur la même condition). Si plusieurs processus attendent, généralement un seul est réveillé.

Les variables de condition

Les variables de condition sont des éléments clés pour la synchronisation à l'intérieur des moniteurs :

• Une variable de condition est :
  • définie à l’aide du type condition ;
  • possède un identificateur ;
  • n'a pas de valeur intrinsèque (contrairement à un sémaphore, qui a une valeur entière).
• Une variable de condition :
  • ne doit pas être initialisée ;
  • ne peut être manipulée que par les primitives Wait et Signal ;
  • est représentée par une file d'attente de processus bloqués sur la même cause ;
  • est donc assimilée à sa file d'attente de processus.
• La primitive Wait bloque systématiquement le processus qui l'exécute et le place dans la file d'attente de la variable de condition spécifiée.
• La primitive Signal réveille un processus de la file d'attente de la condition spécifiée, si cette file d'attente n'est pas vide ; sinon, elle n'a aucun effet.
• Syntaxe courante : cond.Wait; cond.Signal; (où cond est la variable de type condition déclarée comme variable locale).
• Autre syntaxe possible : Wait(cond); Signal(cond);
• Un processus réveillé par Signal continue son exécution à l'instruction qui suit le Wait qui l'avait bloqué.

Exercices d'application

1. Réaliser le moniteur correspondant à l’exemple de la barrière de synchronisation (un mécanisme qui bloque un groupe de processus jusqu'à ce que tous atteignent un certain point d'exécution).

2. Réaliser un moniteur Producteur-Consommateur qui définit deux méthodes produire(M) et consommer(M) permettant respectivement d’ajouter et de supprimer le message M d’un buffer partagé.

Foire Aux Questions (FAQ)

Qu'est-ce qu'un moniteur en synchronisation de processus ?

Un moniteur est un mécanisme de haut niveau qui permet de contrôler l'accès concurrent à des données partagées. Il garantit qu'un seul processus à la fois peut exécuter des procédures critiques, assurant ainsi l'exclusion mutuelle et prévenant les conditions de course.

Quelle est la différence entre un moniteur et un sémaphore ?

Alors qu'un sémaphore est une primitive de bas niveau qui utilise des opérations atomiques P() (attendre) et V() (signaler) pour contrôler l'accès, un moniteur est une structure de haut niveau qui encapsule les données partagées et les procédures d'accès. Le moniteur gère implicitement l'exclusion mutuelle et utilise des variables de condition pour des synchronisations plus complexes, rendant le code plus facile à écrire et à vérifier.

Comment les primitives Wait et Signal fonctionnent-elles dans un moniteur ?

La primitive Wait bloque un processus si une condition n'est pas remplie, le plaçant dans une file d'attente associée à cette condition et libérant l'accès au moniteur pour d'autres processus. La primitive Signal réveille un processus bloqué sur cette même condition, lui permettant de reprendre son exécution et potentiellement de réintégrer le moniteur si la condition est désormais satisfaite.