Loop Expansion y Tree Compression

1. LoopExpansion y TreeCompression David Insa Cabrera Jointworkwith Josep Silva, César Tomás

2. Contenido Introducción Depuración Algorítmica Dos técnicas LoopExpansion (nueva) TreeCompression (mejora) Demostración DDJ Conclusiones

3. Depuración Algorítmica • Depuración algorítmica[Shapiro(1982)]Paradigma Lógico • DOS FASES: • Generar el árbol de ejecución • Recorrer el árbol de ejecución haciendo preguntas hasta encontrar el error Si se detecta el efecto de un error entonces la DA encontrará el error main = 4 ¿Qué es un Árbol de Ejecución? listSum [1,2] = 4 Ejemplo: main = listSum [1,2] listSum [] = 1 listSum (x:xs) = x + (listSumxs) 1+3 = 4 listSum [2] = 3 2+1 = 3 listSum [] = 1

4. Depuración Algorítmica • Recorriendo el árbol de ejecución • REGLA DE ORO: Cuando un nodo incorrecto no tiene hijos incorrectos, entonces este nodo es erróneo. main = 4 listSum [1,2] = 4 Ejemplo: main = listSum [1,2] listSum [] = 1 listSum (x:xs) = x + (listSumxs) 1+3 = 4 listSum [2] = 3 2+1 = 3 listSum [] = 1

5. Depuración Algorítmica • Recorriendo el árbol de ejecución • REGLA DE ORO: Cuando un nodo incorrecto no tiene hijos incorrectos, entonces este nodo es erróneo. main = 5 listSum [1,2] = 5 Ejemplo: main = listSum [1,2] listSum [] = 0 listSum (x:xs) = x + (listSumxs) + 1 1+3+1 = 5 listSum [2] = 3 2+0+1 = 3 listSum [] = 0

6. Contenido Introducción Depuración Algorítmica • Estrategias de la DA Dos técnicas • Sesión de depuración LoopExpansion (nueva) TreeCompression(mejora) Demostración DDJ Conclusiones

7. Estrategias de la Depuración Algorítmica Estrategias Single Stepping Single Stepping Divide & Query Top Down Top Down - Left to Right Top Down - Heaviest First Top Down - More Rules First Top Down - Less Yes First Divide & Query (by Shapiro) Divide & Query (by Hirunkitti) Divide by Rules & Query Divide by Yes & Query Hat Delta Hat Delta - More Wrongs Hat Delta - Less Rights Hat Delta - Best Division

8. Sesión de depuración Sesión de depuración main = sqrTest[1,2] sqrTestx = test (squares (listSumx)) test (x,y,z) = (x==y) && (y==z) listSum[] = 0 listSum(x:xs) = x + (listSumxs) squares x = ((square1 x),(square2 x),(square3 x)) square1 x = square x square x = x*x square2 x = listSum(list x x) list x y | y==0 = [] | otherwise = x:list x (y-1) square3 x = listSum(partialSumsx) partialSumsx = [(sum1 x),(sum2 x)] sum1 x = div (x * (incr x)) 2 sum2 x = div (x + (decr x)) 2 incr x = x + 1 decr x = x - 1

9. Sesión de depuración Sesión de depuración con la búsqueda Top-Down – HeaviestFirst. main = False Empezando la sesión de depuración… main = False? NO sqrTest[1,2] = False? NO squares3 = [9,9,8]? NO square2 3 = 9? SI square3 3 = 8? NO partialSums3 = [6,2]? NO sum1 3 = 6? SI sum2 3 = 2? NO decr 3 = 2? SI Error encontrado en la regla: sum2 x = div (x + (decr x)) 2 sqrTest [1,2] = False test (9,9,8) = False squares 3 = (9,9,8) listSum [1,2] = 3 listSum [2] = 2 squares1 3 = 9 squares2 3 = 9 squares3 3 = 8 listSum [] = 0 square 3 = 9 listSum [3,3,3] = 9 list 3 3 = [3,3,3] partialSums 3 = [6,2] listSum [6,2] = 8 listSum [3,3] = 6 list 3 2 = [3,3] listSum [2] = 2 sum1 3 = 6 sum2 3 = 2 decr 3 = 2 listSum [3] = 3 list 3 1 = [3] listSum [] = 0 incr 3 = 4 listSum [] = 0 list 3 0 = []

10. Sesión de depuración Sesión de depuración main = sqrTest[1,2] sqrTestx = test (squares (listSumx)) test (x,y,z) = (x==y) && (y==z) listSum[] = 0 listSum(x:xs) = x + (listSumxs) squares x = ((square1 x),(square2 x),(square3 x)) square1 x = square x square x = x*x square2 x = listSum(list x x) list x y | y==0 = [] | otherwise = x:list x (y-1) square3 x = listSum(partialSumsx) partialSumsx = [(sum1 x),(sum2 x)] sum1 x = div (x * (incr x)) 2 sum2 x = div (x + (decr x)) 2 incr x = x + 1 decr x = x - 1

11. Contenido Introducción Depuración Algorítmica Dos técnicas LoopExpansion (nueva) TreeCompression(mejora) Demostración DDJ Conclusiones

12. LoopExpansion publicvoidsqrt(double x) { if(x < 0) returnDouble.NaN; doubleb = x; while(Math.abs(b * b - x) > 1e-12) b = ((x / b) + b) / 2; return b; }

13. LoopExpansion publicvoidsqrt(double x) { if (x < 0) return Double.NaN; double b = x; { if (Math.abs(b * b - x) > 1e-12) { Object[] result = this.sqrt_loop(x, b); x = (Double) result[0]; b = (Double) result[1]; } } return b; } publicvoidsqrt(double x) { if(x < 0) returnDouble.NaN; doubleb = x; while(Math.abs(b * b - x) > 1e-12) b = approx(x, b); return b; } privateObject[] sqrt_loop(double x, double b) { b = approx(x, b); if (Math.abs(b * b - x) > 1e-12) return this.sqrt_loop(x, b); return new Object[] { x, b }; } publicvoidapprox(doublex, double b) { return ((x / b) + b) / 2; }

14. LoopExpansion 1 L 1 2 3 L … 2 3 2 3 2 3 2 3 L publicvoidsqrt(double x) { if(x < 0) returnDouble.NaN; doubleb = x; while(Math.abs(b * b - x) > 1e-12) b = approx(x, b); return b; } L 2 3 … …

15. Contenido Introducción Depuración Algorítmica Dos técnicas LoopExpansion (nueva) TreeCompression(mejora) Demostración DDJ Conclusiones

16. TreeCompression 1 1 2 6 1 2 4 6 6 2 2 3 3 4 5 3 4

17. TreeCompression 32 / 9 = 3,55 1 2 1 1 4 5 2 2 2 2 2 2 3 4 5 2 3 4 26 / 8 = 3,25 27 / 7 = 3,86 1 4 1 6 1 2 2 2 4 2 2 2 2 3 4 2 2 2 4 5 6 1 2 3 2 2 2 2 3 4

18. TreeCompression 13/4 +1 1 +3 +2 2 3 4 + 4 3 2 AVG1 = (AVG2 + ) * W2+ (AVG3 + ) * W3 + (AVG4 + ) * W4 1 = 13 AVG1 = (2) + (3) + (4) + 4 / 4 (AVG2 * W2 + W2) + (AVG3 * W3 + 2W3) + (AVG4 * W4 + 3W4) + 4WI1 AVG1 = W1 AVG1 * W1 = (AVG2 * W2 + W2) + (AVG3 * W3 + 2W3) + (AVG4 * W4 + 3W4) + 4WI1 Q1 = (Q2 + W2) + (Q3 + 2W3) + (Q4 + 3W4) + 4WI1

19. TreeCompression 0 13/4 6 1 5 7 2 3 4 Q1 = (Q2 + W2) + (Q3 + 2W3) + (Q4 + 3W4) + 4WI1 Q0 = (Q1 + W1) + (Q5 + 2W5) + (Q6 + 3W6) + (Q7+ 4W7) + 5WI0 Q0 = (Q2 + Q3 + Q4) + Q5+ Q6 + Q7 + W1 + (W2 + 2W3 + 3W4 + 4WI1) + 2W5 + 3W6 + 4W7 + 5WI0

20. TreeCompression 0 2 6 5 3 4 7 Q0 = (Q2 + Q3 + Q4) + Q5+ Q6 + Q7 + W1 + (W2 + 2W3 + 3W4 + 4WI1) + 2W5 + 3W6 + 4W7 + 5WI0 Q’0 = (Q2 + W2) + (Q3 + 2W3) + (Q4 + 3W4) + (Q5+ 4W5) + (Q6 + 5W6) + (Q7 + 6W7) + 5WI0 Q’0 = Q2 + Q3 + Q4 + Q5+ Q6 + Q7 + W2 + 2W3 + 3W4 + 4W5 + 5W6 + 6W7 + 7WI0

21. TreeCompression 0 0 6 1 5 7 2 6 5 3 4 7 2 3 4 (Q2 + Q3 + Q4) + Q5 + Q6 + Q7 + Q0 = W1 + (W2 + 2W3 + 3W4 + 4WI1) + 2W5 + 3W6 + 4W7 + 5WI0 Q2 + Q3 + Q4 + Q5 + Q6 + Q7 + Q’0 = Coste(nodos) = Σ{Pos(nodo, nodos) * Wnodo | nodo ∈nodos} + |nodos| + 1 W2 + 2W3 + 3W4 + 4W5 + 5W6 + 6W7 + 7WI0 Coste(hijos0) + Coste(hijos1) Q0 = Coste(hijos0) + Coste(hijos1) AVG0 = - > W0 Coste(hijos’0) Q’0 = Coste(hijos’0) AVG’0 = W’0

22. TreeCompression recs = {n | n,n’ ∈ N ∧ (n → n’) ∈ E } ∧ l(n) = l(n’)} while (recs≠ ∅) taken ∈ recssuchthat ∃/ n’ ∈ recswith (n → n’) ∈ E+ recs = recs \ {n} parent = n do maxImpr = 0 children = {c | (n → c) ∈ E ∧ l(n) = l(c)} foreachchild∈ children pchildren = Sort(Children(parent)) cchildren = Sort(Children(child)) comb = Sort((pchildren ∪ cchildren) \ {child}) impr = if (impr > maxImpr) maxImpr = impr bestNode = child endforeach if (maxImpr ≠ 0) T’ = Compress(T’, parent, bestNode) while (maxImpr ≠ 0) endwhile 1 1 2 6 1 2 4 6 6 2 2 3 3 4 5 Coste(comb) Coste(pchildren) + Coste(cchildren) - Wparent - 1 Wparent 3 4 Coste(nodos) = Σ{Pos(nodo, nodos) * Wnodo | nodo ∈ nodos} + |nodos| + 1

23. Contenido Introducción Depuración Algorítmica Dos técnicas LoopExpansion (nueva) TreeCompression(mejora) Demostración DDJ Conclusiones

24. Contenido Introducción Depuración Algorítmica Dos técnicas LoopExpansion (nueva) TreeCompression(mejora) Demostración DDJ Conclusiones

25. Conclusiones Reducir el número de preguntas mejorando la estructura del AE Permitir bajar el nivel de granularidad de métodos a bucles Combinar ambas técnicas L 1 2 3 2 3 2 3 L L

26. LoopExpansion y TreeCompression David Insa Cabrera TheDeclarativeDebuggerfor Java (DDJ) http://www.dsic.upv.es/~jsilva/DDJ/