Alain Darte

Chargé de recherches au CNRS

Équipe Compsys

LIP, ENS-Lyon

Compilation avancée: parallélisation et transformations de programmes.

A suivre de préférence après (ou en parallèle avec) les cours d’Yves Robert, Tanguy Risset et Paul Feautrier

Plan

• Introduction.

– Problématique, questions.

– Quelques thèmes abordés.

– Outils mathématiques rencontrés.

– Organisation du cours.

• Pipeline logiciel.

• Transformations de boucles.

• Équations récurrentes uniformes.

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).

Évolution de la thématique

Réseaux systoliques Vectorisation de boucles

Équations récurrentes uniformes

Parallélisation automatique

Transformations de boucles

High Performance Fortran

Parallélisme au niveau des instructions

Langages de haut niveau (Matlab, F90)

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 et l’algorithme “out-of-kilter”. Fonctionnalités des processeurs modernes: registres rotatifs, de prédication, avec spéculation. Passage en et hors SSA, allocation de registres.

• 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.

Organisation du cours

• Choix des thèmes du cours en fonction de ce que vous savez déjà (Mim2 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 (mais peu probable), attitude en cours, rapport + exposé.

Plan

• Introduction.

• 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).

• 1 seul type de “control hazard”:

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 “sofware 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.

Détection de parallélisme

• Quelles sont les transformations valides? Comment représenter les contraintes?

– Analyse et représentation des dépendances voir le cours du DIF 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, ...) suite du cours d’Yves Robert en Mim2.

• 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.

• ...