Informatique parallèle IP 04 : Complexité et modèles de machine

Introduction Un problème Un problème différentes réponses (procédures) possibles Tri Tri-bulle, tri par insertion, quick-sort Intuitivement, le tri semble plus facile que l’ordonnancement Ordonnancement (chapitre 8) LJF, SJF, MRT, Graham …etc solution exacte (la liste triée) au bout d’un temps de calcul raisonnable Combinatoire trop importante Recherche exhaustive de la solution prend trop de temps On se contente d’une bonne solution approchée Procédure = algorithme Procédure = heuristique

Introduction Un problème Un problème différentes réponses (procédures) possibles Evaluer ces procédures (algorithmes ou heuristiques) pour choisir celle qui convient le mieux à la résolution de notre problème. Par exemple, la complexité en temps de calcul sur une machine de Turing en fonction du nombre de données à trier Evaluer = calculer la complexité par rapport à un modèle de machine et un critère en fonction de paramètres Recherche d’ordre de grandeur pour connaître le comportement de la procédure avec des paramètres de grandes valeurs Utilisation des fonctions O, o,  et 

Les fonctions O, o,  et  - f(n) = O(g(n)) si  c > 0 et m /  n  m, f(n)  c g(n) - f(n) = o(g(n)) si   > 0,  m /  n  m, f(n)   g(n) - f(n) = (g(n)) si  c > 0 et m /  n  m, f(n)  c g(n) - f(n) = (g(n)) si  c1 et c2 > 0 et m /  n  m, c1 g(n)  f(n)  c2 g(n) cg(n) cg(n) f(n) f(n) m n c2g(n) f(n) f(n) cg(n) c1g(n) m n

Machines séquentielles : Turing Le modèle de machine de Turing est proposé en 1936 afin de montrer que, si un problème est calculable, alors il existe une machine pour le résoudre. Il s’agit d’une machine à état constituée d’une mémoire d’une taille infinie (un ruban comportant un nombre infini de cases) où la case courante est repérée par un pointeur. Cette machine est capable de réaliser 4 actions : écrire un symbole dans la cellule courante; d'effacer le contenu de la cellule courante (écrire le symbole blanc); se déplacer d'une cellule vers la gauche ou vers la droite (en fonction de son état); lire le symbole contenu dans la cellule courante. Simulation en Javascript disponible à http://zanotti.univ-tln.fr/turing/

Machines séquentielles : Turing D’un point de vue formelle, la machine de Turing peut être définie par 4 éléments (, Q, q0, ) :  est un ensemble fini correspondant à l’alphabet des symboles utilisés pour stocker les informations dans la mémoire (il comporte un symbole « blanc » pour spécifier l’absence d’information) ; Q est un ensemble fini contenant les différents état de la machine ; q0 est l’état initial de la machine ;  est la fonction de transition définie par Q x  vers Q x  x {,} (on définie pour chaque couple (état courant, symbole lu), le(s) triplet(s) formé(s) par le nouvel état, le symbole à écrire et le déplacement à effectuer). La fonction de transition peut être une bijection, la machine de Turing est alors qualifiée de déterministe (DTM). Sinon, la « fonction » de transition peut proposer plusieurs possibilités, la machine de Turing est alors non-déterministe (NDTM). http://www.lim.univ-mrs.fr/~colmer/Courdeug2002/cours/turing.pdf

Machines séquentielles : RAM RAM signifie (Random Access Machine) qui est traduit en français par « machines à registres ». Ce modèle de machine, proposée par Alfred Aho, John Hopcroft et Jeffrey Ullman, est composée de : Un accumulateur R0 pouvant stocker n’importe quel entier pour effectuer des opérations Compteur R0 … R1 Ri Programme Unité de contrôle Une infinité de registre R1 … Ri permettant de stocker n’importe quel entier Une unité de contrôle contenant le programme à exécuter Une compteur permettant de connaître la position dans le programme (l’instruction courante) http://www.cse.tum.de/vtc/FundAlg/ http://www.cs.fit.edu/wds/classes/complexity/lct/turing/ http://www.cs.duke.edu/~reif/courses/cps130/lectures/reif.lectures/ALG1.1.pdf http://wwwzenger.informatik.tu-muenchen.de/lehre/vorlesungen/fundalg/WS02/docs/ram.pdf

Machines séquentielles : RAM Op Code Address 1. LOAD operand 2. STORE 3. ADD 4. SUB 5. MULT 6. DIV 7. READ 8. WRITE 9. JUMP address 10. JGTZ 11. WRITE 12. HALT Ce modèle de machine dispose d’un jeu d’instructions un peu plus fourni que la machine de Turing. Ces instructions sont les « instructions élémentaires » que nous considérons lorsque nous calculons la complexité d’une procédure. Il est possible de « simuler » une machine RAM à partir d’une machine de Turing, et inversement, ces deux modèles sont donc équivalents (d’un point de vue Conceptuel)

Complexités T(n) et S(n) Etant donné un modèle de machine séquentiel, on calcule souvent deux complexités afin de caractériser une procédure : Une complexité spatiale, notée S(n), qui correspond au nombre de mots nécessaires pour exécuter une procédure traitant n éléments (connaissant le nombre de cases mémoire occupée par un mot) Une complexité temporelle, notée T(n), qui correspond au nombres d’instructions, nécessaires au traitement de n données (connaissant la durée d’exécution d’une instruction). http://www.lim.univ-mrs.fr/~colmer/Courdeug2002/cours/turing.pdf http://www.limsi.fr/Individu/jps/enseignement/tutoriels/archi/ARCHI.02.Complexite/ch2complexite.html

Exemple de calcul de complexité Exemple d’un calcul de n! : int factoriel (int n) { int cumul = 1; for (int i=n; i>1; i--) cumul *= n; return cumul; } Complexité temporelle de la procédure factoriel : on distingue l’opération d’affectation A, la multiplication M, le test T et la décrémentation D (dans l’instruction for), on obtient alors : n Opérations effectuée Complexité en temps (1 instruction = 1 unité de temps) A, A, T 3 1 A, A, T 3 2 A, A, T, M, A, D, T 7 3 A, A, T, M, A, D, T, M, A, D, T 11 …etc On constate finalement que Tfactoriel (n) = 3 + 4 x max (n-1, 0). Comme c’est le comportement asymptotique qui nous intéresse, nous considérons que Tfactoriel (n) = 4 n lorsque n est grand, autrement dit, Tfactoriel (n) = (n)

Exemple de calcul de complexité Le calcul de la complexité s’effectue de façon récursive Pour calculer la complexité d’une procédure P faisant appel à d’autres procédure P1 et P2, il faut calculer la complexité de P1 et P2 puis ajouter cette dernière à la complexité de P à chaque appel de P1 et de P2 Exemple : calcul de Cn = n! / (p!.(n-p)!) p La complexité en temps de nbCombinaisons en fonction de p et n est égale à (avec 3 affectations, 1 multiplication et 1 division) : TnbCombinaisons (n,p) = Tfactoriel (n) + Tfactoriel (p) + Tfactoriel (n-p) + 3 + 2 int nbCombinaisons (int n, int p) { int a = factoriel (n); int b = factoriel (p); int c = factoriel (n-p); return a / (b*c); } Finalement, on a TnbCombinaisons (n,p) = (n) + (n) + (n) = (n) http://graal.ens-lyon.fr/~alegrand/Teaching/Algo-DEUG-02/Cours/node13.html

Exercice : Multiplication de matrices Soient A = [ai,j] , B = [bj,k] et C = [ci,k] Le produit matriciel C = A  B est défini par : Ci,k =  (ai,j  bj,k) ,  i[1;m] ,  k[1;o] 1im 1jn 1jn 1ko 1im 1ko m j=1 Matrice multiplication (Matrice A, Matrice B) { int m=A.getNombreDeLignes(); int n=A.getNombreDeColonnes(); int o=B.getNombreDeColonnes(); Matrice C(m,o);   for (int i=1; i<=m; i++) for (int k=1; k<=o; k++) C.getElement(i,k)=0; for (int j=1; j<=n; j++) C.getElement(i,k)+=A.getElement(i,j)*B.getElement(k,j); } return C; Si m=n=o, calculer T(n) et S(n)

Exercice : Multiplication de matrices Complexité spatiale : Nous devons stocker 3 matrices d’entiers, A, B et C, de tailles n² ce qui représente 6 n² donc S(n)=O(n2) Complexité temporelle : Nous exécutons n² fois le code écrit entre les deux accolades, situées après le 3ème for, c’est-à-dire : L’initialisation de Cik Le chargement de la ième ligne de A (nous chargeons successivement les n éléments de cette ligne). Le chargement de la jème ligne de B (les n éléments de cette colonne sont chargés les uns après les autres). n multiplications (aijbjk) n cumuls (addition entre l’ancienne valeur de cik et le résultat du produit précédent) Nous voyons que le temps d’exécution est en O(n3), plus précisément le temps de calcul est en O(n3) et le temps de chargement est en O(n3) On peut améliorer le temps de chargement en utilisant au mieux la mémoire cache

Exercice : Multiplication de matrices 1 2 3 4 5 6 7 8 10 9 13 14 15 11 12 16  1 2 3 4 5 6 7 8 10 9 13 14 15 11 12 16  Distribution triviale Distribution en ligne ou en colonne Pas efficace du point de vue du cache 1 2 3 4 5 6 7 8 10 9 13 14 15 11 12 16  Distribution en blocs

Exercice : Multiplication de matrices Matrice multiplicationParBloc (Matrice A, Matrice B) { int m=A.getNombreDeLignes(); int n=A.getNombreDeColonnes(); int o=B.getNombreDeColonnes(); Matrice C(m,o);   for (int i=1; i<=m/K+1; i++) for (int k=1; k<=o/K+1; k++) C.getBlock(i,k,K)=0; for (int j=1; j<=n/K+1; j++) C.getBlock(i,k,K) += multiplication (A.getBlock(i,j,K),B.getBlock(k,j,K); } Multiplication par blocs (voir BLAS 3) : S(n) = O(n2) Tcalcul(n) = O(n3) Tchargement mémoire centrale vers mémoire cache(n) = O(n3/K3) Tchargement mémoire cache vers processeur(n) = O(K3) http://docserver.ub.rug.nl/eldoc/dis/science/t.a.lippert/c7.pdf

La complexité des problèmes On utilise les calculs de complexité pour caractériser les procédures. On peut également caractériser les problèmes grâce à la complexité. Cela permet de savoir si ça vaut le coup de rechercher un algorithme (doit-on se contenter d’une heuristique ??) On réduit le nouveau problème à un problème déjà classé (s’il est plus dur qu’un problème déjà très dur alors on en déduit qu’il est très dur) On regarde s’il existe un algorithme permettant de résoudre le problème et on calcule sa complexité Différentes classes de problèmes http://www.enseignement.polytechnique.fr/informatique/IF/a13/a13.html http://prolland.free.fr/Cours/Cycle1/MIAS/MIAS2/Decidabilite/decidabilite.html http://fr.wikipedia.org/wiki/Algorithmique http://www.lri.fr/~kesner/algo/poly1.ascii

Les classes de problèmes La classe P est formée des problèmes qui peuvent être résolus par un algorithme polynomial (un algorithme ayant T(n)=O(nk)) La classe NP est formée des problèmes dont la solution peut être vérifiée par un algorithme polynomial. Un exemple classique de problème dans NP est celui du voyageur de commerce. Un voyageur doit visiter n villes reliées un certain nombre de routes. Existe-t-il un trajet permettant de visiter toutes les villes en moins de k kms. On ne connaît pas d’algorithme à ce problème mais on peut vérifier rapidement qu’un trajet fait moins de k kms. On a P  NP mais a-t-on NP  P ? (autrement dit P = NP ?) C’est la question à 1 million de dollars du Clay Mathematic Institute (http://www.claymath.org/millennium/) La classe NP-Complet est une sous-classe de NP. Un problème est NP-Complet quand tous les problèmes appartenant à NP lui sont réductibles. Si on trouve un algorithme polynomial pour un problème NP-Complet, on trouve alors automatiquement une résolution polynomiale des tous les problèmes de classe NP. http://www.aromath.net/Page.php?IDP=667&IDD=0 http://www.bibmath.net/crypto/complements/complexite.php3 http://www.labri.u-bordeaux.fr/Perso/~betrema/MC/MC8.html

La réduction 1 2 On plonge 1 dans 2 (une partie de 2 est isomorphe 1) : 1  2 Les propriétés utilisées pour classer un problèmes : 2  P  1  P 1  NP-complet  2  NP-complet

Du séquentiel au parallèle (ss comm) Turing RAM Machine de type SISD (1 seul processeur élémentaire ou PE) Complexité T(n) et S(n) PRAM Machine parallèle (p PE) Complexité Tp(n) et Sp(n)

Machines parallèles : PRAM PRAM (Parallel Random Access Machine) est une extension du modèle RAM pour modéliser les machines à mémoire partagée. Une machine PRAM est composée de : Un ensemble infini de processeurs, P0, P1, …Pn, où chacun connaît son indice et possède : Un registre m0 qui peut contenir des entiers de taille infinie Une mémoire locale (inaccessible aux autres processeurs) qui est en faite une suite infinie de registres, m1,… mi, qui peuvent également contenir des entiers de taille infinie Un compteur ordinal Un drapeau qui indique si le processeur est actif ou non Une mémoire commune composée d’un nombre infini de cases (M0, M1, … Mj) qui peuvent contenir des entiers de taille infinie et qui sont accessibles par tous les processeurs en lecture et en écriture. Un horloge commune qui synchronise le fonctionnement des processeurs P0 m0 m1 mi compteur Actif/passif P1 Pn …… M0 M1 M2 Mj

Machines parallèles : PRAM A l’instar des machines parallèle à mémoire partagée, il existe différents types de machines PRAM. Lecture Écriture Concurrente Exclusive ERCW ? EREW CRCW CREW Celui qui a la plus haute priorité écrit Un écrivain, choisi au hasard, écrit On écrit s’il y a consensus sur la valeur On écrit une valeur égale au « cumul » des Valeurs de chaque écrivain sur une opération

Mesure de T1(n) et T(n) Un programme parallèle est modélisé sous la forme d’un graphe de flot de données. Généralement, nous calculons deux complexité temporelles : 4 10 2 Le temps séquentielle T1 20 6 1 Le temps parallèle T 2 7 5 T est calculé en utilisant le chemin critique, c’est-à-dire le chemin le plus long dans le graphe de flot de données T1 vaut 57 alors T vaut 34

Lemme de Brent et Tp(n) T1(n)-T(n) Tp(n)  T(n) + p P6 P5 m m ’ P4 temps P1 temps

Le gain et l’efficacité On définit le Gain Gp (N) comme le rapport entre le temps d'exécution en mode séquentiel, c'est-à-dire T1(N), et le temps d'exécution en parallèle sur P PEs : Gp (N) = T1 (N) / Tp (N) On définit l 'Efficacité Ep (N) comme le rapport entre le gain et le nombre de processeurs utilisés : Ep (N) = Gp (N) / P Si le problème est "complètement parallélisable" alors Tp (N) est P fois plus rapide que T1 (N). Dans ce cas, le Gain Gp (N) = P et l'efficacité maximale est donc Ep (N) = 1. Deux cas peuvent se produire : Si N est plus grand que P, on place plusieurs éléments sur un même PE et on les traite en séquence (on dit aussi de manière concurrente). Dans cette méthode dite des processeurs virtuels, la commutation peut prendre du temps : si ce temps est une constante ne dépendant ni de N ni de P alors il n'affecte pas la complexité asymptotique. Dans le cas contraire on a déjà vu que la perte de performance peut être importante. Si N est plus petit que P, on ne peut pas utiliser tous les processeurs ; dans ce cas, seule l'efficacité est affectée. En pratique, la taille du problème est généralement très supérieure au nombre de PEs : N >> P.

Du séquentiel au parallèle (avec comm) Turing RAM Machine de type SISD (1 seul processeur élémentaire ou PE) Complexité T(n) et S(n) PRAM Machine parallèle (p PE) Complexité Tp(n) et Sp(n) MP-RAM Complexité Cp(n) pour le coût des communications DRAM BSP, LogP

Machines parallèles : MP-RAM et DRAM MP-RAM (Message Passing - Random Access Machine) est une tentative de modélisation des Machines MIMD à passage de messages. Il s’agit d’un ensemble de machines RAM reliées par un réseau et qui disposent de deux nouvelles instructions : Send @voisin écrit le contenu de l'ACCU dans l'ACCU de @voisin ; Receive @voisin lit le contenu de l'ACCU de @voisin et le met dans ACCU Réseau P0 P1 Pn …… m0 m1 mi compteur Actif/passif m0 m1 mi compteur Actif/passif m0 m1 mi compteur Actif/passif Il existe une autre variation appelée Dynamic Random Access Machine (DRAM) qui est décrite à http://www-2.cs.cmu.edu/afs/cs.cmu.edu/project/phrensy/pub/papers/LeisersonM88/node12.html http://www.aromath.net/Page.php?IDP=667&IDD=0 http://citeseer.ist.psu.edu/leiserson88communicationefficient.html http://www-2.cs.cmu.edu/afs/cs.cmu.edu/project/phrensy/pub/papers/LeisersonM88/LeisersonM88.html

Machines parallèles : BSP BSP (Bulk Synchronous Parallel) est à la fois un modèle de machines et de programmation qu’on peut télécharger à l’URL http://www.bsp-worldwide.org/ Son fonctionnement repose sur la séparation des calculs et des communications. L’application parallèle est faite d’une succession de super-étapes de calculs (aucune communication n’est générée), séparées par des phases de synchronisation, au cours desquelles les informations nécessaires pour la réalisation de la super-étape suivante, sont envoyées vers les processeurs (c’est durant cette phase que nous pouvons effectuer l’équilibrage de charge). Tous les processeurs passent simultanément d’une super-étape de calcul à une phase de synchronisation et inversement P1 P2 P3 Communications implicite Barrière de synchronisation

Machines parallèles : LogP o : parallel L : latency (la latence du réseau) o : overhead (la quantité d’information supplémentaire) g : gap (le temps d’attente entre l’emballage et l’entrée sur le réseau) P Latence (L) Buffer de communication Mémoire1 Mémoirep Surcoût (overhead o) gap (g)

Mesure de C1(n) et C(n) A l’instar du temps de calcul, nous nous intéressons au coût en communication en calculant deux complexités : 4 Le coût en communication pour un processeur : 10 2 20 6 1 Le coût en communication pour une infinité de processeurs : 2 7 5 Le chemin tel que ce coût soit maximum n’est pas nécessairement le chemin critique du graphe La valeur de l’arc 2-5 correspond au coût de communication entre ces deux tâches La connaissance de cette information peut « guider » l’ordonnancement des travaux (allouer plusieurs tâches à un même processeur afin d’éviter des communications coûteuse)