Fragmentación de Programascon Emparejamiento de Patrones

David Insa CabreraJoint work with

Josep Silva, Salvador Tamarit, César Tomás

IntroducciónProgram Slicing

Pattern Matching

Problema: Pérdida de precisión

Solución

Conclusiones

Contenido

Peculiaridades de Erlang

Erlang Dependence Graph

Program Slicing [Mark D. Weiser (1981)] Paradigma Imperativo

CONSISTE EN:• Obtener la parte del programa (slice) que influencia o es influenciado por un punto de interés (slicing criterion)

Program Slicing

int i;int sum = 0;int product = 1;for (i = 1; i < N; i++) { sum = sum + i; product = product * i;}write(sum);write(product);

Ejemplo:

int i;int sum = 0;int product = 1;for (i = 1; i < N; i++) { sum = sum + i; product = product * i;}write(sum);write(product);

Programa Original Slice

Program Slicing [Mark D. Weiser (1981)] Paradigma Imperativo

DOS FASES:• Generar el System Dependence Graph (SDG) [Horwitz et al. (1990)]• Recorrer el grafo desde un punto de interés (slicing criterion)

Program Slicing

entry main

sum = 0 i = 1 while i < 11 print sum print i

call add

ain = sum bin = i sum = ret

entry add

a = ain b = bin ret = result

result = a + b

call add

ain = i bin = 1 i = ret

static void main() { int i = 1; int sum = 0; while (I < 11) { sum = add(sum, i); i = add(i, 1); } printf("sum = %d\n", sum); printf("i = %d\n", i);}

static int add(int a, int b) { return a + b;}

static void main() { int i = 1; int sum = 0; while (I < 11) { sum = add(sum, i); i = add(i, 1); } printf(“sum = %d\n”, sum); printf("i = %d\n", i);}

static int add(int a, int b) { return a + b;}

IntroducciónProgram Slicing

Pattern Matching

Problema: Pérdida de precisión

Solución

Conclusiones

Contenido

Peculiaridades de Erlang

Erlang Dependence Graph

Erlang es un lenguaje sencillo y eficiente que fue diseñado para la programación concurrente, en tiempo real y para sistemas distribuidos tolerantes a fallos.

Peculiaridades de Erlang

El subconjunto secuencial de Erlang es un lenguaje funcional, con evaluación estricta, asignación única y tipado dinámico.

main() -> Sum = 0, I = 0, {Res, _} = while(Sum, I, 11), Res.

while(Sum, I, Top) -> if I /= Top -> NSum = add(Sum, I), NI = (fun (Z) -> add(Z, 1) end)(I), while(NSum, NI, Top); I == Top -> {Sum, Top} end.

add(A, 0) -> A;add(A, B) -> A + B.

Algunas características de Erlang:• No contiene bucles. Los bucles se consiguen mediante la recursión.• Las variables sólo pueden asignarse una vez.• El Pattern Matching se usa para seleccionar una de las clausulas de una

función.• Funciones de orden superior, list comprehensions, funciones anónimas y

otros constructores sintácticos no presentes en la programación imperativa.

Peculiaridades de Erlang

main() -> Sum = 0, I = 0, {Res, _} = while(Sum, I, 11), Res.

while(Sum, I, Top) -> if I /= Top -> NSum = add(Sum, I), NI = (fun (Z) -> add(Z, 1) end)(I), while(NSum, NI, Top); I == Top -> {Sum, Top} end.

add(A, 0) -> A;add(A, B) -> A + B.

Peculiaridades de Erlang

main() -> Sum = 0, I = 0, _ = while(undef, I, 11). Res.

while(_, I, Top) -> if I /= Top -> NSum = add(Sum, I), NI = (fun (Z) -> add(Z, 1) end)(I), while(undef, NI, Top); I == Top -> {Sum, Top} end.

add(_, 0) -> undef;add(A, B) -> A + B.

main() -> Sum = 0, I = 0, {Res, _} = while(Sum, I, 11), Res.

while(Sum, I, Top) -> if I /= Top -> NSum = add(Sum, I), NI = (fun (Z) -> add(Z, 1) end)(I), while(NSum, NI, Top); I == Top -> {Sum, Top} end.

add(A, 0) -> A;add(A, B) -> A + B.

IntroducciónProgram Slicing

Pattern Matching

Problema: Pérdida de precisión

Solución

Conclusiones

Contenido

Peculiaridades de Erlang

Erlang Dependence Graph

Erlang Dependence Graph

Erlang Dependence Graph

function in main/0

clause in

(guards) []

body

(op)+

(term)X

(term)42

(op){}

(term)X

(term)5

main() -> X = 5, X + 42, {X, 5, X + 42}.

Código:

(op)+

(term)X

(term)42

pm

(term)X

(term)5

Erlang Dependence Graph

function in main/0

clause in

(guards) []

body

pm

(term)X

(op){}

(term)1

(term)2

pm

(term)X

(op){}

(term)A

(term)B

main() -> X = {1, 2}, {A, B} = X.

Código:

Erlang Dependence Graph

function in main/0

clause in

(guards) []

body

pm

(term)X

(op){}

(term)1

(term)2

call

(term)X

(term)f

main() -> X = {1, 2}, f(X).

Código:

return

function in f/1

clause in

(guards) []

body

(op){}

(term)A

(term)B

(term)A

f({A, B}) -> A.

IntroducciónProgram Slicing

Pattern Matching

Problema: Pérdida de precisión

Solución

Conclusiones

Contenido

Peculiaridades de Erlang

Erlang Dependence Graph

Problema: Pérdida de precisión

function in main/0

clause in

(guards) []

body

pm

(term)X

(op){}

(term)1

(term)2

pm

(term)X

(op){}

(term)A

(term)B

main() -> X = {1, 2}, {A, B} = X.

Código:

main() -> X = {1, 2}. {A, B} = X.

Código obtenido:

main() -> X = {1, 2}. {A, B} = X.

Código esperado:

Problema: Pérdida de precisión

function in main/0

clause in

(guards) []

body

pm

(term)X

(op){}

(term)1

(term)2

pm

(term)X

(op){}

(term)A

(term)B

main() -> X = {1, 2}, {A, B} = X.

Código:

main() -> X = {1, 2}, _ = X.

Código obtenido:

main() -> X = {1, 2}, _ = X.

Código esperado:

Problema: Pérdida de precisión

function in main/0

clause in

(guards) []

body

pm

(term)X

(op){}

(term)1

(term)2

pm

(term)X

(op){}

(term)A

(term)B

main() -> X = {1, 2}, {A, B} = X.

Código:

main() -> X = {1, 2}, {A, _} = X.

Código obtenido:

main() -> X = {1, undef}, {A, _} = X.

Código esperado:

IntroducciónProgram Slicing

Pattern Matching

Problema: Pérdida de precisión

Solución

Conclusiones

Contenido

Peculiaridades de Erlang

Erlang Dependence Graph

Solución

function in main/0

clause in

(guards) []

body

pm

(term)X

(op){}

(term)1

(term)2

pm

(term)X

(op){}

(term)A

(term)B

main() -> X = {1, 2}, {A, B} = X.

Código:

main() -> X = {1, undef}, {A, _} = X.

Código obtenido:

Solución interprocedural

function in main/0

clause in

(guards) []

body

pm

(term)X

(op){}

(term)1

(term)2

call

(term)X

(term)f

main() -> X = {1, 2}, f(X).

Código:

return

function in f/1

clause in

(guards) []

body

(op){}

(term)A

(term)B

(term)A

f({A, B}) -> A.

main() -> X = {1, undef}, f(X).

Código obtenido:

f({A, _}) -> A.

Solución interprocedural

function in main/0

clause in

(guards) []

body

pm

(op){}

(term)A

(term)B

call

(term)f

main() -> {A, B} = f().

Código:

return

function in f/0

clause in

(guards) []

body

(term)X

f() -> X = {1, 2}, X.

Código obtenido:

main() -> {A, _} = f().

f() -> X = {1, undef}, X.

pm

(term)X

(op){}

(term)1

(term)2

IntroducciónProgram Slicing

Pattern Matching

Problema: Pérdida de precisión

Solución

Conclusiones

Contenido

Peculiaridades de Erlang

Erlang Dependence Graph

Conclusiones

Program Slicing con Pattern Matching

Ampliación del Erlang Dependence Graph

Nuevo algoritmo de Fragmentación

Mejora de la precisión

body

pm

(term)X

(op){}

(term)1

(term)2

pm

(term)X

(op){}

(term)A

(term)B

main() -> X = {1, 2}, {A, B} = X.

Código:

http://kaz.dsic.upv.es/slicerl

Fragmentación de Programascon Emparejamiento de Patrones

David Insa CabreraThe Erlang Dependence Graph (EDG)

http://kaz.dsic.upv.es/slicerl