1 / 24

Fragmentación de Programas c on Emparejamiento de Patrones

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.

yuri
Download Presentation

Fragmentación de Programas c on Emparejamiento de Patrones

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Fragmentación de Programas con Emparejamiento de Patrones David Insa Cabrera Jointworkwith Josep Silva, Salvador Tamarit, César Tomás

  2. Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones

  3. 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);

  4. 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

  5. Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones

  6. 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.

  7. 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.

  8. 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.

  9. Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones

  10. ErlangDependenceGraph

  11. 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

  12. 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

  13. 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

  14. Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones

  15. 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

  16. 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

  17. 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

  18. Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones

  19. 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

  20. 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

  21. 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

  22. Contenido Introducción ProgramSlicing Peculiaridades de Erlang ErlangDependenceGraph PatternMatching Problema: Pérdida de precisión Solución Conclusiones

  23. 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

  24. Fragmentación de Programas con Emparejamiento de Patrones David Insa Cabrera TheErlangDependenceGraph (EDG) http://kaz.dsic.upv.es/slicerl

More Related