Optimización automática de programas

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

Optimización automática de programas

Tema 3: Funciones, tipos y expresionesTema 3: Funciones, tipos y expresiones

3.1. Intérpretes, compiladores y tiempos de ejecución

3.2. El λ-cálculo sin tipos

3.3. Tres mini-lenguajes de programación


3.1. 3.1. Intérpretes, compiladores y tiempos de ejecución

• Semántica operacionalSemántica operacional describe las normas que rigen la ejecución de un programadescribe las normas que rigen la ejecución de un programa similar a la idea de intérpretesimilar a la idea de intérprete

• Lenguajes de programaciónLenguajes de programación expresamos el “significado” de un programa (escrito en el expresamos el “significado” de un programa (escrito en el

lenguaje L) como una función que, a partir de una entrada, lenguaje L) como una función que, a partir de una entrada, devuelve una salida:devuelve una salida:

[[p]][[p]]LL : input : input output output


Intérpretes y compiladores• IntérpretesIntérpretes

definición ecuacional:definición ecuacional:[[p]][[p]]SS [input] = [[int]] [input] = [[int]]LL [p,input] [p,input]

notación:notación:

• CompiladoresCompiladoresdefinición ecuacional:definición ecuacional:[[p]][[p]]SS [input] = [[[[comp]] [input] = [[[[comp]]LL [p]]] [p]]]TT [input] [input]

notación:notación:

SS

LL

S S T T

LL


Tiempos de ejecuciónTiempos de ejecución• Estimación: suele usarse el número de Estimación: suele usarse el número de

operaciones “elementales”:operaciones “elementales”:acceso al valor de una variableacceso al valor de una variablellamada a funciónllamada a funciónpattern-matchingspattern-matchingsoperaciones aritméticas, etc, etcoperaciones aritméticas, etc, etc

por ejemplo, el coste de evaluar la expresiónpor ejemplo, el coste de evaluar la expresiónx + (2 * y)x + (2 * y)

sería de 5 operaciones elementalessería de 5 operaciones elementales(acceso a “(acceso a “xx”, acceso a “”, acceso a “yy”, recuperar valor de una ”, recuperar valor de una

constante, operación “constante, operación “++” y operación “” y operación “**”)”)notaciónnotación: : ttpp(d(d11,…,d,…,dnn))


Tiempos de ejecución de un intérpreteTiempos de ejecución de un intérprete

• El valor de una expresión, e.g., El valor de una expresión, e.g., x + 2 * yx + 2 * y, , depende del valor de sus variablesdepende del valor de sus variablesconsideramos un “consideramos un “entornoentorno” que almacena el valor ” que almacena el valor

actual de cada variable del programa:actual de cada variable del programa:env: Variable env: Variable Value Value

así, la función que evalúa una expresión sería:así, la función que evalúa una expresión sería:eval: Expression x Environment eval: Expression x Environment Value Value


Tiempos de ejecución de un intérpreteTiempos de ejecución de un intérprete

• En general, existen 2 alternativas para evaluar En general, existen 2 alternativas para evaluar las expresiones de un lenguaje:las expresiones de un lenguaje:por sustituciónpor sustitución: se reemplazan todas las variables : se reemplazan todas las variables

por sus valorespor sus valoresmediante entornomediante entorno: se mantienen los valores en el : se mantienen los valores en el

entorno y sólo se reemplazan las variables por sus entorno y sólo se reemplazan las variables por sus valores cuando es necesariovalores cuando es necesario


EjemploEjemplodata exp = Num int | Var stringdata exp = Num int | Var string

| Add exp exp | Mul exp exp| Add exp exp | Mul exp expeval (Num n) env = neval (Num n) env = neval (Var v) env = env veval (Var v) env = env veval (Add e1 e2) env = (eval e1 env) + (eval e2 env)eval (Add e1 e2) env = (eval e1 env) + (eval e2 env)eval (Mul e1 e2) env = (eval e1 env) * (eval e2 env)eval (Mul e1 e2) env = (eval e1 env) * (eval e2 env)

E.g., evaluamos E.g., evaluamos x+(2*y)x+(2*y) con con env = [xenv = [x5, y5, y7]:7]:eval (Add (Var “x”) (Mul (Num 2) (Var “y”))) enveval (Add (Var “x”) (Mul (Num 2) (Var “y”))) env

(eval (Var “x”) env)(eval (Var “x”) env) + (eval (Mul …) env) + (eval (Mul …) env) (env “x”)(env “x”) + (eval (Mul (Num 2) (Var “y”)) env) + (eval (Mul (Num 2) (Var “y”)) env) 5 + 5 + (eval (Mul (Num 2) (Var “y”)) env)(eval (Mul (Num 2) (Var “y”)) env) 5 + (5 + ((eval (Num 2) env)(eval (Num 2) env) * (eval (Var “y”) env)) * (eval (Var “y”) env)) 5 + (2 * 5 + (2 * (eval (Var “y”) env)(eval (Var “y”) env))) 5 + (2 * 5 + (2 * (env “y”)(env “y”)) ) 5 + (2 * 7)5 + (2 * 7) 5 + 145 + 14 19 19


Sobrecarga de interpretaciónSobrecarga de interpretación

• Si Si exp = x + (2 * y)exp = x + (2 * y), entonces, entoncesttexpexp() = 5() = 5

ttintint(exp) = 9(exp) = 9 (contad el número de (contad el número de ))

• En general, En general, ttintint(p,d(p,d11,…,d,…,dnn) = ) = αα * t * tpp(d(d11,…,d,…,dnn))

siendo siendo αα la llamada “sobrecarga de interpretación” la llamada “sobrecarga de interpretación”su valor, para intérpretes reales, oscila entre su valor, para intérpretes reales, oscila entre

3 y 200, dependiendo del lenguaje…3 y 200, dependiendo del lenguaje…


3.2. 3.2. λλ-cálculo-cálculo sin tipos sin tipos

• Alonzo Church se preguntaba…Alonzo Church se preguntaba… ...qué funciones matemáticas se pueden computar ...qué funciones matemáticas se pueden computar

de forma mecánica (i.e., mediante un algoritmo)?de forma mecánica (i.e., mediante un algoritmo)?Su respuesta fue: aquéllas que se pueden Su respuesta fue: aquéllas que se pueden

especificar en el especificar en el λλ-cálculo (creado por él, 1930)-cálculo (creado por él, 1930)

• El El λλ-cálculo constituye la base teórica de casi -cálculo constituye la base teórica de casi todos los lenguajes funcionalestodos los lenguajes funcionalesLisp, Scheme, ML, Haskell, etcLisp, Scheme, ML, Haskell, etc


Notación Notación λλ para las funciones para las funciones

• Notación básica:Notación básica:λλx.expx.exp (ó (ó λλx x exp ó \x -> exp) exp ó \x -> exp)Se trata de una función “anónima” (sin nombre) con un Se trata de una función “anónima” (sin nombre) con un

solo parámetro, solo parámetro, xx, cuyo cuerpo es , cuyo cuerpo es expexpPor ejemplo, Por ejemplo, ((λλx.x+1) 1 = 2x.x+1) 1 = 2

• Si hay varios parámetros, podemos usar:Si hay varios parámetros, podemos usar:λλ(x(x11,x,x22,…,x,…,xnn).exp ).exp λλxx11..λλxx22.…..….λλxxnn.exp.exp

• También se pueden indicar los tipos:También se pueden indicar los tipos:λλ(x(x11:A:A11,x,x22:A:A22,…,x,…,xnn:A:Ann).exp).exp


EjemplosEjemplos

square = \x -> x*xsquare = \x -> x*x

suma = \x,y -> x+ysuma = \x,y -> x+y

k = \m,n -> (m+n, m-n)k = \m,n -> (m+n, m-n)

twice = \f -> (\x -> f(f(x)))twice = \f -> (\x -> f(f(x)))

add = \x -> (\y -> x+y)add = \x -> (\y -> x+y)

......


Sintaxis del Sintaxis del λλ-cálculo (extendido)-cálculo (extendido)

<Lam> ::=<Lam> ::= <Constant><Constant>

|| <Var><Var>

|| <Lam> <Lam><Lam> <Lam>

|| \<Var> -> <Lam>\<Var> -> <Lam>

|| if <Lam> then <Lam>if <Lam> then <Lam>

else <Lam>else <Lam>

|| <Op> <Lam> ... <Lam><Op> <Lam> ... <Lam>

donde donde <Op><Op> es un operador básico (e.g. es un operador básico (e.g. ++, , --, , **, ...), ...)


Evaluación de Evaluación de λλ-expresiones-expresiones

• Idea básica:Idea básica:reescribimos (toda o parte de) la expresión reescribimos (toda o parte de) la expresión

inicial mediante una serie de inicial mediante una serie de reduccionesreducciones hasta que se alcanza un valorhasta que se alcanza un valor

usamos la notación: M usamos la notación: M P, para indicar que P, para indicar que M se reduce a PM se reduce a P


Algunos conceptos previos…Algunos conceptos previos…

• Ocurrencia ligada de una variable:Ocurrencia ligada de una variable:una ocurrencia de la variable una ocurrencia de la variable xx está ligada en está ligada en

una expresión si aparece dentro del ámbito de una expresión si aparece dentro del ámbito de una lambdauna lambda

e.g., e.g., xx está ligada en está ligada en \x -> x+1\x -> x+1

• Ocurrencia libre de una variable:Ocurrencia libre de una variable:si no está ligada, si no está ligada, e.g., e.g., xx es libre en es libre en \y -> x+y\y -> x+y


Algunos conceptos previos…Algunos conceptos previos…• Variable libre:Variable libre:

una variable una variable xx es libre en una expresión si existe es libre en una expresión si existe al al menos unamenos una ocurrencia libre de ocurrencia libre de xx

e.g., e.g., xx es libre en es libre en \y -> x (\x -> x)\y -> x (\x -> x) pero no en pero no en \y -> (\x -> x)\y -> (\x -> x)

• Sustitución:Sustitución:son funciones finitas que denotan la asignación de son funciones finitas que denotan la asignación de

expresiones a variables libresexpresiones a variables libresasí, así, [N/x]M[N/x]M denota la expresión denota la expresión MM en la que las en la que las

ocurrencias de la variable ocurrencias de la variable xx se han sustituido por se han sustituido por NN también se suele usar también se suele usar M[x/N]M[x/N] o, más a menudo, o, más a menudo, M[x M[x N] N] (nosotros usaremos la última opción!) (nosotros usaremos la última opción!)


Ejercicio 3.1Ejercicio 3.1

• Identifica las ocurrencias de variables libres Identifica las ocurrencias de variables libres y ligadas en las siguientes expresionesy ligadas en las siguientes expresionespara las ligadas, indica la lambda que le afectapara las ligadas, indica la lambda que le afecta

1.- (x (\x -> (\x -> x x)) x) 1.- (x (\x -> (\x -> x x)) x)

2.- (x (\x -> (\x -> x) x) x)2.- (x (\x -> (\x -> x) x) x)

3.- \h3.- \h ->-> (\x(\x ->-> h (x x)) (\xh (x x)) (\x ->-> h (x x))h (x x))


Reglas de reducciónReglas de reducción

• αα-conversión-conversión::\x -> M \x -> M \y -> M[x \y -> M[x y] y]

donde donde yy no debe ser libre en no debe ser libre en MM

• Se emplea para renombrar las variables y Se emplea para renombrar las variables y evitar el “evitar el “problema de la captura de problema de la captura de nombres de variablesnombres de variables” (luego lo vemos…)” (luego lo vemos…)



• ββ-reducción-reducción::(\x -> M) N (\x -> M) N M[x M[x N] N]

• Representa la aplicación de una función a un Representa la aplicación de una función a un argumentoargumento

• Restricción:Restricción:ninguna variable libre de ninguna variable libre de NN puede convertirse en puede convertirse en

ligada tras el paso de ligada tras el paso de ββ-reducción (problema de la -reducción (problema de la captura de nombres de variables)captura de nombres de variables)

se puede evitar con un paso de se puede evitar con un paso de αα-conversión-conversión(luego vemos un ejemplo..)(luego vemos un ejemplo..)



• δδ-reducción-reducción::op aop a11 a a22 ... a ... ann b b

si si bb es el resultado de aplicar el operador es el resultado de aplicar el operador opop sobre las constantes sobre las constantes aa11, , aa22, …, , …, aann

• E.g., E.g., (+ 5 6) (+ 5 6) 11 11

• Restricción:Restricción:los argumentos debe ser constanteslos argumentos debe ser constantes



• Reducción de condicionalReducción de condicional::if true then M else N if true then M else N M M

if false then M else N if false then M else N N N



• Reducción en contextosReducción en contextos::...M... ...M... ...N... ...N... si M si M N N

• Significa que es correcto reducir una parte Significa que es correcto reducir una parte de una expresión, dejando el resto tal cualde una expresión, dejando el resto tal cual



• Reducción repetidaReducción repetida::MM11 M M33 si M si M11 M M22 y M y M22 MM33

• Básicamente, coincide con la propiedad Básicamente, coincide con la propiedad transitiva…transitiva…

• También lo denotaremos así:También lo denotaremos así:MM11 M M22 M M33 ... ...


EjemploEjemplo

(\x -> ((\x -> ((\x -> x+x)5)(\x -> x+x)5)+x+(\x -> x*x)3)4+x+(\x -> x*x)3)4

(\x -> (((\x -> ((5+55+5)+x+(\x -> x*x)3)4)+x+(\x -> x*x)3)4

(\x -> (10+x+(\x -> x*x)3)4(\x -> (10+x+(\x -> x*x)3)4

10+4+10+4+(\x -> x*x)3(\x -> x*x)3

10+410+4+(3*3)+(3*3)

14+(14+(3*33*3))

14+914+9

2323



• Usad las reglas de Usad las reglas de αα- y - y ββ-reducción para -reducción para reducir las siguientes expresionesreducir las siguientes expresiones

1. x ((\y -> x) z)1. x ((\y -> x) z)

2. (\x -> x y) (\z -> z)2. (\x -> x y) (\z -> z)

3. (\y -> (\z -> z y)) (\k -> z)3. (\y -> (\z -> z y)) (\k -> z)

4. (\x -> (\y -> x y) x) (\x -> z)4. (\x -> (\y -> x y) x) (\x -> z)

5. (\f5. (\f -> (\g -> (\x -> f x (g x))))-> (\g -> (\x -> f x (g x))))

(\x(\x ->-> (\y(\y ->-> x))x)) (\x(\x ->-> (\y(\y ->-> x)) ax)) a


Concepto de redexConcepto de redex• Un Un redexredex ( (redreducible ucible exexpression) es:pression) es:

cualquier expresión que se puede reducir mediante una cualquier expresión que se puede reducir mediante una ββ-reducción, una -reducción, una δδ-reducción o una reducción de condicional-reducción o una reducción de condicional

• Un redex Un redex top-leveltop-level es: es: un redex que no se encuentra dentro del ámbito de una lambdaun redex que no se encuentra dentro del ámbito de una lambda

• Una expresión está en Una expresión está en weak head normal formweak head normal form (whnf) si (whnf) si es una constante, e.g., es una constante, e.g., 1717 una función, e.g., una función, e.g., \x -> M\x -> M una variable libre, e.g., una variable libre, e.g., xx o la aplicación de una variable libre a una expresión, e.g., o la aplicación de una variable libre a una expresión, e.g., x x MM


Concepto de redexConcepto de redex

• Si una expresión está en whnfSi una expresión está en whnfno tiene top-level redexesno tiene top-level redexes

• Existen expresiones que nunca alcanzan la whnfExisten expresiones que nunca alcanzan la whnfe.g., e.g., (\y -> y y) (\y -> y y) (\y -> y y) (\y -> y y)

• Ejemplo de captura de nombres:Ejemplo de captura de nombres:(\x -> 2 + (\y -> x + y) 5) (y + 1)(\x -> 2 + (\y -> x + y) 5) (y + 1)

2 + (\y -> (y + 1) + y) 5)2 + (\y -> (y + 1) + y) 5) 2 + (5 + 1) + 5 2 + (5 + 1) + 5 ... ... 13 13

Error!Error!


Evaluación CBV y CBNEvaluación CBV y CBN

• Aunque nos limitemos a la reducción de Aunque nos limitemos a la reducción de top-level redexes, existen 2 posibilidades:top-level redexes, existen 2 posibilidades:

reducir primero “el argumento” de una reducir primero “el argumento” de una función antes de su evaluaciónfunción antes de su evaluación(CBV, (CBV, call by valuecall by value))

reducir primero la aplicación de una funciónreducir primero la aplicación de una función(CBN, (CBN, call by namecall by name))


Evaluación CBV y CBNEvaluación CBV y CBN

• CBV:CBV:para aplicar una para aplicar una ββ-reducción a -reducción a (\x -> N) M(\x -> N) M, ,

antes hay que reducir la expresión antes hay que reducir la expresión MM a whnf a whnf

• CBN:CBN:podemos reducir podemos reducir (\x -> N) M(\x -> N) M sin necesidad sin necesidad

de reducir previamente de reducir previamente MM a una whnf a una whnf


CBV vs CBNCBV vs CBN

• En principio, CBN es preferible porque se cumple la En principio, CBN es preferible porque se cumple la “propiedad de completitud”:“propiedad de completitud”: si existe alguna posibilidad de reducir si existe alguna posibilidad de reducir MM a una whnf a una whnf PP, ,

entonces la estrategia CBN reduce entonces la estrategia CBN reduce MM a a PP probad: probad: (\x -> 1) ((\y -> y y) (\y -> y y))(\x -> 1) ((\y -> y y) (\y -> y y))

• Sin embargo, CBV puede ser más eficiente que CBN!Sin embargo, CBV puede ser más eficiente que CBN! probad a reducir, e.g., probad a reducir, e.g., (\x -> x + x + x) (2+2)(\x -> x + x + x) (2+2)

• La mejor solución: usar CBN con “sharing”…La mejor solución: usar CBN con “sharing”…(base de Haskell, LML, etc)(base de Haskell, LML, etc)



• Encontrad 2 expresiones Encontrad 2 expresiones MM y y NN tales que tales que1.1. MM se evalúe más rápido con CBV que con CBN se evalúe más rápido con CBV que con CBN

2.2. NN se evalúe más rápido con CBN que con CNV se evalúe más rápido con CBN que con CNV



• Una expresión está en Una expresión está en forma normalforma normal si no es posible si no es posible realizar un paso de realizar un paso de ββ-reducción, -reducción, δδ-reducción o -reducción o reducción de condicional sobre cualquier sub-reducción de condicional sobre cualquier sub-expresión (no necesariamente un top-level redex)expresión (no necesariamente un top-level redex)

• Encontrad una expresión P sin variables libres cuya Encontrad una expresión P sin variables libres cuya reducción a forma normal requiera algún reducción a forma normal requiera algún renombramiento mediante renombramiento mediante αα-conversion-conversion


3.3 Tres mini-lenguajes de programación3.3 Tres mini-lenguajes de programación

1.1. Un intérprete para el Un intérprete para el λλ-cálculo CBV sin -cálculo CBV sin tipostipos

2.2. Un intérprete para ecuaciones recursivas Un intérprete para ecuaciones recursivas de primer orden (CBV)de primer orden (CBV)

3.3. Un intérprete para un lenguaje imperativo Un intérprete para un lenguaje imperativo simplesimple


Un intérprete para el Un intérprete para el λλ-cálculo CBV sin tipos-cálculo CBV sin tipos

data lambda = Int int // constante| Var string // variable| Abs string lambda // lambda| Apply lambda lambda // aplicación| Op string [lambda] // operador| If lambda lambda lambda// condicional

type environment = ([string],[value])

data value = Numb int| Closure lambda environment



// función principal:

interpret :: lambda -> value

interpret e = eval e ([],[])

// ([],[]) es el entorno “vacío”

// función auxiliar:

lookup :: a -> ([a],[b]) -> b

lookup x (n:ns,v:vs) =

if x == n then v

else lookup x (ns,vs)



eval :: lambda -> environment -> value

eval (Int n) env = Numb n

eval (Var x) env = lookup x env

eval (Abs x e) env = Closure (Abs x e) env

eval (Apply f e) env = let v = eval e env

Closure (Abs x e1) (ns,vs) = eval f env in eval e1 (x:ns,v:vs)



eval (Op “+” [e1,e2]) env =

let Numb v1 = eval e1 env

Numb v2 = eval e2 env

in Numb (v1 + v2)

// similar para “-”, “*”, etc

eval (If c e1 e2) =

case (eval c env) of

(Numb 1) -> eval e1 env // 1 es True

(Numb _) -> eval e2 env // el resto False



• Escribe un intérprete para el Escribe un intérprete para el λλ-cálculo -cálculo CBN sin tiposCBN sin tipos


Un intérprete para ecuaciones recursivas de Un intérprete para ecuaciones recursivas de primer orden (CBV)primer orden (CBV)

// prog =

// ([nombres_funcion],[([lista_vars],cuerpo)])

type prog = ([string], [([string],expr)])

data expr =

Int int // constante

| Var string // variable

| If expr expr expr // condicional

| Call string [expr] // llamada func.

| Op string [expr] // operador


Un intérprete para ecuaciones recursivas…Un intérprete para ecuaciones recursivas…

// función principal (value = int):

interpret :: prog -> [expr] -> intinterpret pgm [args] = let (_, (vars,exp):_) = pgmin eval exp (vars,args) pgm

// asumimos que la ejecución comienza con // la primera función, por eso sólo pasamos// los argumentos...




lookup :: a -> ([a],[b]) -> b

lookup x (n:ns,v:vs) =

if x == n then v

else lookup x (ns,vs)


evlist :: [exp] -> ([string],[int]) -> prog -> int

evlist [] _ _ = []

evlist (e:es) env pgm =

(eval e env pgm) : (evlist es env pgm)



eval :: exp -> ([string],[int]) -> prog -> int

eval (Int n) env pgm = n

eval (Var x) env pgm = lookup x env

eval (Call f exps) env pgm =

let vals = evlist exps env pgm

(vars,exp) = lookup f pgm

in eval exp (vars,vals) pgm



eval (Op “+” [e1,e2]) env pgm =

(eval e1 env pgm) + (env e2 env pgm)

// similar para “-”, “*”, etc

eval (If c e1 e2) env pgm =

case (eval c env pgm) of

1 -> eval e1 env pgm // 1 es True

_ -> eval e2 env pgm // resto False



• Escribe un intérprete para ecuaciones Escribe un intérprete para ecuaciones recursivas de primer orden CBNrecursivas de primer orden CBN


Un intérprete para un lenguaje Un intérprete para un lenguaje imperativo simpleimperativo simple

• No lo vemos en clase…No lo vemos en clase…

(lo podéis encontrar en [Jones, Gomard, Sestoft 93])(lo podéis encontrar en [Jones, Gomard, Sestoft 93])

Optimización automática de programas

Documents

Transcript of Optimización automática de programas