240 likes | 368 Views
Fragmentación de Programas c on Emparejamiento de Patrones. David Insa Cabrera. Joint work with Josep Silva, Salvador Tamarit , César Tomás. Contenido. Introducción. Program Slicing. Peculiaridades de Erlang. Erlang Dependence Graph. Pattern Matching. Problema: Pérdida de precisión.
E N D
Fragmentación de Programas con Emparejamiento de Patrones David Insa Cabrera Jointworkwith Josep Silva, Salvador Tamarit, César Tomás
Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones
ProgramSlicing • ProgramSlicing[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 (slicingcriterion) Ejemplo: Slice Programa Original int i; int sum = 0; intproduct = 1; for (i = 1; i < N; i++) { sum = sum + i; product = product * i; } write(sum); write(product); int i; int sum = 0; intproduct = 1; for (i = 1; i < N; i++) { sum = sum + i; product= product* i; } write(sum); write(product);
ProgramSlicing • ProgramSlicing[Mark D. Weiser (1981)]Paradigma Imperativo • DOS FASES: • Generar el SystemDependenceGraph (SDG) [Horwitz et al. (1990)] • Recorrer el grafo desde un punto de interés (slicingcriterion) entrymain static void main() { inti = 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 void main() { inti = 1; intsum = 0; while (I < 11) { sum = add(sum, i); i = add(i, 1); } printf("sum = %d\n", sum); printf("i = %d\n", i); } print i print sum i = 1 while i < 11 sum = 0 static int add(int a, int b) { return a + b; } static int add(int a, int b) { return a + b; } calladd calladd sum = ret bin = i ain = sum i = ret bin = 1 ain = i entryadd ret = result b = bin a = ain result = a + b
Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones
Peculiaridades de Erlang 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. El subconjunto secuencial de Erlang es un lenguaje funcional, con evaluación estricta, asignación única y tipado dinámico. 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. main() -> Sum= 0, I = 0, {Res, _} = while(Sum, I, 11), Res. add(A, 0) -> A; add(A, B) -> A + B.
Peculiaridades de Erlang • 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 PatternMatching se usa para seleccionar una de las clausulas de una función. • Funciones de orden superior, listcomprehensions, funciones anónimas y otros constructores sintácticos no presentes en la programación imperativa. 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. main() -> Sum= 0, I = 0, {Res, _} = while(Sum, I, 11), Res. add(A, 0) -> A; add(A, B) -> A + B.
Peculiaridades de Erlang 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. main() -> Sum= 0, I = 0, {Res, _} = while(Sum, I, 11), Res. add(A, 0) -> A; add(A, B) -> A + B. 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. main() -> Sum = 0, I = 0, _= while(undef, I, 11). Res. add(_, 0) -> undef; add(A, B) -> A + B.
Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones
ErlangDependenceGraph function in main/0 Código: clause in main() -> X = 5, X + 42, {X, 5, X + 42}. (guards) [] body (op) {} (op) + pm (term) 5 (term) 42 (op) + (term) X (term) 5 (term) X (term) X (term) 42 (term) X
ErlangDependenceGraph function in main/0 Código: clause in main() -> X = {1, 2}, {A, B} = X. (guards) [] body pm pm (op) {} (op) {} (term) X (term) X (term) B (term) 2 (term) A (term) 1
ErlangDependenceGraph function in f/1 function in main/0 Código: clause in clause in main() -> X = {1, 2}, f(X). (op) {} (guards) [] (guards) [] f({A, B}) -> A. (term) B (term) A body body (term) A call pm (term) f (op) {} (term) X (term) X return (term) 2 (term) 1
Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones
Problema: Pérdida de precisión function in main/0 Código: clause in main() -> X = {1, 2}, {A, B} = X. (guards) [] Código obtenido: body main() -> X = {1, 2}. {A, B} = X. pm pm Código esperado: (op) {} (op) {} (term) X (term) X main() -> X = {1, 2}. {A, B} = X. (term) B (term) 2 (term) A (term) 1
Problema: Pérdida de precisión function in main/0 Código: clause in main() -> X = {1, 2}, {A, B} = X. (guards) [] Código obtenido: body main() -> X = {1, 2}, _ = X. pm pm Código esperado: (op) {} (op) {} (term) X (term) X main() -> X = {1, 2}, _ = X. (term) B (term) 2 (term) A (term) 1
Problema: Pérdida de precisión function in main/0 Código: clause in main() -> X = {1, 2}, {A, B} = X. (guards) [] Código obtenido: body main() -> X = {1, 2}, {A, _} = X. pm pm Código esperado: (op) {} (op) {} (term) X (term) X main() -> X = {1, undef}, {A, _} = X. (term) B (term) 2 (term) A (term) 1
Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones
Solución function in main/0 Código: clause in main() -> X = {1, 2}, {A, B} = X. (guards) [] Código obtenido: body main() -> X = {1, undef}, {A, _} = X. pm pm (op) {} (op) {} (term) X (term) X (term) B (term) 2 (term) A (term) 1
Solución interprocedural function in f/1 function in main/0 Código: clause in clause in main() -> X = {1, 2}, f(X). (op) {} (guards) [] (guards) [] f({A, B}) -> A. (term) B (term) A body body Código obtenido: (term) A call pm main() -> X = {1, undef}, f(X). (term) f (op) {} (term) X (term) X return f({A, _}) -> A. (term) 2 (term) 1
Solución interprocedural function in f/0 function in main/0 Código: clause in clause in main() -> {A, B} = f(). (guards) [] (guards) [] f() -> X = {1, 2}, X. body body Código obtenido: pm (term) X pm main() -> {A, _} = f(). (op) {} (op) {} (term) X call f() -> X = {1, undef}, X. (term) B (term) f (term) A return (term) 2 (term) 1
Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones
Conclusiones ProgramSlicing con PatternMatching body pm pm Código: main() -> X = {1, 2}, {A, B} = X. (op) {} (op) {} (term) X (term) X (term) B (term) 2 (term) A (term) 1 Ampliación del ErlangDependenceGraph Nuevo algoritmo de Fragmentación Mejora de la precisión http://kaz.dsic.upv.es/slicerl
Fragmentación de Programas con Emparejamiento de Patrones David Insa Cabrera TheErlangDependenceGraph (EDG) http://kaz.dsic.upv.es/slicerl