Sei sulla pagina 1di 36

1

DATAFLOW ANALYSIS

Global Dataflow Analysis


2

Motivazione.

necessario conoscere le definizioni (def o gen) e luso (use) delle informazioni nei blocchi basici per:

constant folding dead-code elimination redundant computation elimination code motion induction variable elimination build data dependence graph (DDG) etc.

DataFlow Analysis
3

Reaching definition Live variable analysis ud-chains e du-chains Available expressions

Definizione e uso
4

1. Definition & Use

S:

V1 = V2

S una definizione di V1

S un uso di V2

Calcolo di Def e Use in un programma P?


5

Caso 1: P un blocco basico ? Caso 2: P contiene pi di un blocco basico?

Points and Paths


6

B1
d1: i := m-1 d2: j := n d3: a := u1

Un point in un blocco basico si trova: - fra istruzioni - prima della prima istruzione del blocco - dopo lultima istruzione

B2
d4: i := i+1

B3
d5: j := j+1

Nellesempio?

B4

B5
d6: a := u2

B6

B1 ha 4 punti, B2, B3, e B5 hanno ciascuno due punti.

Points e Paths
7

B1
d1: i := m-1 d2: j := n d3: a := u1

B2
d4: i := i+1

B3
d5: j := j+1

un path una sequenza di punti p1, p2, , pn tali che: (i) se p i immediatamente precede S, allora p i+1 immediatamente segue S. (ii) o p i la fine di un blocco basico e pi+1 linizio del blocco successivo
Nellesempio c un cammino dallinizio del blocco B5 allinizio del blocco B6?
B6

B4

B5
d6: a := u2

S, passa il punto finale di B5 e poi attraverso tutti i punti in B2, B3 e B4 .

Reach e Kill
8

Kill

d1: x :=

una definizione d1 di una variablie v uccisa (killed) fra p1 e p2 se in ogni cammino da p1 a p2 c una definizione di v.

d2 : x :=

Reach un definizione d raggiunge (reaches) un punto p se un cammino d p, e d non ucciso (killed) allinterno del path

d1, d2 reach il punto Solo d1 reach il punto

Esempio di Reach
9

B1

S0: S1: S2: S3: S4:


S5: S6: S7:

PROGRAM READ(L) N =0 K= 0 M =1
K= K + M C =K > L IF C THEN GOTO S11

B2

B3

S8: S9: S10:


S11: S12:

N =N + 1 M =M + 2 GOTO S5
WRITE(N) END

B4 Linsieme def raggiunge luso di N in S8: {S2, S8} (S2, S3, S4, S5, S6, S7, S11)

def S2 reach S11 lungo il cammino:


S8 reach S11 lungo il cammino:

(S8, S9, S10, S5, S6, S7, S11)

10

Data-Flow Analysis di programmi strutturati


I programmi strutturati hanno un utile propriet: c un singolo punto di entrara e un solo punto di uscita in ogni istruzione.

Statement id := Expression | Statement ; Statement | if Expression then Statement else Statement | do Statement while Expression Expression id + id | id

Programmi strutturati
11

Le restrizione sintattiche generano I senguenti flowgraphs

S ::= id := E |S;S | if E then S else S | do S while E E ::= id + id | id

S1 S2

If E goto S1 S1 S2

S1

If E goto S1

S1 S2

if E then S1 else S2

do S1 while E

Data-Flow Values
12

1. Ogni punto del programma associato con un data-flow value

2. Un Data-flow value rappresenta I possibili stati osservabile allinterno del programma 3. I data-flow value dipendono dallobiettivo dellanalisi.

Data una istruzione S, in(S) e out(S) rappresentano rispettivamente I data-flow values prima o dopo lesecuzione di S.

13

Data-Flow Values di un blocco basico


Dato un blocco basico B contenente le istruzioni s1,s2, , sn (s1 la prima istruzione di B e sn lultima istruzione di B), il data-flow values immediatamente prima e dopo B e denotato da:

in(B) = in(s1) out(B) = out(sn)

14

Casi di problem trattabili con una analisi Data-Flow

Reaching Definitions Live-Variable Analysis DU Chains e UD Chains Available Expressions

Per risolvere questi problemi dobbiamo prendere in considerazione il data-flow e il control-flow del programma Un metodo comune per risolvere tali problemi quello di creare un insieme di equazioni dataflow.

15

Metodo iterativo per lanalisi Dataflow

Definire un insieme di relazioni dataflow per ogni blocco basico Stabilire un insieme di equazioni dataflow fra i blocchi basici Stabilire una soluzione iniziale Iterativamente risolvere le equazioni fino al raggiungimento del punto fisso (fixed point )

Generazione dellinsieme: gen(S)


16

In generale, una definizion d appartiene a gen(S) se d raggiunge la fine di S independentemente dal fatto che essa raggiunga linizio di S. Se S un blocco basico, gen(S) contiene tuttie le definizioni allinterno del blocco che sono immediatamente visibili dopo il blocco

Insieme Kill: kill(S)


d kill(S) d non raggiunge mai la f ine di S. Cio equivalente a dire: d raggiunge la f ine di S d non in kill(S)
d1 d2 dk dd
d d: a := b + c

a := a := a: a :=

...

kill(s) = Da - { dd } Naturalmente d1,d2, , dk vengono uccisi tutti tranne dd.

17

Linsieme kill del blocco basico lunione di tutte le definizioni uccise dalle singole istruzioni.

Reaching Definitions
18

Definizione del proplema:


Determinare l'insieme di definizioni che raggiungono un punto in un programma.

19

Algoritmo iterativo per le Reaching Definitions


dataflow equations
L'insieme delle definizioni che raggiungono lingresso di un blocco basico B :

in [B] =

P predecessori di B

out [P]

L'insieme delle definizioni che raggiungono luscita di un blocco basico B :

out [B] = gen[B]{in[B - kill [B] } ]

Algoritmo iterativo per le Reaching Definitions


20

Algoritmo 1) out(ENTRY) = ; 2) for (each basic block B other than ENTRY) out(B) = ; Necessit di un flag per verificare se un out 3) while ( ci sono modifiche) cambiato! Il valore 4) for ( each B other than ENTRY) iniziale del flag true. { in[B] = out[P]; P predecessore di B
out[B] =gen[B]

(in[B] kill[B]);

(AhoSethiUllman, pp. 607)

10

Dataflow Equations un esempio


21

Date-f low equations perr reaching def initions

gen[S] = {d}
S d : a := b + c

kill [S] = Da - {d}

Da linsieme di tutte le definizione nel programma della variabile a!

S1 S2

gen [S] = gen [S2] (gen [S1] - kill [S2]) kill [S] = kill [S2] (kill [S1] - gen [S2])

gen [S] = gen [S1] gen [S2]


S S1 S2

kill [S] = kill [S1] kill [S2]

gen [S] = gen [S1]


S

S1

kill [S] = kill [S1]

Dataflow Equations
22

Date-flow equations for reaching definitions

d : a := b + c

out [S] = gen [S] (in [S] - kill [S])

S1 S2

in [S] = in [S1] in [S2] = out [S1] out [S] = out [S2]

S1

S2

in [S] = in [S1] = in [S2] out [S] = out [S1] out [S2]

S1

in [S] = in [S1] out [S1] out [S]= out [S1]

11

Un esempio di Dataflow Analysis


23

Uso di RD (reaching def) :


d1 : i= 0 in

loop L d2 :

. . i= i + 1

Problema: Quale linsieme di def inizioni raggiungibili alluscita del ciclo L?

out

in (L) = {d 1 } out(L) gen (L) = {d 2 } kill (L) = {d 1 } out [L] = gen [L] {in [L] - kill[L]}

in[L] dipende da on out[L], e out[L] dipende da in[L]!!

Inizializzazione
24

Soluzione
d1 :
i= 0 in loop L

out[L] = Prima iterazione

out(L) = gen (L) (in (L) - kill (L)) = {d2} ({d1} - {d 1}) = {d2}
Seconda iterazione out(L) = gen (L) (in (L) - kill (L)) Ma ora: in (L) = {d 1} out (L) = {d 1} {d2} = {d 1, d2}

d2 :

. . i= i + 1 out

comunque:

out (L) = {d 2} ({d1, d 2} - {d 1}) = {d 2} {d2} = {d2}

in (L) = {d1 } out(L) gen (L) = {d2 } kill (L) = {d1 } out [L] = gen [L] {in [L] - kill[L]}

Cosi abbiamo raggiunto il punto fisso!

12

Un ulteriore esempio di Reaching Definitions


25

ENTRY

B1 d1: i := m-1
d2: j := n d3: a := u1

Step 1: Calcolare gen e kill per ogni blocco

gen[B1] = {d 1, d 2, d 3}

B2 d4: i := i+1
d5: j :=j - 1

kill[B1] = {d 4, d 5, d 6, d 7} gen[B2] = {d4, d5}

B3
d6: a := u2

kill [B2] = {d1, d2, d7} gen[B3] = {d6} kill [B3] = {d3}
gen[B4] = {d7} kill [B4] = {d1, d4}

B4 d7: i := u3
EXIT

26

ENTRY

Step 2: Per ogni blocco basico:


B1 d1: i := m-1
d2: j := n d3: a := u1 out[B] =

Inizializzazione:
out[B1] =
out[B2] = out[B3] = out[B4] =

B2 d4: i := i+1
d5: j :=j - 1

B3
d6: a := u2

B4 d7: i := u3
EXIT

13

27

ENTRY

B1 d1: i := m-1 d2: j := n d3: a := u1


B2 d4: i := i+1
d5: j :=j - 1

Per semplificare la rappresentazone di in[B] e out[B] gli insiemi sono rappresentabili come sequenza di bit. Assumendo la rappresentazione d1d2d3 d4d5d6d7 si ottieme:

Initializzazione:
out[B1] = Block B1 B2 B3 B4 in[B]

B3
d6: a := u2

out[B2] =
out[B3] = out[B4] =

B4 d7: i := u3
EXIT

Initial out[B] 000 0000 000 0000 000 0000 000 0000

Notation: d 1d2d3 d 4d5d6d7

gen[B1] = {d1, d2, d3} kill[B1] = {d4, d5, d6, d7} gen[B2] = {d4, d5} kill [B2] = {d1, d2, d7} gen[B3] = {d6} kill [B3] = {d3} 28 gen[B4] = {d7} kill [B4] = {d1, d4}

ENTRY
dove P un predecessore di B out[B] = gen[B] (in[B]-kill[B]) in[B] = out[P]

B1 d1: i := m-1
d2: j := n d3: a := u1

B2 d4: i := i+1
d5: j :=j - 1

Block B1 B2 B3 B4 Block B1 B2 B3 B4

in[B]

B3
d6: a := u2

Initial out[B] 000 0000 000 0000 000 0000 000 0000

B4 d7: i := u3
EXIT Notation: d 1d2d3 d 4d5d6d7

First Iteration in[B] out[B] 000 0000 111 0000 000 0000 000 1100 000 0000 000 0010 000 0000 000 0001

out(B) = gen(B)

14

gen[B1] = {d1, d2, d3} kill[B1] = {d4, d5, d6, d7} gen[B2] = {d4, d5} kill [B2] = {d1, d2, d7} gen[B3] = {d6} kill [B3] = {d3} 29 gen[B4] = {d7} ENTRY kill [B4] = {d1, d4}

B1 d1: i := m-1 d2: j := n d3: a := u1


B2 d4: i := i+1
d5: j :=j - 1

dove P un predecessore di B out[B] = gen[B] (in[B]-kill[B])

in[B] = out[P]

Block

B3
d6: a := u2

B1 B2 B3 B4
Block B1 B2 B3 B4

First Iteration in[B] out[B] 000 0000 111 0000 000 0000 000 1100 000 0000 000 0010 000 0000 000 0001

B4 d7: i := u3
EXIT Notation: d 1d2d3 d 4d5d6d7

Second Iteration in[B] out[B] 000 0000 111 0000 111 0010 001 1110 000 1100 000 11 10 000 1100 001 0111

gen[B1] = {d1, d2, d3} kill[B1] = {d4, d5, d6, d7} gen[B2] = {d4, d5} kill [B2] = {d1, d2, d7} gen[B3] = {d6} kill [B3] = {d3} 30 gen[B4] = {d7} ENTRY kill [B4] = {d1, d4}

B1 d1: i := m-1
d2: j := n d3: a := u1

dove P un predecessore di B out[B] = gen[B] (in[B]-kill[B]) Second Iteration in[B] out[B] 000 0000 111 0000 111 0010 001 1110 000 1100 000 11 10 000 1100 001 0111

in[B] = out[P]

B2 d4: i := i+1
d5: j :=j - 1

Block
B1 B2 B3 B4 Block

B3
d6: a := u2

B4 d7: i := u3
EXIT Notation: d 1d2d3 d 4d5d6d7

B1 B2 B3 B4

Third Iteration in[B] out[B] 000 0000 111 0000 111 1110 001 1110 001 1110 000 11 10 001 1110 001 0111

Abbiamo raggiunto il punto fisso

15

gen[B1] = {d1, d2, d3} kill[B1] = {d4, d5, d6, d7} gen[B2] = {d4, d5} kill [B2] = {d1, d2, d7} gen[B3] = {d6} kill [B3] = {d3} 31 gen[B4] = {d7} ENTRY kill [B4] = {d1, d4}

B1 d1: i := m-1 d2: j := n d3: a := u1


B2 d4: i := i+1
d5: j :=j - 1

dove P un predecessore di B out[B] = gen[B] (in[B]-kill[B]) Third Iteration in[B] out[B] 000 0000 111 0000 111 0010 001 1110 000 1100 000 11 10 000 1100 001 0111

in[B] = out[P]

Block
B1 B2 B3 B4 Block

B3
d6: a := u2

B4 d7: i := u3
EXIT Notation: d 1d2d3 d 4d5d6d7

B1 B2 B3 B4

Forth Iteration in[B] out[B] 000 0000 111 0000 111 1110 001 1110 001 1110 000 11 10 001 1110 001 0111

Abbiamo raggiunto il punto fisso

Esempio
32

1 2 3 4 5 6 L1: 7 8 L2: 9 10 11 12 13 L3:

Receive s fo 0 f1 1 If m <= 1 goto L3 I 2 If i <= m goto L2 return f2 f2 f0 +f1 fo f1 f1 f2 i i+1 goto L1 return m

16

Esempio
33

1 2 3 4 5 6 L1: 7 8 L2: 9 10 11 12 13 L3:

Receive s fo 0 f1 1 If m <= 1 goto L3 I 2 If i <= m goto L2 return f2 f2 f0 +f1 fo f1 f1 f2 i i+1 goto L1 return m

Blocco B1

Esempio
34

1 2 3 4 5 6 L1: 7 8 L2: 9 10 11 12 13 L3:

Receive s fo 0 f1 1 If m <= 1 goto L3 I 2 If i <= m goto L2 return f2 f2 f0 +f1 fo f1 f1 f2 i i+1 goto L1 return m

Blocco B2

17

Esempio
35

1 2 3 4 5 6 L1: 7 8 L2: 9 10 11 12 13 L3:

Receive s fo 0 f1 1 If m <= 1 goto L3 I 2 If i <= m goto L2 return f2 f2 f0 +f1 fo f1 f1 f2 i i+1 goto L1 return m

Blocco B3

Esempio
36

1 2 3 4 5 6 L1: 7 8 L2: 9 10 11 12 13 L3:

Receive s fo 0 f1 1 If m <= 1 goto L3 I 2 If i <= m goto L2 return f2 f2 f0 +f1 fo f1 f1 f2 i i+1 goto L1 return m

Blocco B4

18

Esempio
37

1 2 3 4 5 6 L1: 7 8 L2: 9 10 11 12 13 L3:

Receive s fo 0 f1 1 If m <= 1 goto L3 I 2 If i <= m goto L2 return f2 f2 f0 +f1 fo f1 f1 f2 i i+1 goto L1 return m

Blocco B5

Esempio
38

1 2 3 4 5 6 L1: 7 8 L2: 9 10 11 12 13 L3:

Receive m fo 0 f1 1 If m <= 1 goto L3 I 2 If i <= m goto L2 return f2 f2 f0 +f1 fo f1 f1 f2 i i+1 goto L1 return m

Blocco B6

19

39

entry

B1
B2 B5 B3

B4 B6

exit

Formalizing Analysis
40

Each basic block has


IN insieme di definizioni che raggiungono linizio del blocco OUT - insieme di definizioni che raggiungono la fine del blocco GEN - insieme di definizioni generate nel blocco KILL - insieme di definizioni uccise nel blocco

I compilatori analizzano ogni blocc per derivare gli insiemi GEN e KILL,

20

41

Posizione del Bit 1. 2. 3. 4. 5. 6. 7. 8.

definizione m in node 1 fo in node 2 f1 in node 3 i in node 5 f2 in node 8 f0 in node 9 f1 in node 10 i in node 11

42

Gen(B1) = Gen(B2) = Gen(B3) = Gen(B4) = Gen(B5) = Gen(B6) =

{1,2,3} {} {4} {} {} {5,6,7,8}

11100000 00000000 00010000 00000000 00000000 00001111

21

43

Kill(B1) = {1,2,3,6,7} kill(B2) = {} Kill(B3) = {4} Kill(B4) ={} Kill(B5) ={} kill (B6) = {2,3,4,5,6,7,8}

Equazioni di Dataflow
44

IN[b] = OUT[b1] U ... U OUT[bn]

dove b1, ..., bn sono I predecessori di b nel CFG

OUT[b] = (IN[b] - KILL[b]) U GEN[b] IN[entry] = 0000000 Risultato: un sistema di equazioni

22

Risoluzione del sistema di equazioni


45

Uso di algoritmi basati sulla ricerca del punto fisso Inizializzazione alla soluzione OUT[b] = 0000000 Applicare ripetitivamente le equazioni
IN[b] = OUT[b1] U ... U OUT[bn] OUT[b] = (IN[b] - KILL[b]) U GEN[b]

Fino al raggiungimento del punto fisso Fino a quando le equazioni non producono altri effetti utilizzare una worklist per tracciare lapplicazione di quali equazioni potra avere effetto.

Algorimo iteratibo per le Iterative Reaching Definitions


46

Algoritmo 1) out(ENTRY) = ; 2) for (each basic block B other than ENTRY) out(B) = U; Necessit di un flag per verificare se a 3) while ( changes to any out occur) cambiato! Il valore 4) for ( each B other than ENTRY) iniziale del flag true . { in[B] = out[P]; P predecessor of B
out[B] =e_gen[B]

(in[B] e_kill[B]);

(AhoSethiUllman, pp. 607)

23

Altre applicazionu dellanalisi Data flow


47

Live Variable Analysis DU and UD Chains Available Expressions Constant Propagation Constant Folding

48

Utilizzo dellanalisi dataflow per la analisi delle variabili vive (Liveness analysis)

Una variabile V viva alla fine di un blocco basico n, se c un cammino def-free da n ad un uso esterno di V in un nodo n.

live variable analysis problem - determinare l'insieme di variabili che sono vive all'uscita di ogni punto del programma Liveness analysis un analisi "backwards must", cio un analisi eseguita in ordine inverso .

24

Utilizzo dellanalisi dataflow per la analisi delle Live Variable


49

L1: b := 3; L2: c := 5; L3: a := b + c; goto L1;

Linsime delle variabili vive alla linea L2 {b,c}, ma linsieme delle variabiabili vive alla line L1 solo {b} dato che c aggiornata alla linea 2. Il valore di "a" non mai utilizzato peranto tale variabile non mai viva.

Live Variable Analysis: Insiemi Def e use


50

gen[B]: linsieme delle variabili definite nel blocco basico B prima di qualsiasi uso di tale variabile in B use[B]: linsieme delle variabili I cui valori possono essere usati prima di qualsiasi definizione della variabile.

25

Live Variable Analysis


51

dataflow equations

in[B] = use[B]{out[B - gen[B] } ] out[B] =

S successore di B

in [S ]

52

Algorimo iterativo per lanalisi delle variabili vive


Algoritmo 1) out(EXIT) = ; 2) for (each basic block B other than EXIT) in(B) = ; Necessit di un flag per verificare se a 3) while ( changes to any in occur) cambiato! Il valore 4) for ( each B other than EXIT) iniziale del flag true { out[B] = in[S]; S successori of B
in[B] =use[B]

(out[B] gen[B]);

26

Live Variable Analysis


53

Calcolo dellinsieme delle live variable in(B) e out(B) per il programma:


B1 d1: i := m-1
d2: j := n d3: a := u1

B2 d4: i := i+1
d5: j :=j - 1

B3
d6: a := u2

B4 d7: i := u3

D-U e U-D Chains


54

Molte analisi dataflow richiedono di trovare il posto di utilizzo (use-sites) e il posto di definizione (definitionsites) di ogni variabile. Def-Use (D-U), e Use-Def (U-D) chains sono strutture dati efficenti in grado di mantenere tali informazioni

Quando un codice rappresentato in una forma Static Single-Assignment (SSA) (come accade nei moderni compilatori) non ce necessita di mantenere D-U e U-D chains.

27

UD Chain
55

Un UD chain una lista di tutte le definizioni che possono raggiungere un dato uso di una variabile.
... S1: v= ... ... Sm : v = ...

Sn: ... = v ... A UD chain: UD(Sn, v) = (S1, , Sm ).

DU Chain
56

Una DU chain una lista di tutte gli usi che possono raggiungere da una data definizione di una variabile. DU Chain duale a una UD Chain.
.. . Sn: v =

S1: = v ...

Sk : = v ...

A DU chain: DU(Sn , v) = (S1, , Sk ).

28

Use di DU/UD Chains nellottimizzazione/parallelizzazione


57

Dependence analysis Live variable analysis Alias analysis Analysis for various transformations

Available Expressions
58

Una espressione x+y available a un punto p se:


(1) Ogni cammino da start al nodo p valuta x+y.

(2) Dopo lultima valutazione prima di raggiungere p, non c una successiva assegnazione ad x o a y.
Diremo che un blocco basico uccide lespressione se puo assegnare x o y, e non ricalcola successivamente x+y.

29

Esempio di Available Expression


59

B1

S1: TEMP = A * B S1:X = TEMP + CC X=A *B+

B2

S2: TEMP = A * B S2: Y Y = TEMP +CC =A*B +

B3

S3: C = 1

B4

S4: = A * B + C D E S4: Z =TEMP +C --D * * E

lespressione A I cammini che portano a Si. generato in tutti * B disponibile allinizio delto non blocco basico B4?sua generazione in ogni ucciso dopo la cammino. Quindi la espressione ridondante pu essere eliminata.

B4

Esempio di Available Expression


60

B1

S1: X = A * B S2: Z = X + C

B2

S3: Y = A * B S4: W=Y + C

B3

S5: C = 1

B4

S6: T = A * B S7: V= D * T

Si. generato in tutti I cammini che portano a to B4 e non ucciso dopo la sua generazione in ogni cammino. Quindi la espressione ridondante pu essere eliminata.

30

61

Available Expression: Example


B1
S1: temp = A * B S2: Z = temp + C

B2

S3: temp = A * B S4: W=temp + C

B3

S5: C = 1

B4

S6: T = temp S7: V= D * T

Si. generato in tutti I cammini che portano a to B4 e non ucciso dopo la sua generazione in ogni cammino. Quindi la espressione ridondante pu essere eliminata.

Available Expressions: Insiemi gen e kill


62

Detto U linsieme universale di tutte le espressioni che appaino in una o pi istruzioni in un programma.

gen[B]: insieme delle espressioni generate da B kill[B]: insieme delle espresioni in U uccise in B.

31

63

Calcolo dellinsieme Gen per le espressioni disponibili


No generated expression

x= y+z

p S:
q S: aggiungi y+z a S; Cancella le espressioni che utilizzano x in S

S
a =b+ c b= a d c= b + c d= a - d

b+c
b+c , a - d a d, b + c

a-d

Algoritmo iterativo per le Espressini disponibili (Available Expressions)


64

dataflow equations

in [B] =

P predecessor of B

out [P]

out[B] = gen[B] (in[B] kill[B])

32

Uso delle Available Expressions


65

Scoperta delle sottopressioni comuni globali

66

Altri usi dellanalisi DataFlow


Constant propagation: il processo consente di sostituire il valore conosciuto di una costante in una espressione a compile time.
Constant folding la tecnica di ottimizzazione dove le sottoespressioni costanti sono valutate a compile time.

33

Esempio di Constant Folding


67

i = 32*48-1530

i= 6

Il constant folding pu essere implementato: Nel front end di un compilatore sullIR (prima che esso sia tradotto in codice a tre indirizzi) Nel back end, come aggiunta al constant propagation

Esempio di Constant Propagation


68

int x = 14; int y = 7 - x / 2; return y * (28 / x + 2);

Constant propagation

int x = 14; int y = 7 - 14 / 2; return y * (28 / 14 + 2);


Constant folding

int x = 14; int y = 0; return 0;

34

69

Fondamenti matematici per risolvere le equazione di Dataflow


As long as the dataflow value domain is nice (e.g. semi-lattice) And each function specified by the dataflow equation is nice -- then iterative application of the dataflow equations at each node will eventually terminate with a stable solution (a fix point).

For mathematical foundation -- read


Ken Kenedy: A Survey of Dataflow Analysis Techniques, In Programm Flow Analysis: Theory and Applications, Ed.
Muchnik and Jones, Printice Hall, 1981.

Muchniks book: Section 8.2, pp 223 For a good discussion: also read 9.3 (pp 618-632) in new Dragon Book

Algorithm Convergence
70

Intuitivamente si puo osservare che lalgoritmo converge ad un punto fisso poich linsieme mai decresce in dimenzione.
Si pu mostrare che il limite superiore nel numero delle iterazioni richieste per raggiungere il punto fisso uguale al numero di nodi nel grafo di flusso. Intuitivamente se una definizione raggiunge un punto essa pu raggiunge tale punto attraverso un cammino senza cicli e nessun cammino senza cicli pu essere pi lungo del numero di nodi del grafo.

Lesperienza suggerisce che il numero reale di iterazioni richieste per raggiungere il punto fisso sia minore di 5

35

Alcune note
71

Se data-flow framework raggiunge una "buona" condizione allora il punto fisso a ha una soluzione unica Lalgoritmo iterativo raggiunge il miglior La soluzione non dipende dallordine di calcolo Lalgoritmo pu scegliere un ordine per convergere rapidamente

Ordine dei nodi per massimizzare la propagazione


Visita in postordine inveros : I predecessori sono visitati prima dei nodi La visita in preordine inverso utile nei problemi backward Postordine inverso su CFG inverso equivale preordine inverso

4 2 1 3 3

1 2 4

Post ordine
Visita prima I figli

Postordine inverso
Visita prima I genitori

36