Diviser pour calculer plus vite Fork - Join. riveill@unice.fr h.p://

Transcription

1 Diviser pour calculer plus vite Fork - Join riveill@unice.fr h.p://

2 Quelques modèles en programma>on parallèle et leur mise en œuvre en Java 2

3 Situa>on 1 Il existe de nombreux problèmes organisés de la manière suivante : données données données Calcul Calcul Calcul Synchronisa>on et échange des données Les données peuvent être iden>ques ou non Les calcul peuvent être iden>que ou non, l important c est qu ils s effectuent sur des données indépendantes 3

4 Synchroniser un ensemble de thread : la barrière Idée : tous les processus franchissent au même moment la barrière Implémenta-on : Facile à implémenter par un moniteur ou avec des sémaphores a été introduit dans Java 7 Principe en Java 7 : Un processus crée un objet barrière il donne le nombre N de processus a.endu Chaque processus exécute «await» sur l objet barrière Quand N est a.eint, la barrière s ouvre 4

5 La barrière public class MonRunnable implements Runnable { private CyclicBarrier barrier; string name = Thread.currentThread().getName(); public MonRunnable(CyclicBarrier barrier) { this.barrier = barrier; public void run() { System.out.println(threadName + " is started"); Thread.sleep(400*new Random().nextInt(10)); System.out.println(threadName + " is waiting on barrier"); barrier.await(); System.out.println(threadName + " has crossed the barrier"); 5

6 La barrière main(string args[]) { //creating CyclicBarrier with 3 Threads needs to call await() CyclicBarrier cb = new CyclicBarrier(3, new Runnable(){ public void run(){ //This task will be executed once all thread reaches barrier System.out.println("All parties are arrived at barrier"); ); //starting each of thread Thread t1 = new Thread(new MonRunnable(cb), "Thread 1"); Thread t2 = new Thread(new MonRunnable(cb), "Thread 2"); Thread t3 = new Thread(new MonRunnable(cb), "Thread 3"); System.out.println("Début démarrage des threads"); t1.start(); t2.start(); t3.start(); System.out.println("Fin démarrage des threads"); 6

7 La barrière Un exemple d exécu>on Début démarrage des threads Fin démarrage des threads Thread 3 is started Thread 1 is started Thread 2 is started Thread 1 is waiting on barrier Thread 2 is waiting on barrier Thread 3 is waiting on barrier All parties are arrived at barrier, lets play Thread 3 has crossed the barrier Thread 2 has crossed the barrier Thread 1 has crossed the barrier Evidemment dans la cas de tâches cycliques, il faut réini>aliser la barrière reset() 7

8 La barrière en Java Class Barrier { private final int N_THREADS; int arrived; public Barrier (int n) { N_THREADS = n; public synchronized void await () { arrived++; if (arrived < N_THREADS) { wait(); else { arrived = 0; notifyall(); Sans un phénomène bien curieux appelé à Spurious wakeup 8

9 Spurious wakeup h6p://docs.oracle.com/javase/7/docs/api/java/lang/object.html A thread can also wake up without being no>fied, interrupted, or >ming out, a so- called spurious wakeup. While this will rarely occur in prac>ce, applica>ons must guard against it by tes>ng for the condi>on that should have caused the thread to be awakened, and con>nuing to wait if the condi>on is not sa>sfied. In other words, waits should always occur in loops, like this one: Arrive en par>culier sur synchronized (obj) { Linux car mise en œuvre while (<condition does not hold>) de la JVM avec les pthread qui me.ent en obj.wait(timeout); gardent contre les... // Perform action «Spurius wakeup» For more informa>on on this topic, see Sec>on in Doug Lea's "Concurrent Programming in Java (Second Edi>on)" (Addison- Wesley, 2000), or Item 50 in Joshua Bloch's "Effec>ve Java Programming Language Guide" (Addison- Wesley, 2001). 9

10 La barrière en Java Class Barrier { private final int N_THREADS; int[] counts = new int[] {0, 0; int current = 0; public Barrier (int n) { N_THREADS = n; public synchronized void await () { int my = current; counts[my]++; if (counts[my] < N_THREADS) while (counts[my] < N_THREADS) wait(); else { current ^= 1; counts[current] = 0; Prise en compte du Spurious wakeup notifyall(); 10

11 Situa>on 2 Il existe de nombreux problèmes qui peuvent être décomposé en sous- problèmes indépendants et qui sont donc facilement parallélisables Principe On crée autant de thread que de problème à résoudre (fork) La thread principale a.end la terminaison des différents calculs (join) Pa.ern de calcul forkjoin 11

12 Proposi>on de solu>on Principe de mise en œuvre Créa>on d autant de tâches que de sous- problèmes Exécu>on en parallèle de toutes ces tâches A.ente de la fin de toutes les tâches (barrière) Java moniteur Class { int i; Synchronized a.endre (int N) { i := N; wait (); Synchronized fini () { i- - ; if (i<=0) no>fy (); // appel thread principale // appel des N thread filles Java semaphore for (i:=0; i++; i<n) s.down(); s.up (); Fusion des résultats par>els // appel thread principale // appel des N thread filles Depuis Java 7 il est possible de traiter ce cas directement avec le modèle forkjoin 12

13 Cas d u>lisa>on du modèle Fork / Join Lorsque le traitement est décomposable en sous- tâches indépendantes Existence d'algorithmes parallèles spécifiques La décomposi>on en sous- tâches peut être : sta>que : découper un tableau en zones fixes dynamique : découvrir une arborescence de fichiers A.en>on à maîtriser le volume de tâches créées récursive

14 Problème 1 : contrôler le nombre de thread en ac>vité 14

15 Contrôle du parallélisme Le parallélisme c est bien mieux si on peut effec-vement calculer en parallèle Exploita>on d une l architecture mul>- cœur Java Nom du thread courant : Thread.currentThread().getName() Nombre de cœur sur le processeur : Thread.currentThread().getName() Quel est l intérêt de lancer 10 thread si on a que 4 cœurs? Jusqu à présent on créait des threads parallèles sans jamais se poser la ques>on du nombre de threads qui était effec>vement exécuté en // Un modèle : les «pools» de thread Créer une thread coûte cher Alors on recycle J 15

16 Pool de thread Principe On crée un ensemble de N threads Généralement moins que de processeurs/coeurs existants Ou au contraire légèrement plus pour prendre en compte les opéra>ons bloquantes (entrée/sor>e, réseau) On crée un ensemble de tâche Le nombre dépend généralement du problème à résoudre Les tâches sont successivement exécutées par les thread Mise en œuvre en Java à l aide d une nouvelle hiérarchie : Executor 16

17 Classe Executors une autre manière d ac>ver une thread public class MonRunnable implements Runnable { public void run(){ System.out.println("Debut execution dans le thread " //On simule un traitement long Thread.sleep(4000); +Thread.currentThread().getName()); System.out.println("Fin execution dans le thread " Solu>on déjà connue +Thread.currentThread().getName()); Thread thread = new Thread(new MonRunnable()); thread.start(); En u>lisant l interface Executor Executor executor = Executors.newSingleThreadExecutor(); executor.execute(new MonRunnable()); 17

18 Classe Executors : exécu>on séquen>elle des tâches List<Runnable> runnables = new ArrayList<Runnable>(); //création de 4 tâches runnables.add(new MonRunnable()); runnables.add(new MonRunnable()); runnables.add(new MonRunnable()); runnables.add(new MonRunnable()); //création executor mono-thread ExecutorService executor = Executors.newSingleThreadExecutor(); //exécution des tâches selon le modèle choisi for(runnable r : runnables){ executor.execute(r); //attente de la terminaison de toutes les tâches executor.shutdown(); 18

19 Classe Executors : exécu>on séquen>elle des tâches Serveur Le CPU est inac>f pendant les E/S A A CPU B C C B File contenant les requêtes en a.ente Avantage Facile à u>liser 19

20 Classe Executors : exécu>on séquen>elle des tâches Evidemment les traces d exécu>on sont : Debut execution dans le thread pool-1-thread-1 Fin execution dans le thread pool-1-thread-1 Debut execution dans le thread pool-1-thread-1 Fin execution dans le thread pool-1-thread-1 Debut execution dans le thread pool-1-thread-1 Fin execution dans le thread pool-1-thread-1 Debut execution dans le thread pool-1-thread-1 Fin execution dans le thread pool-1-thread-1 20

21 Classe Executors : exécu>on parallèle des tâches List<Runnable> runnables = new ArrayList<Runnable>(); //création de 4 tâches runnables.add(new MonRunnable()); runnables.add(new MonRunnable()); runnables.add(new MonRunnable()); runnables.add(new MonRunnable()); Seul changement //création executor pool de 2 threads ExecutorService executor = Executors.newFixedThreadPool(2); //Executors.newSingleThreadExecutor(); //exécution des taches selon le modèle choisi for(runnable r : runnables){ executor.execute(r); //attente de la terminaison de toutes les taches executor.shutdown(); 21

22 Classe Executors : exécu>on parallèle des tâches Serveur Un nombre op>mum de thread peut être créé et recyclé A A CPU B CPU B C C Avantage Moins de requête dans la file d a.ente Minimize la créa>on /destruc>on de thread Désavantage Nécessité de «tunning» pour >rer le meilleur par> du matériel Pas facile à me.re en œuvre avant Java

23 Classe Executors : exécu>on parallèle des tâches Un exemple d exécu>on des threads Debut execution dans le thread pool-1-thread-1 Debut execution dans le thread pool-1-thread-2 Fin execution dans le thread pool-1-thread-2 Fin execution dans le thread pool-1-thread-1 Debut execution dans le thread pool-1-thread-2 Debut execution dans le thread pool-1-thread-1 Fin execution dans le thread pool-1-thread-1 Fin execution dans le thread pool-1-thread-2 23

24 Problème 2 : lancer un calcul et récupérer plus tard son résultat 24

25 Un modèle : l appel asynchrone avec avec future Appel synchrone appelant client appelé serveur Appel asynchrone avec futur appelant client appelé serveur futur execute() submit() new() returns() get() returns() put() Appel de méthode Appel de procédure à distance (RPC) Client- serveur Acteurs / objets ac>fs Appel aynchrone de procédure à distance (A- RPC) 25

26 Runnable versus Callable<T> Runnable Introduced in Java 1.0 Runnable cannot be parametrized Classes implemen>ng Runnable needs to implement run() method Runnable.run() returns no Value Can not throw Checked Excep>ons publicinterfacerunnable { void run(); Callable<T> Introduced in Java 1.5 as part of java.u>l.concurrent library Callable is a parametrized type whose type parameter indicates the return type of its run method Classes implemen>ng Callable needs to implement call() method Callable.call() returns a value of Type T Can throw Checked Excep>ons publicinterfacecallable<v>{ V call() throwsexception; 26

27 Classe Callable public class MonCallable implements Callable<Integer> { public Integer call() { System.out.println("Debut execution ); //Simulation traitement long Thread.sleep(4000); System.out.println("Fin execution); return new Random().nextInt(10); 27

28 La classe Future<T> // création d un Executor ExecutorService executor = Executors.newSingleThreadExecutor(); //Appel de la tache et récupération d un Future<V> Future<Integer> future = executor.submit(new MonCallable()); System.out.println("Apres submit"); //On a besoin du résultat on appel : future.get() // appel bloquant System.out.println("Resultat=" + future.get()); System.out.println("Avant shutdown"); execute.shutdown(); 28

29 Appel asynchrone avec futur Exemple de trace Apres submit Debut execution Fin execution Resultat=6 Avant shutdown 29

30 Mise en oeuvre du modèle forkjoin en Java 30

31 Mise en oeuvre du pa.ern forkjoin en Java Exemple >ré de : h.p://fr.openclassrooms.com/informa>que/cours/apprenez- a- programmer- en- java/depuis- java- 7- le- pa.ern- fork- join Le problème Parcourir tous les répertoires de mon $HOME et afficher le nombre de fichier contenant le suffixe psd Se décompose assez aisément en sous- problèmes indépen- dants L analyse d un répertoire peut être réalisé de manière récur- sive par analyse des sous ré- pertoire 31

32 Algorithme Dans chaque répertoire : On lance une nouvelle analyse pour chaque sous- répertoires On compte le nombre de fichier correspondant au filtre On a.end la terminaison des analyses des sous répertoires et on addi>onne le nombre de fichier trouvé 32

33 Approche séquen>elle Il y a 92 fichier(s) portant l'extension *.psd Temps de traitement : U>lisa>on de 4 coeurs Il y a 92 fichier(s) portant l'extension *.psd Temps de traitement : Mais temps d a.ente presque 3 fois plus cours 33

34 Le pa.ern forkjoin ForkJoinPool : représente un pool de thread qui reçoit la liste des tâches à réaliser invoque : lance les tâches passées en paramètre de manière synchrones execute : lance les tâches passées en paramètre de manière asynchrones submit : lance la tâche passée en paramètre de manière asynchrone et renvoie un objet futur immédiatement ForkJoinTask : représente une tâche unique invoke(): exécu>on de la tâche par la thread courante fork(): lance une autre tâche dans le même pool que la thread courante join(): retourne le résultat de l exécu>on de ce.e tâche Un ForkJoinPool exécute des ForkJoinTasks <interface> Executor <interface> ExecutorService ForkJoinPool <interface> Future<V> <abstract> ForkJoinTask<V> T invoke(task) void execute(task) Future<T> submit(task) RecursiveTask<V> RecursiveAction compute(), invoke(), fork(), join(), isdone(), get()... 34

35 ForkJoinTask RecursiveAction Implémente Future<Void> Modélise un traitement qui ne renvoie pas de valeur Peut néanmoins modifier les données passées en paramètre Ex : trier un tableau "in- place" RecursiveTask<V> Implémente Future<V> Modélise un traitement récursif qui renvoie une valeur Ex : calculer la taille totale d'une arborescence de fichiers compute() est la méthode excécutée par la tâche équivalent à run() pour les thread Les tâches peuvent être appelées de manière synchrone ou asynchrone Synchrone : invoke() Asynchrone : fork()

36 Main // Nombre de processeurs disponibles int processeurs = Run>me.getRun>me().availableProcessors(); // Créa>on du pool de thread ForkJoinPool pool = new ForkJoinPool(processeurs); // Créa>on de l'objet FolderScanner FolderScanner fs = new FolderScanner(chemin, filtre); // Créa>on de l'objet FolderScanner RecursiveTask<Long> fs = new FolderScanner(chemin, filtre); // Analyse resultat = fs.sequen>alscan(); // Analyse resultat = pool.invoke(fs); // exécute compute // Un transparent qui suit décrit : // sequen>alscan // Un transparent qui suit décrit : // compute 36

37 Synchrone ou Asynchrone? (ForkJoinPool) Resultat = pool.invoke(fs); est équivalent à : Resultat = pool.execute(fs); est équivalent à : pool.invoke(fs); pool.execute(fs); Bla bla bla resultat = fs.join(); Bla bla bla resultat = fs.join(); 37

38 FolderScanner public class FolderScanner { public long sequen>alscan() { // Récupéra>on de la liste des fichiers du répertoire d analyse DirectoryStream<Path> lis>ng = Files.newDirectoryStream(path)); for (Path nom : lis>ng) { if (Files.isDirectory(nom.toAbsolutePath())) { // S'il s'agit d'un dossier il est analysé result += new FolderScanner( nom.toabsolutepath(), this.filter).sequen>alscan(); // Récupéra>on de la liste des fichiers répondant au filtre DirectoryStream<Path> lis>ng = Files.newDirectoryStream(path, this.filter)); for (Path nom : lis>ng){ // Pour chaque fichier, on incrémente le compteur result++; public class FolderScanner extends RecursiveTask<Long> public Long compute() { // Récupéra>on de la liste des fichiers du répertoire d analyse DirectoryStream<Path> lis>ng = Files.newDirectoryStream(path)); for (Path nom : lis>ng) { if (Files.isDirectory(nom.toAbsolutePath())) { // S'il s'agit d'un dossier il est analysé subtasks.add(new FolderScanner( nom.toabsolutepath(), this.filter).fork()); // Récupéra>on de la liste des fichiers répondant au filtre DirectoryStream<Path> lis>ng = Files.newDirectoryStream(path, this.filter)); for (Path nom : lis>ng) { // Pour chaque fichier, on incrémente le compteur result++; // Récupéra>on du résultat de toutes les sous- tâches for (ForkJoinTask<Long> subtask : subtasks) result += subtask.join(); return result; return result; 38

39 Synchrone ou asynchrone? (ForkJoinTask/RecursiveTask/RecursiveAc>on) if (Files.isDirectory(nom.toAbsolutePath())) { // S'il s'agit d'un dossier il est analysé ForkJoinTask<Long> fs = new FolderScanner( nom.toabsolutepath(), this.filter) if (Files.isDirectory(nom.toAbsolutePath())) { // S'il s'agit d'un dossier il est analysé ForkJoinTask<Long> fs = new FolderScanner( nom.toabsolutepath(), this.filter).invoke();.fork(); fs.invoke(); fs.fork(); Bla bla bla fs.join(); Bla bla bla fs.join(); 39

40 Asynchronisme et tâches récursives (RecursiveTask) // correct protected Long compute() { List<ForkJoinTask<Long>> subtasks = new ArrayList<>(); long size = 0; // Incorrect protected Long compute() { ForkJoinTask<Long> subtask; long size = 0; for(file f : root.listfiles()) { if (f.isdirectory()) { subtasks.add(new Task(f).fork()); else { size += f.length(); for (ForkJoinTask<Long> subtask : subtasks) { size += subtask.join(); return size; for (File f : root.listfiles()) { if (f.isdirectory()) { subtask = new Task(f).fork(); size += subtask.join(); else { size += f.length(); return size; /* l asynchronisme souhaité (fork) n est pas exploité : on a.end tout de suite */

41 Bonnes pra>ques A.en>on au coût de ges>on Le bénéfice obtenu en parallélisant un traitement doit être supérieur au coût de ges>on par le framework Trouver la bonne granularité A.en>on à la consomma>on mémoire Grosses structures : préférer la modifica>on "in- place" Découverte dynamique des sous- tâches A.en>on à la complexité Op>misa>on prématurée? Maintenance

42 Op>misa>ons Framework Fork / Join Threads >= Degré de parallélisme Les tâches en a.ente de join() sont mises de côté pour perme.re à d'autres tâches d'être traitées Tâches Eviter la synchronisa>on manuelle U>liser fork() et join() uniquement Op>miser la granularité à l'aide des sta>s>ques du pool getqueuedsubmissioncount(), getstealcount()... Possibilité d'op>misa>on dynamique

43 Quelques références qui m ont aidées pour préparer ce cours API Java 7, package java.u>l.concurrent h.p://download.java.net/jdk7/docs/api/ Etude de Doug Lea h.p://gee.cs.oswego.edu/dl/papers/ˆ.pdf Des blogs/tutoriaux h.p:// join html h.p://blog.paumard.org/2011/07/05/java- 7- forkjoin/ h.p://sdz.tdct.org/sdz/le- framework- executor.html h.p://fr.openclassrooms.com/informa>que/cours/apprenez- a- programmer- en- java/depuis- java- 7- le- pa.ern- fork- join

44 Un modèle proche mais complémentaire Map Reduce Sera présenté en détail dans certains parcours de 5ème année 44

45 Map Reduce Modèle de programma>on très contraint qui permet Une parallélisa>on automa>que De l équilibrage de charge Des op>misa>ons sur les transferts disques et réseaux De la tolérance aux pannes 1. Lecture des données 2. Map A chaque élément du flux repéré par une clé K1, Map associe un liste de couple <clé, valeur> Map: <K1, V1> à list (K2, V2) 3. Shuffle/Sort : regrouper les sor>es et les trier selon les clés K2 4. Reduce Exécuté une fois la phase Map terminée Agréga>on en liste de toutes les valeurs intermédiaires associées à une clé K2 Agréga>on est une opéra>on associa>ve Reduce: <K2, list(v2) > à list (K3, V3) bien souvent : K2 = K3 5. Ecrire les données 45

46 Exemple Parmis un ensemble de texte, compter les occurrences de chaque mot 1. Données : ensemble de fichier 2. Map Sur chaque texte, décomposer en mots, et à chaque mot m, ajouter à la liste des couples émis le couple (m, 1) 3. Shuffle/Sort Le système regroupe toutes les couples émis et les regroupes selon la clé m (a,1), (b,1), (c, 1), (b, 1), (a, 1), à (a, 1, 1), (b, 1, 1), (c, 1), 4. Reduce Les valeurs 1 sont addi>onnées pour chaque mot (a, 1, 1), (b, 1, 1), (c, 1), à (a, 2), (b, 2), (c, 1) 46

47 Exemple : Compter l occurrence de chaque mots dans un ensemble de fichiers Map Map: <K1, V1> à list (K2, V2) Exemple: K1 = nom du fichier, permet d associer chaque fichier à un noeud qui va traiter la fonc>on Map V1 = contenu du fichier K2 = mot V2 = 1 (présence d une occurrence) Pomme Orange Poire Pomme Pomme Orange Poire Orange Map <Pomme, 1> <Orange, 1> <Poire, 1> <Pomme, 1> <Pomme, 1> <Orange, 1> <Poire, 1> <Orange, 1> Map 47

48 Exemple (suite) Reduce <K2, list(v2) > à list (K3, V3) bien souvent : K2 = K3 Exemple: K2 = mot, permet d associé un mot à un noeud qui va traiter la fonc>on reduce V2 = 1 (présence d une occurrence) K3 = K2 V3 = N (nbre d occurrence détectée) La fonc>on d aggréga>on est la somme, elle est bien associa>ve <Pomme, 1, 1, 1> Reduce <Pomme, 3> <Orange, 1, 1, 1> Reduce <Orange, 3> <Poire, 1, 1> Reduce <Poire, 2> 48

49 Exemple Pomme Pomme Orange Orange Poire Poire Pomme Orange S P L I T Pomme Orange Poire Pomme Pomme Orange Poire Orange Map Map <Pomme, 1> <Orange, 1> <Poire, 1> <Pomme, 1> <Pomme, 1> <Orange, 1> <Poire, 1> <Orange, 1> S H U F F L E / S O R T <Orange, 1, 1, 1> <Poire, 1, 1> <Pomme, 1, 1, 1> <Orange, 3> Reduce <Poire, 2> Reduce <Pomme, 3> Reduce 49

50 Exemple (Mise en oeuvre) L u>lisateur programme les fonc>ons Map / Reduce En pseudo Java Map(String input_key, String input_value) { foreach word w in input_value do { EmitIntermediate (w, 1); Reduce (String key, Iterator<Integer> intermediate_value) { int result =0; foreach v in intermediate_value do { result += v; Le framework fourni les fonc>ons SPLIT / SORT mais aussi la ges>on du flux de données 50

51 ForkJoin versus MapReduce ForkJoin Single machine Takes advantage of mul>ple cores ForkJoin recursively par>>ons a task into several subtasks, on a single machine Starts quickly and scales well for small inputs (<5MB), but it cannot process larger inputs due to the size restric>ons of shared- memory, single node architectures. No fault tolerance No distribu>on Exist in Java since Java 7 MapReduce Cluster machine Take advantages of cluster machine. Massively scalable. Does only one big split, with no communica>on between the parts un>l the reduce step. MapReduce takes tens of seconds to start up, but scales well for much larger inputs (>100MB) on a compute cluster. Generally, fault tolerant implementa>on, transparent task distribu>on Exist since 2004 Popularized by google Open source implementa>on: hadoop (h.p://hadoop.apache.org/) 51

52 Q&A h.p:// 53