Structure globale Transformation de l’AST en un graphe de blocs de base S´election des instructions Allocation des registres Ordonnancement des instructions

(1)

Structure globale

Transformation de l’AST en un graphe de blocs de base S ´election des instructions

Allocation des registres

Ordonnancement des instructions

(2)

Blocs de base

Un bloc de base est une s ´equence d’instructions avec

•

Un seul point d’entr ´ee, au d ´ebut du bloc

•

Un seul point de sortie, à la fin du bloc G én éralement courts

Les appels de fonction peuvent y apparaˆıtre, selon les cas Une liste d’instructions ponctu ´ee par un branchement

(3)

Blocs de base ´etendus

Un bloc de base ´etendu est une s ´equence d’instructions avec

•

Un seul point d’entr ´ee, au d ´ebut du bloc

•

Un point de sortie `a la fin du bloc, pas forc ´ement seul

Donc, l’extension est de permettre de quitter le bloc en cours de route Encore courts, mais moins que les blocs de base

Une liste d’instructions ponctu ´ee par un branchement D’autres branchments peuvent ˆetre inclus dans la liste

(4)

Graphe de flot de contr ˆ ole (CFG)

Un CFG est un graphe dont les nœuds sont des blocs de base Chaque fonction est repr ´esent ´ee par un CFG

(5)

Exemple (Source)

struct list { int x; struct list next; } struct list list_rev (struct list *l) {

struct list *r = NULL;

while (l) {

struct list *new = malloc (sizeof (struct list));

new->x = l->x;

new->next = r;

r = new;

l = l->next;

}

return r;

(6)

Exemple (BBs)

BB0 struct list r = NULL; goto BB1 BB1 if null l, goto BB3 else goto BB2 BB2 list new = malloc (sizeof (list));

new->x = l->x;

new->next = r;

r = new;

l = l->next;

goto BB1

(7)

Exemple (EBBs)

BB0 struct list *r = NULL; goto BB1 BB1 if null l, goto BB2 else

list *new = malloc (sizeof (list));

new->x = l->x;

new->next = r;

r = new;

l = l->next;

goto BB1

BB2 return r;

(8)

Static Single Assignment (SSA)

Repr ésentation o ù chaque variable n’est affect ée qu’ à un endroit Chaque affectation introduit une nouvelle variable

Chaque BB commence avec des fonction

φ

pour compenser

•

E.g.

x

₉

= φ(x

₁

, x

₃

, x

₆

)

Repr ´esentation plus explicite du flot de donn ´ees

D écoupe chaque usage de variable en él éments ind épendants

•

Evite contraintes arbitraires dues `a r ´eutilisation de variable^´

(9)

Exemple (SSA)

BB0 struct list *r0 = NULL; goto BB1

BB1 l1 = phi(l0, l2); r1 = phi(r0, r2);

if null l, goto BB2 else

list *new0 = malloc (sizeof (list));

new->x = l1->x;

new->next = r1;

r2 = new0;

l2 = l1->next;

goto BB1

BB2 return r1;

(10)

Conversion vers SSA

Conversion na¨ıve:

•

Ajouter une fonction

φ

pour chaque variable au d ´ebut de chaque BB

•

Autant d’arguments que de liens entrant au BB Minimization:

•

Eliminer fonctions^´

φ

de la forme

x

_i

= φ(x

_a

, x

_b

, x

_c

, x

_d

, ...)

o `u

{a, b, c, d, ..} ∈ {i, k}

: Remplacer par

x

_i par

x

_k. Nettoyage (pruning):

•

Eliminer fonctions^´

φ

mortes

(11)

Exemple (autre SSA)

BB0() struct list *r0 = NULL; goto BB1(l0, r0);

BB1(l1,r1) if null l, goto BB2() else

list *new0 = malloc (sizeof (list));

new->x = l1->x;

new->next = r1;

r2 = new0;

l2 = l1->next;

goto BB1(l2,r2);

BB2() return r1;

(12)

Conversion minimale vers SSA

Dominance stricte: Un nœud A domine strictement un nœud B si on passe n ´ecessairement par A avant B

Dominance: Un nœud A domine un nœud B si A = B ou si A domine strictement B.

Fronti `ere de dominance: Un nœud B est dans la fronti `ere de

dominance d’un nœud A si A ne domine pas B strictement, mais il domine un pr ´edecesseur imm ´ediat de B.

Un nœud de la forme

x = e

n ´ecessitera une fonction

φ

à l’entr ée de chaque BB dans la fronti ère de dominance de ce nœud

(13)

Arbre de dominance

Dominateur imm ´ediat: nœud qui domine strictement A mais ne domine strictement aucun autre dominateur strict de A.

Dominator Tree: arbre constitu ´e par la relation de dominance

imm édiate. Il a pour racine le nœud de d épart et chaque nœud a pour enfants les nœuds dont il est le dominateur imm édiat

Repr ´esentation efficace: chaque nœud a un champ

idom

IDom

(n) = n→

idom

Dom

(n) = {n, n→

idom

, n→

idom

→

idom

, ...}

SDom

(n) = {n→

idom

, n→

idom

→

idom

, ...}

(14)

A Simple, Fast Dominance Algorithm,

Cooper et.al.

Analyse de type forward dataflow:

SDom

(n) =

_T

m∈Pred(n) Dom

(m)

for

n ∈

^nodes

, n→

^idom

= >;

^changed

=

^true

; n

0

→

^idom

= ∅

while changed

changed

=

^false for

n ∈

nodes

idom

=

^T

m∈pred(n)

m

if

n→

idom

6=

idom

n→

idom

=

idom

;

changed

=

^true

(15)

Intersection efficace de Dom(n)

Num ´eroter en preorder depuis

n

₀

m ∈

SDom

(n) ⇒

PreOrder

(m) <

PreOrder

(n)

donc Dom

(n)

est naturellement tri ´e:

n→

idom

< n

inter

n

₁

n

₂

=

if n

₁

= > ^then n

₂

else if n

₂

= > ∨ n

₁

= n

₂

^then n

₁

else if n

₁

< n

₂

^then

inter

n

₁

(n

₂

→

idom

)

else

inter

(n

₁

→

idom

) n

₂

(16)

Allocation de registres

Analyse de liveness

Cr ´eation du graphe d’interf ´erence Allocation et spilling

Passage d’arguments Coalescing

Simplifications

(17)

Analyse de liveness

Analyse de type backward dataflow:

Live-in

(i) = (

Live-out

(i) −

Defs

(i)) ∪

Use

(i)

Live-out

(i) =

_S

j∈succ(i) Live-in

(j )

i

est une instruction

Ensembles g én éralement impl ément és par des bitset

(18)

Construction du graphe d’interf ´erences

Parcours simple du control flow graph (CFG)

Interf ´erences entre defs

(i)

et

(

Live-out

(i) −

Defs

(i))

Graphe typiquement repr ésent é par deux structures de donn ées redondantes

•

bitmatrix IF, telle que IF

(v

₁

, v

₂

)

indique s’il y a interf ´erence

•

edge sets, o `u ES

(v)

liste les variables qui interf `erent

(19)

Allocation, assignation, et spilling

L’allocation est comparable `a la coloration de graphe Allocation par simplification du graphe d’interf ´erences:

•

Si

v

a moins que

k

voisins: enlever et ajouter `a la pile

•

Sinon, choisir un candidat au spill: enlever et ajouter `a la pile Ensuite, d ´epiler les variables dans l’ordre:

•

Si registre disponible, assigner

•

Sinon marquer le registre comme spill

S’il y a du spill: ajuster le code, et recommencer

(20)

Convention d’appel de fonction

Placement des arguments

•

Ajouts d’instructions

move

Placements des valeurs de retour

•

Ajouts d’instructions

move

Registres caller-save

•

Interf ´erences entre caller-save et

(

Live-out

(i) −

Defs

(i))

Registres callee-save

•

Ajouts de

move t

_i

:= r

_i

. . . ^move r

_i

:= t

_i

(21)

Coalescing

Elimination des´

move

Ajouter un graphe de pr ´ef ´erences Pref

Durant la simplification du graphe d’interf ´erence:

•

Enlever d’abord les

v

qui ne sont pas dans Pref

•

Si Pref

(v

₁

, v

₂

)

et ils ont (ensemble) moins que

k

voisins: coalesce Lors de l’assignation, choisit la m ˆeme couleur si disponible

(22)

Spilling

Choix des variables `a spill:

•

Co ût estim é de placer la variable en m émoire

•

Probabilit ´e que faire ce spill de

v

´evite d’autres spill Choix possible:

Value

(v) = |

ES(v)

|

Cost

(v)

Possibilit ´e aussi de faire du splitting

•

Divise la variable en deux et ajoute un

move

entre les deux

•

Peut parfois ´eviter le spill

(23)

Simplifications

Au lieu de tout recommencer, apr `es un spill:

•

Mettre `a jour le graphe d’inf ´erence

•

R ´esultat conservateur

(24)

Allocation de registres en SSA

SSA augmente le nombre de variables mais simplifie le graphe:

•

Clique de taille N

⇒

N variables live simultan ´ement!

•

Coloration optimale: greedy par pr ´e-ordre du dominator tree S ´eparation d’allocation et assignation

•

Ajout de spill pour r ´eduire taille max de live-set

– Cons ´equences et gains de chaque spill imm ´ediatement visibles!

•

Choix de couleur affecte seulement le coalescing – Choix optimal de coalescing co ˆuteux: NP

(25)

Linear Scan Allocation

Allocation de registres tr `es rapide, quoique moins bonne Algorithme classique ans les compilateurs JIT

Ordonne toutes les instructions

•

Choix de l’ordre affecte le r ´esultat

Forces chaque live-range `a ˆetre un intervalle contigu

•

Approximation conservatrice

Allocation greedy en traversant le code lin ´eairement

•

S’il n’y a plus de registres, spill le live-range le plus long

(26)

Ordonnancement d’instructions

Rapprocher les instructions ind ´ependentes

•

Exploiter le parall ´elisme de type ILP Eloigner les instructions´ d ´ependentes

•

Eviter d’attendre le r ésultat d’une longue op ération^´ Bloc de base = graphe acyclique de flot de donn ées

•

Ordonnancement est un encodage s ´equentiel

•

Processeur OOO re-d ´ecode ensuite en un graphe de flot de donn ´ee

(27)

D ´ependances

RAW (Read After Write): vrai d ´ependance

WAR (Write after Read): anti-d épendance; lire avant de perdre WAW (Write After Write): d ép. de sortie; perdre la bonne écriture

¡Attention aux exceptions!

SSA ne garde que les d ´ependances vraies

Allocation de registres r é-introduit de fausses d épendances Construction de graphe de d épendances:

•

Graphe orient ´e

•

Chaque ar ˆete porte la latence associ ´ee

(28)

Ordonnancement du graphe

L’ordonnancement est un tri topologique:

•

Choisir une source du graphe

•

Ajouter `a la fin des instructions accumul ´ees

•

Enl `ever du graphe; recommencer jusqu’ `a ce que le graphe soit vide Choix de la source:

•

Consid ère la latence entre instructions d éj à choisies et sources

•

Regarde disponibilit ´e de ressource `a ce point du code

•

Pr ´ef `ere instructions sur le critical path

Structure globale Transformation de l’AST en un graphe de blocs de base S´election des instructions Allocation des registres Ordonnancement des instructions