análisis de control de flujo

CompiladoresAnálisis de Control de Flujo

Resumen

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

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)

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

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

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

Optimicemos...

x = 0; y = 0;

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

Constant Propagation

x = 0; y = 0;

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

x = 0; y = 0;

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

x = 0; y = 0;

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

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

Algebraic Simplification

x = 0; y = 0;

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

x = 0; y = 0;

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

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

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

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

x = 0; y = 0;

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

x = x; } return x;}

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

Copy Propagation

x = 0; y = 0;

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

return x;}

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

x = 0; y = 0;

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

return x;}

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

x = 0; y = 0;

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

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

return x;}

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

x = 0; y = 0;

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

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

return x;}

x = 0;

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

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

return x;}

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

Loop Invariant Removal

x = 0;

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

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

return x;}

x = 0;

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

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

return x;}

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

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

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

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

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

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

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

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

Register Allocation

fpVariable local X Variable local Y Variable local I

Register Allocation

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

fpVariable local X Variable local Y Variable local I

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

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

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

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

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

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

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

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?

Resumen

x = 0; y = 0;

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

x = 0; y = 0;

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

x = 0; y = 0;

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

x = 0; y = 0;

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

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

• 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

• Forma un grafo

• Un grafo muy grande

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

instrucciones

• Forma un grafo

instrucciones

• Forma un grafo

instrucciones

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

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

sw zero, 4($fp)

sw zero, 8($fp)

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

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

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

¿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

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

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

Identificando loops de estructuras recursivas

bb4bb3

• Identificar aristas de retornobb1

bb4bb3

• Identificar aristas de retorno

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

bb4bb3

• 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

bb4bb3

• 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?

bb4bb3

Resumen

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

Dominators

• ¿Es bb1 dom bb5?

bb4bb3

Dominators

bb4bb3

Dominators

bb4bb3

Dominators

bb4bb3

Dominators

bb4bb3

Dominators

• ¿Es bb1 dom bb5? ¡Sí!

bb4bb3

Pregunta

• ¿Es bb3 dom bb6?bb1

bb4bb3

Pregunta

bb4bb3

Pregunta

bb4bb3

Pregunta

bb4bb3

Pregunta

• ¿Es bb3 dom bb6? ¡No!bb1

bb4bb3

Dominators

bb4bb3

bb1bb2

bb1bb2bb3

bb1bb2bb4

bb1bb2bb5

bb1bb2bb5bb6

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

bb4bb3

{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

bb4bb3

{bb1} bb1

bb1bb2bb3bb4bb5bb6

bb4bb3

{bb1} bb1

bb1bb2bb3bb4bb5bb6

bb4bb3

bb1bb2bb3bb4bb5bb6

bb4bb3

bb1bb2bb3bb4bb5bb6

bb4bb3

bb1bb2bb3bb4bb5bb6

bb1bb2

bb4bb3

{bb1} bb1

bb1bb2bb3bb4bb5bb6

bb1bb2

bb1bb2bb3bb4bb5bb6

bb4bb3

{bb1} bb1

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2bb3bb4bb5bb6

bb1bb2

bb4bb3

{bb1} bb1

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb4bb5bb6

bb4bb3

{bb1} bb1

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb3bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb3bb5bb6

bb1bb2bb3bb4bb5bb6

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb3bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb3bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

• 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

¿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

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

bb4bb3

{bb1} bb1

bb1bb2bb4

bb1bb2bb3

bb1bb2

bb1bb2bb5bb6

bb1bb2bb5

Resumen

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

Depth-First Spanning Tree

bb4bb3

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

Resumen

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.

CFGs Reducibles

bb4bb3

CFGs Reducibles

bb4bb3

CFGs Reducibles

bb4bb3

CFGs Reducibles

bb4bb3

bb5bb6

CFGs Reducibles

bb4bb3

CFGs Reducibles

bb4bb3

CFGs Reducibles

bb4bb3

bb5bb6

CFGs Reducibles

bb4bb3

bb5bb6

CFGs Reducibles

bb4bb3

bb5bb6

CFGs Reducibles

bb4bb3

Grafos Irreducibles

Resumen

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)

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

bb4bb3

Resumen

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

bb4bb3

bb1bb2

bb1bb2bb3

bb1bb2bb4

bb1bb2bb5

bb1bb2bb5bb6

Dominators

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

bb4bb3

bb1bb2

bb1bb2bb5

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

bb4bb3

bb2 bb2

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

bb4bb3

bb6bb5bb2

bb6bb5bb3

bb6bb5bb4

bb6bb5

bb6bb5bb2bb1

Dominators(dom)

bb0bb1bb4

bb0bb1bb4bb5

bb0bb1bb4bb6

bb0bb1bb4bb8

bb0bb1bb4bb8bb9

bb0bb1

bb0bb0

bb3bb0bb1bb2bb3

bb2bb0bb1bb2

bb7bb0bb1bb4bb6bb7

Strictly Dominates(sdom)

bb0bb1

bb0bb1bb4

bb0bb1bb4bb8

bb3bb0bb1bb2

bb2bb0bb1

bb7bb0bb1bb4bb6

Immediately Dominates

(idom) bb1

Post Dominators(pdom)

bb4bb8bb9

bb5bb8bb9

bb6bb7bb8bb9

bb8bb9

bb1bb4bb8bb9

bb0bb1bb4bb8bb9

bb3bb1bb3bb4bb8bb9

bb1bb2bb3bb8bb9

bb7bb7bb8bb9

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

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

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

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

Lecturas

• Ballena– Capitulo 8

• Dragon– Capitulos 10.5, 10.6

análisis de control de flujo

Documents

análisis de flujo de fondos

control flujo sanguineo

análisis de flujo

control del flujo sanguÍneo

análisis de flujo de materiales (mfa)

compiladores análisis de flujo de datos. 2 resumen overview...

anÁlisis de flujo vehicular

control de flujo de programa

13 ava control de flujo vertederos

análisis del flujo de materiales - gub.uy...3.3 como...

control de flujo y caudal_ramiro_perdomo

reporte modelo matematico. control de flujo

control de flujo - flow control | completions de flujo...

labotatorio de control de flujo[1]

4 flujo de control

20947070 control pid flujo en pic

control de calidad diagrama de flujo

planta festo: control de flujo de flujo planta festo... ·...

flujo de control

expresiones y control del flujo java