Optimización automática de programas

Optimización automática de programas (OAP) Germán Vidal 1

Optimización automática de programas

Tema 4: Evaluación parcial offlineTema 4: Evaluación parcial offline4.1. Conceptos básicos4.2. Binding-time analysis (BTA)4.3. Incluyendo anotaciones4.4. Algoritmo de especialización4.5. Unfolding


4.1. 4.1. Conceptos básicos

• Objetivo del temaObjetivo del tema:: definir un evaluador parcial definir un evaluador parcial offlineoffline para un lenguaje para un lenguaje

funcional de primer orden sencillo (un subconjunto de funcional de primer orden sencillo (un subconjunto de Scheme)Scheme)

• La ventaja de considerar programas Scheme (o Lisp) es La ventaja de considerar programas Scheme (o Lisp) es que el parsing es muy sencillo que el parsing es muy sencillo cada elemento del lenguaje va precedido por una “etiqueta”, cada elemento del lenguaje va precedido por una “etiqueta”,

e.g., call, if, quote, etce.g., call, if, quote, etc

• Asumimos que la ejecución del programa siempre Asumimos que la ejecución del programa siempre comienza con una llamada a la comienza con una llamada a la primeraprimera función función la llamada “goal function” (como la llamada “goal function” (como mainmain en C) en C)


SintaxisSintaxis<Program><Program> ::= (<Equation> ... <Equation>) ::= (<Equation> ... <Equation>)<Equation> ::= <Equation> ::=

(define (<FuncName> <VarList>) <Expr>)(define (<FuncName> <VarList>) <Expr>)<VarList> ::= <Var> ... <Var><VarList> ::= <Var> ... <Var><Expr> ::= <Constant><Expr> ::= <Constant>

| <Var>| <Var> | (if <Expr> <Expr> <Expr>)| (if <Expr> <Expr> <Expr>) | (call <FuncName> <ArgList>)| (call <FuncName> <ArgList>) | (<Op> <ArgList>)| (<Op> <ArgList>)

<ArgList><ArgList> ::= <Expr> ... <Expr> ::= <Expr> ... <Expr><Constant> ::= <Numeral> | (quote <Value>)<Constant> ::= <Numeral> | (quote <Value>)<Op><Op> ::= car | cdr | cons | = | + ::= car | cdr | cons | = | + | ...| ...


Puntos del programa y divisionesPuntos del programa y divisiones• Puntos del programaPuntos del programa

cada nombre de función representa un “punto del cada nombre de función representa un “punto del programa” programa”

• DivisiónDivisiónclasificación de cada parámetro de una función clasificación de cada parámetro de una función

como como estáticoestático o o dinámicodinámicopuede ser puede ser monovariantemonovariante (una división por función) (una división por función)

o o polivariantepolivariante (más de una división por función) (más de una división por función)consideraremos divisiones monovariantes consideraremos divisiones monovariantes

(las polivariantes se podrían simular creando copias (las polivariantes se podrían simular creando copias de las funciones)de las funciones)


CongruenciaCongruencia

• Decimos que una división es Decimos que una división es congruentecongruente si siel valor de un parámetro estático viene determinado el valor de un parámetro estático viene determinado

únicamente por parámetros estáticosúnicamente por parámetros estáticossi un parámetro depende al menos de un parámetro si un parámetro depende al menos de un parámetro

dinámico, entonces debe ser también dinámicodinámico, entonces debe ser también dinámico


Especialización de puntos del programaEspecialización de puntos del programa

• Puntos del programa especializadosPuntos del programa especializadosse nombran se nombran (f,vs)(f,vs), donde , donde ff es el nombre original es el nombre original

de la función y de la función y vsvs la lista de parámetros estáticos la lista de parámetros estáticosa menudo se crean también versiones especializadas a menudo se crean también versiones especializadas

para para (if e(if e11 e e22 e e33)) si si ee11 es dinámico es dinámico


Compresión de transicionesCompresión de transiciones

• La “compresión de transiciones” se corresponde La “compresión de transiciones” se corresponde con el desplegado de una función (unfolding)con el desplegado de una función (unfolding)puede ser “on-the-fly” o puede ser “on-the-fly” o como un post-procesocomo un post-proceso

• En cualquier caso, se debe evitar:En cualquier caso, se debe evitar:unfolding infinitounfolding infinitoduplicación de código o computacionesduplicación de código o computacionesproducir más llamadas residuales de las necesariasproducir más llamadas residuales de las necesarias


Estrategias para el unfolding on-the-flyEstrategias para el unfolding on-the-fly

• No unfolding No unfolding pobre especialización, ya que todas las llamadas a pobre especialización, ya que todas las llamadas a

función se consideran dinámicasfunción se consideran dinámicas

• Desplegar sólo las llamadas a función cuyos Desplegar sólo las llamadas a función cuyos argumentos sean todos estáticos argumentos sean todos estáticos buenos resultados, aunque sigue habiendo riesgo de buenos resultados, aunque sigue habiendo riesgo de

no terminación…no terminación…Elegimos esta opciónElegimos esta opción


Binding-time analysisBinding-time analysis

• Proceso:Proceso: toma un programa y la división para la función toma un programa y la división para la función

principal y devuelve una división principal y devuelve una división congruentecongruente para para todas las funciones del programatodas las funciones del programa

• Se define como una instancia del marco de Se define como una instancia del marco de interpretación abstractainterpretación abstractaDominio abstracto: Dominio abstracto: {S,D}{S,D}SS: valor estático: valor estáticoDD: valor dinámico: valor dinámico


AnotacionesAnotaciones• Generamos anotaciones a partir del las divisionesGeneramos anotaciones a partir del las divisiones

la división nos dice si un parámetro es estático o la división nos dice si un parámetro es estático o dinámicodinámico

las anotaciones nos dicen cómo debe evaluarse cada las anotaciones nos dicen cómo debe evaluarse cada expresión del programaexpresión del programa

• En realidad ambas cosas representan la misma En realidad ambas cosas representan la misma informacióninformaciónes decir, las anotaciones no son realmente necesarias, es decir, las anotaciones no son realmente necesarias,

pero simplifican el proceso de evaluación parcialpero simplifican el proceso de evaluación parcial

• División congruente División congruente anotación consistente anotación consistente


Anotaciones: sintaxisAnotaciones: sintaxis

• Para expresar las anotaciones se suele emplear un Para expresar las anotaciones se suele emplear un lenguaje a dos niveleslenguaje a dos nivelesse crean dos versiones de cada construcción del se crean dos versiones de cada construcción del

lenguaje (condicional, llamada a función, etc)lenguaje (condicional, llamada a función, etc) la versión estática se emplea para indicar que debe la versión estática se emplea para indicar que debe

evaluarse en tiempo de evaluación parcialevaluarse en tiempo de evaluación parcial la versión dinámica se emplea para indicar que la la versión dinámica se emplea para indicar que la

expresión debe debe “residualizarse” (continuando expresión debe debe “residualizarse” (continuando con la evaluación parcial de los argumentos)con la evaluación parcial de los argumentos)


4.2. Binding-Time Analysis (BTA)4.2. Binding-Time Analysis (BTA)• Sólo monovariante Sólo monovariante

i.e., i.e., unauna división para cada funcióndivisión para cada función

• Basado en interpretación abstractaBasado en interpretación abstractadominio abstracto: dominio abstracto: {S,D}{S,D}

• Datos de entrada:Datos de entrada:(define (f(define (f11 x x1111 ... x ... x1a1a11

) e) e11))

......

(define (f(define (fnn x xn1n1 ... x ... xnanann) e) enn))

yyττ11 (binding-times para f (binding-times para f11))


Dominios y órdenesDominios y órdenes• Dominios:Dominios:

t t BindingTime BindingTime = {S,D}= {S,D}

BTEnvBTEnv = [BindingTime]= [BindingTime]

div div Monodivision Monodivision = FuncName = FuncName BTEnv BTEnv

• Órdenes:Órdenes:sobre BindingTime:sobre BindingTime:t t ≤ t’ ≤ t’ t = S o t = t’ (≤: menos dinámico) t = S o t = t’ (≤: menos dinámico)sobre BTEnv:sobre BTEnv:(s(s11,...,s,...,snn) ) ≤ (t≤ (t11,...t,...tnn) ) s sii ≤ t ≤ tii i=1,...,n i=1,...,n

sobre divisiones:sobre divisiones:divdiv11 ≤ div≤ div22 div div11(f) ≤ div(f) ≤ div22(f) para toda f(f) para toda f


Objetivo del análisisObjetivo del análisis

• Encontrar la división Encontrar la división congruente congruente menos dinámica (con el orden menos dinámica (con el orden ≤≤))

• Pensad que, por ejemplo, la divisiónPensad que, por ejemplo, la divisióndivdivii = [D,D,…,D] = [D,D,…,D]

siempre es congruente (pero no sirve para nada)siempre es congruente (pero no sirve para nada)• Usaremos el lub Usaremos el lub ::

S S S = S S = SS S D = D D = D S = D S = D D = D D = D(y su extensión a BTEnv y divisiones)(y su extensión a BTEnv y divisiones)


FuncionesFunciones

• Funciones del análisis:Funciones del análisis:BBvv[[e]]: BTEnv [[e]]: BTEnv FuncName FuncName BTEnv BTEnv

dada una expresión, un BTEnv y un nombre de dada una expresión, un BTEnv y un nombre de función, nos dice cuál debería ser el BTEnv de función, nos dice cuál debería ser el BTEnv de dicha función de acuerdo a las llamadas que dicha función de acuerdo a las llamadas que aparecen en la expresiónaparecen en la expresión

BBee[[e]]: BTEnv [[e]]: BTEnv BindingTime BindingTime

dada una expresión y un BTEnv, nos dice si la dada una expresión y un BTEnv, nos dice si la expresión es estática o dinámicaexpresión es estática o dinámica


Función Función BBvv[[e]][[e]]BBvv[[c]] [[c]] g = (S,...,S) g = (S,...,S)

BBvv[[x[[xjj]] ]] g = (S,...,S) g = (S,...,S)

BBvv[[if e[[if e11 e e22 e e33]] ]] g = B g = Bvv[[e[[e11]] ]] g g

BBvv[[e[[e22]] ]] g g B Bvv[[e[[e33]] ]] g g

BBvv[[call f e[[call f e11 ... e ... enn]] ]] g = g =

t t (Be[[e (Be[[e11]]]],...,Be[[e,...,Be[[enn]]]]]]) if f=g) if f=g

tt if f if f≠g≠gwhere t = Bwhere t = Bvv[[e[[e11]] ]] g g ...... BBvv[[e[[enn]] ]] g g

BBvv[[op e[[op e11 ... e ... enn]] ]] g = g =

BBvv[[e[[e11]] ]] g g ... ... BBvv[[e[[enn]] ]] g g


Función Función BBee[[e]][[e]]

BBee[[c]] [[c]] = S = S

BBee[[x[[xjj]] ]] = t = tjj where where = (t = (t11,..., t,..., tnn))

BBee[[if e[[if e11 e e22 e e33]] ]]

= B= Bee[[e[[e11]] ]] B Bee[[e[[e22]] ]] B Bee[[e[[e33]] ]]

BBee[[call f e[[call f e11 ... e ... enn]] ]]

= B= Bee[[e[[e11]] ]] ...... BBee[[e[[enn]] ]]

BBee[[op e[[op e11 ... e ... enn]] ]]

= B= Bee[[e[[e11]] ]] ... ... BBee[[e[[enn]] ]]


El requerimiento de congruenciaEl requerimiento de congruencia

• Se debe cumplir:Se debe cumplir:si hay alguna llamada a una función si hay alguna llamada a una función gg cuyo cuyo

argumento argumento nn es dinámico, entonces el parámetro es dinámico, entonces el parámetro nn de de gg debe ser dinámico: debe ser dinámico:

(div g) = (div g) = UUi=1,…,ni=1,…,n B Bvv[[e[[eii]](div f]](div fii) g) g

donde donde ff11,…,f,…,fnn son las funciones del programa yson las funciones del programa y ee11,…,e,…,enn son las partes derechasson las partes derechas

• Generalizando:Generalizando:(div f(div fkk) = ) = UUi=1,…,ni=1,…,n B Bvv[[e[[eii]](div f]](div fii) f) fkk

para para k = 1,…,nk = 1,…,n


Algoritmo BTAAlgoritmo BTA

• Sirve para obtener la “mejor” división congruente Sirve para obtener la “mejor” división congruente (es decir, la menos dinámica)(es decir, la menos dinámica)

• Proceso iterativo: Proceso iterativo: divdiv00 ≤≤ div div11 ≤≤ div div22 ≤≤ … …

(1) Inicio:(1) Inicio:divdiv00 == [f[f11 ,, ff22 (S,…,S),…,f(S,…,S),…,fnn (S,…,S)](S,…,S)]

(2) Computamos (2) Computamos divdivjj::

UUi=1,…,ni=1,…,n B Bvv[[e[[eii]](div]](divj-1j-1 f fii) f) fkk, k = 1,…,n, k = 1,…,n

(3) Si (3) Si divdivjj = div = divj-1j-1 STOP STOP

si no si no vuelta al paso (2) vuelta al paso (2)


Algoritmo BTAAlgoritmo BTA

• La terminación está garantizada…La terminación está garantizada…¿por que?¿por que?

• OJO: hay un error en el libro:OJO: hay un error en el libro: la función la función ff11 es una excepción: es una excepción:

(div(divjj f f11) = ) =

UU UUi=1,…,ni=1,…,n B Bvv[[e[[eii]](div]](divj-1j-1 f fii) f) f11


Ejercicio 5.1 (a)Ejercicio 5.1 (a)

• Calculad el resultado del BTA para el programaCalculad el resultado del BTA para el programa(define (power x n)(define (power x n)

(if (= n 0)(if (= n 0)

11

(* x (call power x (- n (* x (call power x (- n 1)))1)))

))

))

con con xx dinámica y dinámica y nn estática estática


De divisiones a anotaciones (1)De divisiones a anotaciones (1)

• Realizamos los siguientes pasos:Realizamos los siguientes pasos:cada funcióncada función

(define (f x(define (f x11 ... x ... xaa) e)) e)

se tranforma en se tranforma en (define (f (x(define (f (xs1s1 ... x ... xsmsm) (x) (xd1d1 ... x ... xdkdk)) ))

eeannann) ) donde donde

(x(xs1s1 ... x ... xsmsm) ) son los parámetros estáticos, son los parámetros estáticos, (x(xd1d1 ... x ... xdkdk) ) son los parámetros dinámicos y son los parámetros dinámicos y eeannann es el cuerpo de la función anotado es el cuerpo de la función anotado



• La expresión anotada La expresión anotada eeannann se obtiene así: se obtiene así: llamadas a función llamadas a función (call g e(call g e11 ... e ... eaa))::

(calls g (e(calls g (e11 … e … eaa) ()) ) ()) si todos los args son estáticossi todos los args son estáticos

(calld g (e(calld g (es1s1 … e … esmsm) (e) (ed1d1 … e … edkdk)) )) en otro casoen otro caso

condicionales condicionales (if e(if e11 e e2 2 ee33))::(ifs e(ifs e11 e e2 2 ee33) ) si si ee11 es estático es estático

(ifd e(ifd e11 e e2 2 ee33) ) si si ee11 es dinámico es dinámico

operaciones operaciones (op e(op e11 … … eenn))::(ops e(ops e11 … … eenn) ) si si ee11 … … eenn son todos estáticos son todos estáticos

(opd e(opd e11 … … eenn) ) en otro casoen otro caso



• ¿Cuando hay que usar el nuevo operador ¿Cuando hay que usar el nuevo operador liftlift??cuando cuando ee es una expresión estática que aparece en un es una expresión estática que aparece en un

“contexto dinámico”, e.g.:“contexto dinámico”, e.g.:los argumentos de un los argumentos de un calldcalld / / opdopd / / ifdifdlas alternativas de un las alternativas de un ifsifs que está dentro de un contexto que está dentro de un contexto

dinámicodinámicoel cuerpo de la función principalel cuerpo de la función principalel cuerpo de una función con al menos un parámetro el cuerpo de una función con al menos un parámetro

dinámicodinámico……

en estos casos, reemplazamos en estos casos, reemplazamos ee con con (lift e)(lift e)


Ejercicio 5.1 (b)Ejercicio 5.1 (b)

• Anotad el programa Anotad el programa (define (power x n)(define (power x n)

(if (= n 0)(if (= n 0)

11

(* x (call power x (- n (* x (call power x (- n 1)))1)))

))

))

empleando la información obtenida en el BTA del empleando la información obtenida en el BTA del Ejercicio 5.1 (a)Ejercicio 5.1 (a)


4.4. Algoritmo de especialización4.4. Algoritmo de especialización

• Datos de entrada:Datos de entrada:programa anotadoprograma anotadovalores de los parámetros estáticos de valores de los parámetros estáticos de ff11

• El algoritmo se basa en tres funciones:El algoritmo se basa en tres funciones:specializespecialize: inicialización: inicializacióncompletecomplete: nivel “global” (proceso iterativo): nivel “global” (proceso iterativo)reducereduce: nivel “local” (reducción simbólica): nivel “local” (reducción simbólica)


función función specializespecialize

specialize pgm vs =specialize pgm vs =

let let

(define (f(define (f11 _ _) : _) = pgm _ _) : _) = pgm

in in

complete [(fcomplete [(f11 vs)] [] pgm vs)] [] pgm


función función completecompletecomplete pending marked pgm =complete pending marked pgm =if pending==[] then []if pending==[] then []else else

let (f vs) ‘in’ pendinglet (f vs) ‘in’ pending (define (f xs xd) e) = lookup f pgm(define (f xs xd) e) = lookup f pgm

eevsvs = reduce e (xs++xd,vs++xd) pgm = reduce e (xs++xd,vs++xd) pgm nmarked = (f vs) : markednmarked = (f vs) : marked npending = pending npending = pending

UU (successors e (successors evsvs) – nmarked) – nmarked

newdef = define ((f,vs) xd) enewdef = define ((f,vs) xd) evsvs)) in newdefin newdef :: complete npending nmarked pgmcomplete npending nmarked pgm


función función reduce (1)reduce (1)reduce e env pgm =reduce e env pgm = case e ofcase e ofNumber n => nNumber n => nQuote c => cQuote c => c

Var x => lookup x envVar x => lookup x env

ifs eifs e11 e e22 e e33 => if (reduce e => if (reduce e11 env pgm) env pgm)

then (reduce ethen (reduce e22 env pgm) env pgm)

else (reduce eelse (reduce e33 env pgm) env pgm) ifd eifd e11 e e22 e e33 => ’if (reduce e => ’if (reduce e11 env pgm) env pgm)

then (reduce ethen (reduce e22 env pgm) env pgm)

else (reduce eelse (reduce e33 env pgm) env pgm)


función función reduce (2)reduce (2)

reduce e env pgm =reduce e env pgm =

case e ofcase e of

......

calls f es ed => calls f es ed =>

letlet (define(define (f(f xsxs xd)xd) eeff) = lookup f pgm) = lookup f pgm

res = reducelist (es++ed) env pgmres = reducelist (es++ed) env pgm

in reduce ein reduce eff (xs++xd,res) pgm (xs++xd,res) pgm

calls f es ed => letcalls f es ed => let (es’++ed’)(es’++ed’) ==

reducelistreducelist (es++ed)(es++ed) envenv pgmpgm

in ’call (f,es’) ed’in ’call (f,es’) ed’


función función reduce (3)reduce (3)

reduce e env pgm =reduce e env pgm =

case e ofcase e of

......

ops es => ops es =>

letlet res = reducelist es env pgmres = reducelist es env pgm

in op resin op res

opd es => opd es =>

letlet res = reducelist es env pgmres = reducelist es env pgm

in ’op resin ’op res

lift e’ => ’quote (reduce e’ env pgm)lift e’ => ’quote (reduce e’ env pgm)


Ejercicio 5.1 (c)Ejercicio 5.1 (c)

• Obtener la versión especializada del programa del Obtener la versión especializada del programa del Ejercicio 5.1 (a) usando el programa anotado del Ejercicio 5.1 (a) usando el programa anotado del Ejercicio 5.1 (b) y el valor Ejercicio 5.1 (b) y el valor n=3n=3


4.5. Unfolding4.5. Unfolding

• Tipos de unfolding:Tipos de unfolding:on-the-flyon-the-fly: realizamos el desplegado de : realizamos el desplegado de

(algunas) llamadas en la función (algunas) llamadas en la función reducereducepost-procesopost-proceso: : reducereduce nunca realiza el nunca realiza el

desplegado de una llamada a función (es decir, desplegado de una llamada a función (es decir, no existe el caso no existe el caso callscalls), ),


Unfolding on-the-flyUnfolding on-the-fly

• Permite obtener programas más Permite obtener programas más especializados (y menos funciones especializados (y menos funciones residuales)residuales)

• Pero se corre un mayor riesgo de que el Pero se corre un mayor riesgo de que el proceso no termine…proceso no termine…

• Ejemplo:Ejemplo:(power,3) x = x * x * x * 1(power,3) x = x * x * x * 1


Unfolding como post-procesoUnfolding como post-proceso• Suele haber mucho menos riesgo de no Suele haber mucho menos riesgo de no

terminaciónterminación• Pero los programas están menos especializados y Pero los programas están menos especializados y

tienen más reglas residuales…tienen más reglas residuales…• Ejemplo:Ejemplo:

(power,3) x = x * (power,2) x(power,3) x = x * (power,2) x(power,2) x = x * (power,1) x(power,2) x = x * (power,1) x(power,1) x = x * (power,0) x(power,1) x = x * (power,0) x(power,0) x = 1(power,0) x = 1

• A partir de aquí el post-proceso tratará de A partir de aquí el post-proceso tratará de obtener:obtener:(power,3) x = x * x * x * 1(power,3) x = x * x * x * 1


Estrategias unfolding on-the-flyEstrategias unfolding on-the-fly• No unfoldingNo unfolding

seguro, pero muy poco precisoseguro, pero muy poco preciso

• Desplegar sólo las llamadas que tengan únicamente Desplegar sólo las llamadas que tengan únicamente argumentos estáticosargumentos estáticos suele terminar, pero no siempre; buenos resultados en la mayor suele terminar, pero no siempre; buenos resultados en la mayor

parte de los casosparte de los casos

• Uso de un wfo/wqo sobre argumentos estáticosUso de un wfo/wqo sobre argumentos estáticos termina en el 99% de los casos; mejores resultados!termina en el 99% de los casos; mejores resultados!

• Desplegar las llamadas que no estén dentro de un if Desplegar las llamadas que no estén dentro de un if dinámicodinámico muy buenos resultados en ejemplos “realistas”, no hay muy buenos resultados en ejemplos “realistas”, no hay

garantías de terminacióngarantías de terminación


Ejercicio 5.2 (a)Ejercicio 5.2 (a)• Obtened la especialización del programaObtened la especialización del programa

(define (ack m n)(define (ack m n)

(if (= m 0)(if (= m 0)

(+ n 1)(+ n 1)

(if (= n 0)(if (= n 0)

(ack (- m 1) 1)(ack (- m 1) 1)

(ack (- m 1) (ack m (- n (ack (- m 1) (ack m (- n 1)))1)))

))))))

con con mm estática ( estática (m=2m=2) y ) y nn dinámica dinámica

(usamos la estrategia de unfolding de (usamos la estrategia de unfolding de reducereduce))


Ejercicio 5.2 (b)Ejercicio 5.2 (b)• ¿Qué problema tiene la estrategia de unfolding ¿Qué problema tiene la estrategia de unfolding

on-the-fly empleada?on-the-fly empleada?Determina una estrategia de unfolding que de un Determina una estrategia de unfolding que de un

resultado mejor…resultado mejor…Especializa de nuevo el programa usando dicha Especializa de nuevo el programa usando dicha

estrategiaestrategia

• Supongamos que ahora especializamos el Supongamos que ahora especializamos el programa con m dinámica y n estáticaprograma con m dinámica y n estáticaExplica por qué un BTA da resultados tan Explica por qué un BTA da resultados tan

innecesariamente malosinnecesariamente malosEsboza una posible solución…Esboza una posible solución…

Optimización automática de programas

Documents

Transcript of Optimización automática de programas