alain darte paul feautrier chargé de recherches au cnrs professeur ens-lyon Équipe compsys lip,...
Post on 03-Apr-2015
116 Views
Preview:
TRANSCRIPT
Alain Darte Paul FeautrierChargé de recherches au CNRS Professeur ENS-Lyon
Équipe Compsys
LIP, ENS-Lyon
Compilation avancée: analyse de programmes, optimisations de code.
A suivre de préférence après le cours de base de compilation (Tanguy Risset).
Des connections également avec les cours d’algorithmique.
Plan
• Introduction.
– Organisation du cours.
– Problématique, questions.
– Quelques thèmes abordés.
– Outils mathématiques rencontrés.
• Quelques problèmes sur des processeurs spécifiques.
• Pipeline logiciel.
• Transformations de boucles.
• Équations récurrentes uniformes.
Organisation du cours
• Choix des thèmes du cours en fonction de ce que vous savez déjà (Master 2 notamment) et du nombre de participants.
• Une grosse moitié de cours « magistraux » pour
– donner les bases,
– présenter quelques techniques en détails,
– et introduire quelques problèmes.
• Une seconde partie de découverte de sujets plus pointus par lecture et présentation d’articles.
• Évaluation: 1 devoir à la maison, 1 examen final éventuel, attitude en cours, rapport + exposé.
Problématique
• Comprendre ce qui peut se faire automatiquement dans le domaine de la compilation (souvent avec des problèmes liés à la mémoire et au parallélisme):
– Formalisation des problèmes (modèle, fonction objective).
– Étude des problèmes (NP-complétude?, algorithmes).
– Étude des modèles (limites, contre-exemples).
• Établir des liens entre différents problèmes/théories.
• Applications:
– Parallélisation automatique (et compilation de HPF).
– Optimisations avancées en compilation “traditionnelle”.
– Compilation de circuits (ex: compilateur PICO des HP Labs/Synfora, MMAlpha ici).
Évolution de la thématique
Réseaux systoliques Vectorisation de boucles
Équations récurrentes uniformes
Parallélisation automatique
Transformations de boucles
High Performance Fortran
ILP et processeurs embarqués
Langages de haut niveau (Matlab, OpenMP,UPC,
CoArray Fortran, …)
“Compilation” de circuits spécialisés
Sujets abordés
• Rappels d’ordonnancement « de base »: graphes de tâches acycliques, contraintes de ressources, “deadlines”.
• Ordonnancement cyclique et pipeline logiciel: liens avec le retiming. Supports hardware pour le pipeline logiciel: registres rotatifs, de prédication, avec spéculation.
• Compilation-parallélisation; premier pas: transformations de boucles. Algorithmes d’Allen et Kennedy, de Lamport. Transformation unimodulaires. Réécriture de code.
• Systèmes d’équations récurrentes uniformes: calculabilité, ordonnancement, liens avec la parallélisation. Synthèse de circuits: méthode systolique de base et extensions.
• Localité et allocation mémoire: fusion de boucles, contraction de tableaux, repliement mémoire.
Outils mathématiques
• Modélisation:
– Systèmes d’équations récurrentes uniformes.
– Graphes de toutes sortes (control-flow, de dominance, d’ínterférence, de dépendances, etc.).
– Polyèdres, réseaux (« lattices »).
• Analyse:
– NP-complétude.
– Algorithmes de graphes.
– Techniques d’ordonnancement.
– Algèbre linéaire. Formes d’Hermite et de Smith.
– Calculs sur polyèdres, programmation linéaire.
Plan
• Introduction.
• Quelques problèmes sur des processeurs spécifiques
• Pipeline logiciel
• Transformations de boucles.
• Équations récurrentes uniformes.
Constructeurs de processeurs « embarqués »
Motorola (Mcore, SC140e) Philips (Trimedia)
STMicro (LX/ST200 family) Intel (StrongARM, Xscale)
TI (TMS320 family) Agere (Payload)
ARM MIPS
Tensilica (XTensa) Synfora
Atmel (Diopsis, ATmega) IBM (PowerPC family)
Ubicom (IP3023) StarCore (SC1400)
et plein plein d’autres compagnies…
Network processor Myricom
• Une seul unité pipelinée de profondeur 3 (ou 4 selon la version): moves, jumps, ALU, load/store.
• Pas de hiérarchie mémoire.
• Peu de registres, avec une sémantique particulière.
Voir les autres transparents, exemple du pipeline logiciel
Agere Payload Plus
• VLIW de largeur 4.
• 1 ALU par « slice » de 1 octet.
• 32 registres de 4 octets, un pour chaque « slice », plus registres spéciaux Y et Q:
– Q = mémoire temporaire, « slice » par « slice »
– Y = écrit « slice » par « slice », lu par tout le monde Seul moyen de communication!
• Code à … 2 adresses! (sauf pour Q et Y).
Ubicom IP3023
• Processeur scalaire « in order ».
• 8 contextes de registres pour support « multi-thread ».
• Possibilité de mélanger les instructions de différents « threads » cycle par cycle.
• 256Ko I-ScratchPad + 64Ko D-ScratchPad.
ST220
• Processeur VLIW (largeur 4).
• Direct-mapped I-Cache (512 lignes de 64o).
• Prédication limitée (Select = move conditionnel).
• Multiply-add, auto-incréments.
Registres étranges
• Registres d’adresse avec incréments et décréments:
– ex: TI TMS320C25, Motorola DSP56K
• Registres rotatifs:
– ex: Itanium
• « Clusters » de registres:
– ex: Agere Payload
• « Register windows »:
– ex: WMIS Microcontroller
• Registres pour load/store doubles:
– ex: IBM PowerPC405, Intel StrongARM pour IXP-1200
Support hard pour le code
• Cache d’instructions
• ScratchPad pour les instructions
• Support pour l’exécution des boucles
• Compression de code
– ex: Atmel Diopsis Dual Core DSP
Et encore plein d’autres options et problèmes…
• Processeurs extensibles (custom functional units).
– ex: Xtensa (Tensilica)
• Hiérarchies mémoires, horizontales, verticales, avec ou sans by-pass, …
• I-Cache + D-Cache, avec ou sans ScratchPads.
• Problèmes de parallélisme au niveau des chips.
• Puissance: drowsy modes, …
Plan
• Introduction.
• Quelques problèmes sur des processeurs spécifiques
• Pipeline logiciel:
– exemple du LANai 3.0
• Transformations de boucles.
• Équations récurrentes uniformes.
Qu’est-ce que le pipeline logiciel?
• Exemple du LANai 3.0:
– une unité séquentielle (pipelinée) effectuant loads, stores, branches, moves et opérations arithmétiques.
– latence apparente: 1 cycle sauf pour le load et les branches (2 cycles) “shadow”
• 1 seul type de “control hazard”, et déterministe:
r1 = load (toto)
r1 = r2 + 1
priorité pour le move entre registres.
Exemple d’ordonnancement de code
Code initial
L400:
ld[r26] r27
nop
add r27, 6740 r26
ld 0x1A54[r27] r27
nop
sub.f r27, r25 r0
bne L400
nop
L399:
Temps 8+8n
Code compacté
L400:
ld[r26] r27
nop
ld 0x1A54[r27] r27
add r27, 6740 r26
sub.f r27, r25 r0
bne L400
nop
L399:
Temps 7+7n !
Code “software pipeliné”
ld[r26], r27
nop
add r27, 6740 r26
L400:
ld 0x1A54[r27] r27
ld[26] r27
sub.f r27, r25 r0
bne L400
add r27, 6740 r26
L399:
Temps 8+5n !!!
Plan
• Introduction.
• Pipeline logiciel.
• Transformations de boucles.
– Détection du parallélisme.
– Fusion, décalage et mémoire.
• Équations récurrentes uniformes.
• Allocation de registres.
• Quelles sont les transformations valides? Comment représenter les contraintes?
– Analyse et représentation des dépendances voir le cours de Paul Feautrier.
• Quel parallélisme peut-on espérer?
– Algorithmes de plus en plus complexes en fonction des représentations des dépendances (Allen-Callahan-Kennedy, Lamport, Wolf-Lam, Feautrier, ...)
• Optimalité, dans quel sens? Complexité? Généralité des méthodes? Extensibilité?
do k = 1, n
a(k,k) = sqrt(a(k,k))
do i = k+1, n
a(i,k) = a(i,k)/a(k,k)
do j = k+1, i
a(i,j) = a(i,j) – a(i,k)*a(j,k)
enddo
enddo
enddo
doseq k = 1, n
a(k,k) = sqrt(a(k,k))
do i = k+1, n
a(i,k) = a(i,k)/a(k,k)
do j = k+1, i
a(i,j) = a(i,j) – a(i,k)*a(j,k)
enddo
enddo
enddo
doseq k = 1, n
a(k,k) = sqrt(a(k,k))
doseq i = k+1, n
a(i,k) = a(i,k)/a(k,k)
dopar j = k+1, i
a(i,j) = a(i,j) – a(i,k)*a(j,k)
enddo
enddo
enddo
Exemple, Allen-Callahan-Kennedy
i
j
f,
f, , 2
doseq k = 1, n
a(k,k) = sqrt(a(k,k))
dopar i = k+1, n
a(i,k) = a(i,k)/a(k,k)
enddo
dopar i = k+1, n
dopar j = k+1, i
a(i,j) = a(i,j) – a(i,k)*a(j,k)
enddo
enddo
enddof, a, o, 1f, a, o, 1
f,
f, , 2
f, a, o, 1
Allen-Callahan-Kennedy (suite)
• Dépendances: par niveau.
• Transformations de boucles:
– marquage (doseq/dopar) et distribution.
• Forces:
– optimal pour les niveaux de dépendances: pourquoi?
– souvent suffisant en pratique.
• Faiblesses:
– insuffisant pour une description des dépendances plus fine,
– insuffisant pour appliquer plus de transformations.
• Exemple: toutes les transformations unimodulaires, le décalage d’instructions et la fusion de boucles.
do i = 1,n+1
dopar j = 1,n+1
if (i 1) & (j 1)
b(i-1,j-1) = a(i-1,j-1) + a(i-1,j-2)
if (i n) & (j n)
a(i,j) = b(i-1,j-1)
enddo
enddo
Autres transformations (exemples)do i = 1,n
do j = 1,n
a(i,j) = a(i,j-1)+a(i-1,j-1)
enddo
enddo
do j = 1,n
dopar i = 1,n
a(i,j) = a(i,j-1)+a(i-1,j-1)
enddo
enddo
do i = 1,n
do j = 1,n
a(i,j) = b(i-1,j-1)
b(i,j) = a(i,j)+a(i,j-1)
enddo
enddo
do i = 1,n
dopar j = 1,n
a(i,j) = b(i-1,j-1)
enddo
dopar j = 1,n
b(i,j) = a(i,j)+a(i,j-1)
enddo
enddo
prologue
do i = 2,n
a(i) = d(i) + 1
b(i) = a(i)/2
c(i-1) = b(i) + a(i-1)
enddo
épilogue
prologue
do i = 2,n
a(i) = d(i) + 1
b = a(i)/2
c(i-1) = b + a(i-1)
enddo
épilogue
Un exemple de problème de fusion pour la mémoire: la contraction de tableaux• But: transformer un tableau temporaire en scalaire.
– application: Matlab, Fortran90, etc.
a = d + 1
b = a/2
c(1..n) = b(2..n+1) + a(1..n)
do i = 1,n
a(i) = d(i) + 1
enddo
do i = 1,n
b(i) = a(i)/2
enddo
do i = 1,n
c(i) = b(i+1) + a(i)
enddo
do i = 1,n
a(i) = d(i) + 1
b(i) = a(i)/2
c(i) = b(i+1) + a(i)
enddo
do i = 1,n
a = d(i) + 1
b(i) = a/2
c(i) = b(i+1) + a
enddo
do i = 1,n
a = d(i) + 1
b(i) = a/2
c(i) = b(i+1) + a
enddo
Plan
• Introduction.
• Pipeline logiciel.
• Transformations de boucles.
• Équations récurrentes uniformes.
– Principes.
– Exemple.
– Résultats et intérêts du modèle.
Équations récurrentes uniformes
Pour 1 i,j,k n
a(i,j,k) = b(i,j-1,k) + a(i,j,k-1)
b(i,j,k) = a(i-1,j,k) + b(i,j,k+1)
• Description à assignation unique.
• Dépendances uniformes.
• Principe de calcul: membre droit d’abord.
• Dépendances explicites.
• Ordre d’exécution implicite.
• Mémoire dépliée.
1
0
0
0
1
0
0
0
1
0
0
-1
SUREs: principes généraux
• Analyse des unions de cycles de poids total nul:
calculabilité du système.
degré de parallélisme du système.
• Analyse “duale” (en termes de programmation linéaire):
ordonnancement du système.
• Attribution d’une sémantique temps + espace:
description d’une architecture systolique lorsque le “temps” est mono-dimensionnel.
pas de mémoire globale mais des temporisations.
SURE, exemple
Pour 1 i,j,k n
a(i,j,k) = b(i,j-1,k) + a(i,j,k-1)
b(i,j,k) = a(i-1,j,k) + b(i,j,k+1)
1
0
0
0
1
0
0
0
1
0
0
-1
chemin de dépendance en N*N
do i = 1,n
do k = n,1,-1
dopar j = 1,n
b(i,j,k) = a(i-1,j,k) + b(i,j,k+1)
enddo
enddo
do k = 1,n
dopar j = 1,n
a(i,j,k) = b(i,j-1,k) + a(i,j,k-1)
enddo
enddo
enddo
Pourquoi ce modèle?
• Avantages:
– Modèle simplifié, plus simple à analyser.
– Flot de calcul explicite. Correspondance calcul-mémoire.
– Dépendances uniformes “délais” constants.
– Description “propre” à la fois proche de l’algorithme et de l’architecture.
– Possibilités de transformations dans le même formalisme.
• Inconvénients:
– Langage correspondant (Alpha) restrictif.
– Langage loin des habitudes des programmeurs.
Boucles, polyèdres, réseaux
i
j
Outils mathématiques: exemple des transformations de boucles.
• Bornes de boucles Polyèdres.
• Points entiers (itérations) Réseaux, sous-réseaux.
• Transformations de boucles Changement de base.
• Représentations des dépendances Polyèdres.
• Allocation des données Algèbre linéaire, réseaux.
• Analyse et génération des communications en HPF Polyèdres + Presburger.
• Optimisations Programmation linéaire.
• ...
top related