1 / 26

Loop Expansion y Tree Compression

Loop Expansion y Tree Compression. David Insa Cabrera. Joint work with Josep Silva, César Tomás. Contenido. Introducción. Depuración Algorítmica. Dos técnicas. Loop Expansion (nueva). Tree Compression (mejora). Demostración. DDJ. Conclusiones. Depuración Algorítmica.

avedis
Download Presentation

Loop Expansion y Tree Compression

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

More Related