Contrôle de l'exclusion mutuelle

Plusieurs processus utilisent une même ressource (qui sera ici plutôt symbolique) ; deux processus ne doivent pas simultanément utiliser la ressource (il doit y avoir exclusion mutuelle sur l'utilisation de la ressource). Dans la version actuelle du programme fourni, l'exclusion mutuelle n'est pas respectée. Le travail consiste à réaliser l'exclusion mutuelle gryâce à l'algorithme de Naimi et Tréhel.

Chaque utilisateur de la ressource a un "gestionnaire" chargé d'obtenir la ressource quand l'utilisateur en a besoin puis de restituer la ressource quand l'utilisateur la libère.
Concrètement, chaque utilisateur est un processus démarré par une méthode main ; chaque utilisateur crée son gestionnaire qui devra être une instance de la classe Thread (ou d'une sous-classe de celle-ci). L'utilisateur et son gestionnaire font donc partie du même processus, mais ont chacun une "file d'exécution". Le thread du gestionnaire est démarré dans le constructeur de celui-ci.

La communication entre les différents gestionnaires se fait par datagrammes.

Le travail effectué par chaque utilisateur est une succession répétitive de :

• attente sans rien faire, pendant une durée variable ;
• demande puis attente de la ressource ;
• utilisation de la ressource (sans rien faire) pendant un temps qui est fixe, identique pour tous les processus, et lu dans le fichier des données (dont il est question plus bas) ;
• restitution de la ressource.

• indiquer à chaque processus le travail qu'il doit faire (grosso modo, la suite des temps d'attente entre deux utilisations de la ressource) ; le nombre de processus qui doivent participer à l'action et les informations sur le travail de chacun de ces processus sont dans un fichier lu par le serveur ; chaque processus, au moment de sa création, se connecte avec le serveur et commence par prendre connaissance du travail à faire ;
• choisir un processus qui pourra avoir un rôle particulier dans l'algorithme (ici celui qui possède au départ le "jeton") ;
• attendre que tous les processus soient prêts pour donner le feu vert pour le départ ;
• effectuer des affichages graphiques pour vérifier le bon déroulement de l'algorithme. Dans cet affichage, chaque processus est représenté par un point : noir quand le processus n'a pas la ressource et rouge quand il en dispose. Deux points rouges simultanément indiquent un manquement à l'exclusion mutuelle ;
• fermer tous les processus quand ils ont tous fini leur travail. Le programme serveur ne doit pas gérer l'exclusion mutuelle, car il s'agit d'un TP sur le contrôle réparti...

Les fichiers contenant les classes servant au TP (en principe, il ne vous est pas nécessaire de prendre connaissance du détail de ces classes, seul le fichier GestionnaireNaimi.java devra être modifié) sont :

• la classe Utilisateur qui est la classe qui modélise un des processus utilisateur de la ressource. Cette classe contient une méthode main qui instancie un utilisateur. Une méthode de nom travailler décrit le travail de l'utilisateur ;
• la classe GestionnaireNaimi est la classe à compléter pour assurer l'exclusion mutuelle ; à chaque utilisateur de la ressource est associée une instance de la classe GestionnaireNaimi ; l'algorithme fonctionnera par échange de messages entre ces instances ;
• la classe Travail est une classe très simple qui modélise le travail d'un utilisateur et sert essentiellement à faire naviguer l'information sur ce travail du serveur au processus utilisateur de la ressource ;
• la classe Identite est très simple et modélise l'identité d'un processus (adresse IP de sa machine, port servant à la réception et l'envoi de datagrammes et aussi un numéro attribué par le serveur pouvant servir à des affichages ; un objet Identite pourra être envoyé par datagrammes pour caractériser un processus qui demande la ressource ; ; chaque utilisateur possède un attribut de type Identite, nommé identite, donnant son identité ;
• la classe Message sert à contenir l'information d'un message envoyé d'un processeur à l'autre ;
• la classe Serveur qui donne la description du serveur et contient une méthode main pour lancer celui-ci ;
• la classe Dessin étend la classe JPanel et sert pour y définir les affichages graphiques ;
• la classe ImageUtilisateur est une classe utilisée par le serveur ; elle est instanciée une fois pour chaque utilisateur de la ressource ; elle contient des informations nécessaires au serveur sur chaque utilisateur et sert aussi à gérer la connexion (en mode connecté) entre un utilisateur et le serveur ;

Vous allez :

• Sauvegarder l'archive TPReparti.tar ;
• décompresser l'archive (tar xvf TPReparti.tar) ;
• vous mettre dans le répertoire TPReparti
• compiler les fichiers java : javac *.java
• faire tourner le serveur et trois utilisateurs ; pour cela, vous allez exécuter les commandes suivantes, sur une ou plusieurs machines :
• java Serveur scenarios/3.dat 32654 : le premier argument est le nom du fichier décrivant le travail des utilisateurs ; le dernier nombre est un numéro de port, que vous pouvez choisir librement ; cette commande lance le serveur ;
• java Utilisateur fantine 32654 : le mot fantine doit être remplacé par le nom de la machine sur laquelle tourne le programme Serveur, le numéro de port doit être le même que dans la première commande ; cette commande lance un utilisateur ; elle doit être exécutée à l'identique trois fois.

Vous devez constater avec l'expérience ci-dessus l'absence d'exclusion mutuelle et arranger le problème en complétant le fichier GestionnaireNaimi.java pour y programmer l'algorithme de Naimi et Tréhel. Vous n'avez pas à modifier d'autre fichier que celui-ci.

S'il vous reste du temps à la fin du TP, vous pouvez faire en sorte que l'arborescence de l'algorithme soit affichée dans l'affichage graphique du serveur. Il vous suffi pour cela d'utiliser les méthodes prévues dans GestionnaireNaimi.java.

S'il vous reste encore du temps, vous pouvez programmer un autre algorithme de contrôle de l'exclusion mutuelle.

Corrigé