I L AS «Compilation pour les systèmes embarqués» II Méthodes d analyse et d optimisation de programmes

Transcription

1 I L AS «Compilation pour les systèmes embarqués»...situation et problématique II Méthodes d analyse et d optimisation de programmes...approche collaborative et exemples de techniques Philippe Clauss ICPS-LSIIT, UMR CNRS 7005 Université Louis Pasteur, Strasbourg clauss@icps.u-strasbg.fr

2 Christine Eisenbeis Philippe Clauss 2

3 démarrage septembre 2002 AS commune aux RTPs Architecture & Compilation, SoC et SECC : réflexions et actions communes 16 participants u spécialités : parallélisation automatique, analyse de programmes, optimisation, modélisation mathématique, architectures reconfigurables, traitement du signal, processeurs multimédia, langages spécifiques, vérification des systèmes temporisés. u LIP, INRIA, IRISA, Philips, ST-MicroElectronics, CRI, Labri, Verimag, ICPS/LSIIT, LIENS 3

4 minimisation consommation minimisation taille mémoire parallélisme architecture cible à déterminer ou partiellement connue réutilisation d unités matérielles & logicielles temps-réel augmentation de la complexité des problèmes 4

5 Matériel Logiciel ASICS DSP Média-Proc Proc généraux efficacité, exploitation du parallélisme flexibilité, evolutivité 5

6 Compilation de circuits et / ou Compilation de programmes Architecture cible connue? entièrement ou partiellement? adéquation logiciel - matériel 6

7 Incidences sur... ü les applications ü le matériel ü le langage ü le processus de compilation ü le système d exploitation 7

8 algorithmes de plus en plus complexes ü difficulté d analyse ü difficulté d une conception entièrement automatique ü opérations de natures diverses (contrôle, calcul) ü difficulté à garantir le comportement ü solutions de + en + logicielles? 8

9 Le moins performant possible (coût) unités parallèles ü moins consommateur qu un seul processeur à haute fréquence ü problème de la communication entre unités (complexité, temps) réutilisation d unités (architecture prédéfinie, IP) üréduction du «time-to-market», des coûts üconnaissance des performances 9

10 Que doit-il exprimer? le «quoi» et/ou le «comment»? À quel niveau de précision? le parallélisme? le temps? les ressources? abstraction selon des «motifs» logiciels? Reconnaissance de ces motifs? Expression modulaire? définition d un langage adapté? ü permettant une analyse précise ü pratiques de l industrie (C, Matlab,...) 10

11 Part de décisions laissées au programmeur? Pratiques de l industrie : compilateur générique, essais successifs capacité du programmeur à exprimer le «comment» complexité des problèmes d optimisation ü temps de compilation ü modification des pratiques de conception 11

12 Compilation dédiée, stratégies multiples selon l architecture cible selon la partie logicielle selon la granularité Compilation modulaire problème de l unification des modules prise en compte de la granularité (temps-réel) réutilisation d IPs logiciels Vérification du code généré 12

13 Complexité des problèmes d optimisation Approche frontale ou ordonnée des objectifs (inter-influence) Non-linéarité, combinatoire Outils, méthodes? Approximations, heuristiques? Finalisation par une exploration des solutions possibles? 13

14 Influence sur le comportement des programmes peut altèrer l effet escompté des optimisations ü commutation de tâches doit avoir un rôle contrôlable ou limité ü sauvegarde de contexte 14

15

16 Programmes Approche collaborative : Schéma général Analyse précise Statique Structures à contrôle statique (nids de boucles affines) Modèle polyédrique paramétré Dynamique Structures à contrôle dynamique Profiling adaptatif Adaptation & optimisation Environnement d exécution (local réseau) Statique Optimisations génériques Optimisations dédiées Dynamique Code paramétré Découpage délégation - distribution Compilation JIT (just-in-time)

17 Modèle polyédrique for (i = 0 ; i < 8 ; i++) for (j = 0 ; j < i+1 ; j++) {...} j i Polyèdres paramétrés : - opérations ensemblistes - transformations affines - coordonnées paramétriques des sommets - polynômes d Ehrhart : nombre exact de points entiers Librairie PolyLib, solveur PIP, calculateurs SPPoC ou Omega

18 for (i = 0 ; i < N ; i++) for (j = i ; j < N ; j++) { a[j - i, i] =... ; = a[j + i, j]; } Itération (i, j) qui met à jour a[x,y] : E(x,y) = {(i,j) D j-i = x, i = y} = {(y, x + y) D} Itération (i,j) qui utilise a[x,y] : L(x,y) = {(i,j) D j+i = x, j = y} = {(x - y, y) D}

19 Nombre d itérations avant la mise à jour de a[x,y] (incluse) = #{(i, j) D (i, j) lex (y, x + y)} = #{(i, j) D i < y} + #{(i, j) D i = y, j x + y} = - ½ y 2 + (N + ½) y + x + 1 Nombre d itérations avant la lecture de a[x,y] (incluse) = #{(i, j) D (i, j) lex (x - y, y)} = # {(i, j) D i < x - y} + #{(i, j) D i = x - y, j y } = - ½ x 2 ½ y 2 + x y + (N ½) x (N 3/2) y + 1 = durée de vie d une donnée a[x,y] = - ½ x 2 + x y - (2N 1) y + (N 3/2) y

20 Utile pour l analyse du temps d exécution Part essentielle dans les temps d exécution et la consommation électrique Accès aux mémoires cache difficilement prévisibles Possibilité d analyse statique pour les programmes à contrôle statique

21 for (i = 0 ; i < N ; i++) for (j = 0 ; j < M ; j++) x += t[i+j] * t[2*i] ; Analyse du comportement pour un niveau de mémoire (cache) s éléments / ligne de cache bloc mémoire contenant un élément t[x] : Memory_Block(x) = x + s b où b = adresse de base du tableau t

22 Chaque accès mémoire t[x] (t[i+j]ou t[2*i]) correspond à une de ces 3 situations : Memory_Block(x) jamais chargé auparavant défaut de cache initial Memory_Block(x) déjà chargé auparavant mais remplacé depuis défaut de remplacement Memory_Block(x) déjà chargé auparavant et encore présent dans le cache donnée trouvée dans le cache

23 Le bloc mémoire accédé a-t-il déjà été accédé? analyse d un accès mémoire à l itération (i,j) : ensemble des itérations précédant (i,j) qui accèdent au même bloc par exemple, accès par t[i+j]: Same_Block(i + j) (i', j' ) < lex (i, j), Memory_Block(i' + j' ) = Memory_Block(i + j) = U (i', j' ) < lex (i, j), Memory_Block(2i') = Memory_Block(i + j) Si vide : défaut de cache initial Si non vide : le bloc est-il encore présent en mémoire?

24 Nombre de chargements de blocs différents dans le même ensemble de lignes de cache entre l accès le plus récent et l accès présent au bloc mémoire courant Si a : cache de remplacement (a = associativité) Si < a : donnée trouvée Calcul du dernier accès au bloc mémoire courant = maximum lexicographique de Same_Block(x) = (imax, jmax)

25 Itérations entre (imax, jmax) et (i,j) accédant un bloc mémoire chargé dans le même ensemble de lignes de cache par exemple, dernier accès au même bloc par t[imax+jmax] et analyse de l accès t[2*i] : (imax, jmax) < lex (i', j' ) lex (i, j), Cache_Set(i' + j' ) = Cache_Set(2i) Same_Set(2i) = U (imax, jmax) lex (i', j' ) < lex (i, j), Cache_Set(2i' ) = Cache_Set(2i) où Cache_Set(x) = ( Memory_Block(x) mod ns ) (ns = nombre d ensembles de lignes) MAIS : plusieurs itérations peuvent accéder au même bloc

26 Blocs différents chargés dans le même ensemble que le bloc courant entre (imax, jmax) et (i,j) Same_Set(2i) Memory_Block(i' + j' ) / (imax, jmax) < lex (i', j' ) lex (i, j), Cache_Set(i' + j' ) = Cache_Set(2i) = U Memory_Block(2i') / (imax, jmax) lex (i', j' ) < lex (i, j), Cache_Set(2i' ) = Cache_Set(2i) Si #Blocks_In_Set(2i) >= a : défaut de remplacement Sinon : donnée trouvée

27 Sur l ensemble de la boucle, nombre total de défauts de cache initiaux = + # # {(i, j) D/Same_Block(i + j) = } {(i, j) D/Same_Block(2i) = } nombre total de défauts de remplacement = + # # {(i, j) D/# Blocks_In_Set(i + j) a} {(i, j) D/# Blocks_In_Set(2i) a} nombre de fois où la donnée est trouvée dans le cache = # + # {(i, j) D/# Blocks_In_Set(i + j) < a} {(i, j) D/# Blocks_In_Set(2i) < a}

28 Le résultat permet de : évaluer précisément le coût électrique et le temps : = #(défauts initiaux) C C Li + #(donnée trouvée) C accès RAM + #(défauts de remplacement) C accès L guider les optimisations (selon le niveau de paramétrisation de l analyse) : padding : résultat exprimé en fonction de l adresse de base b modification par ajout de dimension de tableau taille des lignes de cache ou associativité adaptées i accès L i+ 1

29 Complexité et outils mathématiques maximum lexicographique : PIP nombre d éléments : polynômes d Ehrhart (PolyLib) insuffisants selon le niveau de non-linéarité et de paramétrisation : contraintes de types «modulo» et «partie entière» linéarisation et «explosion» du nombre de variables «tout paramétrique» : contraintes non-linéaires (polynômes multi-variables)

30 Nécessaire pour l analyse de programmes de tous types Collaboration statique - dynamique structx *p[n];... for (i = 0 ; i < N ; i++) y += p[i]->val; Analyse statique : Nombre d itérations et d instructions, coût important prévisible Questions : localité des accès mémoire? affectation de p[n] dépendant du comportement? Analyse dynamique (profiling) : Observation des accès mémoire modélisation, détection de «régularités»

31 1) Mémorisation des adresses accédées [31688,31832,31976,32120,31768,31912,32056,31704,31848,31992,3 2136,31784,31928,32072,31720,31864,32008,32152,31800,31944,320 88,31736,31880,32024,32168,31760,31904,32048,31696,31840,31984,32128,31776,31920,32064,31712,31856,32000,32144,31792,31936,3 2080,31728,31872,32016,32160,31808,31952,32096] 2) Recherche d une fonction génératrice de la suite d adresses: exemple des fonctions rationnelles génératrices Package GFUN/Maple (B. Salvy, P. Zimmermann) h := x x x x x x x 7 > rgf_term(h,x,12); > rgf_term(h,x,60); x x 7 + x 8

32 ---- : adresses réelles ---- : adresses générées par le modèle Bonne corrélation 3) la fraction rationnelle peut servir à une re-allocation des données ou au pré-chargement des données

33 Stratégie : focaliser l observation sur une structure de données et sur une fonction ou procédure Algorithmes & méthodes de détection de «régularités» répétition de suites pas constants ou représentables par une fonction fréquences de motifs outils permettant la prévision interpolation exclue fonctions rationnelles génératrices lois de probabilité algorithmes de l intelligence artificielle (data mining, moins coûteux?)

34 Ré-ordonnancement des instructions : localité temporelle des accès mémoire parallélisme Ré-allocation des données : localité spatiale des accès mémoire compression mémoire Découpage de programme : parallélisme exécution distribuée selon la disponibilité des ressources Directives d exécution : unités matérielles controlées par logiciel (smart cache) pré-chargement

35 Code paramétré : volume et nature des opérations modulés selon la disponibilité des ressources (QoS) Code en hiérarchie de modules : découpage selon la disponibilité des ressources distribution de modules à travers un réseau compilation JIT ou machine virtuelle exécution distribuée Code réactif à son comportement : optimisations «JIT»

36 problèmes d optimisation plus complexes architecture cible partiellement connue réutilisation d IPs matériels et/ou logiciels architectures cibles diverses temps-réel nécessité d outils mathématiques d analyse paramétrées non-linéarité des problèmes nécessité de l expression des contraintes et du «comment» changement des pratiques de l industrie temps de compilation validation des solutions automatiques