compiladores optimizaciones tradicionales simplificación algebraica, copy propagation, y constant...

Compiladores

Optimizaciones Tradicionales

Simplificación Algebraica,

Copy Propagation, y Constant Propagation

2

Resumen

• Overview de análisis de control de flujo• Simplificación algebraica• Copy Propagation• Constant Propagation

40

3

Expresiones Disponibles

• Dominio– conjunto de expresiones

• Dirección de flujo de datos Hacia adelante• Función de flujo de datos

– OUT = gen (IN - kill)– gen = { a | a se calcula en el bloque básico }– kill = { a | una variable va que es definida en el b.b. }

• Operación Meet– IN = OUT

• Valores iniciales conjunto entero (Top)

4

Cadena DU (Reaching Definitions)

• Dominio– conjunto de definiciones


– OUT = gen (IN - kill)– gen = { x | x es definida en el statement}– kill = { x | LHS var. de x es redefinido en el statement. }


• Valores iniciales Conjunto vacío (Bottom)

5

Framework para análisis

• Análisis de control de flujo– Identificar la estructura del programa

– Ayuda a construir el análisis de flujo de datos

• Análisis de flujo de datos– Framework para encontrar la información necesaria para

optimizar

– Hasta ahora hemos encontrado• expresiones disponibles

• cadenas UD y DU

– ¡Ahora usemos esta información para hacer algo interesante!

6

Optimizaciones

• Cada optimización es muy simple– Reduce la complejidad

• Se necesitan múltiples optimizaciones

• Es posible que haya que aplicar la misma optimización múltiples veces

7

Resumen


40

8

Simplificación algebraica

• Aplicar nuestro conocimiento de algebra, teoría de números, etc para simplificar expresiones

9



• Ejemplo– a + 0 a– a * 1 a– a / 1 a– a * 0 0– 0 - a -a– a + (-b) a - b– -(-a) a

10



• Ejemplo– a true a– a false false– a true true– a false a

11



• Ejemplo– a ^ 2 a*a– a * 2 a + a– a * 8 a << 3

12

Oportunidades para Simplificación Algebraica

• En el código– Los programadores no simplifican expresiones– Los programas son más legibles con exresiones

completas

• Luego de la expansión del compilador– Ejemplo: Lectura de array A[8][12] va a ser

expandida a:– *(Abase + 4*(12 + 8*256)) que puede ser

simplificada después de otras optimizaciones

13

Utilidad de Simplificación Algebraica

• Reduce el número de instrucciones

• Usa expresiones menos “caras”

• Habilita otras optimizaciones

14

Implementación

• ¡No es una optimización de flujo de datos!

• Encontrar candidatos que hagan match con las reglas de simplificación y simplificar los árboles de expresión

• Los candidatos pueden no ser obvios

15

Implementación

• ¡No es una optimización de flujo de datos!

• Encontrar candidatos que hagan match con las reglas de simplificación y simplificar los árboles de expresión

• Los candidatos pueden no ser obvios– Ejemplo

a + b - aa -

b a

+

16

Usar nuestro conocimiento de los operadores

• Operadores conmutativos a op b = b op a

• Operadores asociativos (a op b) op c = b op (a op c)

17

Forma Canónica

• Poner los árboles de expresiones en forma canónica– Suma de multiplicandos– Ejemplo

• (a + 3) * (a + 8) * 4 4*a*a + 44*a + 96

– La Sección 12.3.1 de la ballena habla de esto

18

Efectos en la estabilidad numérica

• Algunas simplificaciones algebraicas pueden producir resultados incorrectos

19



• Ejemplo– (a / b)*0 + c

20



• Ejemplo– (a / b)*0 + c– Podemos simplificar esto a c

21



• Ejemplo– (a / b)*0 + c– Podemos simplificar esto a c– Pero qué pasa cuándo b = 0

debería ser una excepción, pero vamos a obtener un resultado

22

Resumen


40

23

Copy Propagation

• Eliminar copias múltiples– propagar el valor directamente a su uso

• Ejemploa = b + c

d = a

e = d

f = d + 2*e + c

24

Copy Propagation



d = a

e = d

f = d + 2*e + c

25

Copy Propagation



d = a

e = a

f = d + 2*e + c

26

Copy Propagation



d = a

e = a

f = d + 2*e + c

27

Copy Propagation



d = a

e = a

f = a + 2*e + c

28

Copy Propagation



d = a

e = a

f = a + 2*e + c

29

Copy Propagation



d = a

e = a

f = a + 2*a + c

30

Copy Propagation



d = a

e = a

f = a + 2*a + c

31

Oportunidades para Copy Propagation

• En código del usuario

• Después de otras optimizaciones– Ejemplo: Simplificación algebraica

32

Ventajas de Copy Propagation

• Lleva a más simplificaciones algebraicas

33




d = a

e = a

f = a + 2*a + c

34




d = a

e = a

f = a + 2*a + c

35




d = a

e = a

f = 3*a + c

36


• Reduce instrucciones al eliminar ops de copia– Crea código muerto que puede ser eliminado

37




d = a

e = a

f = 3*a + c

38




f = 3*a + c

39

Cómo hacer copy propagation

• Para cada expresión RHS Para cada variable v usada en expresión RHS– si la variable v es definida por un statement v = u– reemplazar la variable v por u

• En cada punto del programa hay que saber– qué variables son iguales– un elemento <u,v> está en el conjunto ssi v = u

(u, v son variables)

40

Cómo hacer copy propagation

• Una asignación v = u todavía es válida en un punto dado de ejecución ssi– Un statement v = u occurre en cada camino de

ejecución que llega al punto actual– La variable v no es redefinida en ninguno de estos

caminos de ejecución entre el statement y el punto actual

– La variable u no es redefinida en ninguno de caminos de ejecución entre el statement y el punto actual

• ¡un problema de flujo de datos!

41

Problema de Data-Flow paraCopy Propagation

• Dominio– Conjunto de tuplas <v,u> representando un statement v = u


– OUT = gen (IN - kill)– gen = { <v,u> | v = u es el statement }– kill = { <v,u> | LHS var. del stmt. es v ó u }


• Valores Iniciales Conjunto vacio (Bottom)

42

Ejemplo

b = a

c = b + 1

d = b

b = d + c

b = d

43

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <v,u> | v = u es el statement }kill = { <v,u> | LHS var. del stmt. es v ó u }

44

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

gen = { }

gen = { <d,b> }

gen = { }

gen = { <b,d> }


45

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }


46

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

OUT = gen (IN - kill)

47

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

OUT = { <b,a> }

IN = { }


48

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

OUT = { <b,a> }

IN = { <b,a> }

IN = { }


49

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

IN = { <b,a> }

IN = { <b,a> }

IN = { }

OUT = { <b,a>, <d,b> }


50

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

IN = { <b,a> }

IN = { <b,a> }

IN = { }

IN = { <b,a>, <d,b> }

OUT = { }


51

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

IN = { <b,a> }

IN = { <b,a> }

IN = { }

IN = { <b,a>, <d,b> }

IN = { }

OUT = { <b,d> }


52

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,b> }

{ }

{ <b,d> }


53

Ejemplo

b = a

c = b + 1

d = b

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,b> }

{ }

{ <b,d> }

54

Ejemplo

b = a

c = b + 1

d = a

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,b> }

{ }

{ <b,d> }

55

Ejemplo

b = a

c = b + 1

d = a

b = d + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,b> }

{ }

{ <b,d> }

56

Ejemplo

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,b> }

{ }

{ <b,d> }

57

Ejemplo

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,b>, <b,d> }

gen = { }

kill = { }

gen = { <d,b> }

kill = { <b,d> }

gen = { }

kill = { <b,a> <d,b>, <b,d> }

gen = { <b,d> }

kill = { <b,a>, <d,b> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,b> }

{ }

{ <b,d> }

58

Ejemplo

b = a

c = b + 1

d = a

b = b + c

b = d

¿Terminamos?

¡No!

59

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

gen = { }

gen = { <d,a> }

gen = { }

gen = { <b,d> }


60

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }


61

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

OUT = { <b,a> }

IN = { }


62

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

OUT = { <b,a> }

IN = { <b,a> }

IN = { }


63

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

IN = { <b,a> }

IN = { <b,a> }

IN = { }

OUT = { <b,a>, <d,a> }


64

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

IN = { <b,a> }

IN = { <b,a> }

IN = { }

IN = { <b,a>, <d,a> }

OUT = { <d,a> }


65

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

IN = { <b,a> }

IN = { <b,a> }

IN = { }

IN = { <b,a>, <d,a> }

IN = { <d,a> }

OUT = {<d,a> ,<b,d> }


66

Ejemplo

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,a> }

{ <d,a> }

{<d,a> ,<b,d> }

67

Ejemplo

b = a

c = b + 1

d = a

b = b + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,a> }

{ <d,a> }

{<d,a> ,<b,d> }

68

Ejemplo

b = a

c = b + 1

d = a

b = a + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,a> }

{ <d,a> }

{<d,a> ,<b,d> }

69

Ejemplo

b = a

c = b + 1

d = a

b = a + c

b = d

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,a> }

{ <d,a> }

{<d,a> ,<b,d> }

70

Ejemplo

b = a

c = b + 1

d = a

b = a + c

b = a

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,a> }

{ <d,a> }

{<d,a> ,<b,d> }

71

Ejemplo

b = a

c = b + 1

d = a

b = a + c

b = a

gen = { <b,a> }

kill = { <d,a>, <b,d> }

gen = { }

kill = { }

gen = { <d,a> }

kill = { <b,d> }

gen = { }

kill = { <b,a>, <b,d> }

gen = { <b,d> }

kill = { <b,a> }

{ <b,a> }

{ <b,a> }

{ }

{ <b,a>, <d,a> }

{ <d,a> }

{<d,a> ,<b,d> }

72

Ejemplo

b = a

c = b + 1

d = a

b = a + c

b = a

¿Terminamos?

¡Sí!

73

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

74

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }

Gen = {<d,a>, <s,p> } Gen = {<d,a> }

Gen = { }


75

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }


76

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }


IN = OUT

77

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

78

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

79

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

80

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { }

81

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { }

82

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { }

OUT = { <d,a>, <s,p> }

83

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }

84

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }

85

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

86

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

IN = { <d,a> }

87

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

IN = { <d,a> }

88

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

Gen = { }Kill = {<d,a>, <s,p> }

Gen = {<d,a>, <s,p> }Kill = { }

Gen = {<d,a> }Kill = { }

Gen = { }Kill = {{<d,a> }

IN = { }


IN = OUT

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

OUT = { }

IN = { <d,a> }

89

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

IN = { }

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

OUT = { }

IN = { <d,a> }

90

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = d + p

d = a

IN = { }

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

OUT = { }

IN = { <d,a> }

91

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = a + p

d = a

IN = { }

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

OUT = { }

IN = { <d,a> }

92

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = a + p

d = a

IN = { }

OUT = { }

IN = { } IN = { }

OUT = { <d,a>, <s,p> }OUT = { <d,a> }

OUT = { }

IN = { <d,a> }

93

Otro Ejemplo

a = b + cp = q + r

d = as = p

a = a + p

d = a

94

Resumen


40

95

Constant Propagation

• Usar valores constantes– Usar la constante conocida para una variable

96



• Ejemploa = 43

b = 4

d = a + 2*b + c

97



• Ejemploa = 43

b = 4

d = a + 2*b + c

98



• Ejemploa = 43

b = 4

d = 43 + 2*b + c

99



• Ejemploa = 43

b = 4

d = a + 2*b + c

100



• Ejemploa = 43

b = 4

d = 43 + 2*4 + c

101

Oportunidades paraConstant Propagation

• Constantes definidas por el usuario– Las mismas constantes se propagan por muchos

caminos– Constantes simbólicas definidas como variables

• Constantes conocidas al compilador– data sizes, stack offsets

• Constantes disponibles después de otras optimizaciones– Simplificación algebraica– Copy propagation

102

Ventajas de Constant Propagation

• Simplificación del programa

103



• Ejemploa = 43

b = 4

d = 43 + 2*4 + c

104



• Ejemploa = 43

b = 4

d = 43 + 2*4 + c

105



• Ejemploa = 43

b = 4

d = 51 + c

106



107



• Ejemploa = 4

b = 8

d = 2*a - b + c

e = c + d

108



• Ejemploa = 4

b = 8

d = 2*a - b + c

e = c + d

109



• Ejemploa = 4

b = 8

d = 2*4 - b + c

e = c + d

110



• Ejemploa = 4

b = 8

d = 2*4 - b + c

e = c + d

111



• Ejemploa = 4

b = 8

d = 2*4 - 8 + c

e = c + d

112



• Ejemploa = 4

b = 8

d = 2*4 - 8 + c

e = c + d

113



• Ejemploa = 4

b = 8

d = 8 - 8 + c

e = c + d

114



• Ejemploa = 4

b = 8

d = 8 - 8 + c

e = c + d

115



• Ejemploa = 4

b = 8

d = 0 + c

e = c + d

116



• Ejemploa = 4

b = 8

d = 0 + c

e = c + d

117



• Ejemploa = 4

b = 8

d = c

e = c + d

118



• Ejemploa = 4

b = 8

d = c

e = c + d

119



• Ejemploa = 4

b = 8

d = c

e = c + d

120



• Ejemploa = 4

b = 8

d = c

e = c + c

121



• Ejemploa = 4

b = 8

d = c

e = c + c

122



• Ejemploa = 4

b = 8

d = c

e = c + c

123



• Ejemploa = 4

b = 8

d = c

e = 2*c

124



• Ejemploa = 4

b = 8

d = c

e = 2*c

125



• Ejemploa = 4

b = 8

e = 2*c

126

Cómo hacer Constant Propagation

• En cada expresión RHS Para cada variable v usada en expresión RHS– si la variable v es una constante conocida k– reemplazar la variable v por k

• En cada punto del programa hay que saber– Para cada variable v, si v es una constante, y si lo

es, el valor constante

127

Cómo hacer Constant Propagation

• Una variable v es la constante k en un punto de ejecución ssi– el statement actual es v = k

o– todo camino que llega al punto actual tiene la

constante k asignada a v

• ¡Un problema de flujo de datos!

128

Valores de dos caminos

a = 5

b = a + 10

a = 5

a = 5

129


a = 5

b = a + 10

a = k + 2

a no es constante

130


a = 5

b = a + 10

a = 7

a no es constante

131


a = 5

b = a + 10

a no definida

a = 5

132


a = 5

b = a + 10

a no definida

a = 5

• programa tonto, usa un valor no inicializado

133


a = 5

b = a + 10

a no definida

a = 5

• programa tonto, usa un valor no inicializado• semántica de alto nivel que el compilador no entiende hace que este sea un programa correcto

134

Lattice para Constant Propagation

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

135

Lattice (repaso)

• Un lattice L consiste de– un conjunto de valores – dos operaciones meet( ) y join ( )– un valor top (T) y un valor bottom ()

136

Lattice (repaso)

• Ejemplo: el lattice para el problema de reaching definitions cuándo sólo hay 3 definiciones

{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

137

Operaciones Meet y Join

{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d2, d3 } = ???

138


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d2, d3 } = ???

139


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d2, d3 } = ???

140


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d2, d3 } = { d2 }

141


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d3 } = ???

142


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d3 } = ???

143


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d3 } = ???

144


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d3 } = ???

145


{ d1, d2 }

{ d2, d3 }

{ d1 }

{ d3 }

= { }

T = { d1, d2, d3 }

{ d1, d3 }

{ d2 }

{ d1, d2 } { d3 } = { d1, d2, d3 }

146

Lattice para Constant Propagation

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

147

Operación Meet en el lattice

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 a = 2

= a

2 2 =

148


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 a = 2

= a

2 2 =

149


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 a = 2

= a

2 2 = 2

150


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 a = 0

= a

2 0 =

151


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 a = 0

= a

2 0 =

152


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 a = 0

= a

2 0 =

153


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 a = 0

= a

2 0 = not a constant

154


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 undefined

= a

2 undefined =

155


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 undefined

= a

2 undefined =

156


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 undefined

= a

2 undefined =

157


= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

a = 2 undefined

= a

2 undefined = 2

158

Problema de Data-Flow paraConstant Propagation

• Dominio– Para cada variable un lattice Lv


– OUT = gen (IN resv)

159




– OUT = gen (IN resv) T si v no es LHS

– gen = xv xv = valor si v es LHS & RHS es constante de otra forma

160






– prsv = xv xv = T si v es el LHS si v no es el LHS

161






– prsv = xv xv =

• Valores Iniciales T (= undefined)

T si v es el LHS si v no es el LHS

162

i = 1 j = 2k = false

i = 3 j = 2

print j j = j + 1

k

exit

i < n

163

i = 1

j = 2

k = false

164

•

T si v no es LHS– gen = xv xv = valor si v es LHS & RHS es constante.

de otra forma


165

gen ={ i:T, j:T, k:T, n:T }

•


de otra forma


166

gen ={ i:T, j:T, k:T, n:T }

prsv = { i:, j:, k:, n: }•


de otra forma


167

i = 1

gen ={ i:1, j:T, k:T, n:T }

prsv = { i:T, j:, k:, n: }•


de otra forma


168

i = 1

j = 2

gen ={ i:1, j:2, k:T, n:T }

prsv = { i:T, j:T, k:, n: }•


de otra forma


169

i = 1

j = 2

k = false

gen ={ i:1, j:2, k:false, n:T }

prsv = { i:T, j:T, k:T, n: }•


de otra forma


170


i = 3 j = 2

print j j = j + 1

k

exit

i < n

gen ={ i:1, j:2, k:false, n:T } prsv = { i:T, j:T, k:T, n: }

gen ={ i:T, j:T, k:T, n:T } prsv = { i:, j:, k:, n: }

gen ={ i:3, j:2, k:T, n:T } prsv = { i:T, j:T, k:, n: }



gen ={ i:T, j:, k:T, n:T } prsv ={ i:, j:T, k:, n:}


171


i = 3 j = 2

print j j = j + 1

k

exit

i < n








172


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }

173

i = 1

j = 2

k = false

gen = { i:1, j:2, k:false, n:T }

prsv = { i:T, j:T, k:T, n: }

IN = { i:T, j:T, k:T, n:T }

174

i = 1

j = 2

k = false


prsv = { i:T, j:T, k:T, n: }

IN = { i:T, j:T, k:T, n:T }

OUT = gen (IN resv)

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

175

i = 1

j = 2

k = false


prsv = { i:T, j:T, k:T, n: }

IN = { i:T, j:T, k:T, n:T }

OUT = gen (IN resv)

IN = { i:1, j:2, k:false, n:T }

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

176


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }

OUT ={ i:T, j:T, k:T, n:T }

OUT ={i:1, j:2, k:false, n:T }

177


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }



178

i < n

out1 = { i:T, j:T, k:T, n:T }

out2 = { i:1, j:2, k:false, n:T }

IN = out1 out2

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

179

i < n

out1 = { i:T, j:T, k:T, n:T }

out2 = { i:1, j:2, k:false, n:T }

IN = out1 out2

IN = { i:1, j:2, k:false, n:T }

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

180


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }


OUT ={i:1, j:2, k:false, n:T } IN ={i:1, j:2, k:false, n:T }

181


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }




182


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }




183


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }



IN ={i:1, j:2, k:false, n:T }


184

i = 3

j = 2

gen = { i:3, j:2, k:T, n:T }

prsv = { i:T, j:T, k:, n: }

IN = { i:1, j:2, k:false, n:T }

OUT = gen (IN resv)

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

185

i = 3

j = 2

gen = { i:3, j:2, k:T, n:T }

prsv = { i:T, j:T, k:, n: }

IN = { i:1, j:2, k:false, n:T }

OUT = gen (IN resv)

IN = { i:3, j:2, k:false, n:T }

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

186


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }





187


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }





188

i < n

out1 = { i:1, j:2, k:false, n:T }

out2 = { i:3, j:2, k:false, n:T }

IN = out1 out2

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

189

i < n

out1 = { i:1, j:2, k:false, n:T }

out2 = { i:3, j:2, k:false, n:T }

IN = out1 out2

IN = { i:, j:2, k:false, n:T }

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

190


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }


OUT ={i:1, j:2, k:false, n:T } IN ={i:, j:2, k:false, n:T }


OUT ={i:, j:2, k:false, n:T }

191


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }




OUT ={i:, j:2, k:false, n:T } IN ={i:, j:2, k:false, n:T }

IN ={i:, j:2, k:false, n:T }

192


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }







193


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }







194


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }








195


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }









196


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }









197


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }










198

j = j + 1

gen = { i:T, j:, k:T, n:T }

prsv = { i:, j:T, k:, n: }


OUT = gen (IN resv)

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

199

j = j + 1

gen = { i:T, j:, k:T, n:T }

prsv = { i:, j:T, k:, n: }


OUT = gen (IN resv)

IN = { i:, j:, k:false, n:T }

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

200


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }









OUT ={i:, j:, k:false, n:T }


201


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }











202

exit

out1 = { i:, j:2, k:false, n:T }

out2 = { i:, j:, k:false, n:T }

IN = out1 out2

IN = { i:, j:, k:false, n:T }

= not a constant

T = undefined

false true …. -2 -1 0 1 2 3 4 ….

203


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }












204


i = 3 j = 2

print j j = j + 1

k

exit

i < n








IN ={ i:T, j:T, k:T, n:T }












205


i = 3 j = 2

print j j = j + 1

k

exit

i < n

IN ={ i:T, j:T, k:T, n:T }




IN ={i:, j:2, k:false, n:T } IN ={i:, j:2, k:false, n:T }


206


i = 3 j = 2

print j j = j + 1

k

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






207


i = 3 j = 2

print j j = j + 1

false

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






208


i = 3 j = 2

print j j = j + 1

false

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






209


i = 3 j = 2

print 2 j = j + 1

false

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






210


i = 3 j = 2

print 2 j = j + 1

false

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






211


i = 3 j = 2

print 2 j = j + 1

false

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






212


i = 3 j = 2

print 2 j = 2 + 1

false

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






213


i = 3 j = 2

print 2 j = 2 + 1

false

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






214


i = 3 j = 2

j = 2 + 1

exit

i < n

IN ={ i:T, j:T, k:T, n:T }






215

Lecturas

• Ballena– Capítulo 13

compiladores optimizaciones tradicionales simplificación algebraica, copy propagation, y constant...

Documents

optimizacin de flujo

datosanlisis de flujo

expresionesejemploa

teora de nmeros

reglas de simplificacin

expresinlos candidatos

simplificacin algebraicaen

optimizacionescada optimizacin