Compiladores Anlisis de Control de Flujo 5 Resumen

Compiladores Análisis de Control de Flujo

5 Resumen • • Overview de Optimizaciones Análisis de Control de Flujo Dominators Recorrido

Anatomía de un Compilador Programa (character stream) Analizador Lexico (Scanner) Token Stream Analizador Sintactico

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

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

Optimicemos. . . int sumcalc(int a, int b, int N) { int i; int

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

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

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

Common Subexpression Elimination int sumcalc(int a, int b, int N) { int i; int

Dead Code Elimination int sumcalc(int a, int b, int N) { int i; int

Loop Invariant Removal int sumcalc(int a, int b, int N) { int i; int

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

Register Allocation fp Variable local X Variable local Y Variable local I 38

Register Allocation fp Variable local X Variable local Y Variable local I $t 9

11 Ejemplo Optimizado int sumcalc(int a, int b, int N) { int i; int

test: subu add sll div add $fp, $t 9, $t 0, $t 7, $t

Codigo No Optimizado test: subu sw sw sw lab 1: mul div lw mul

Pregunta: Pueden Optimizar. . . int foobar(int N) { int i, j, k, x,

Pregunta: Pueden Optimizar. . . int foobar(int N) { int i, j, x, t

Pregunta: Pueden Optimizar. . . • Rendimiento – Programa Original: 17, 670 ciclos –

Implementando constant propagation • Encontrar una expresión LHS que sea constante • Reemplazar el

Representando el control de flujo del progama • La mayoria de instrucciones – Se

Representando el control de flujo del progama • Forma un grafo • Un grafo

Bloques Básicos • Un bloque básico es una secuencia máxima de instrucciones tales que

test: subu sw sw sw lab 1: mul div lw mul lw addui $t

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

Control Flow Graph (CFG) • El bloque con la primera instrucción de un procedimiento

¿Por qué hacer Control-flow Analysis? • Es importante optimizar los loops – Los programas

Retos en Control-Flow Analysis • Control de flujo no estructurado – Uso de goto’s

Construyendo CFGs • Simple: – Programas son escritos usando control de flujo estructurado –

Identificando loops de estructuras recursivas bb 1 bb 2 bb 3 bb 4 bb

Identificando loops de estructuras recursivas bb 1 • Identificar aristas de retorno bb 2

Identificando loops de estructuras recursivas bb 1 • Identificar aristas de retorno • Encontrar

Identificando loops de estructuras recursivas • Identificar aristas de retorno • Encontrar los nodos

Dominators • El nodo x domina al nodo y (x dom y) si todo

Dominators • ¿Es bb 1 dom bb 5? bb 1 bb 2 bb 3

Dominators • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 bb 2 bb

Pregunta • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 • ¿Es bb

Dominators bb 1 bb 2 bb 3 {bb 1} bb 1 bb 2 bb

Computando Dominators • a dom b ssi – a=bo – a es el unico

Computando Dominators • Algoritmo – Hacer que el conjunto de dominators del nodo de

Computando Dominators • Lo que vimos fue un algoritmo iterativo de análisis de flujo

¿Qué es una arista de retorno? • Un edge (x, y) E es una

Recorriendo el CFG • Depth-First Traversal – Visita todos los descendientes del nodo ántes

Depth-First Spanning Tree bb 1 bb 2 bb 3 bb 4 bb 5 bb

Preorder y Postorder • En recorrido preorder, cada nodo es procesado antes que sus

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

CFGs Reducibles bb 1 bb 2 bb 3 bb 2 bb 4 bb 3

CFGs Reducibles bb 1 bb 2 x bb 3 bb 4 bb 5 bb

CFGs Reducibles bb 1 bb 2 y bb 3 bb 4 bb 5 bb

CFGs Reducibles bb 1 bb 2 bb 1 z bb 3 bb 4 bb

Approaches para análisis de control de flujo • Análisis Iterativo – Usar un CFG

Análisis Basado en Intervalos • Si un nodo no incluye un grafo: – Calcular

Análisis Basado en Intervalos bb 1 bb 2 bb 3 bb 4 bb 5

Análisis Basado en Intervalos bb 1 bb 6 143

Análisis Basado en Intervalos bb 1 bb 6 144

Análisis Basado en Intervalos bb 1 bb 6 145

Dominators • Nodo x domina al nodo y (x dom y) si todo camino

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

Dominators • Nodo x domina inmediatamente al nodo y (x idom y) si –

Dominators • Nodo x post domina al nodo y (x pdom y) si todo

Dominators (dom) bb 0 bb 1 bb 2 bb 3 bb 0 bb 1

Strictly Dominates (sdom) bb 0 bb 1 bb 2 bb 1 bb 0 bb

Immediately Dominates (idom) bb 0 bb 1 bb 4 bb 2 bb 6 bb

Post Dominators (pdom) bb 1 bb 2 bb 3 bb 8 bb 9 bb

Bloques Básicos • Un bloque básico es una secuencia máxima de instrucciones tal que

Bloques Básicos Extendidos • Un bloque básico extendido es una secuencia máxima de instrucciones

Lecturas • Ballena – Capitulo 8 • Dragon – Capitulos 10. 5, 10. 6

Slides: 163

Download presentation

Compiladores Análisis de Control de Flujo

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

Anatomía de un Compilador Programa (character stream) Analizador Lexico (Scanner) Token Stream Analizador Sintactico (Parser) Arbol de Parseo Generador de Codigo Intermedio Representación Intermedia Optimizador Codigo Intermedio Representación Intermedia Optimizada Generador de Codigo Código en Assembler 3

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; } 4

test: subu $fp, 16 sw zero, 0($fp) # x = 0 sw zero, 4($fp) # y = 0 sw zero, 8($fp) # i = 0 lab 1: # for(i=0; i<N; i++) mul $t 0, $a 0, 4 # a*4 div $t 1, $t 0, $a 1 # a*4/b lw $t 2, 8($fp) # i mul $t 3, $t 1, $t 2 # a*4/b*i lw $t 4, 8($fp) # i addui$t 4, 1 # i+1 lw $t 5, 8($fp) # i addui$t 5, 1 # i+1 mul $t 6, $t 4, $t 5 # (i+1)*(i+1) addu $t 7, $t 3, $t 6 # a*4/b*i + (i+1)*(i+1) lw $t 8, 0($fp) # x add $t 8, $t 7, $t 8 # x = x + a*4/b*i + (i+1)*(i+1) sw $t 8, 0($fp). . . 5 6

6 . . . lw mul lw add sw $t 0, $t 1, $t 2, lw $t 0, addui$t 0, sw $t 0, ble $t 0, 4($fp) $t 0, a 1 0($fp) $t 2, $t 1 0($fp) # # y b*y x x = x + b*y 8($fp) # i $t 0, 1 # i+1 8($fp) $a 3, lab 1 lw $v 0, 0($fp) addu $fp, 16 b $ra 6

Optimicemos. . . 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; } 7

Constant Propagation 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; } 8

Constant Propagation 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; } 9

Constant Propagation 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; } 10

Constant Propagation 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*0; } return x; } 11

Algebraic Simplification 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*0; } return x; } 12

Algebraic Simplification 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*0; } return x; } 13

Algebraic Simplification 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 + 0; } return x; } 14

Algebraic Simplification 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 + 0; } return x; } 15

Algebraic Simplification 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 + 0; } return x; } 16

Algebraic Simplification 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; } return x; } 17

Copy Propagation 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; } return x; } 18

Copy Propagation 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); } return x; } 19

Common Subexpression Elimination 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); } return x; } 20

Common Subexpression Elimination 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); } return x; } 21

Common Subexpression Elimination 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; } 22

Common Subexpression Elimination 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 + t*t; } return x; } 23

Dead Code Elimination 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 + t*t; } return x; } 24

Dead Code Elimination 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 + t*t; } return x; } 25

Dead Code Elimination int sumcalc(int a, int b, int N) { int i; int x, y, t; x = 0; for(i = 0; i <= N; i++) { t = i+1; x = x + (4*a/b)*i + t*t; } return x; } 26

Dead Code Elimination 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; } 27

Loop Invariant Removal 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 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; } 29

Loop Invariant Removal 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; } 30

Strength Reduction 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 int sumcalc(int a, int b, int N) { int i; int x, t, u; u*0, x = 0; u*1, u = (4*a/b); u*2, for(i = 0; i <= N; i++) { u*3, t = i+1; u*4, x = x + u*i + t*t; . . . } return x; } 32 v=0, v=v+u, . . .

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; } 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 + v + t*t; v = v + u; } return x; } 34

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 + v + t*t; v = v + u; } return x; } 35

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 + v + t*t; v = v + u; } return x; } 36

Strength Reduction int sumcalc(int a, int b, int N) { int i; int x, t, u, v; 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; } 37

11 Ejemplo Optimizado int sumcalc(int a, int b, int N) { int i; int x, t, u, v; 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; } 40

test: subu add sll div add $fp, $t 9, $t 0, $t 7, $t 6, $t 5, lab 1: addui$t 8, mul $t 0, addu $t 1, addu $t 9, 16 zero, zero # $a 0, 2 # $t 0, $a 1 # zero, zero # x = 0 a<<2 u = (a<<2)/b v = 0 i = 0 # for(i=0; i<N; i++) $t 5, 1 # t = i+1 $t 8, $t 8 # t*t $t 0, $t 6 # v + t*t t 9, $t 1 # x = x + v + t*t addu $6, $7 # v = v + u addui$t 5, 1 # i = i+1 ble $t 5, $a 3, lab 1 addu $v 0, $t 9, zero addu $fp, 16 b $ra 41

Codigo No Optimizado test: subu sw sw sw lab 1: mul div lw mul lw addui mul addu lw add sw lw mul lw add sw lw addui sw ble lw addu b Codigo Optimizado test: subu add sll div add lab 1: addui mul addui ble $fp, 16 zero, 0($fp) zero, 4($fp) zero, 8($fp) $t 0, $t 1, $t 2, $t 3, $t 4, $t 5, $t 6, $t 7, $t 8, $t 0, $t 1, $t 2, $t 0, $a 0, 4 $t 0, $a 1 8($fp) $t 1, $t 2 8($fp) $t 4, 1 8($fp) $t 5, 1 $t 4, $t 5 $t 3, $t 6 0($fp) $t 7, $t 8 0($fp) 4($fp) $t 0, a 1 0($fp) $t 2, $t 1 0($fp) 8($fp) $t 0, 1 8($fp) $a 3, lab 1 addu b $ra $fp, $t 9, $t 0, $t 7, $t 6, $t 5, 16 zero, zero $a 0, 2 $t 0, $a 1 zero, zero $t 8, $t 5, 1 $t 0, $t 8 $t 1, $t 0, $t 6 $t 9, $t 1 $6, $7 $t 5, 1 $t 5, $a 3, lab 1 $v 0, $t 9, zero $fp, 16 $v 0, 0($fp) $fp, 16 $ra 4*ld/st + 2*add/sub + br + N*(9*ld/st + 6*add/sub + 4* mul + div + br) = 7 + N*21 Tiempo de Ejecución = 43 sec 6*add/sub + shift + div + br + N*(5*add/sub + mul + br) = 9 + N*7 Tiempo de Ejecución = 17 sec 42

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; } 43 12

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; } 44 19

Pregunta: Pueden Optimizar. . . int foobar(int N) { int i, j, x, t 0, t 1; x = 0; t 1 = 2048; for(i = 0; i <= N-1; i++) { t 0 = (i*i)<<3 + i<<12; x = x + (N-i)*t 0; for(j = i+1; j <= N; j++) { x = x + t 1*j; } t 1 = t 1 + 4; } return x; } 45

Pregunta: Pueden Optimizar. . . int foobar(int N) { int i, j, x, t 0, t 1; x = 0; t 1 = 1024; for(i = 0; i <= N-1; i++) { t 0 = (i*i)<<3 + i<<12; x = x + (N-i)*t 0 + t 1*(N*(N+1)-i*(i+1)); t 1 = t 1 + 2; } return x; } 46

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? 47 19

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

Constant Propagation 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; } 49

Constant Propagation 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; } 50

Constant Propagation 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; } 51

Constant Propagation 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*0; } return x; } 52

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 53

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 Jump – Ejecutan una localidad diferente – Salto en el control de flujo • Instrucciones Branch – Ejecutan ya sea la siguiente intrucción o una localidad diferente – Fork en el control de flujo 54

Representando el control de flujo del progama • Forma un grafo • Un grafo muy grande • Observación – Muchas conexiones de línea recta – Simplificamos el grafo agrupando algunas instrucciones 55

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 58

test: subu sw sw sw lab 1: mul div lw mul lw addui $t 5 addu $t 8 lw a 1 $t 1 sw lw ble lw addu b $fp, 16 zero, 0($fp) zero, 4($fp) zero, 8($fp) $t 0, $t 1, $t 2, $t 3, $t 4, lw $a 0, 4 $t 0, $a 1 8($fp) $t 1, $t 2 8($fp) $t 4, 1 $t 5, 8($fp) $t 5, 1 mul $t 6, $t 4, $t 7, $t 3, $t 6 lw $t 8, add $t 8, sw $t 8, $t 0, 4($fp) mul $t 1, lw $t 2, add $t 2, 0($fp) $t 7, 0($fp) $t 0, 0($fp) $t 2, 0($fp) $t 0, 8($fp) addui $t 0, 1 sw $t 0, 8($fp) $t 0, $a 3, lab 1 $v 0, 0($fp) $fp, 16 $ra 59

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 60

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 61

¿Por qué hacer Control-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-thenelse, for-loops etc. ) – Optimizador puede aprovecharse de esto – Pero hay que descubrirlos primero 62

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 • Control de flujo obscurecido – Invocaciones de metodos – Variables de procedimiento – Funciones de alto orden – Tablas de jumps 63 L 1: x = 0 if (y > 0) goto L 3 L 2: if (y < 0) goto L 1 L 3: y = y + z goto L 2 Myobject->run()

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 64

Identificando loops de estructuras recursivas bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 65

Identificando loops de estructuras recursivas bb 1 • Identificar aristas de retorno bb 2 bb 3 bb 4 bb 5 bb 6 66

Identificando loops de estructuras recursivas bb 1 • Identificar aristas de retorno • Encontrar los nodos y aristas en el loop dado por la arista de retorno bb 2 bb 3 bb 4 bb 5 bb 6 67

Identificando loops de estructuras recursivas • 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 68 bb 1 bb 2 bb 3 bb 4 bb 5 bb 6

Identificando loops de estructuras recursivas bb 1 • 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? 69 bb 2 bb 3 bb 4 bb 5 bb 6

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

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 71

Dominators • ¿Es bb 1 dom bb 5? bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 72

Dominators • ¿Es bb 1 dom bb 5? bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 73

Dominators • ¿Es bb 1 dom bb 5? bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 74

Dominators • ¿Es bb 1 dom bb 5? bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 75

Dominators • ¿Es bb 1 dom bb 5? bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 76

Dominators • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 77

Pregunta • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 • ¿Es bb 3 dom bb 6? bb 2 bb 3 bb 4 bb 5 bb 6 78

Pregunta • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 • ¿Es bb 3 dom bb 6? bb 2 bb 3 bb 4 bb 5 bb 6 79

Pregunta • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 • ¿Es bb 3 dom bb 6? bb 2 bb 3 bb 4 bb 5 bb 6 80

Pregunta • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 • ¿Es bb 3 dom bb 6? bb 2 bb 3 bb 4 bb 5 bb 6 81

Pregunta • ¿Es bb 1 dom bb 5? ¡Sí! bb 1 • ¿Es bb 3 dom bb 6? ¡No! bb 2 bb 3 bb 4 bb 5 bb 6 82

Dominators bb 1 bb 2 bb 3 {bb 1} bb 1 bb 2 bb 3 bb 1 bb 2 bb 5 bb 6 83 bb 4 bb 5 bb 6 bb 1 bb 2 bb 4

Computando Dominators • a dom b ssi – a=bo – 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 84

Computando Dominators • 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 {bb 1} bb 1 bb 2 bb 3 bb 4 bb 5 bb 6

Computando Dominators • 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 116

¿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 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 {bb 1} bb 1 bb 2 bb 3 bb 4 bb 1 bb 2 bb 5 bb 6 bb 1 bb 2 bb 4

¿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 119 {bb 1} bb 1 bb 2 bb 3 bb 4 bb 1 bb 2 bb 5 bb 6 bb 1 bb 2 bb 4

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

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 121

Depth-First Spanning Tree bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 122

Preorder y Postorder • En recorrido preorder, cada nodo es procesado antes que sus descendientes en el árbol depthfirst • En recorrido postorder, cada nodo es procesado después que sus descendientes en el árbol depth -first 123

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

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

CFGs Reducibles bb 1 bb 2 bb 3 bb 2 bb 4 bb 3 bb 5 bb 4 bb 5 bb 6 126

CFGs Reducibles bb 1 bb 2 bb 3 bb 2 bb 4 bb 3 bb 5 bb 4 bb 5 bb 6 127

CFGs Reducibles bb 1 bb 2 x bb 3 bb 4 bb 5 bb 6 128

CFGs Reducibles bb 1 bb 2 x bb 3 bb 4 bb 5 bb 6 129

CFGs Reducibles bb 1 bb 2 x bb 3 bb 4 bb 5 bb 6 130

CFGs Reducibles bb 1 bb 2 y bb 3 bb 4 bb 5 bb 6 131

CFGs Reducibles bb 1 bb 2 y bb 3 bb 4 bb 5 bb 6 132

CFGs Reducibles bb 1 bb 2 y bb 3 bb 4 bb 5 bb 6 133

CFGs Reducibles bb 1 bb 2 bb 1 z bb 3 bb 4 bb 5 bb 6 134

CFGs Reducibles bb 1 bb 2 bb 1 z bb 3 bb 4 bb 5 bb 6 135

Grafos Irreducibles 136

Grafos Irreducibles 137

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

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

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 140

Análisis Basado en Intervalos bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 141

Análisis Basado en Intervalos bb 1 bb 2 bb 3 bb 4 bb 5 bb 6 142

Análisis Basado en Intervalos bb 1 bb 6 143

Análisis Basado en Intervalos bb 1 bb 6 144

Análisis Basado en Intervalos bb 1 bb 6 145

Análisis Basado en Intervalos 146

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

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 bb 1 bb 2 bb 3 {bb 1} bb 1 bb 2 bb 3 bb 1 bb 2 bb 5 bb 6 148 bb 4 bb 5 bb 6 bb 1 bb 2 bb 4

Dominators • Nodo x domina estrictamente al nodo y (x sdom y) si – x dom y –x y bb 1 bb 2 149 {} bb 1 bb 2 bb 3 bb 4 bb 1 bb 2 bb 5 bb 6 bb 1 bb 2

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 bb 2 150 {} bb 1 bb 2 bb 3 bb 4 bb 2 bb 5 bb 6 bb 2

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 bb 6 bb 5 bb 1 incluye al nodo x bb 2 bb 1 bb 6 bb 5 bb 2 bb 6 bb 5 bb 3 151 bb 2 bb 3 bb 4 bb 6 bb 5 bb 6 bb 5 bb 4

Dominators (dom) bb 0 bb 1 bb 2 bb 3 bb 0 bb 1 bb 0 bb 1 bb 4 bb 2 bb 4 bb 6 bb 0 bb 1 bb 4 bb 5 bb 3 152 bb 5 bb 7 bb 0 bb 1 bb 4 bb 8 bb 9 bb 0 bb 1 bb 4 bb 6 bb 7

Strictly Dominates (sdom) bb 0 bb 1 bb 2 bb 1 bb 0 bb 1 bb 4 bb 2 bb 0 bb 1 bb 4 bb 3 153 bb 6 bb 0 bb 1 bb 4 bb 7 bb 0 bb 1 bb 4 bb 6 bb 5 bb 0 bb 1 bb 4 bb 8 bb 9

Immediately Dominates (idom) bb 0 bb 1 bb 4 bb 2 bb 6 bb 2 bb 3 bb 4 bb 5 bb 7 bb 4 bb 8 154 bb 8 bb 9 bb 6

Post Dominators (pdom) bb 1 bb 2 bb 3 bb 8 bb 9 bb 2 bb 1 bb 3 bb 4 bb 8 bb 9 bb 3 bb 0 bb 1 bb 4 bb 8 bb 9 bb 4 bb 6 bb 5 bb 8 bb 9 155 bb 7 bb 8 bb 9 bb 6 bb 7 bb 8 bb 9

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 156

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 158

Lecturas • Ballena – Capitulo 8 • Dragon – Capitulos 10. 5, 10. 6 163