Denis Trystram
Grenoble INP
51 avenue J. Kuntzmann, F-38330 Montbonnot St. Martin Institut Universitaire de France
trystram@imag.fr
RÉSUMÉ. Paralléliser c’est exécuter des opérations (instructions ou programmes) sur plusieurs ressources simultanément. Gérer efficacement la répartition de tâches sur ces ressources est un problème qui se pose quel que soit le support d’exécution matériel, le système d’exploitation ou le langage cible choisi pour exécuter une application et à tous les niveaux (instructions élémen- taires, composants de bibliothèque, applications). De plus, on peut envisager ce problème de différents points de vue (utilisateurs, administrateurs système). L’ordonnancement est au cœur de la gestion efficace de ressources. Il s’agit de déterminer où et quand exécuter les tâches en optimisant si possible un ou plusieurs objectifs avec des contraintes variées. C’est un problème qui s’est posé dès l’introduction des premières machines vectorielles et parallèles dans les années 1970 et qui reste aujourd’hui toujours d’actualité, souvent avec des déclinaisons bien plus larges comme nous allons essayer de le montrer dans cet article. L’objectif ici est de dresser un bilan des recherches menées lors des dernières décénies autour du thème de l’ordonnancement dans le contexte du parallélisme et d’en discuter les principaux enjeux aujourd’hui. Nous défendons en particulier une approche de conception d’algorithmes bien fondée sur le plan théorique, permettant à faible coût d’obtenir des garanties de performance.
ABSTRACT. Parallelizing means executing simultaneously multiple operations. The efficient management of the assignment of tasks on available computing resources is a challenging problem. Whatever the considered execution support, this problem is crucial at any level from basic instructions, library components to full applications. Moreover, it can be studied from various points of view (users, system administrators). Scheduling is the main part for efficient resource management. It consists in determining where and when to execute the tasks while optimizing one or several objectives under hardware constraints. This is an old problem which arised with the first vector machines in the early seventies. Today, it is still a challenging problem since many new constraints should be considered. The purpose of this paper is to review the main constraints and to show how to take them into account in the scheduling policies. We defend a position of well-founded approaches for designing scheduling algorithms that allow to obtain guaranteed performances at a reasonable cost.
MOTS-CLÉS :parallélisme, optimisation combinatoire, gestion de ressources, ordonnancement.
KEYWORDS:parallelism, combinatorial optimization, resource management, scheduling.
DOI:10.3166/TSI.31.1021-1047 c2012 Lavoisier
Technique et science informatiques – no8-9-10/2012, 1021-1047
1. Introduction
Le thème de l’ordonnancement est transversal à la plupart des disciplines du pa- rallélisme. Il s’y décline de nombreuses manières. Informellement, on peut présen- ter l’ordonnancement comme l’allocation detravail(instructions élémentaires d’un programme ou grosses applications de simulation numériques) sur des ressources (re- gistres, CPU, co-processeurs de calcul, mémoires ou liens de communication). La dif- ficulté provient de ce que les ressources sont limitées et ont leurs propres contraintes.
Domaine ancien, l’ordonnancement reste parfaitement d’actualité. Il a motivé des re- cherches dans diverses disciplines depuis l’apparition des premières machines paral- lèles il y a plusieurs dizaines d’années. Il est encore plus ancien (et reste toujours très actif) dans la communauté de la recherche opérationnelle pour ses applications aux systèmes manufacturiers. Des liens étroits se sont tissés entre ces communautés au fil des années. La recherche opérationnelle fournit des outils puissants pour la résolu- tion, le parallélisme (comme les réseaux, télécommunications, systèmes embarqués, etc.) offre une ouverture sur de nouveaux domaines d’applications. Il existe un groupe de travail au sein du GdR ASR sur les modèles de calcul, l’algorithmique parallèle et l’ordonnancement, et plusieurs projets concernant le parallélisme ont également été soutenus par le GdR RO (en particulier, étude de flexibilité et robustesse pour l’ordonnancement, génération aléatoire de graphes de précédence, ordonnancement hétérogène sur des GPU, etc.).
Nous proposons ici une extension de la présentation donnée lors des vingtièmes rencontres du parallélisme en mai 2011 à Saint-Malo qui dresse les grandes lignes de l’évolution du domaine de l’ordonnancement depuis l’apparition du parallélisme en Informatique. Dans un premier temps, nous présentons l’évolution des plates- formes de calcul parallèles. Ceci permettra de dégager les principales caractéristiques et contraintes intervenant dans les problèmes d’ordonnancement et de discuter des modèles et de leur pertinence. En effet, il s’agit de construire des outils qui suivent (et quelquefois même anticipent) les évolutions technologiques. Nous détaillons les principaux résultats obtenus en ordonnancement (complexité, approximation) sur des problèmes simples et présentons comment les généraliser à la plupart des hypothèses réalistes. Cet article se termine par une ouverture et une discussion sur des enjeux actuels.
2. Un peu d’histoire...
2.1. Evolution des plates-formes parallèles
Bien que très ancienne, l’idée du parallélisme en Informatique s’est développée au milieu des années 1970 sous des formes primitives dans les premières machines vec- torielles, ciblées sur des applications numériques (manipulant des données régulières, organisées en tableaux ou matrices). Les unités de calcul étaient pipelinées et quelques périphériques d’entrées-sorties fonctionnaient déjà en parallèle des calculs. On a vu se développer beaucoup de travaux pour rendre efficaces les codes numériques. Le
principe commun est d’organiser un découpage fin des codes pour tirer parti au mieux des caractéristiques architecturales (taille des registres, temps de cycle des unités de calcul, bande passante mémoire, etc.). Des résultats de ce type ont été rapidement intégrés dans les compilateurs. L’évolution naturelle de ces systèmes a consisté à re- grouper entre elles quelques unités vectorielles communicant par une grande mémoire partagée. Les supercalculateurs ont évolué en faisant appel à des processeurs de plus en plus sophistiqués.
La décennie des années 1980 est caractérisée par un foisonnement d’idées et de réalisations concrètes de machines parallèles. Parmi les plus significatives, citons les machines construites à base du processeur anglais Transputer issu de projets euro- péens. Ce processeur possédait 4 liens physiques pour connecter directement d’autres transputers à sa mémoire locale. N’ayant pas de matériel adapté au calcul flottant, il a connu plus de succès pour programmer les machines à laver que pour le cal- cul scientifique. C’est également à cette époque qu’est sortie laConnection Machine (CM2) avec ses216processeurs 1-bit (en pratique, chaque carte de 32 bits formait une unité flottante). Chaque constructeur de microprocesseurs a proposé sa propre ver- sion d’unemachineparallèle en adaptant les processeurs à de nouvelles fonctionna- lités et à un réseau d’interconnexion avec de bonnes propriétés. Les livres (Leighton, 1992) (Cosnard, Trystram, 1993) permettront de satisfaire les lecteurs les plus cu- rieux. Les contraintes économiques ont vite remis de l’ordre dans cette période qui a duré quelques années. Ce foisonnement d’idées a conduit à la convergence vers des machines distribuées de quelques centaines à milliers de processeurs reliés physique- ment par un réseau d’interconnexion physique structuré. Elles ont été développées dans le cadre de quelques grosses entreprises. C’était en quelque sorte les ancêtres des grappes actuelles.
L’idée de lagrille, proposée dans les années 1990 (Foster, Kesselmann, 2004), était à l’origine de construire une infrastructure de calcul distribuée pour faire tourner des applications à distance. Une telle plate-forme est constituée de multiples systèmes mutualisés, possédant chacun leur administration propre, ces systèmes étant dispersés géographiquement et hétérogènes. Le succès de l’entreprise est d’en avoir permis l’ac- cès à de nombreux chercheurs partout dans le monde, en particulier dans certains pays défavorisés. La grille a évolué rapidement vers de grosses infrastructures lourdes à gérer (et pas seulement du seul point de vue technique...). Cette idée a pu être réalisée en particulier grâce au développement d’Internet et des réseaux rapides. Le concept de grille s’est décliné de diverses façons.
A la fin des années 1990, naît le projet NOW (Networks of Workstations) à Berke- ley qui regroupe plusieurs centaines de stations de travail connectées localement et qui dépassent la puissance de calcul des gros supercalculateurs. Un peu plus tard, apparaît le calcul volontaire (volunteer computing) conçu pour des calculs spécifiques à paral- lélisme massif et simple à gérer (par exemple pour la recherche de grands nombres pre- miers ou pour les projets seti@home, folding@home, etc.). Ces dispositifs regroupent des centaines de milliers de machines et ont largement contribué à populariser le cal- cul parallèle auprès du grand public (Anderson, Fedak, 2006). Dans ces systèmes, les
mécanismes sont simples : un programme client est déployé sur chaque machine vo- lontaire lorsqu’elle est inutilisée. Ils sont bien adaptés à certains types d’applications avec peu de communications et plusieurs infrastructures logicielles permettent de gé- rer ces systèmes comme BOINC ou le projet français xtremWeb. Cette présentation ne serait pas complète si l’on n’évoquait pas certaines plates-formes de calcul issues du pair-à-pair, caractérisées par leur gestion décentralisée.
Les grappes de PC (ou clusters) constituent une alternative flexible et à moindre coût aux autres formes de calcul. Beaucoup de machines de ce type figurent au Top500 des infrastructures de calcul les plus puissantes au monde. Les processeurs sont sou- vent standard, relativement homogènes, reliés par un réseau local et placés sous une administration centralisée unique.
Plus récemment, les progrès technologiques ont permis d’intégrer plusieurs cœurs sur une même carte. On décline ainsi les plates-formes précédentes à partir de ces nouveaux processeurs multicœurs et de plus en plus demany-coresselon le nombre mis en œuvre. Comme dans beaucoup d’autres domaines, l’histoire bégaie : on assiste aujourd’hui à un retour aux sources avec l’ajout de coprocesseurs pour accélérer les calculs. En particulier, les processeurs graphiques GPU pour exploiter certaines par- ties de code, notamment celles à parallélisme régulier. En plus des caractéristiques précédentes et des niveaux supplémentaires de hiérarchies, il faut donc gérer en plus l’hétérogénéité des unités de calcul (Bader, 2007).
Ainsi, on parle aujourd’hui plutôt de supports d’exécution et non plus de machines pour souligner la diversité des composants dans les systèmes de calcul : les ressources deviennent totalement virtualisées. Cette idée qui était à la base des grilles se retrouve en particulier dans les nuages (clouds) qui sont des architectures de services. Imagi- nez dans votre salon ou dans une PME des prises permettant de se connecter à des ressources de calcul extérieures pour effectuer toute sorte de traitements. Cette vi- sion de l’informatique est dans la continuité des grilles de calcul, mais les masses immenses de données et l’ouverture au marché grand public créent de nouveaux défis scientifiques (Fosteret al., 2009).
2.2. Synthèse : vers une méthodologie générique
Cette longue introduction a permis de rappeler la grande diversité des systèmes de calcul parallèle disponibles aujourd’hui. Face à cette complexité croissante, l’atti- tude des développeurs d’applications a dû s’adapter. Ces utilisateurs experts dans leur domaine se concentrent sur le cœur scientifique de leurs métiers plutôt que sur des questions techniques liées à la machine, mais il faut être en mesure de prévoir l’évo- lution de leurs codes, l’idée étant de créer des interfaces de programmation de haut niveau qui permettent de les libérer des tâches difficiles (et parfois fastidieuses) de l’ordonnancement, de gestion des ressources et autres opérations de bas niveau.
On trouve ci-après une liste des principaux caractères communs aux ressources des différents types de plates-formes parallèles actuelles. Selon les cas, certains pa-
ramètres sont plus importants que d’autres, ils prennent des valeurs extrèmes qui influencent plus ou moins les politiques d’ordonnancement : ordre de grandeur du nombre d’unités de calcul, caractère distribué, hiérarchisé, hétérogène ou volatile des ressources, opérant sur des données incertaines (mal connues ou sujettes à perturba- tions), etc.
Toutes ces caractéristiques conduisent à un accroissement de la complexité des supports d’exécution. Pour y faire face, la recherche s’est organisée en couches plus ou moins indépendantes qui nécessitent chacune une expertise toujours plus pous- sée (Culler, Singh, 1999). Les systèmes actuels sont caractérisés par l’existence d’une forme ou une autre de parallélisme à chaque niveau (Hwang, 1993). Devenir LE spé- cialiste du portage d’un code numérique sur une machine donnée n’a plus beaucoup de sens aujourd’hui, on doit se focaliser sur quelques sous-problèmes (allocation de registres, gestion des niveaux de mémoire, optimisation de la bande passante, déploie- ment du code, etc.) en gardant si possible une vue d’ensemble cohérente. On ne peut pas réécrire le code d’une application à chaque nouvelle génération de machines ! La recherche de pointe en parallélisme se fait dans des équipes où l’on trouve des compétences multiples. Les problèmes sont décomposés en couches successives et on dialogue aux interfaces. Ainsi, l’ordonnancement est découplé de l’algorithmique pro- prement dite et s’appuie sur des mécanismes mis au point dans les intergiciels. Il reste bien sûr nécessaire de s’attaquer aussi à des problèmes transversaux qui se retrouvent à chaque niveau (gérer la diversité des utilisateurs, l’adaptivité, le passage à l’échelle, la gestion des données incertaines, etc.).
Quel que soit le niveau, la gestion du parallélisme revient à ordonnancer des tâches, ce qui peut s’exprimer comme un problème d’optimisation combinatoire, c’est-à-dire, d’une fonction objectif discrète à optimiser sous contraintes. La méthodologie clas- sique pour l’analyse est rappelée ci-dessous :
1. Etude et caractérisation de l’environnement – modélisation 2. Définition formelle du problème
3. Etude de la complexité (NP-complétude, inapproximation) 4. Conception d’algorithme(s)
5. Analyse (bornes au pire des cas, en moyenne) 6. Validation par simulations ou tests en vraie grandeur.
Selon la formation scientifique de base et la communauté d’appartenance, certaines étapes sont implicites ou tout simplement ignorées... Les algorithmiciens auront ten- dance à se focaliser sur les étapes 2 à 5 en laissant tomber la validation expérimentale, les chercheurs en Système développeront plutôt les points 4 et 6 (heuristiques souvent astucieuses, mais pas forcément garanties, destinées à tourner dans des conditions réelles). Peu d’équipes de recherche au monde peuvent prétendre couvrir l’ensemble de ces points.
2.3. L’ordonnancement dans une perspective historique
L’évolution des architectures de systèmes parallèles que nous venons de présenter a été étroitement liée aux progrès en algorithmique, au développement de méthodes et d’outils pour gérer le parallélisme, d’environnements de programmation ou encore de langages permettant d’exprimer la concurrence (Blazewiczet al., 2000). Les solutions que l’on cherche à concevoir pour gérer les ressources doivent être flexibles, c’est-à- dire, composées de mécanismes pas trop compliqués pour pouvoir évoluer rapidement tout en restant performants. On distingue deux approches possibles pour cela. On peut soit faire évoluer les mécanismes existants d’une génération à la suivante, c’est ce qui s’est passé pendant longtemps, soit en imaginer de nouveaux mieux adaptés aux be- soins des systèmes actuels (et futurs). Reprenons l’évolution des supports d’exécution sous cet angle.
Historiquement, les développeurs de codes numériques se sont appropriés leur vi- sion propre du domaine de l’ordonnancement. Les premières recherches en algorith- mique parallèle ne faisaient pas appel à l’ordonnancement proprement dit. Le vectoriel et le parallélisme sur les supercalculateurs à mémoire partagée du début des années 1980 ont conduit à une algorithmiquead hoc. Comme le monsieur Jourdain du Bour- geois Gentilhomme, les développeurs faisaient de l’ordonnancement sans le savoir...
Les stratégies de découpage des données et d’allocation d’opérations se faisaient à la main directement dans le code avec l’objectif d’équilibrer les calculs. Puis, on a cher- ché rapidement à rendre cette opération extérieure aux programmes en remplaçant les directives explicites par des mécanismes de plus haut niveau. Formulé de cette manière, cela revenait d’une certaine manière à déplacer le problème vers les couches Système. On rejoignait là une des préoccupations importantes d’équilibrage de charge.
Informellement, le problème de l’ordonnancement consiste à optimiser l’exécu- tion sur des ressources limitées d’un graphe qui représente une application ou des processus.
L’apparition des architectures à mémoire distribuée où les communications ne sont plus simplement des mouvements internes sur la mémoire (souvent négligeables), mais deviennent un facteur prépondérant dans la performance, a fait évoluer les mo- dèles d’ordonnancement (Bampiset al., 1997). Le plus répandu est le modèledélai (voir section 6.1). L’idée est d’ajouter un délai de communication entre deux tâches allouées sur des unités de calcul différentes. On voit bien ici comment le choix de l’al- location influence l’ordonnancement. En général, les communications peuvent être recouvertes par du calcul si une tâche est disponible localement. Pendant plus d’une décennie, les communications ont ainsi été prises en compte explicitement et l’école française a été une des plus actives sur ce thème. Dans le modèle de base introduit par Rayward-Smith, les temps de communication étaient unitaires, mais de nombreuses variantes ont été proposées. En particulier, si les temps de communication sont affines (start-upplus un terme proportionnel au volume de données à transférer), il est amu- sant ici de remarquer que l’on retrouve de façon plus systématique de nombreuses analyses menées quelques années auparavant (Leighton, 1992).
On a continué à raffiner le modèle délai pour se rapprocher encore des caracté- ristiques physiques des architectures parallèles. Un des achèvements les plus aboutis est le modèleLogP(Drozdowski, 2009). L’idée est de distinguer les phases élémen- taires dans les opérations de communication (empaquetage, transfert sur le réseau, réception) et de considérer une latence constante pour tous les messages jusqu’à une certaine taille. Deux communications successives sur le même processeur doivent at- tendre un certain temps (gap). On retrouve le modèle délai pour les valeurs particu- lières de surcoût d’empaquetage-réception et sans gap. Malheureusement, les analyses sur de quelques structures particulières de graphes ont montré les limites de ce modèle.
Les problèmes pour les modèles à communications explicites comme LogP deviennent rapidement trop sophistiqués et donc, pratiquement impossibles à résoudre efficace- ment. Par exemple, le problème d’ordonnancer un simple grapheForkavec des temps d’exécution quelconques sur un nombre non borné de processeurs identiques est déjà NP-difficile !
De plus, les meilleurs facteurs d’approximation connus sur ces modèles dépendent des paramètres du problème, en particulier, il n’existe pas de garantie constante pour des grands temps de communication. Dans ces conditions, déterminer le meilleur or- donnancement devient hasardeux. On peut toujours utiliser les algorithmes de liste dont le principe est détaillé plus loin, mais la qualité du résultat n’est pas toujours garantie...
2.4. Modèles alternatifs
On vient de voir que la voie qui consiste à raffiner les modèles à communications explicites avait en quelque sorte conduit à une impasse pour l’ordonnancement. C’est pourquoi on a eu recours à des solutions alternatives que nous allons rapidement pré- senter et discuter.
Un des modèles les plus significatifs est BSP (Bulk Synchronous Programming), apparu à la fin des années 1980. Il était destiné à faire un pont entre les architec- tures et les modèles d’exécution. Le principe est d’organiser les tâches en étapes de calcul pur (super-steps) séparées par de grosses barrières de synchronisation. Ainsi, le modèle peut être considéré du point de vue théorique comme une PRAMà gros grain (Cosnard, Trystram, 1993). Du côté pratique, les algorithmes écrits en BSP sont faciles à implémenter et conduisent à de bonnes performances pourvu que le décou- page en super-steps soit bien adapté. Un autre intérêt de ce modèle est qu’il est associé à un modèle de coût relativement simple à évaluer. Actuellement, des articles faisant référence à ce modèle sortent régulièrement. Il pourrait en particulier connaître une renaissance avec la programmation sur les accélérateurs de type GPU. L’idée res- tant la même : contraindre l’écriture des programmes pour obtenir une structure plus simple à paralléliser en particulier en regroupant les communications. Notons éga- lement que ce modèle est très en vogue actuellement dans la communauté du cloud computing (Malewicz, 2009).
L’autre modèle alternatif important est celui des tâches parallèles. Partant du constat que la gestion explicite des communications au niveau fin d’un programme rendait le problème vraiment difficile, ce modèle propose de changer de granularité en considérant des tâches plus grosses, elles-mêmes parallélisables, sans se préoccuper des caractéristiques internes trop fines. On distingue deux types de tâches parallèles : les tâches rigides (pour lesquelles le nombre de processeurs alloués est fixé à l’avance) et les tâches modelables (lorsque ce nombre est variable) (Feitelson, 2010). La figure 1 présente un exemple d’ordonnancement de tâches parallèles rigides indépendantes sur une grappe de processeurs. Pour les tâches modelables, des algorithmes d’approxi- mation efficaces ont été développés (Leung, 2004).
Figure 1. Exemple d’ordonnancement d’applications (tâches parallèles rigides). Les niveaux de gris correspondent à différents utilisateurs
De nombreuses recherches ont aussi été menées pour des classes d’applications particulières. Une des plus importantes est sans doute les tâches divisibles (divisible loadou la variante debag of tasks). Ceci correspond à des applications constituées d’un grand nombre de tâches élémentaires indépendantes. Cette structure particulière permet de simplifier l’analyse et de se focaliser sur certains points (comme la topolo- gie de communications). On distingue le comportement transitoire et le régime perma- nent. On s’intéresse alors à de nouveaux objectifs comme la minimisation duthrough- putqui représente le débit (nombre de tâches effectuées par unités de temps). Des dé- tails peuvent être trouvés dans (Robert, Vivien, 2009). Une discussion plus approfon- die portant sur une comparaison des différents modèles est présentée dans (Trystram, 2001).
3. Résultats classiques en ordonnancement 3.1. Préliminaires
A l’apparition des premiers calculateurs parallèles, les utilisateurs ont développé leurs codes en les optimisant au cas par cas, sans référence explicite au domaine de la recherche opérationnelle. A l’époque, on les a parfois accusés de réinventer la roue, ce qui n’était pas toujours faux...
Avant de présenter le problème central de l’ordonnancement, voyons comment sont représentées les applications. On utilise généralement un grapheG = (V, E)
dont les sommetsV correspondent aux instructions (ou à un grain plus grossier des procédures) et les arêtesEreprésentent les liens entre ces tâches (associés au volume des données à transférer). Il existe plusieurs variantes : statique lorsque la structure, les opérations et le volume des calculs sont connus a priori (par exemple pour la parallélisation de composants de bibliothèques numériques (Cosnard, Trystram, 1993)) ou graphes à flots de données (data flow) construits dynamiquement où les tâches se découvrent au fur et à mesure du déroulement des calculs.
Notations.La plate-forme d’exécution cible est composée demressources de calcul identiques (que l’on appellera processeur pour simplifier). Supposons que l’on cherche à paralléliser une application composée dentâches séquentielles de durées pj pour1 ≤j ≤ n. Les tâches sont liées par une relation de précédence, c’est une relation d’ordre partiel qui représente les contraintes de chronologies entre les tâches.
Si certaines tâches ne sont pas disponibles dès le début, on parle derelease dates. On suppose ici que toutes les données sont connues à l’avance (off-line). On notepmax
le temps d’exécution de la plus grande tâche. Le problème de l’ordonnancement revient à résoudre deux questions : l’allocation des tâches aux processeurs et leur séquencement (date d’exécution). Plus formellement :
DÉFINITION1. —Ordonnancer un système de tâches, c’est déterminer les deux ap- plicationsπetσoùπassocie un processeur à chaque tâche etσleur associe un temps de début d’exécution.
Parmi tous les ordonnancements possibles, on cherche à déterminer un ordonnan- cement réalisable (c’est-à-dire qui satisfasse les contraintes) ayant le temps d’exécu- tion global le plus petit possible.
Le makespan, noté Cmax, est défini comme le maximum des temps de com- plétion Cj (c’est-à-dire, le temps où toutes les tâches sont terminées) Cmax = maxj=1,...,n(σ(j) +pj). La figure 2 illustre ces notions.
rj
dj
j
Cj
σ(j) processeurπ(j)
temps pj
Figure 2. Illustration d’un ordonnancement (fonctionsπetσ). La tâchejest soumise à la daterjet elle a une date d’échéancedj
La faisabilité de l’ordonnancement est donnée par les contraintes suivantes : σ(j) ≥ σ(i) +pi+γ(i, j) pour tous les couples de tâches(i, j) ∈ E (telles que iprécèdej).
Cette expression traduit simplement le fait que la tâchejne peut commencer son exécution que lorsqueiest terminée. Dans le cas de processeurs hétérogènes, le temps d’exécution dépend du processeurπ(i)sur lequel est allouée la tâche. Les temps de communication peuvent être paramétrés selon le support d’exécution sous-jacent. Par exemple, dans la version simple du modèle délai à temps de communication unitaires, on aγ(i, j) = 1∀i etj tels queπ(i) 6= π(j), dans le modèle LogP, on distingue les surcoûts pour l’empaquetage et le désempaquetage des messages plus la latence de traversée du réseau d’interconnexion :γ(i, j) =Osend+L+Orec. Le modèle général étant le modèle affineβ+Li,jτavec un temps d’initialisation (start-upβ) et un facteur proportionnel à la taille des messages (oùτest l’inverse de la bande passante du lien).
3.2. Classification des problèmes
Le problème central précédent est une base que l’on peut décliner selon les pro- blèmes cibles. Une manière commode pour présenter et manipuler les nombreuses variantes est d’utiliser la notation diteà trois champsα|β|γoù chaque champ repré- sente une caractéristique du problème (Lawleret al., 1982), plus précisément,
– αreprésente les diverses ressources : on distingue les ressources identiques (α= P) fixées, arbitraires non fixées ou non bornées, uniformes, hétérogènes ou dédiées ;
– β contient les hypothèses sur les tâches et les contraintes imposées sur l’exé- cution. On y décrit le type d’applications ciblées : on distingue par là la structure (qualitative) et les valeurs des données (quantitatives) ;
– γ précise les fonctions objectifs. Historiquement, beaucoup de travaux concernent le makespan (maximum des temps de complétion), c’est d’ailleurs essen- tiellement ce que nous étudions dans cet article, mais les performances importantes des systèmes actuels ont conduit à diversifier de plus en plus les objectifs étudiés.
Ainsi, on étudie aussi la fiabilité que l’on cherche à maximiser ou la consommation énergétique que l’on cherche à minimiser. Notons que l’optimisation simultanée de plusieurs objectifs est un domaine en pleine expansion depuis quelques années.
Par exemple, Q|tree, pj = 1|Cmax correspond à ordonnancer sur un nombre arbitraire de machines uniformes (champ Q) une application dont la structure des tâches est un arbre (tree) avec des tâches unitaires (pj= 1). Enfin, on vise à minimiser le makespan (Cmax).
On pourrait également rajouter des caractéristiques pertinentes comme le contrôle (il est en général centralisé, mais on cherche de plus en plus à concevoir des algo- rithmes efficaces avec contrôle décentralisé) ou la diversité des utilisateurs (tradition- nellement, les utilisateurs sont tous considérés de la même manière, ce qui se reflête dans la fonction objectif et l’on cherche plutôt à optimiser le comportement global du système que celui de chaque utilisateur. Cette dimension nouvelle est de plus en plus considérée dans les travaux récents).
4. Cas particulier des tâches indépendantes
Afin d’illustrer la méthode de résolution, considérons le problème central le plus simple possible qui consiste à ordonnancer ntâches indépendantes sur un nombre arbitraire de processeurs identiques en minimisant le makespanCmax. En utilisant la notation à trois champs précédente, il est notéP||Cmax.
4.1. Complexité
Il est facile de remarquer que ce problème est NP-difficile au sens faible pour2 machines (il est en effet équivalent à une 2-Partition de l’ensemble des entiers qui sont les temps d’exécution des tâches). On peut aller un peu plus loin en montrant qu’il est NP-difficile au sens fort pour un nombre arbitraire de processeurs. Ce problème peut se réduire à partir du problème 3-Partition qui est rappelé ci-dessous (Garey, Johnson, 1979) :
Instance.Un entierBet un ensemble fini de3nentiers tels que∀i B4 < i <B2 Question.Existe-t-il une partition ennsous-ensemblesSj de3entiers telle que
∀jP
i∈Sji=B?
La contrainte de taille sur les indicesiimpose qu’il y a exactement trois entiers par ensemble Sj. La réduction consiste à fixer le nombre de processeursm = net considérer3ntâches indépendantes, chaque entier correspondant au temps d’exécu- tion d’une tâche à ordonnancer. L’ordonnancement optimal a un makespan égal àBoù chaque processeur exécute3tâches de chaque sous-ensemble. De plus, comme nous le verrons à la section 5.1 en présence de contraintes de précédence, le problème est NP-difficile au sens fort à partir de2machines.
Comme le problème est difficile, on ne peut attendre de solutions exactes pour des instances trop grandes. On cherche alors à concevoir des algorithmes efficaces, en particulier ceux dont on peut borner le rapport à l’optimal dans le pire des cas. Pour cela, on introduit la mesure suivante (Hochbaum, 1995).
DÉFINITION2. —Le rapport d’approximation d’un algorithmeApour un problème de minimisation est défini de la façon suivante :
ρA=inf{r≥1tel queρA(I)≤r}pour toutes les instancesIdu problème où le termeρA(I)est le rapport de la valeur de l’objectif deAà l’optimal pour l’instanceI:ρA(I) = ωωA∗(I)(I)
Comme le problèmeP||Cmaxest difficile, la plupart des variantes plus sophis- tiquées seront aussi NP-difficiles (avec précédences, avec communications, pour des processeurs non identiques, pour des tâches parallèles, etc.). Pour un nombre constant de processeurs, le problème admet un schéma d’approximation polynômial (PTAS) c’est-à-dire un rapport d’approximation1 +dont la complexité est polynomiale en
1
. Notre objectif est de concevoir des algorithmes de faible coût en gardant un bon rapport d’approximation. En particulier, il existe une recette générale que nous allons développer dans la suite et analyser dans différents contextes : lesordonnancements de liste (Leung, 2004 ; Sinnen, 2007).
4.2. Algorithmes de liste
Dans cette section, nous détaillons le principe et l’analyse de ce schéma al- gorithmique général, puis nous montrons comment le généraliser sous différentes hypothèses plus générales.
Principe.L’algorithme de liste de Graham dans sa forme originale date de 1969, il est basé sur une liste des tâches prêtes. On pioche dans cette liste tant qu’il y a des ressources (processeurs) libres.
Cet algorithme n’est pas optimal, mais il possède une garantie dans le pire des cas (facteur d’approximation constant égal à2). La preuve est simple, mais elle mérite que l’on s’y arrête car la plupart des extensions suivent le même schéma.
PROPOSITION3. —L’algorithme de liste est une2-approximation.
Preuve.La preuve est basée sur un argument géométrique sur le diagramme de Gantt (ressources-temps) qui est schématisé dans la figure 3. On exprime que la surface du rectangle global est égale à la surface des tâches plus celle des temps d’inactivité, soit m.Cmax=W+Sidle(oùW = Σj=1,npj) etSidleest la surface cumulée de tous les moments d’inactivité (en gris sur la figure 3).
m k
Cmax
≤pmax
Figure 3. Ordonnancement de liste pour des tâches indépendantes
Il existe deux bornes inférieures triviales de la durée d’un ordonnancement : Cmax∗ ≥ Wm etCmax∗ ≥pmax
Le premier terme de la sommeCmax = Wm + Sidlem correspond exactement à la borne inférieure sur le travailW. Borner le second terme n’est pas difficile, il suffit de remarquer que suivant le principe de liste, les moments d’inactivité se trouvent tous regroupés à la fin. Considérons une des tâches qui se termine en dernier (la tâchek sur la figure 3). Dans le pire des cas, seul le processeur qui exécutekest actif, ainsi Sidle≤(m−1)pk ≤(m−1)pmax.
Compte tenu quepmaxest une borne inférieure de l’optimum, on obtient finale- ment :Cmax≤(1 +m−1m )Cmax∗ ≤2Cmax∗ .
Remarquons que dans le pire des cas, les deux bornes s’équilibrent et se cumulent, d’où le facteur2. De plus, la borne de2est atteinte pour cet algorithme.
Plus généralement, remarquons que l’algorithme de liste est générique et simple à mettre en œuvre. Dans le cas de tâches indépendantes, le principe de liste garantit que les temps d’inactivité sont regroupés à la fin. Ceci permet d’améliorer la borne d’approximation de2 si l’on place à la fin les petites tâches. C’est l’idée derrière la politique LPT (Largest Processing Time) qui trie les tâches par temps d’exécution décroissants avant de les ordonnancer par l’algorithme de liste (Leung, 2004). Sans perte de généralité, on renumérote les tâches dans cet ordre,pndésigne la plus petite tâche. On peut alors démontrer le résultat suivant.
PROPOSITION4. —LPT est une 43-approximation.
Preuve.L’analyse de ce résultat vient de ce que l’algorithme est optimal pour un petit nombre de tâches.
On considère la tâche qui termine en dernier que l’on notekcomme précédemment et on élimine les tâches d’indices supérieurs (ici,10et11sur la figure 4 de gauche).
On considère alors deux cas : Cmax∗ <3pk.
Ici, chaque processeur a au plus 2 tâches à exécuter dans l’instance réduite. Il n’est alors pas difficile de montrer que la solution est optimale.
Cmax∗ ≥ 3pk. Comme dans la précédente preuve, on décompose l’ordonnance- ment en deux phases (pleine activité suivie d’une zone avec des temps d’inactivité).
Dans le pire des cas, l’inactivité est majorée par(m−1)pk.
La surface totale du diagramme de Gantt estm.Cmax=W +Sidle. Ainsi,Cmax=Wm+Sidlem ≤Cmax∗ +(m−1)pm k.
Commepk ≤Cmax∗3 , on obtient en reportant dans l’expression précédente : Cmax≤Cmax∗ +(m−1)C3mmax∗ ≤(43−3m1 )Cmax∗
A partir de la situation simple que l’on vient de décrire, on peut faire le bilan suivant sur l’algorithme de liste :
k 1
3 2
5 6
7 8
10
11 9
4
t
π(k)
Cmax
Figure 4. Adaptation de la preuve de l’algorithme de liste général à LPT
– il est peu coûteux (outre un tri initial si l’on considère des priorités, l’algorithme est linéaire en nombre de tâches) ;
– il est asymptotiquement optimal pour un grand nombre de tâches, carpmax devient alors arbitrairement petit au regard du makespan ;
– enfin, il fonctionne indifféremment pour une gestion de la liste statique (off- line) ou dynamique (on-line). Dans ce dernier cas, la garantie de LPT pour des tâches indépendantes passe à 32 avec une borne inférieure en 1.347 (i.e. aucun algorithme en-ligne ne peut avoir une meilleure borne) (Chen, Vestjens, 1997). Le rapport est un peu plus mauvais que LPT, mais reste acceptable.
Ici aussi, la borne est atteinte pour une famille particulière d’instances.
4.3. Schémas d’approximation polynômiaux
Pour un nombre constant de processeurs, le problèmeP m||Cmaxadmet un PTAS (schéma d’approximation polynômial en 1 où est une valeur fixée). Plus précisé- ment, (Hochbaum, Shmoys, 1988) proposent une famille d’algorithmes d’approxima- tion A qui réalisent chacun une approximation en (1 +)en temps appartenant à O(n12). Cet algorithme est très coûteux lorsque l’on cherche des valeurs d’approxi- mation proches de1. Par exemple, si l’on cible comme pour LPT une43-approximation (correspondant à= 13), le PTAS est enO(n9)!
Nous allons développer rapidement dans cette section un autre PTAS avec un rap- port d’approximation aussi près que possible de l’optimal. Ce résultat est classique, il est coûteux, mais aussi plus simple à comprendre à partir de l’analyse que nous avons faite pour LPT. L’idée de base pour construire le PTAS consiste à essayer systémati- quement toutes les positions possibles desqplus grandes tâches.
Soit un réel positif, la valeur de l’entier qsera fixée plus tard en fonction de et du nombre de processeursm. On suppose que les tâches sont triées par temps d’exécution décroissants. Le PTAS consiste en deux phases successives : on génère tout d’abord en brute force toutes les partitions possibles desqpremières tâches enm
parties (ce qui coûte de l’ordre demm!q. C’est polynômial siqest fixé), puis on complète l’ordonnancement obtenu en appliquant LPT sur lesn−qtâches restantes.
On se place dans le cas où la valeur du makespan du PTAS est strictement supé- rieure à celle du makespan de la première phase (sinon, le PTAS est tout simplement optimal). Comme pour les analyses précédentes, on considère la dernière tâche à être exécutée (notéek), on a alors l’expression suivante :
Cmax≤Cmax∗ + (1−m1pk)
En considérant la charge des processeurs (nombre de tâches allouées) après la première phase, on peut montrer :
pk ≤(1 +bmqc)Cmax∗
En reportant dans la majoration deCmax, on obtient : Cmax≥(1 +1+b1−m1q
mc)Cmax∗
On choisissantq=d1− em, on obtient un rapport d’approximation en1 +.
5. Graphes avec précédences
5.1. Complexité
Le cas des tâches indépendantes que nous venons d’exposer correspond soit à des grosses applications, soit à un cas particulier pas toujours réaliste. A grain fin, la plupart des codes parallèles ont des instructions dont l’exécution dépend de résultats d’autres instructions. Comme évoqué précédemment, la complexité du problème est NP-difficile au sens fort dans le cas de tâches avec précédences. La preuve mérite que l’on s’y arrête.
PROPOSITION5. —P|prec|Cmaxest NP-difficile au sens fort.
Preuve. Remarquons tout d’abord que le problème appartient évidemment à N P.
Nous allons le réduire à partir du problème 3-Partition (introduit à la section 4.1) pour m= 2. Pour cela, considérons le graphe de précédence particulier décrit à la figure 5 composé d’une succession den−1diamants et de3ntâches indépendantes de durées pi. Ces dernières tâches correspondent à l’instance de 3-Partition cherchée. Les n tâches de jonctions des diamants ont une durée égale àB, les autres tâches parallèles deux à deux sont de durées unitaires.
Pour ordonnancer optimalement l’ensemble des tâches, il n’y a pas d’autre solution que d’exécuter les blocs de diamants au plus tôt, comme le montre la figure 6.
On peut montrer une borne d’inapproximation en43, sauf siP =N P.
B
1 1
1 1
B B B
...
1
1 B
×(n−1)
Figure 5. Graphe de base pour la réduction
B proc.1
proc.2
...
...
B 1
B 1 1 B
B
Figure 6. Gantt final d’un algorithme optimal. Les tâches grisées correspondent à la 3-Partition
5.2. Résolution par algorithme de liste
Le principe de l’algorithme de liste reste valide et efficace pour ordonnancer des tâches avec précédences. Plutôt que de disposer de la liste de toutes les tâches au début, la liste sera mise à jour au fur et à mesure. Le facteur d’approximation de cet algorithme reste le même que précédemment, mais la preuve est un peu plus délicate.
PROPOSITION6. —L’algorithme de liste est une 2-approximation pour P|prec|Cmax.
Preuve.Comme pour le cas des tâches indépendantes, l’idée repose sur un argument géométrique sur la surface du diagramme de Ganttm.Cmax=W+Sidle. Cependant, la preuve est plus difficile car les relations de précédence peuvent induire des temps d’inactivité n’importe où et pas seulement à la fin.
On dispose de deux bornes inférieures :Wm ≤Cmax∗ et lechemin critique, c’est- à-dire, la plus longue chaîne du graphe (notée t∞). Sur l’exemple du graphe de la figure 8, la chaîne de tâches (4)-(5)-(8)-(10) constitue un des chemins critiques.
La principale difficulté ici est de borner le second terme de cette somme (et donc, Sidle). Pour cela, on considère une des tâches qui se termine en dernier (par exemple la tâche (10)sur l’exemple de la figure 9) et on construit à rebours une chaîne de tâches sur chaque intervalle où il existe un temps d’inactivité, comme indiqué dans la figure 7.
La dernière tâche est forcément successeur d’une tâche en cours d’exécution dans l’intervalle précédent où il y a un temps d’inactivité, sinon, d’après le principe de liste,
Figure 7. Principe de construction d’une chaîne sur les périodes d’inactivité
elle aurait été exécutée à ce moment-là. Ainsi, en considérant qu’il y a au plus(m−1) processeurs inactifs, on obtientSidle ≤(m−1).LoùLest la longueur de la chaîne que l’on vient de construire. Bien sûr, cette longueur est inférieure au chemin critique t∞ (qui est la plus longue des chaînes) qui est une borne inférieure du makespan optimal.
Au final, on obtient :Cmax≤ Wm+m−1m t∞≤Cmax∗ +m−1m Cmax∗ ≤(2−m1)Cmax∗
(10) (6)
(5) (1) (2) (3) (4)
(8) (9)
(7)
Figure 8. Exemple de graphe de précédence. (3) et (8) sont de durées unitaires, (1), (5), (6) et (10) de durées 2 et (2), (4), (7) et (9) de durées 3
(3) (4) (7)
(5) (8) (10)
(6) (9)
(1) (2)
Figure 9. Ordonnancement de liste du graphe de la figure 8
5.3. Pour aller un peu plus loin...
L’algorithme de liste est simple, rapide et possède une garantie de performance.
Le principe reste valable pour d’autres objectifs standard comme la somme des Ci (ici, la meilleure priorité de liste est d’ordonnancer les tâches par temps d’exécution croissants, c’est-à-dire l’inverse de LPT) ou les retards dans le cas d’ordonnancements avec dates d’échéances (Leung, 2004).
La limite de ces algorithmes vient de leur caractère glouton, où une fois qu’une décision est prise, elle ne sera jamais remise en cause dans la suite.
On peut contrer cela en considérant des algorithmes simples par approximation duale (Hochbaum, 1995). L’idée ici est de fixer une borne pour le makespan (unguess notéλ) que l’on ajustera par dichotomie. En effet, si la valeur de l’optimal est connue, on peut utiliser des algorithmes de bin packing qui possèdent de bonnes bornes d’ap- proximation (par exemple FFDFirst Fit Decreasing) (Coffmanet al., 1978). Ici, on cherche le nombre minimum de boîtes (bins) pour placer nobjets. Rappelons que l’algorithme FFD approxime asymptotiquement la solution optimale à un facteur
11
9 = 1.22. Plus précisément,N ≤119N∗+ 4oùNest le nombre de boîtes.
On voit clairement une relation entre la valeur du makespan du problème d’ordon- nancement dentâches indépendantes et le nombre de boîtes (nombre de processeurs m). Considérons la borne inférieure naturelle du problème :LB =max(Wm, pmax) et fixons une borne supérieure U B = max(2Wm, pmax)où W = Σ1≤j≤npj. On peut construire une heuristique garantie (appeléemultifit) en appliquant itérativement FFD par dichotomie sur les bornes LB et UB, la valeur deλcorrespond au milieu de l’intervalle[LB, U B].
Si FFD nécessite plus dem processeurs, la solution n’est pas réalisable, et on relance alors FFD sur un intervalle restreint à[U B−LB2 , U B].
Sinon, on peut améliorer la valeur deλen relançant FFD sur[LB,U B−LB2 ].
On peut alors montrer la borne finale obtenue aprèskitérations : Cmax(k)≤(119 +21k)Cmax∗
Cet algorithme n’est plus un glouton, il possède une meilleure borne asymptotique que LPT, mais il est aussi un peu plus coûteux (il nécessitekappels à FFD).
6. Extensions
Le principe des algorithmes de liste peut être étendu à de nombreuses autres situa- tions que celles que nous avons présentées (processeurs identiques et tâches indépen- dantes ou avec précédences). De plus, dans la plupart des cas il est possible de prouver des garanties sur les facteurs d’approximation. Même dans les cas où ces facteurs sont importants (voire non bornés), le comportement est en général très bon en moyenne.
6.1. Précédences et communications explicites
Dans le cas de tâches avec précédences et avec communications, le facteur d’ap- proximation dépend des communications. La figure 10 illustre schématiquement pour- quoi (un délai est introduit entre les tâches (4) et (5) et entre (5) et (9)).
Du point de vue géométrique à partir du diagramme de Gantt, la surface des temps d’inactivitéSidleest constituée de deux types de slots : les temps d’inactivité structu- rels dus aux précédences (comme précédemment, en gris sur la figure) et ceux induits par l’attente de communications (en noir sur la figure). L’analyse de l’algorithme de liste est la même que dans le cas sans communication : on construit de proche en
(3) (4) (7) (6) (1)
(2)
(8) (10) (5)
(9)
Figure 10. Ordonnancement de liste pour des tâches avec précédences et délais de communication (en noir)
proche une chaîne de tâches à partir de la dernière tâche le long des périodes d’in- activité. Comme le temps d’attente peut provenir des communications, il nous faut rajouter un terme supplémentaire. On obtient dans le pire des scénarios la majoration suivante :
Cmax≤ Wm +m−1m .t∞+γ∞.
où γ∞ est le maximum des sommes des temps de communications sur une chaîne du graphe. Pour les petits temps de communication (c’est-à-dire si∀(i, j)γ(i, j) ≤ min(pj)), on peut borner le dernier terme par un facteur constant deCmax∗ . Par contre, pour des grands temps de communication, ce terme n’est pas borné (le meilleur facteur connu est enlogde la plus grande communication).
En complément à ces analyses algorithmiques, plusieurs implémentations pra- tiques ont été proposées. Une des plus utilisées est sans doute l’algorithme de liste ETF (Earliest Task First) dont le principe consiste à chercher la meilleure date d’exé- cution possible parmi les tâches prêtes :∀q(processeur)maxj(σ(j) +pj+γ(i, j)) pour(i, j)∈Eetπ(j)6=q. Le temps de cet algorithme est enO(m.n2).
6.2. Processeurs non identiques
Considérons maintenant le cas d’une machine parallèle dont les processeurs sont hétérogènes. On distingue deux configurations selon que les processeurs ont des vi- tesses différentesuniformesou sans liensunrelated(une opération peut prendre plus ou moins de temps sur tel ou tel processeur). Les deux problèmes correspondants sont connus dans la littérature respectivement commeQ||CmaxetR||Cmax. Bien sûr, en tant que généralisation deP||Cmax, ces problèmes sont au moins aussi difficiles.
Nous présentons rapidement les principaux résultats dans l’esprit du reste de l’article.
– Sur processeurs uniformes, une tâchej aura un temps d’exécution qui dépend du processeur où elle est allouée : vpj
π(j) oùvi est la vitesse du processeuri. Pourm fixé, il existe un PTAS basé une sur technique d’approximation duale (obtenu à partir du problème de bin packing avec des boîtes de tailles variables) (Hochbaum, Shmoys, 1988).
On peut généraliser l’algorithme de liste LPT. L’analyse de la performance est plus technique, elle conclut à un rapport d’approximation compris entre1.52et53(Friesen, 1987). Pour des tâches avec précédence, on perd la garantie de performance (facteur
d’approximation constant). Ce cas est plus difficile que pour des processeurs iden- tiques car il faut redéfinir la notion de chemin critique (ici, elle dépend de l’alloca- tion). Une solution possible est de considérer une vitesse moyenne. Nous invitons le lecteur intéressé à consulter l’article de (Chekuri, Bender, 2001). L’idée est de décom- poser le graphe en chaînes de longueurs décroissantes et d’allouer les plus grandes aux processeurs les plus rapides.
– Pour des processeurs hétérogènes quelconques, on peut montrer que le problème n’est pas approximable à moins d’un rapport 32 (sauf siP = N P) (Lenstraet al., 1990). Par contre, il existe un PTAS coûteux pour m fixé, basé sur une technique d’arrondi d’une formulation en programme linéaire en nombres entiers.
Pratiquement, il existe une heuristique sans garantie pour le cas de tâches avec précé- dences (Topcuogluet al., 1999). HEFT (Heterogeneous Earliest Finish Time) procède en deux phases : calcul de priorités sur les tâches en fonction de leurs profondeurs dans le graphe, puis sélection des processeurs sur lesquels la date de terminaison est la plus petite. HEFT n’est pas un algorithme de liste au sens où certaines ressources de calcul peuvent rester inactives bien qu’une tâche soit disponible.
Pour terminer cette section, arrêtons-nous un moment sur le problème d’ordonnan- cement sur des plates-formes parallèles mixtes (multicœurs avec accélérateurs type GPU). Il existe beaucoup de résultats récents qui étudient des implémentations pour des applications particulières et conduisent parfois à de bonnes bornes théoriques.
L’ordonnancement n’est pas toujours explicite. L’enjeu est de proposer des ordonnan- cements efficaces qui prennent en entrée des structures quelconques de tâches.
Le modèle de machines consiste en deux familles de processeurs identiques (m processeurs classiques etkGPU). C’est un cas particulier du problèmeR|prec|Cmax pour lequel on pourrait attendre des bornes plus fines.
6.3. Tâches parallèles (communications implicites)
Le principe de liste s’applique également bien aux tâches parallèles, c’est-à-dire aux tâches nécessitant plusieurs processeurs. Comme nous l’avons évoqué à la sec- tion 2.4, il existe plusieurs types de tâches parallèles selon la façon dont est déterminé le nombre de processeurs. Si ce nombre est fixé à l’avance (comme par exemple dans une application écrite en MPI), les tâches sont rigides. Il peut alternativement être dé- terminé par l’algorithme d’ordonnancement, on parle alors de tâches modelables. Si de plus, ce nombre peut évoluer au cours de l’exécution, la tâche est dite malléable. Nous allons passer en revue les principaux résultats d’approximabilité sous ces différentes hypothèses.
6.3.1. Tâches parallèles rigides
En utilisant la notation à trois champs, ce problème se noteP|pj, sizej|Cmax.
Le nombre de processeurs nécessaires à l’exécution de la tâchej est notéqj. Il faut rajouter une contrainte supplémentaire par rapport au cas standard des tâches séquen-
tielles :∀t >0,Σj∈Itqj ≤moùIt={itelle queσ(i)≤t≤σ(i)+pi}(pour chaque slot de temps, les tâches en cours d’exécution utilisent au plusmprocesseurs).
Il y a deux façons d’étudier ce problème : comme un ordonnancement avec contraintes de ressources supplémentaires ou comme un problème de strip packing où les tâches rigidesj sont vues comme des rectangles de côtéspj par qj. La dif- férence vient essentiellement de la contrainte de contiguïté dans les ressources que l’on impose dans le strip packing. Le problème est inapproximable polynômialement à moins de 32.
Dans le premier cas, (Garey, Graham, 1975) ont proposé un algorithme de liste dans le cas de multiples contraintes de ressources dont la démonstration a été simpli- fiée par une analyse continue (Eyraud-Dubois et al., 2007). La borne d’approxima- tion de 2 est conservée pour des tâches indépendantes. Dans le second cas, il existe également des algorithmes 2-approchés. Comme précédemment, on peut raffiner les approximations en construisant un schéma en 32+coûteux.
On peut montrer des propriétés de dominance intéressantes pour des politiques particulières. Par exemple, HF (Highest First) est la politique qui alloue les tâches par ordre décroissant desqj, c’est une généralisation de LPT à la dimension des res- sources. Un tel ordonnancement est constitué de deux phases successives où la plate- forme parallèle est d’abord chargée à plus de 50 %, puis, à moins de 50 % (Pascual et al., 2009). Malheureusement, ceci ne permet pas semble-t-il de réduire le facteur d’approximation.
On peut étendre ces résultats au cas de plates-formes hiérarchiques, composées dekmulticœurs deni processeurs chacunes. La figure 11 montre une allocation de tâches dans ce cas. Ce problème est plus difficile, il est notamment inapproximable à moins d’un facteur 2 de l’optimal. On peut construire une52-approximation (Bougeret et al., 2010b) en appliquant une technique d’approximation duale ou même un schéma en2 +(Bougeretet al., 2010a).
Figure 11. Allocation initiale de tâches parallèles rigides et ordonnancement local sur une plate-forme hiérarchique
Par contre, un algorithme glouton très efficace peut être appliqué en pratique comme le montre la figure 12, mais pour lequel il n’existe pas de borne théorique garantie dans le cas général. L’idée ici est d’ordonner les multicœurs depuis celui qui possède la charge minimale jusqu’au plus chargé et de la répartir en équilibrant les
charges deux à deux de proche en proche par un simple glouton. Sur l’exemple de la figure 11, on commence ainsi par répartir les tâches de la machine 5 vers la 4, puis les tâches de fin de la machine 3 sur 4 et 5, etc. C’est l’algorithme ILBA (Iterative Load Balancing) qui est décrit et analysé dans (Pascualet al., 2009).
Figure 12. Ordonnancement final en appliquant ILBA
6.3.2. Tâches parallèles modelables
Passons maintenant au cas de tâches qui peuvent s’exécuter en parallèle sur un nombre quelconque de processeurs. Ce problème a été étudié sous l’hypothèse réa- liste de monotonie des tâches, c’est-à-dire que le temps d’exécution diminue si l’on considère plus de processeurs, mais le travail augmente car on a alors plus de synchro- nisations et de communications.
Les algorithmes connus procèdent en deux phases : détermination du nombre adé- quat de processeurs pour chaque tâche, puis ordonnancement rigide correspondant. Le meilleur algorithme connu pour ce problème est une approximation duale basée sur un algorithme de sac à dos pour sélectionner les tâches à exécuter dans deux étagères successives (Mounieet al., 2007). Une technique analogue a conduit avec succès à des approximations pour le cas de tâches parallèles avec précédences.
6.3.3. Retour sur le volet pratique
Nous avons montré jusqu’à présent en quoi le principe de liste était universel dans le sens où il s’adapte à la plupart des situations, y compris pour les tâches parallèles ri- gides. Dans la plupart des cas, il possède une garantie de performance et se comporte très bien en moyenne. Par contre, il convient de noter que si l’on analyse les outils existants, on constate que les algorithmes de liste sont finalement peu employés. Pra- tiquement, la gestion de ressources des gros systèmes parallèles est très rudimentaire.
Les tâches sont soumises en-ligne et l’ordonnancement est construit à partir de plu- sieurs files de priorité qui gèrent les tâches avec une politique très simple du premier arrivé – premier servi (FCFS). Au fil du temps, on a imaginé des mécanismes pour en améliorer les performances comme le back fillingoù l’idée est d’avancer l’exé- cution d’une tâche si cela ne retarde pas d’autres tâches plus prioritaires (Feitelson,
2010) (illustrée dans la figure 13). Ces politiques sont arbitrairement mauvaises. On peut en effet facilement construire une instance qui a une garantie de performance non bornée : successions de longues tâches séquentielles et courtes tâches occupant toute la machine. Notons également que dans le cas de tâches séquentielles, FCFS est un algorithme de liste particulier car dès qu’un processeur se libère, on pourra toujours exécuter la tâche suivante dans la queue...
L’avantage de FCFS et ses variantes est clairement la simplicité et une garantie que toutes les tâches soient exécutées (pas de famine), mais c’est au prix d’une perte conséquente de performance, même si l’on bricole toujours de nouvelles fonctionna- lités pour s’adapter aux évolutions des systèmes (queues multiples par priorités ou par tailles de tâches, etc.).
Figure 13. Principe de l’algorithme FCFS classique (gauche) et FCFS avec back filling (droite)
6.4. Liste décentralisée et vol de travail
La dernière extension que nous présentons ici concerne l’impact d’un contrôle décentralisé. Le principe même d’un ordonnancement de liste nécessite une vision unique centralisée de toutes les tâches. L’algorithme de vol de travail (work stealing) introduit par (Arora et al., 1998) est un algorithme en-ligne avec une politique dé- centralisée où les processeurs qui n’ont plus de travail à effectuer localement vont voler des tâches à d’autres processeurs. Cette politique est particulièrement bien adap- tée aux machines actuelles avec un grand nombre de processeurs regroupés autour de mémoires partagées.
L’algorithme de vol de travail peut être vu comme un principe de liste décentralisé, où des listes partielles sont délocalisées sur chaque processeur. Il n’y a pas de vision globale. Un processeur inactif cherche aléatoirement un processeur cible, puis lui vole le cas échéant une partie des tâches prêtes. Une analyse théorique complète a été faite récemment pour différents scénarios (Tchiboukdjian et al., 2012). La figure 14 montre un diagramme de Gantt obtenu par simulations pour le cas de tâches indépendantes unitaires. Initialement, seul le premier processeur possède des tâches à effectuer. On remarque que rapidement, tous les processeurs ont réussi à voler du travail et qu’à la fin de l’ordonnancement, il apparaît des temps d’inactivité.
Même sur un cas aussi simple qu’ordonnancer des tâches unitaires indépendantes, on constate que même si les processeurs démarrent rapidement, des temps d’inactivités
apparaissent sporadiquement et de façon de plus en plus importante à mesure que l’on s’approche de la fin de l’ordonnancement. L’analyse est élégante (elle est basée sur des fonctions de potentielle adéquates) et conduit à des approximations garanties asymptotiquement :
Pour des tâches unitaires,Cmax≤Wm + 3.24log2(W) + 2.59
Pour des tâches indépendantes,Cmax≤Wm +m−1m pmax+ 3.24log2(W) + 2.59 Pour des tâches avec précédences,Cmax≤Wm+ 5.5t∞+ 1
Ces valeurs montrent un comportement proche des bornes inférieures classiques dans le cadre centralisé. Ici encore, le principe de liste glouton est simple et efficace.
Figure 14. Diagramme de Gantt d’un ordonnancement de vol de travail sur des tâches indépendantes unitaires
7. Conclusion : l’ordonnancement aujourd’hui 7.1. Quelles leçons retenir ?
Comme nous l’avons montré dans cet article, le domaine de l’ordonnancement pour le parallélisme a fait de gros progrès au fil des années. Du côté théorique, les mo- dèles et algorithmes actuels permettent de tenir compte efficacement des nouvelles ca- ractéristiques des plates-formes modernes. Du côté pratique, les ordonnanceurs exis- tants ont aussi été enrichis avec de nouvelles fonctionnalités et sont opérationnels.
Nous avons défendu ici l’idée qu’il est possible d’étudier les différentes variantes du problème avec des outils communs à partir de la notion d’algorithme de liste. Les analyses suivent le même schéma qui consiste à borner les temps d’inactivité par des bornes inférieures. La plupart des extensions sont adaptables et efficaces sur le pa- pier, c’est-à-dire compte tenu de conditions souvent idéalisées (bonne connaissance des temps d’exécution des tâches, existence d’un modèle de communication réaliste, caractéristiques des mémoires et unités de calcul, etc.). Il est indispensable aujourd’hui de renforcer le pont entre ces deux approches.
7.2. Les enjeux actuels
La première série d’enjeux est d’ordre scientifique et technique. Elle concerne la prise en compte efficace des nouvelles fonctionnalités pour les ordonnanceurs, tant du point de vue théorique que pratique. En particulier : tenir compte au mieux de la dis- ponibilité sporadique des ressources, réduire l’impact des données mal estimées sur la qualité des ordonnancements, concevoir des méthodes adaptées aux ressources hété- rogènes et hiérarchiques, renforcer la sûreté des calculs, développer des mécanismes autoconfigurables qui détectent les ressources inutilisées et sont capables de les réal- louer, diversifier les objectifs pour gérer des ressources non conventionnelles (voire, optimiser simultanément plusieurs objectifs), prendre en compte l’utilisateur dans le dispositif, par exemple en développant des mécanismes d’équité.
Le second enjeu porte sur l’évolution des outils par des méthodes performantes qui ne soient pas trop compliquées pour pouvoir être déclinées et compatibles aux différents niveaux. En effet, le parallélisme est présent à tous les niveaux d’une machine sous une forme ou une autre. Les techniques pour le gérer sont souvent différentes et les décisions prises à un niveau ont évidemment des incidences sur les autres. Des mécanismes comme les algorithmes de liste sont de bons candidats, car ils se déclinent facilement et permettent un interfaçage relativement aisé.
Remerciements
J’aimerais exprimer toute ma reconnaissance à mes nombreux co-auteurs avec une mention spéciale à Marin Bougeret et Daniel Cordeiro pour leur relecture assidue et leur retour constructif.
Ce travail a été soutenu partiellement par Google.
Bibliographie
Anderson D., Fedak G. (2006). The computational and storage potential of volunteer compu- ting. InCcgrid.
Arora N., Blumofe R., Plaxton G. (1998). Thread scheduling for multiprogrammed multipro- cessors. InTenth ACM symposium on parallel algorithms and architectures.
Bader D. (Ed.). (2007).Petascale computing. CRC press.
Bampis E., Guinand F., Trystram D. (1997). Some models for scheduling parallel programs with communication delays.Discrete Applied Maths, vol. 72.
Blazewicz J., Ecker K., Plateau B., Trystram D. (Eds.). (2000). Handbook on parallel and distributed computing. Springer Verlag.
Bougeret M., Dutot P.-F., Jansen K., Otte C., Trystram D. (2010a). Approximation algorithms for multiple strip packing. In7th internat. workshop on approximation and online algo- rithms, vol. 5893. Copenhagen, Denmark, Springer.
