1 / 51

Régulation de charge

Régulation de charge. École ParDi Oujda - Octobre 1999. Jean-Louis Roch. Projet APACHE Laboratoire ID - IMAG. Plan. I. Introduction : Régulation de charge et langages parallèles II. Définition du problème de régulation de charge

chill
Download Presentation

Régulation de charge

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Régulation de charge École ParDiOujda - Octobre 1999 Jean-Louis Roch Projet APACHE Laboratoire ID - IMAG

  2. Plan • I. Introduction : Régulation de charge et langages parallèles • II. Définition du problème de régulation de charge • III. Analyse théorique : compétitivité et coût • IV. Ordonnancement UMA (sans communication) • V. Ordonnancement NUMA (avec communications) • VI. Ordonnancements hybrides

  3. Partie I Introduction Régulation de charge et langages parallèles • Principales techniques de régulation • Codage à la main de la régulation • Limites du codage à la main • Langages intégrant la régulation

  4. Principales techniques de régulation • Techniques de régulation : nombreuses, bien décrites, utilisées • Exemples [Stratageme96,…]: • Ordonnancement glouton [Graham66,…] : minimiser l'inactivité • limiter la mémoire et les migrations [Work-Stealing, … ], • limiter les communications [ETF, DSC, ...] • Analyse des précédence entre taches • Partitionnement de graphe : minimiser les communications [Metis94, Scotch96] • Analyse des dépendances entre taches communicantes • En pratique : stratégie hybride : statique/dynamique • exemples : Dynamique moléculaire [Bernard97] , Chloesky creux […,Dumitrescu98, ]

  5. Codage à la main de la régulation • Approche "classique"[Stratageme96, ...] 1. Analyse de l'application/exécution 2. Choix d’une régulation adaptée à l’application 3. Écriture d’un programme parallèle (MPI) qui implémente simultanément application et régulation • Exemple : ScaLapack :algèbre linéaire dense pour architectures distribuées 1. Analyse : Algèbre linéaire : • opérations de blocs assez équilibres • beaucoup de communications potentielles 2. Choix régulation : • distribution bloc-cyclique bi-dimensionnelle de la matrice • "Owner computes rule" pour placement des calculs 3. Codage : MPI (SMPD sur BLACS) : synchrone par super pas

  6. Limites du codage à la main • Écriture de plusieurs programmes : • un pour calculer l'information sur l'exécution • ex: graphe de taches pour Metis • l'autre pour programmer l'application (avec la régulation) • Problème de fiabilité : • l'information utilisée pour la régulation est-elle cohérente avec l'application ? • Problème de portabilité : • si l'architecture change, qu'est qui doit changer dans le code ? • Problème de maintenance : • si l'information/régulation change mais pas l'application : tout réécrire

  7. Langages intégrant la régulation • Langages restreints pour une classe d'applications : • information implicite sur les programmes  régulation intégrée dans le langage • Théorèmes : garantie de performances pour une classe de programmes/exécution • Exemples : • BSP : super-pas synchrone; à chaque pas, permutation prochaine (h-relation) • routage efficace [Valliant90,…] • Cilk, Nesl : programmes série-parallèle + ordonnancement séquentiel (LIFO) • work-stealing efficace : temps, mémoire, défauts de page [Blunhofe94,…, Randall99] • Athapascan-1 : construction implicite du flot de données [Roch&al98] • tout programme • ordonnancements efficaces pour des classes de programmes: UMA, NUMA,... • Autre motivation : sémantique [Rinard98]

  8. F(2,a) G(a, b) H(b) b a H(a) O(b,7) PGCD = flot de données • Flot de données : informations de précédence et dépendance Class f { operating()( shared_r_w<int> x ) { x = sin(x->val ) * BB(taq ( x ) ) ; } void main(int argc, char* argv) { Fork<f> ( shared<int> (3) ) ; } • Peut être calculé implicitement par interprétation abstraite[Sisal, Jade] • avec un surcoût borné[Athapascan-1] • Annotations : pour ajouter des informations

  9. Définition du problème de régulation Interface régulation - programme / application Interface régulation - exécution / architecture Hypothèses application Hypothèses architecture Partie II. Formalisation du problème de régulation de charge

  10. Flot de données Mémoire Temps Définition du problème de régulation Architecture parallèle Programme + Données d ’entrée Interface avec l ’application Interface avec l ’architecture Régulation de charge • Entrée : • un programme A + une donnée x • une machine M • Sortie : • une exécution correcte de A(x) sur M

  11. Application Informations sur l'exécution Opérateurs de parcours du graphe de flot de données Allocations de ressources pour l'application : Opérateurs de • création de tâches • allocation de mémoire Abstraction de la machine réelle Régulation Interface régulation - application

  12. Régulation Contrôle l’utilisation des ressources Réaction aux changements d’état des ressources • inactivité des processeurs • disponibilité des modules mémoire • surcharge du réseau Exploitation directe des ressources • allocation de mémoire dans un module • création de flots d’exécution (processus, thread) • démarrage/arrêt de tâches • informations sur l’utilisation des ressources Programmation bas-niveau de l'architecture Architecture Interface régulation - architecture

  13. Hypothèses application • (H0) Flot de données de A(x) invariant • mais a priori inconnu avant la fin de l'exécution • doit pouvoir être construit à la volée • (H1) Hypothèses simplificatrices pour assurer • la correction : • si une tache t crée une tache t' t' < t • si une tache t ajoute une dépendance " t1 < t2" t < t1 et t < t2

  14. Hypothèses architecture • (H3) Données - Synchronisation - communication • Lire / Écrire (adr_globale, adr_locale ) …. • Lock / Unlock (verrou global) • (H4) Exécution / Entrelacement des taches • Démarrer ( tache, processeur inactif ) • Dupliquer (tache ) • Préempter ( tache en cours) restreinte (Kill) ou générale (continuation / migration)

  15. Performance intrinsèque et compétitivité Modèle de coût du programme Compétitivité : Exemple d'un algorithme glouton Coût global de l'algorithme glouton Bornes inférieures et optimalité Partie III Analyse théorique de la régulation : compétitivité et coût

  16. Mémoire Temps Performance intrinsèque et compétitivité Programme A entrée x Régulation • Performance intrinsèque :Texec sur p processeurs ( A(x) ) = ( P, x, Machine(p), ... ) incluant ou non le coût du calcul de l'ordonnancement • Performance relative : par rapport à d'autres régulationsRatio : comparaison entre l'ordt calculé et l'ordt optimal dans une classe donnée

  17. Le flot de données est invariant ! • Toute exécution de P(x) donne le même flot  Connaissance symbolique de P(x) • Modèle de coûtbasé sur le grapheassocié à P(x) • T1 : la durée d'une exécution séquentielle • T : la durée d'un chemin critique • C1, C : volume total et critique des accès distants : les communications • S1 : l'espace mémoire consommé par une exécution séquentielle •  : la taille du graphe (nœuds et arêtes) • Calcul de ces grandeurs ? • T1, T, C1, Cet: dynamiquement sur le graphe d'une exécution test de P(x) • S1 à partir d'une exécution séquentielle de P(x) Modèle de coût

  18. Attente Prête Nœud central . . . Exécution Exécution Exécution Nœud 1 Nœud 2 Nœud n T1 Tp + T p Un exemple : Ordonnancement glouton • Maintenir les processeurs au maximum actifs • Processeur inactif  prendre une tâche prête •  Théorème [Graham 66]

  19. Compétitivité : • sans la gestion de la liste [Graham 66] : Ratio = ( 2 - 1/p) < 2 • Coût global de l'exécution :si centralisée = ( # taches) • Prise en compte du coût de la gestion de la listesi centralisée = ( # taches) = (  ) T1 Tp + T p Coût global de l'algorithme de liste + (  )

  20. Méthode 1 : minorer la performance de tout algorithme de régulation sur une instance de grapheexemple: taches indépendantes pour ordt à la volée Méthode 2 : Montrer une contradiction avec P  NPThéorème de l'impossibilité [Lenstra-Shmoys] : si le problème sur m machines est NP-complet, alors Ratio > (m+1)/m exemple: taches de durée 1, sans com. : Ratio > 4/3 Bornes inférieures et optimalité

  21. Vous avez dit glouton ? Non, distribuez ! Optimiser le surcoût en temps : dégénération séquentielle Exemple : Cilk Comparaisons expérimentales Optimiser le surcoût en mémoire Comparaisons expérimentales Partie IV. Régulation sur machine UMA (SMP)ouOrdonnancements sans communication

  22. Distribuer la liste des taches : Localement : gestion des taches créées/exécutées sur le processeur Si inactivité : vol de tache(s) sur un autre processeur Contention pour l'accès a la liste locale : éviter les prises de verrouVerrou arithmétique [Dikjstra,...][Cilk,..] Exemple : stratégie FIFO : accès locaux en tête -- vol en queue . . . Attente Exécution Attente Exécution Attente Exécution Prête Prête Prête Nœud 1 Nœud 2 Nœud n Vous avez dit glouton ? Non, distribuez !

  23. Optimiser le coût : dégénération séquentielle • Dans un algorithme glouton, un processeur est rarement inactif ! ( < p. T ) • "Work-first principle" : privilégier T1surT • Optimiser l'exécution sans vol :nano-tache = appel de fonction + minimum pour autoriser un vol • Mettre le surcoût lors du vol de tache : lemicro-tache = création effective de la tache puis déplacement vers le processeur voleur

  24. Exemple : Cilk • Optimiser l'exécution sans vol :- Exécution en profondeur d'abord : tache = appel de fonction - Sauvegarde minimale pour autoriser une continuation (pointeur sur le contexte)sync = nop !!! • Mettre le surcoût lors du vol de tache : - Vol de la suite, pas des spawn !!! - Restauration contexte : compteur ordinal, pile, framesync = teste si les spawn précédents sont terminés spawn suivants : exécutés en version optimisée

  25. Fibonacci pour 1 et 2 processeurs (SMP) durée = f( seuil ) Cilk   Ath-1 Comparaisons expérimentales Séquentiel Athapascan-1 sans dégénération séquentielle Cilk Dégénération séquentielle

  26. allocations S1 = logn + un morceau d'image = 78 ko Et la consommation mémoire ? • Calcul récursif : Découpe en 4 découpes de l'image découpes du calcul affichage affichage

  27. p0 p1 S2 = 548ko S1 = 78ko  Ordre d'exécution des tâches (p = 2) arbitraire S2 = 146ko S1 = 78ko LIFO

  28. p0 p1 S2 = 548ko S1 = 78ko arbitraire  S2 = 146ko S1 = 78ko LIFO Ordre d'exécution des tâches (p = 2) S2 = 143ko S1 = 78ko O2 : seq loc O1 : seq glob

  29. p0 p1 S2 = 548ko S1 = 78ko 17 18 21 22 arbitraire 20 19 24 23 2 1 33 13 34 14 26 29 30 25  36 16 35 15 27 32 31 28 1 2 37 38 S2 = 146ko S1 = 78ko LIFO 4 3 S2 = 143ko S1 = 78ko O2 : seq loc 3 4 Ordre d'exécution des tâches (p = 2) 1 2 5 6 4 3 8 7 10 9 11 12 O1 : seq glob

  30. p0 p1 S2 = 548ko S1 = 78ko  S2 = 146ko S1 = 78ko LIFO S2 = 143ko S1 = 78ko O2 : seq loc S2 = 84ko S1 = 78ko O1 : seq glob  Ordre d'exécution des tâches (p = 2) arbitraire

  31. arbitraire pS1 LIFO seq loc seq glob S1 Optimiser la mémoire

  32. Sp #T S1 • P lacement arbitraire des tâches • Listes locales puis vol de travail arbitraire • graphes série-parallèle [Blumofe-Leiserson98] • Ordre de référence suivi localement • Parcours en profondeur • Cilk, Athapascan-1 SpqS1 • Ordre de référence suivit de manière globale • graphes statiques [Narlikar98] • graphes dynamiques : Athapascan-1 SpS1 + q.O(T ) Consommation mémoire théorique • Arbitraire • « séquentiel local » • « séquentiel global » [Narlikar98]

  33. Compromis temps/mémoire • Arbitraire • Placement arbitraire des tâches : surcoût très faible • Beaucoup de messages : 1800 tâches migrées (sur 2405) pour p=4 • LIFO • Vol de travail arbitraire : peu de vols • Peu de messages : 240 tâches migrées (sur 2405) pour p=4 • « séquentiel local » • Vol de travail arbitraire : peu de vols • Peu de messages : 240 tâches migrées (sur 2405) pour p=4 • Parcours en profondeur : léger surcoût • « séquentiel global » • Ordre de référence maintenu de manière globale : + h q/p O(s ) • Beaucoup de messages : 1850tâches migrées (sur 2405) pour p=4

  34. Exemple d'application Recherche de séquence d'ADN Algorithme séquentiel générique [Musser98] Compromis Knuth-Morris-Pratt/Boyer-Moore Parallélisation : découpe en taches indépendantes Pentium 4x200MHz

  35. Modèle de machine : LogP Difficulté de l'ordonnancement avec communication Extension des algorithmes gloutons Prise en compte de la localité Exemples expérimentaux Optimiser le coût : Dégénération distribuée Exemples expérimentaux Partie V. Régulation sur machine NUMAou Ordonnancements avec communications

  36. Modèle de machine : LogP

  37. Masquage des latences de communication • Outil de base : "parallel slackness" [Valliant 90, Karp 96,…] • Mise en œuvre : multithreading • Régulation a deux niveaux • global : placement des taches et données sur les nœuds • local : ordonnancement local des tâches prêtes sur des threads dédiés

  38. Difficulté de l'ordonnancement avec communication #p entrée B_inf B_sup 4/3 2 5/4 7/3 1+1/(c+3) c + 2 #p petit p=2 : polyn. p=3 : ouvert p=2 : ouvert p=2 : NP-complet #p infini B_inf B_sup 1 1 7/6 4/3 1 c + 1 h = 0 h = 1 h grand Ordonnancement de taches de durée = 1 avec précédences. Rapport communication/calcul = h

  39. T1 + hC1 p durée d'accèsdistant h Tp + O(T + hC )  . . . qprocesseurs virtuels hq  p . . . pprocesseurs physiques Extension des algorithmes gloutons • Hachage universel : distribution des mots de donnée dansles modules mémoire [Karp&al 96, …] • Ordonnancement sur q processeurs virtuels, latence d'accès = h • En pratique, h grand : il faut prendre en compte la localité

  40. Prise en compte de la localité • Algorithme de liste avec choix sur critère de localité Exemple : ETF = Earliest Task First • Regroupement des taches fortement communicantes Exemple : DSC = Direct-semi clustering [Pyros] • Éloignement des taches les moins communicantes Exemple : bissection récursive [Metis, Scotch] • Restriction des programmes considérés Exemple : graphes série-parallèle [Metis, Scotch]#défauts de page en distribué < #p. #défauts de page en séquentiel

  41. Modèle de communication et régulation • Cholesky creux : [Doreille99] Ordonnancement ETF et modèle délai  sensibilité importante au rapport bande passante/vitesse processeur 16 processeurs (IBM-SP1) MFlops = f( taille ) 16 proc 4 proc 1 proc

  42. 1. Génération dynamique du graphe de flot de données 2. Calcul d'un "ordonnancement" du graphe annoté : placement des tâches et des données sur les nœuds de l'architecture graphe de flots de données  JIT-compilation du graphe des communications à réaliser entre nœuds 3. Exécution distribuée efficace de l'application : sur chaque nœud, ordonnancement local : poster les requêtes de lectureà distance (tâches non prêtes) : réception Boucle : exécution tâche prête poster les écritures à distance : émission mettre à jour l'état local  Pas plus de communications qu'une écriture directe en MPI Régulation et dégénération distribuée

  43. Exemples expérimentaux Athapascan-1 : 5000 taches ScaLapack : 16 proc. MPI • Cholesky dense : dpotrf[Doreille99] 16 processeurs (IBM-SP1) Athapascan1- JITcom ETF MFlops = f( taille ) Athapascan1- JITcom bloc-bidim ScaLapack bloc-bidim

  44. Processeurs non-identiques et relaxation Clusters de SMP Partie VI. Régulation sur un réseau de machines Ordonnancements hybrides

  45. Processeurs non-identiques et relaxation • Difficulté : modélisation précise du problème • Machines uniformes : vitesses proportionnelles (connues ou non) • Machines non-uniformes :durée d'une tache varie selon le processeur • Borne inférieure : ratio > log m [Shmoys,…] • Borne supérieure : relaxation [Shmoys,…]migration de taches trop longues

  46. Exemple d'application Recherche de séquence d'ADN Recherche distribuée dans 2 répertoires de même taille chacun sur un disque distant (NFS) • Séquentiel Pentium 4x200 Mhz • SMP Pentium 4x200 Mhz • Architecture distribuée MyrinetPentium 4x200 Mhz + 2x333 Mhz

  47. Exemple : cluster de SMP = grappe - Réseau de N nœuds identiques - Chaque nœud est un SMP multi-processeurs hiérarchie mémoire

  48. Mixer ordonnancement statique et dynamique - Hypothèse : information sur l'exécution flot de données annoté - Placement statique des taches sur les nœuds - A l'intérieur d'un nœud: ordonnancement dynamique (liste) sur les processeurs

  49. Athapascan1 entre 33% et 100% plus rapide que Scalapack Un exemple expérimental Athapascan-1 : 330000 taches ScaLapack : 64 proc. MPI • Cholesky dense : dpotrf[Doreille99] Grappe de 64 processeurs 16 SMP x 4 (16 stations SUN295 MHz) [Delaware] MFlops = f( taille ) - Grain : bloc 100x100 - Sur les 16 nœuds : Bloc-cyclique bidim - Sur chaque SMP ordt glouton

  50. Conclusion • Régulation : lien entre programme et machine • Difficulté : forte dépendance avec l'architecture => peu de résultats sur des modèles réalistes (LogP) • Progrès importants depuis 10 ans : il existe des approches efficaces et portables : exemple : Cilk (SMP), Athapascan-1 (distribuée) • Une clef de l'efficacité est la maîtrise du surcoût d'ordonnancement : - dégénération séquentielle / Work-stealing - dégénération distribuée basée sur l'analyse du flot

More Related