análisis de control de flujo

CompiladoresAnálisis de Control de Flujo

2

Resumen

• Overview de Optimizaciones• Análisis de Control de Flujo• Dominators• Recorrido de Grafos• Grafos Reducibles• Análisis de Intervalos• Algunas Definiciones

5

3

Anatomía de un Compilador

Optimizador Codigo Intermedio

Generador de Codigo

Representación Intermedia Optimizada

Código en Assembler

Generador de Codigo Intermedio

Representación Intermedia

Analizador Lexico (Scanner)

Analizador Sintactico (Parser)

Token Stream

Arbol de Parseo

Programa (character stream)

4

Ejemplo

int sumcalc(int a, int b, int N){ int i; int x, y;

x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

x = x + b*y; } return x;}

5

test:subu $fp, 16sw zero, 0($fp) # x = 0sw zero, 4($fp) # y = 0sw zero, 8($fp) # i = 0

lab1: # for(i=0;i<N; i++)mul $t0, $a0, 4 # a*4div $t1, $t0, $a1 # a*4/blw $t2, 8($fp) # imul $t3, $t1, $t2 # a*4/b*ilw $t4, 8($fp) # iaddui$t4, $t4, 1 # i+1lw $t5, 8($fp) # iaddui$t5, $t5, 1 # i+1mul $t6, $t4, $t5 # (i+1)*(i+1)addu $t7, $t3, $t6 # a*4/b*i + (i+1)*(i+1)lw $t8, 0($fp) # xadd $t8, $t7, $t8 # x = x + a*4/b*i + (i+1)*(i+1)sw $t8, 0($fp)...

6

6

...lw $t0, 4($fp) # ymul $t1, $t0, a1 # b*ylw $t2, 0($fp) # xadd $t2, $t2, $t1 # x = x + b*ysw $t2, 0($fp)

lw $t0, 8($fp) # iaddui$t0, $t0, 1 # i+1sw $t0, 8($fp)ble $t0, $a3, lab1

lw $v0, 0($fp)addu $fp, 16b $ra

6

7

Optimicemos...


x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


8

Constant Propagation


x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


9



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


10



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


11



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

x = x + b*0; } return x;}

12

Algebraic Simplification


x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


13



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


14



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

x = x + 0; } return x;}

15



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

x = x + 0; } return x;}

16



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

x = x + 0; } return x;}

17



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

x = x; } return x;}

18

Copy Propagation


x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

x = x; } return x;}

19

Copy Propagation


x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

}

return x;}

20

Common Subexpression Elimination


x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

}

return x;}

21


x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);

}

return x;}


22

int sumcalc(int a, int b, int N){ int i; int x, y, t;

x = 0; y = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + (i+1)*(i+1); }

return x;}


23


x = 0; y = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + t*t; }

return x;}


24

Dead Code Elimination


x = 0; y = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + t*t; }

return x;}

25



x = 0; y = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + t*t; }

return x;}

26



x = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + t*t; }

return x;}

27


int sumcalc(int a, int b, int N){ int i; int x, t;

x = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + t*t; }

return x;}

28

Loop Invariant Removal


x = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + t*t; }

return x;}

29



x = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + (4*a/b)*i + t*t; }

return x;}

30


int sumcalc(int a, int b, int N){ int i; int x, t, u;

x = 0; u = (4*a/b);

for(i = 0; i <= N; i++) { t = i+1;

x = x + u*i + t*t; }

return x;}

31

Strength Reduction


x = 0; u = (4*a/b);

for(i = 0; i <= N; i++) { t = i+1;

x = x + u*i + t*t; }

return x;}

32

Strength Reduction


x = 0; u = (4*a/b);

for(i = 0; i <= N; i++) { t = i+1;

x = x + u*i + t*t; }

return x;}

u*0, u*1, u*2, u*3, u*4,...

v=0, v=v+u,v=v+u,v=v+u,v=v+u,...

33

Strength Reduction

int sumcalc(int a, int b, int N){ int i; int x, t, u, v;

x = 0; u = (4*a/b); v = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + u*i + t*t; v = v + u;

} return x;}

34

Strength Reduction


x = 0; u = (4*a/b); v = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + v + t*t; v = v + u;

} return x;}

35

Strength Reduction


x = 0; u = (4*a/b); v = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + v + t*t; v = v + u;

} return x;}

36

Strength Reduction


x = 0; u = (4*a/b); v = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + v + t*t; v = v + u;

} return x;}

37

Strength Reduction


x = 0; u = ((a<<2)/b); v = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + v + t*t; v = v + u;

} return x;}

38

Register Allocation

fpVariable local X Variable local Y Variable local I

39

Register Allocation

$t9 = X$t8 = t$t7 = u$t6 = v$t5 = i

fpVariable local X Variable local Y Variable local I

40

Ejemplo Optimizado


x = 0; u = ((a<<2)/b); v = 0;

for(i = 0; i <= N; i++) { t = i+1;

x = x + v + t*t; v = v + u;

} return x;}

11

41

test:subu $fp, 16add $t9, zero, zero # x = 0sll $t0, $a0, 2 # a<<2div $t7, $t0, $a1 # u = (a<<2)/badd $t6, zero, zero # v = 0add $t5, zero, zero # i = 0

lab1: # for(i=0;i<N; i++)addui$t8, $t5, 1 # t = i+1mul $t0, $t8, $t8 # t*taddu $t1, $t0, $t6 # v + t*taddu $t9, t9, $t1 # x = x + v + t*t

addu $6, $6, $7 # v = v + u

addui$t5, $t5, 1 # i = i+1ble $t5, $a3, lab1

addu $v0, $t9, zeroaddu $fp, 16b $ra

42

test:subu $fp, 16add $t9, zero, zero sll $t0, $a0, 2div $t7, $t0, $a1 add $t6, zero, zero add $t5, zero, zero

lab1: addui $t8, $t5, 1 mul $t0, $t8, $t8 addu $t1, $t0, $t6 addu $t9, t9, $t1 addu $6, $6, $7 addui $t5, $t5, 1 ble $t5, $a3, lab1

addu $v0, $t9, zeroaddu $fp, 16b $ra

test:subu $fp, 16sw zero, 0($fp) sw zero, 4($fp) sw zero, 8($fp)

lab1: mul $t0, $a0, 4 div $t1, $t0, $a1 lw $t2, 8($fp) mul $t3, $t1, $t2 lw $t4, 8($fp) addui $t4, $t4, 1 lw $t5, 8($fp) addui $t5, $t5, 1 mul $t6, $t4, $t5 addu $t7, $t3, $t6 lw $t8, 0($fp) add $t8, $t7, $t8 sw $t8, 0($fp)lw $t0, 4($fp) mul $t1, $t0, a1 lw $t2, 0($fp) add $t2, $t2, $t1 sw $t2, 0($fp)lw $t0, 8($fp) addui $t0, $t0, 1 sw $t0, 8($fp)ble $t0, $a3, lab1


4*ld/st + 2*add/sub + br +N*(9*ld/st + 6*add/sub + 4* mul + div + br)= 7 + N*21

6*add/sub + shift + div + br +N*(5*add/sub + mul + br)= 9 + N*7

Codigo No Optimizado Codigo Optimizado

Tiempo de Ejecución = 17 secTiempo de Ejecución = 43 sec

43

Pregunta: Pueden Optimizar...int foobar(int N){ int i, j, k, x, y; x = 0; y = 0; k = 256; for(i = 0; i <= N; i++) { for(j = i+1; j <= N; j++) {

x = x + 4*(2*i+j)*(i+2*k);if(i>j)

y = y + 8*(i-j);else

y = y + 8*(j-i); }

} return x;}

12

44

Pregunta: Pueden Optimizar...int foobar(int N){ int i, j, k, x, y; x = 0; y = 0; k = 256; for(i = 0; i <= N; i++) { for(j = i+1; j <= N; j++) {

x = x+8*i*i+4096*i+j*(4*i+2048); }

} return x;}

19

45

Pregunta: Pueden Optimizar...int foobar(int N){ int i, j, x, t0, t1; x = 0;

t1 = 2048; for(i = 0; i <= N-1; i++) { t0 = (i*i)<<3 + i<<12;

x = x + (N-i)*t0; for(j = i+1; j <= N; j++) {

x = x + t1*j; }

t1 = t1 + 4; }

return x;}

46

Pregunta: Pueden Optimizar...int foobar(int N){ int i, j, x, t0, t1; x = 0;

t1 = 1024; for(i = 0; i <= N-1; i++) { t0 = (i*i)<<3 + i<<12;

x = x + (N-i)*t0 + t1*(N*(N+1)-i*(i+1));

t1 = t1 + 2; }

return x;}

47

Pregunta: Pueden Optimizar...

• Rendimiento– Programa Original: 17,670 ciclos– Programa Optimizado: 2,204 ciclos

• Viabilidad– Hicimos algunas optimizaciones bastante

agresivas– ¿Puede gcc hacer estas optimizaciones?

19

48

Resumen


5

49



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


50



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


51



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


52



x = 0; y = 0;

for(i = 0; i <= N; i++) { x = x + (4*a/b)*i + (i+1)*(i+1);


53

Implementando constant propagation

• Encontrar una expresión LHS que sea constante

• Reemplazar el uso de la variable RHS con la constante LHS dado que:– Todos los caminos al uso del RHS pasan por la

asignación del RHS como constante– No hay definiciones intermedias de la variable RHS

• Necesitamos saber el “control de flujo” del programa

54

• Instrucciones Jump– Ejecutan una localidad diferente– Salto en el control de flujo

Representando el control de flujo del progama

• La mayoria de instrucciones – Se ejecuta la siguiente instrucción– Control de flujo es una linea recta

• Instrucciones Branch– Ejecutan ya sea la siguiente intrucción o una

localidad diferente– Fork en el control de flujo

55


• Forma un grafo

• Un grafo muy grande

• Observación– Muchas conexiones de línea recta– Simplificamos el grafo agrupando algunas

instrucciones

56


• Forma un grafo



instrucciones

57


• Forma un grafo



instrucciones

58

Bloques Básicos

• Un bloque básico es una secuencia máxima de instrucciones tales que– Sólo la primera instruccion puede ser alcanzada

desde afuera del bloque básico– Si la primera instrucción es ejecutada, todas las

demás instrucciones son ejecutadas consecutivamente

• No hay instrucciones branch o jump en el bloque básico– Excepto en la última instruccion

• No hay etiquetas en el bloque básico– Excepto antes de la primera instrucción

59

test:subu $fp, 16sw zero, 0($fp)

sw zero, 4($fp)

sw zero, 8($fp)

lab1:

mul $t0, $a0, 4

div $t1, $t0, $a1

lw $t2, 8($fp)

mul $t3, $t1, $t2

lw $t4, 8($fp)

addui $t4, $t4, 1lw $t5,

8($fp) addui $t5, $t5, 1

mul $t6, $t4, $t5 addu $t7, $t3, $t6

lw $t8, 0($fp) add $t8, $t7, $t8 sw $t8, 0($fp)lw $t0, 4($fp)

mul $t1, $t0, a1 lw $t2, 0($fp) add $t2, $t2, $t1 sw $t2, 0($fp)lw $t0, 8($fp)

addui $t0, $t0, 1 sw $t0, 8($fp)ble $t0, $a3, lab1


60

Control Flow Graph (CFG)• Control-Flow Graph G = <N, E>

• Nodes(N): Bloques Básicos

• Edges(E): (x,y) E ssi la primera instrucción en el bloque básico y sigue a una instrucción en el bloque básico x– Primera instrucción en y es el target de una

instrucción branch o jump (última instrucción) en el bloque básico x

– Primera instrucción de y es la siguiente a la última instrucción de x en memoria y la última instrucción de x no es una instrucción jump

61

Control Flow Graph (CFG)

• El bloque con la primera instrucción de un procedimiento es un entry node (bloque con la etiqueta del procedimiento)

• Los bloques con la instrucción de retorno (jr) son los exit nodes– Se puede hacer un solo exit node agregando un

nodo especial

62

¿Por qué hacerControl-flow Analysis?

• Es importante optimizar los loops– Los programas pasan mucho tiempo en loops y

ciclos recursivos– Se pueden hacer muchas optimizaciones

especiales en los loops

• Los programadores organizan el código usando estructuras de control de flujo (if-then-else, for-loops etc.)– Optimizador puede aprovecharse de esto– Pero hay que descubrirlos primero

63

Retos en Control-Flow Analysis

• Control de flujo no estructurado– Uso de goto’s por el programador– Unica forma de construir ciertas

estructuras de control

L1: x = 0

if (y > 0) goto L3

L2: if (y < 0) goto L1

L3: y = y + z

goto L2

• Control de flujo obscurecido– Invocaciones de metodos– Variables de procedimiento– Funciones de alto orden– Tablas de jumps

Myobject->run()

64

Construyendo CFGs

• Simple:– Programas son escritos usando control de flujo

estructurado– Tienen patrones simples de CFG

• ¡No es así!– Gotos pueden crear patrones de control de flujo

diferentes a lo que está dado por el control de flujo estructurado

– Necesitamos hacer análisis para identificar los verdaderos patrones de control de flujo

65

Identificando loops de estructuras recursivas

bb1

bb2

bb4bb3

bb5

bb6

66


• Identificar aristas de retornobb1

bb2

bb4bb3

bb5

bb6

67


• Identificar aristas de retorno

• Encontrar los nodos y aristas en el loop dado por la arista de retorno

bb1

bb2

bb4bb3

bb5

bb6

68


• Identificar aristas de retorno

• Encontrar los nodos y aristas en el loop dado por la arista de retorno

• Aparte de la arista de retorno– Aristas entrantes sólo al bloque

básico con la cabeza de la arista de retorno

– Una arista saliente del bloque básico a la cola de la arista de retorno

bb1

bb2

bb4bb3

bb5

bb6

69


• Identificar aristas de retorno• Encontrar los nodos y aristas en el

loop dado por la arista de retorno• Aparte de la arista de retorno

– Aristas entrantes sólo al bloque básico con la cabeza de la arista de retorno

– Una arista saliente del bloque básico a la cola de la arista de retorno

• ¿Cómo encontramos las aristas de retorno?

bb1

bb2

bb4bb3

bb5

bb6

70

Resumen


5

71

Dominators

• El nodo x domina al nodo y (x dom y) si todo camino de ejecución posible desde la entrada hasta el nodo y incluye el nodo x

72

Dominators

• ¿Es bb1 dom bb5?

bb1

bb2

bb4bb3

bb5

bb6

73

Dominators


bb1

bb2

bb4bb3

bb5

bb6

74

Dominators


bb1

bb2

bb4bb3

bb5

bb6

75

Dominators


bb1

bb2

bb4bb3

bb5

bb6

76

Dominators


bb1

bb2

bb4bb3

bb5

bb6

77

Dominators

• ¿Es bb1 dom bb5? ¡Sí!

bb1

bb2

bb4bb3

bb5

bb6

78

Pregunta


• ¿Es bb3 dom bb6?bb1

bb2

bb4bb3

bb5

bb6

79

Pregunta



bb2

bb4bb3

bb5

bb6

80

Pregunta



bb2

bb4bb3

bb5

bb6

81

Pregunta



bb2

bb4bb3

bb5

bb6

82

Pregunta


• ¿Es bb3 dom bb6? ¡No!bb1

bb2

bb4bb3

bb5

bb6

83

Dominators

bb1

bb2

bb4bb3

bb5

bb6

bb1bb2

{bb1}

bb1bb2bb3

bb1bb2bb4

bb1bb2bb5

bb1bb2bb5bb6

84

Computando Dominators

• a dom b ssi– a = b o– a es el unico predecesor inmediato de b o– a es un dominador de todos los predecesores inmediatos de b

• Algoritmo– Hacer que el conjunto de dominators del nodo de entrada

sólo contenga ese nodo– Hacer que el conjunto de dominators del resto de los nodos

contenga todos los nodos– Visitar los nodos en cualquier orden– Hacer que el conjunto de dominators del nodo actual sea la

intersección del conjunto de dominators del nodo predecesor y el nodo actual

– Repetir hasta que no hayan cambios

85


bb2

bb4bb3

bb5

bb6

{bb1} bb1

• Algoritmo– Hacer que el conjunto de

dominators del nodo de entrada sólo contenga ese nodo

– Hacer que el conjunto de dominators del resto de los nodos contenga todos los nodos

– Visitar los nodos en cualquier orden

– Hacer que el conjunto de dominators del nodo actual sea la intersección del conjunto de dominators del nodo predecesor y el nodo actual


86


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

87


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

88


bb1

bb2

bb4bb3

bb5

bb6

{bb1}







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

89


bb1

bb2

bb4bb3

bb5

bb6

{bb1}







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

90


bb1

bb2

bb4bb3

bb5

bb6

{bb1}







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2

91


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2

bb1bb2bb3bb4bb5bb6

92


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2bb3bb4bb5bb6

bb1bb2

93


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb4bb5bb6

94


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

95


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb4bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

96


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

97


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb3bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

98


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

99


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

100


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

101


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

102


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

103


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

104


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb5

105


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb5

106


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

107


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

108


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

109


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

110


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

111


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

112


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

113


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

114


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

115


bb2

bb4bb3

bb5

bb6

{bb1} bb1







bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

116


• Lo que vimos fue un algoritmo iterativo de análisis de flujo de datos en acción– Inicializa todos los nodos a un valor dado– Visita los nodos en algún orden– Calcula el valor del nodo– Se repite hasta que no cambie ningún valor

• Vamos a hablar de esto en la próxima clase

117

¿Qué es una arista de retorno?

• Un edge (x, y) E es una arista de retorno ssi y dom x– el nodo y está en el

conjunto de dominators del nodo x

118




bb2

bb4bb3

bb5

bb6

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

119




bb2

bb4bb3

bb5

bb6

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

120

Resumen


5

121

Recorriendo el CFG

• Depth-First Traversal – Visita todos los descendientes del nodo ántes de

visitar a los hermanos

• Depth-first spanning tree– Un conjunto de aristas correspondientes a una visita

depth-first del CFG

122

Depth-First Spanning Tree

bb2

bb4bb3

bb5

bb6

bb1

123

Preorder y Postorder

• En recorrido preorder, cada nodo es procesado antes que sus descendientes en el árbol depth-first

• En recorrido postorder, cada nodo es procesado después que sus descendientes en el árbol depth-first

124

Resumen


5

125

CFGs Reducibles

• La reducibilidad formaliza la buena estructuración de un programa

• Un grafo es reducible ssi aplicar múltiples veces las siguientes dos acciones resulta en un grafo con un solo nodo– Reemplazar loops a él mismo con un solo nodo– Reemplazar una secuencia de nodos en la que todas

las aristas entrantes son al primer nodo y todas las aristas salientes son del último nodo, por un solo nodo.

126

CFGs Reducibles

bb2

bb4bb3

bb5

bb6

bb1

bb2

bb4bb3

bb5

bb6

bb1

127

CFGs Reducibles

bb2

bb4bb3

bb5

bb6

bb1

bb6

bb1

bb2

bb4bb3

bb5

128

CFGs Reducibles

bb2

bb4bb3

bb5

bb6

bb1

bb2x

bb6

bb1

129

CFGs Reducibles

bb6

bb1

bb2

bb4bb3

bb5bb6

bb1

bb2x

130

CFGs Reducibles

bb6

bb1

bb2

bb4bb3

bb5

bb2x

bb6

bb1

131

CFGs Reducibles

bb6

bb1

bb2

bb4bb3

bb5

bb2y

bb6

bb1

132

CFGs Reducibles

bb6

bb1

bb2

bb4bb3

bb5bb6

bb1

bb2y

133

CFGs Reducibles

bb6

bb1

bb2

bb4bb3

bb5bb6

bb1

bb2y

134

CFGs Reducibles

bb6

bb1

bb2

bb4bb3

bb5bb6

bb1

bb1z

135

CFGs Reducibles

bb6

bb1

bb2

bb4bb3

bb5

bb1z

136

Grafos Irreducibles

137

Grafos Irreducibles

138

Resumen


5

139

Approaches para análisis de control de flujo

• Análisis Iterativo– Usar un CFG– Propagar valores– Iterar hasta que no hayan cambios

• Análisis Basado en Intervalos– Usar un CFG reducible– Calcular en grafos jerárquicos– No hay iteraciones (más rápido)

140

Análisis Basado en Intervalos

• Si un nodo no incluye un grafo:– Calcular el valor

• Si un nodo incluye un grafo– Calcular valores de los nodos en el grafo– Propagar valores (no aristas de retorno no

iteracion)– Usar valor de entrada (o salida) como valor del

nodo que contiene este grafo

141


bb6

bb1

bb2

bb4bb3

bb5

142


bb6

bb1

bb2

bb4bb3

bb5

143


bb6

bb1

144


bb6

bb1

145


bb6

bb1

146


147

Resumen


5

148

Dominators

• Nodo x domina al nodo y (x dom y) si todo camino de ejecución posible desde la entrada hasta el nodo y incluye al nodo x

bb1

bb2

bb4bb3

bb5

bb6

bb1bb2

{bb1}

bb1bb2bb3

bb1bb2bb4

bb1bb2bb5

bb1bb2bb5bb6

149

Dominators

• Nodo x domina estrictamente al nodo y (x sdom y) si– x dom y– x y bb1

bb2

bb4bb3

bb5

bb6

bb1

{}

bb1bb2

bb1bb2

bb1bb2

bb1bb2bb5

150

Dominators

• Nodo x domina inmediatamente al nodo y (x idom y) si – x dom y– x y– c N tal que

c x & c y & x dom c & c dom y

bb1

bb2

bb4bb3

bb5

bb6

bb1

{}

bb2 bb2

bb2

bb5

151

Dominators

• Nodo x post domina al nodo y (x pdom y) si todo camino de ejecucion posible desde el nodo y hasta el nodo de salida incluye al nodo x bb1

bb2

bb4bb3

bb5

bb6

bb6bb5bb2

bb6bb5bb3

bb6bb5bb4

bb6bb5

bb6

bb6bb5bb2bb1

152

Dominators(dom)

bb1

bb4

bb6

bb5

bb8

bb9

bb0bb1bb4

bb0bb1bb4bb5

bb0bb1bb4bb6

bb0bb1bb4bb8

bb0bb1bb4bb8bb9

bb0bb1

bb0bb0

bb3bb0bb1bb2bb3

bb2bb0bb1bb2

bb7bb0bb1bb4bb6bb7

153

Strictly Dominates(sdom)

bb1

bb4

bb6

bb5

bb8

bb9

bb0bb1

bb0bb1bb4

bb0bb1bb4

bb0bb1bb4

bb0bb1bb4bb8

bb0

bb0

bb3bb0bb1bb2

bb2bb0bb1

bb7bb0bb1bb4bb6

154

Immediately Dominates

(idom) bb1

bb4

bb6

bb5

bb8

bb9

bb0

bb0

bb3

bb2

bb7

bb1

bb2

bb1

bb4

bb4

bb8

bb4

bb6

155

Post Dominators(pdom)

bb1

bb4

bb6

bb5

bb8

bb9

bb4bb8bb9

bb5bb8bb9

bb6bb7bb8bb9

bb8bb9

bb9

bb1bb4bb8bb9

bb0

bb0bb1bb4bb8bb9

bb3bb1bb3bb4bb8bb9

bb2

bb1bb2bb3bb8bb9

bb7bb7bb8bb9

156

Bloques Básicos• Un bloque básico es una secuencia

máxima de instrucciones tal que– Sólo la primera instrucción puede

alcanzarse desde fuera del bloque

– Si la primera instrucción es ejecutada, todas las demás instrucciones son ejecutadas consecutivamente

• No instrucciones branch ni jump en el bloque básico

– Excepto la última instruccion

• No etiquetas dentro del bloque básico– Excepto antes de la primera instrucción

157

Bloques Básicos• Un bloque básico es una secuencia

máxima de instrucciones tal que– Sólo la primera instrucción puede

alcanzarse desde fuera del bloque

– Si la primera instrucción es ejecutada, todas las demás instrucciones son ejecutadas consecutivamente

• No instrucciones branch ni jump en el bloque básico

– Excepto la última instruccion

• No etiquetas dentro del bloque básico– Excepto antes de la primera instrucción

158

Bloques Básicos Extendidos• Un bloque básico extendido es una

secuencia máxima de instrucciones tal que– Sólo la primera instrucción puede

alcanzarse desde fuera del bloque• No etiquetas dentro del bloque básico

excepto ántes de la primera instrucción

159





160





161





• Rearreglamos el grafo para reducir el número de bloques básicos

162





• Rearreglamos el grafo para reducir el número de bloques básicos

163

Lecturas

• Ballena– Capitulo 8

• Dragon– Capitulos 10.5, 10.6

análisis de control de flujo

Documents