Exercices INF5171 : série #4 (Automne 2012)

Transcription

1 Exercices INF5171 : série #4 (Automne 2012) 1. Opération collective de réduction (moniteur pseudo-mpd) Programme MPD 1 Un moniteur avec une opération de réduction (somme). monitor Reduction op somme( int v ) returns int sommetotale; body Reduction( int nbthreads )... end On veut dénir un moniteur en pseudo-mpd permettant d'eectuer une réduction, plus précisément une réduction pour faire la somme d'une série de nombres entiers spéci- és par divers threads. L'interface du moniteur est présentée dans le Programme MPD 1 (exprimée en pseudo-mpd). Plus précisément, ce module fonctionne de la façon suivante : L'argument nbthreads du constructeur indique le nombre de threads qui seront impliqués dans l'utilisation de l'opération de réduction. Tant que tous les threads n'ont pas eectué leur appel à somme, aucun résultat n'est produit. Donc, les nbthreads-1 premiers threads qui appellent somme bloquent en attente du résultat. Lorsque tous les nbthreads threads ont eectué leur appel à somme, le résultat (somme- Totale) est retourné à chacun des threads, lesquels poursuivent ensuite leur exécution. Le programme MPD 2 présente un petit programme utilisant ce moniteur. Une trace possible produite par l'exécution de ce programme est présentée à la Figure 1. Complétez le corps du moniteur Reduction en supposant l'utilisation de la discipline Signaler-et-Continuer. 1

2 Programme MPD 2 Un petit programme utilisant le module de réduction pour une somme. resource TesterReduction() const int N = 5; import Reduction; cap Reduction reduction = create Reduction( N ); process p [i = 1 to N] { for [k = 0 to 1] { int r = reduction.somme( 10**k * i ); printf( "Thread %d: r = %d\n", i, r ); end % a.out Thread 5: r = 15 Thread 1: r = 15 Thread 2: r = 15 Thread 3: r = 15 Thread 4: r = 15 Thread 4: r = 150 Thread 5: r = 150 Thread 1: r = 150 Thread 2: r = 150 Thread 3: r = 150 Figure 1: Trace possible d'exécution pour le programme MPD 2. 2

3 2. Le problème des violonistes (Java) Le programme Java 1 présente une classe Violoniste qui vise à simuler le comportement d'un violoniste ayant le comportement suivant : Lors de la création d'une instance de la classe, on spécie le numéro d'identication du violoniste (pour la trace d'exécution) ainsi que le nombre de pièces de musique que ce violoniste doit jouer. Un violoniste alterne entre des moments où il va dormir() (pour une période de temps aléatoire), puis se réveiller et tenter de jouer() une pièce (d'une durée aléatoire) : voir dormir() et jouer() dans le programme Java 1. Les diérents violonistes doivent se partager un nombre limité de violons et d'archets. Or, pour jouer une pièce, le violoniste doit avoir en sa possession et un violon, et un archet. Le nombre de violons et d'archets disponibles sont spéciés par l'intermédiaire d'une variable de classes et les setter appropriés. Le programme Java 2 présente un petit programme utilisant cette classe. Une trace possible produite par l'exécution de ce programme est présentée à la Figure 2. Complétez la classe Violoniste pour obtenir le comportement désiré. 3

4 Programme Java 1 Une classe Violoniste. public class Violoniste implements Runnable { // Variables globales, pour simplifier le constructeur d'instances. static private int nbviolons; static private int nbarchets; // Methodes pour definir les variables globales. static public void setnbviolons( int nb ) { nbviolons = nb; static public void setnbarchets( int nb ) { nbarchets = nb; // A completer: Autres variables d'instance. // Elements lies a l'aspect comportement aleatoire. static Random rnd = new Random(); final static int MAX_DUREE_SOMMEIL = 10; final static int MAX_DUREE_JEU = 10; // Variables d'instance privees. private int numvioloniste; private int nbpieces; Violoniste( int numvioloniste, int nbpieces ) { this.numvioloniste = numvioloniste; this.nbpieces = nbpieces; private void dormir() { try { Thread.currentThread().sleep( rnd.nextint( MAX_DUREE_SOMMEIL ) ); catch ( InterruptedException ie ) {; private void jouer( int piece ) { System.out.println( "Le violoniste " + numvioloniste + " joue sa piece " + piece ); try { Thread.currentThread().sleep( rnd.nextint( MAX_DUREE_JEU ) ); catch ( InterruptedException ie ) {; public void run() { // A completer: methode run. 4

5 Programme Java 2 Un petit programme de test utilisant la classe Violoniste. private static String pluriel( int n ) { return n <= 1? "" : "s"; // Petit programme de test simple. public static void main( String args[] ) { // On lit les arguments de la ligne de commande. nbviolons = Integer.parseInt( args[0] ); nbarchets = Integer.parseInt( args[1] ); Violoniste.setNbViolons( nbviolons ); Violoniste.setNbArchets( nbarchets ); int nbviolonistes = Integer.parseInt( args[2] ); int nbpieces = Integer.parseInt( args[3] ); // On cree et on active les violonistes. System.out.println( "Les " + nbviolonistes + " violoniste" + pluriel(nbviolonistes) + " vont jouer" + " " + nbpieces + " piece" + pluriel(nbpieces) + " avec" + " " + nbviolons + " violon" + pluriel(nbviolons) + " " + nbarchets + " archet" + pluriel(nbarchets) + ":" ); for( int i = 0; i < nbviolonistes; i++ ) { new Thread( new Violoniste( i, nbpieces ) ).start(); $ java Violoniste Les 4 violonistes vont jouer 2 pieces avec 3 violons 3 archets: Le violoniste 3 joue sa piece 1 Le violoniste 1 joue sa piece 1 Le violoniste 2 joue sa piece 1 Le violoniste 0 joue sa piece 1 Le violoniste 3 joue sa piece 2 Le violoniste 1 joue sa piece 2 Le violoniste 0 joue sa piece 2 Le violoniste 2 joue sa piece 2 Figure 2: Trace possible d'exécution pour le programme Java 1. 5

6 3. Nombres pseudo-aléatoires avec variables atomiques (Java) Soit l'interface suivante, qui spécie une opération pour obtenir un nombre pseudoaléatoire : interface PseudoRandom { // Retourne un entier pseudo-aleatoire compris entre 0 et n-1; int nextint( int n ); Soit la classe utilitaire suivante, qui dénit une méthode statique permettant de produire une série de nombres pseudo-aléatoires à l'aide d'une méthode simple : public class Util { final static private int A = 129; final static private int B = 13; public static int calculatenext( int v ) { return Math.abs( A * v + B ); Le programme Java 3 présente une classe mettant en oeuvre l'interface PseudoRandom. La méthode nextint y est dénie comme étant synchronized, ce qui permet à plusieurs threads s'exécutant de façon concurrente de partager la même série de valeurs pseudoaléatoires. Cette classe contient aussi un petit programme de test (méthode main). Voici un exemple d'exécution de ce programme : $ java PseudoRandomUsingSync Écrivez une classe PseudoRandomUsingAtomic qui met en oeuvre l'interface PseudoRandom, mais sans utiliser de verrous. 6

7 Programme Java 3 Une classe PseudoRandomSync mettant en oeuvre l'interface PseudoRandomSync, à l'aide d'une méthode synchronized. // Exemple adapte de public class PseudoRandomUsingSynch implements PseudoRandom { private int seed; public PseudoRandomUsingSynch( int seed ) { this.seed = seed; public synchronized int nextint( int n ) { int s = seed; seed = Util.calculateNext( seed ); return s % n; public static void main( String args[] ) { int n = Integer.parseInt( args[0] ); PseudoRandom rnd = new PseudoRandomUsingSynch( n ); for ( int i = 1; i <= n; i++ ) { System.out.println( rnd.nextint( 100 ) ); 7