Introducción Program Slicing Pattern Matching Problema: Pérdida de precisión Solución Conclusiones 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) 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);
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) entry main sum = 0 i = 1 while i < 11 print sum print i call add a in = sum b in = i sum = ret entry add a = a in b = b in ret = result result = a + b call add a in = i b in = 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ón Program Slicing Pattern Matching Problema: Pérdida de precisión Solución Conclusiones 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. 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. 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.
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ón Program Slicing Pattern Matching Problema: Pérdida de precisión Solución Conclusiones Peculiaridades de Erlang Erlang Dependence Graph
function in main/0 clause in (guards) [] body (op) + (op) + (term) X (term) X (term) 42 (term) 42 (op) {} (op) {} (term) X (term) X (term) 5 (term) 5 main() -> X = 5, X + 42, {X, 5, X + 42}. (op) + (op) + (term) X (term) X (term) 42 (term) 42 pm (term) X (term) X (term) 5 (term) 5
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 pm (term) X (term) X (op) {} (op) {} (term) A (term) A (term) B (term) B main() -> X = {1, 2}, {A, B} = X.
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 call (term) X (term) X (term) f (term) f main() -> X = {1, 2}, f(X). return function in f/1 clause in (guards) [] body (op) {} (op) {} (term) A (term) A (term) B (term) B (term) A (term) A f({A, B}) -> A.
Introducción Program Slicing Pattern Matching Problema: Pérdida de precisión Solución Conclusiones Peculiaridades de Erlang Erlang Dependence Graph
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 pm (term) X (term) X (op) {} (op) {} (term) A (term) A (term) B (term) B main() -> X = {1, 2}, {A, B} = X. main() -> X = {1, 2}. {A, B} = X. main() -> X = {1, 2}. {A, B} = X.
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 pm (term) X (term) X (op) {} (op) {} (term) A (term) A (term) B (term) B main() -> X = {1, 2}, {A, B} = X. main() -> X = {1, 2}, _ = X. main() -> X = {1, 2}, _ = X.
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 pm (term) X (term) X (op) {} (op) {} (term) A (term) A (term) B (term) B main() -> X = {1, 2}, {A, B} = X. main() -> X = {1, 2}, {A, _} = X. main() -> X = {1, undef}, {A, _} = X.
Introducción Program Slicing Pattern Matching Problema: Pérdida de precisión Solución Conclusiones Peculiaridades de Erlang Erlang Dependence Graph
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 pm (term) X (term) X (op) {} (op) {} (term) A (term) A (term) B (term) B main() -> X = {1, 2}, {A, B} = X. main() -> X = {1, undef}, {A, _} = X.
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 pm (term) X (term) X (op) {} (op) {} (term) A (term) A (term) B (term) B main() -> X = {1, 2}, {A, B} = X. main() -> X = {1, undef}, {A, _} = X.
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 call (term) X (term) X (term) f (term) f main() -> X = {1, 2}, f(X). return function in f/1 clause in (guards) [] body (op) {} (op) {} (term) A (term) A (term) B (term) B (term) A (term) A f({A, B}) -> A. main() -> X = {1, undef}, f(X). f({A, _}) -> A.
function in main/0 clause in (guards) [] body pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 call (term) X (term) X (term) f (term) f main() -> X = {1, 2}, f(X). return function in f/1 clause in (guards) [] body (op) {} (op) {} (term) A (term) A (term) B (term) B (term) A (term) A f({A, B}) -> A. main() -> X = {1, undef}, f(X). f({A, _}) -> A.
function in main/0 clause in (guards) [] body pm (op) {} (op) {} (term) A (term) A (term) B (term) B call (term) f (term) f main() -> {A, B} = f(). return function in f/0 clause in (guards) [] body (term) X (term) X f() -> X = {1, 2}, X. main() -> {A, _} = f(). f() -> X = {1, undef}, X. pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2
function in main/0 clause in (guards) [] body pm (op) {} (op) {} (term) A (term) A (term) B (term) B call (term) f (term) f main() -> {A, B} = f(). return function in f/0 clause in (guards) [] body (term) X (term) X f() -> X = {1, 2}, X. main() -> {A, _} = f(). f() -> X = {1, undef}, X. pm (term) X (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2
Introducción Program Slicing Pattern Matching Problema: Pérdida de precisión Solución Conclusiones Peculiaridades de Erlang Erlang Dependence Graph
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 (term) X (op) {} (op) {} (term) 1 (term) 1 (term) 2 (term) 2 pm (term) X (term) X (op) {} (op) {} (term) A (term) A (term) B (term) B main() -> X = {1, 2}, {A, B} = X.