Les moniteurs

Définition

• les variables sont locales, totalement inaccessibles de l'extérieur (privées),
• certaines procédures ou fonctions sont appelées des points d'entrée du moniteur, ce sont les seuls éléments du moniteur à être exportés. On dit qu'un processus "entre" dans le moniteur quand il exécute les instructions du moniteur. Dès lors, il peut accéder aux variables privées. L'utilisation du moniteur garantit que ses variables sont utilisées en exclusion mutuelle. Celle-ci est obtenue en assurant que les accès au moniteur lui-même sont réalisés en exclusion mutuelle. En d'autres termes, quand un processus accède à un point d'entrée du moniteur, aucun autre processus ne peut plus y accéder jusqu'à ce que le premier en soit sorti. C'est le moniteur qui gère la liste des processus en attente,
• un processus qui entre dans un moniteur peut être mis en attente d'un événement. Il sera réactivé lorsque cet événement surviendra. En pratique, le moniteur peut contenir des "variables" particulières appelées conditions à chacune desquelles n'est associée aucune valeur mais une file d'attente. Soit une telle variable c. Un processus entré dans un moniteur peut se mettre en attente dans la file correspondant à la condition c par l'appel de la primitive attendre(c). Dès lors il ne pourra se réactiver lui-même. Pour cela, un autre processus doit donc entrer lui aussi dans le moniteur (les variables du moniteur sont locales), et envoyer à la condition un signal par l'intermédiaire de la primitive signaler(c). Si plusieurs processus sont en attente dans la file d'attente, c'est en principe le premier qui sera réveillé (FIFO). Le moniteur étant accédé en exclusion mutuelle, si un processus était mis en attente à l'intérieur du moniteur, aucun autre ne pourrait plus y entrer pour le réveiller. Ainsi, la primitive attendre() doit mettre le processus "en dehors" du moniteur. Nous verrons ultérieurement la sémantique détaillée des moniteurs,
• le moniteur peut aussi contenir une procédure qui ne sera exécutée qu'une seule fois au moment du chargement. C'est dans cette phase que peuvent être effectuées les initialisations nécessaires. Elle est appelée le corps du moniteur. Ecrit dans le style C++, ces initialisations apparaissent généralement, mais pas toujours, à la définition des variables,
• certains auteurs ajoutent la primitive vide(c) qui permet de tester si la file d'attente associée à la variable condition c est vide.

    Nous désignerons un moniteur par son identificateur et ses points d'entrée par des appels de fonction qualifiés (c'est-à-dire utilisant un qualifieur).

    Exemple de déclaration du moniteur Synchro :
 

moniteur Synchro;

    Si l'une des fonctions de ce moniteur est Entree_1, elle sera appelée par :
 

Synchro.Entree_1;

Premier exemple de synchronisation par moniteur

    L'algorithme est écrit en "style" C++ ^[1] :
 

moniteur Synchro ; static boolean EcritureFaite = false; static condition Fini;      // la condition est supposée initialisée à vide void DebutLire ()   { if (!EcritureFaite) attendre (Fini); ) void FinEcrire () {     EcritureFaite = true ;     signaler (Fini); } // FinEcrire()

Point de rendez-vous

    Le processus précédemment mis en file d'attente est donc réveillé, sort du schéma alternatif et passe lui aussi dans la primitive signaler qui réveille le précédent, et ainsi de suite. Tous les processus sont ainsi réveillés en cascade.

    Les moniteurs ne sont ni plus ni moins puissants que les sémaphores, mais seulement plus sûrs, et tous les problèmes résolus par l'utilisation des uns peut l'être par l'utilisation des autres.

Gestion de ressources banalisées

Gestion d'un périphérique par un moniteur

    Le moniteur Disque est chargé de la réalisation des requêtes de transfert :
 

moniteur Disque; static condition FileTransfert; void Echange (Requete_t Requete) {     //     if (EtatDisque != pret) TraiterErreur (ERR_DSK_NOT_READY);     PreparerTransfert (Requete);  // Préparation du programme canal     LancerTransfert();            // Commander au pilote le transfert     attendre (FileTransfert)     if (EtatDisque == erreur) TraiterErreur (ERR_TRANSFERT);     // ... } void TraitantD_Interruption() {     if (FileTransfert.Vide) TraiterErreur (ERR_DSK);     signaler (FileTransfert); }

    Le moniteur FileRequetes fonctionne comme une boîte aux lettres, suivant le modèle "Producteurs/Consommateurs" vu plus loin.

Le problème des "Lecteurs/Rédacteurs"

    On remarque que NbLecteurs n'est pas le nombre de lecteurs actifs, mais ayant essayé d'accéder à la lecture. Si un rédacteur est actif, NbLecteurs est le nombre de lecteurs en attente de lecture. Le réveil met de nouveau en œuvre un mécanisme en cascade, tout lecteur débloqué commençant par réveiller un (éventuel) lecteur de la file d'attente des lecteurs avant d'entrer lui-même en activité. Le réveil n'a aucun effet si la file des processus en attente est vide.

Le problème des "Producteurs/Consommateurs"

    Le mécanisme d'un moniteur ne permettant qu'à un seul processus d'exécuter son code, l'exclusion mutuelle est réalisée tant pour le buffer lui-même que pour les indicateurs. Les deux variables conditions gèrent chacune une file d'attente, d'un message ou d'une place dans le tampon. Il peut y avoir un nombre quelconque de producteurs et de consommateurs, ayant chacun la structure suivante :
 

void Consommateur () {     Message_t Message ;     while (1)     {         //.....         BufferCirculaire.Retirer (Message); // retire le message du buffer         //  .....     } } // Consommateur() void Producteur () {     Message_t Message ;     while (1)     {         // ......          BufferCirculaire.Deposer (Message);         // ......     } } // Producteur()

    Comme on le voit, l'utilisateur est totalement déchargé de tous les soucis d'exclusion mutuelle et de cohérence des informations dans le tampon. Il peut considérer l'action de dépôt ou de retrait comme synchrone, même s'il reste bloqué un certain temps dans le moniteur.

Sémantique des moniteurs

• à un instant donné, au maximum un seul processus peut être en cours d'exécution à l'intérieur d'un moniteur.
• lorsque le processus actif exécute la primitive attendre(), il se met dans l'état attente, et "en même temps", il libère le moniteur de l'utilisation en exclusion mutuelle.  De ce fait, un autre processus peut y pénétrer (sinon il y aurait à tout coup un interblocage !).
• lorsque le processus actif exécute la primitive signaler(), c'est le processus qu'il débloque qui devient actif

• Un processus Pl actif réveille un processus P2 en attente sur une condition. Pl se met en attente et P2 devient actif. Puis P2 réveille lui-même un processus P3 qui devient à son tour actif pendant que P2 devient en attente. P3 retourne en file d'attente par l'exécution de la primitive attendre(). Lequel des processus Pl et P2 doit redevenir actif ?
• Un processus Pl actif réveille un processus P2 en attente sur une condition. Pl se met en attente et P2 devient actif. Pendant ce temps, un processus P3 veut pénétrer dans le moniteur et se met en attente dans la file d'attente d'entrée du moniteur. Le processus P2 termine son exécution dans le moniteur et libère celui-ci de l'exclusion mutuelle. Lequel des processus Pl et P3 doit devenir actif ?

• actif : c'est l'état du seul processus qui est en train de s'exécuter dans le moniteur.
• activable : c'est l'état du seul processus qui peut s'exécuter. Il ne lui manque que le processeur pour devenir actif. S'il y a un processus actif il n'y en a pas d'activable et inversement.
• stoppé : c'est l'état d'un processus qui attend la levée de l'exclusion mutuelle du moniteur pour devenir activable. Nous distinguerons deux états stoppé correspondant aux deux causes qui peuvent conduire un processus à ces états :
• stoppé-entrée : le processus veut entrer à l'un des points d'entrée du moniteur qui est actuellement occupé par un autre.
• stoppé-signaler : le processus stoppé vient lui-même d'en réveiller un autre par la primitive signaler().
• c-attente : un processus passe dans cet état en exécutant la primitive attendre(c) sur la condition c.
• sorti : c'est l'état d'un processus qui est en dehors du moniteur considéré, soit avant d'avoir appelé une fonction "point d'entrée" du moniteur, soit après en être sorti.

• entrer : c'est l'action d'essayer d'entrer dans le moniteur par un de ses points d'entrée.
• sortir : c'est l'action de terminer l'exécution des instructions dans le moniteur, et d'en lever l'exclusion mutuelle.
• attendre(c) : voir la définition des moniteurs.
• signaler(c) :   "             "                     "

    Le tableau suivant résume les différentes situations (lorsqu'un événement peut provoquer deux transitions différentes, c'est la première qui est prioritaire) :

    Les règles A1 et A2 expriment l'exclusion mutuelle du moniteur : un processus ne peut entrer dans un moniteur que si un autre n'est pas en train de l'occuper. En d'autres termes, un processus déjà entré dans un moniteur a la priorité sur un processus encore à l'extérieur.

    Les règles B1, B2 et B3 traduisent le fait que, lorsqu'un processus P1 exécute la primitive attendre(), pendant qu'un processus P2 attend d'entrer dans le moniteur et qu'un moniteur P3 attend de redémarrer dans le moniteur, c'est ce dernier qui a la priorité. De nouveau, un processus déjà entré dans un moniteur a la priorité sur un processus encore à l'extérieur.

    Les règles C1 et C2 illustrent le réveil d'un processus en attente de signal. Si aucun n'est en attente, le signal est perdu.

    Les règles D1, D2 et D3 montrent que la levée de l'exclusion mutuelle par un processus qui sort d'un moniteur profite en priorité à un processus stoppé parce qu'il a lui-même réveillé un processus plutôt qu'à un processus qui a appelé un point d'entrée du moniteur. De nouveau, un processus déjà entré dans un moniteur a la priorité sur un processus encore à l'extérieur.

    Pour compléter la description du fonctionnement d'un moniteur, il faut indiquer l'ordre dans lequel sont choisis les processus lorsque plusieurs sont bloqués pour la même raison. Il y trois sortes d'ensembles de processus bloqués correspondant aux états suivants :

• stoppé-entrée : ils sont naturellement gérés par une file FIFO.
• stoppé-signaler : ils sont gérés grâce à une pile.
• c-attendre : ils sont naturellement gérés par une file FIFO.