Régulation de charge Jean-Louis Roch Projet APACHE Laboratoire ID - IMAG École ParDi Oujda - Octobre 1999

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

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

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

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

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

Langages intégrant la régulation Langages restreints pour une classe d'applications : yinformation implicite sur les programmes  régulation intégrée dans le langage yThéorèmes : garantie de performances pour une classe de programmes/exécution Exemples : yBSP : super-pas synchrone; à chaque pas, permutation prochaine (h-relation) þ routage efficace [Valliant90,…] yCilk, Nesl : programmes série-parallèle + ordonnancement séquentiel (LIFO) þ work-stealing efficace : temps, mémoire, défauts de page [Blunhofe94,…, Randall99] yAthapascan-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]

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

Partie II. Formalisation du problème de régulation de charge 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

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

Interface régulation - application 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 Régulation Abstraction de la machine réelle

Interface régulation - architecture Régulation Réaction aux changements d’état des ressources inactivité des processeurs disponibilité des modules mémoire surcharge du réseau Contrôle l’utilisation des ressources Architecture 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

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 " t 1 < t 2 "  t < t 1 et t < t 2

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)

Partie III Analyse théorique de la régulation : compétitivité et coût 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é

Performance intrinsèque et compétitivité Programme A entrée x Temps Mémoire Performance intrinsèque : T exec 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égulations Ratio : comparaison entre l'ordt calculé et l'ordt optimal dans une classe donnée Régulation

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

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

Coût global de l'algorithme de liste 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) T p  + T  T1T1 p +  (  ) Prise en compte du coût de la gestion de la liste si centralisée =  ( # taches) =  (  )

Bornes inférieures et optimalité Méthode 1 : minorer la performance de tout algorithme de régulation sur une instance de graphe exemple: taches indépendantes pour ordt à la volée Méthode 2 : Montrer une contradiction avec P  NP Thé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

Partie IV. Régulation sur machine UMA (SMP) ou Ordonnancements sans communication 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

Vous avez dit glouton ? Non, distribuez ! 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 verrou Verrou arithmétique [Dikjstra,...][Cilk,..] Exemple : stratégie FIFO : accès locaux en tête -- vol en queue Nœud 1 Exécution Prête Attente Nœud 2 Exécution Prête Attente Nœud n Exécution Prête Attente...

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 T 1 sur T  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 : le micro-tache = création effective de la tache puis déplacement vers le processeur voleur

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, frame sync = teste si les spawn précédents sont terminés spawn suivants : exécutés en version optimisée

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

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

S 2 = 548ko S 1 = 78ko  Ordre d'exécution des tâches (p = 2) LIFO arbitraire p0p0 p1p1 S 2 = 146ko S 1 = 78ko

S 2 = 548ko S 1 = 78ko  LIFO S 2 = 146ko S 1 = 78ko arbitraire Ordre d'exécution des tâches (p = 2) p0p0 p1p1 O2 : seq loc O1 : seq glob S 2 = 143ko S 1 = 78ko

S 2 = 548ko S 1 = 78ko  O2 : seq loc S 2 = 143ko S 1 = 78ko LIFO S 2 = 146ko S 1 = 78ko arbitraire Ordre d'exécution des tâches (p = 2) p0p0 p1p1 O1 : seq glob

Ordre d'exécution des tâches (p = 2) p0p0 p1p1 arbitraire S 2 = 84ko S 1 = 78ko O1 : seq glob O2 : seq loc S 2 = 143ko S 1 = 78ko LIFO S 2 = 146ko S 1 = 78ko S 2 = 548ko S 1 = 78ko 

Optimiser la mémoire pS 1 S1S1 LIFO seq loc seq glob arbitraire

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

Compromis temps/mémoire –Ordre de référence maintenu de manière globale : + h q/p O(  ) –Beaucoup de messages : 1850 tâches migrées (sur 2405) pour p=4 –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 –Vol de travail arbitraire : peu de vols –Peu de messages : 240 tâches migrées (sur 2405) pour p=4 –Placement arbitraire des tâches : surcoût très faible –Beaucoup de messages : 1800 tâches migrées (sur 2405) pour p=4 « séquentiel global » « séquentiel local » LIFO Arbitraire

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

Partie V. Régulation sur machine NUMA ou Ordonnancements avec communications 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

Modèle de machine : LogP

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

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 h = 0 h = 1 h grand #p infini B_inf B_sup 1 1 7/6 4/3 1 c + 1 Ordonnancement de taches de durée = 1 avec précédences. Rapport communication/calcul = h

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

Prise en compte de la localité Regroupement des taches fortement communicantes Exemple : DSC = Direct-semi clustering [Pyros] Éloignement des taches les moins communicantes Exemple : bissection récursive [Metis, Scotch] Algorithme de liste avec choix sur critère de localité Exemple : ETF = Earliest Task First 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

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

Régulation et dégénération distribuée 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

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

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

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

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

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

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

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

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

Athapascan - 1 Portabilité : librairie C++ / Athapascan-0  Parallélisme indépendant de l’architecture Performances : Ordonnancement adapté à l'architecture Analyse du flot de données