24
Fragmentación de Programas on Emparejamiento de Patrone David Insa Cabrera Joint work with Josep Silva, Salvador Tamarit, César Tomás
| Date post: | 02-Apr-2015 |
| Category: |
Documents |
| Upload: | agota-monico |
| View: | 109 times |
| Download: | 1 times |
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
