Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

Plasterkowanie Leszek Mierzejewski. Cel referatu kilka definicji struktury danych i algorytmy plasterkowania dla programów imperatywnych analiza zależności.

Podobne prezentacje


Prezentacja na temat: "Plasterkowanie Leszek Mierzejewski. Cel referatu kilka definicji struktury danych i algorytmy plasterkowania dla programów imperatywnych analiza zależności."— Zapis prezentacji:

1 Plasterkowanie Leszek Mierzejewski

2 Cel referatu kilka definicji struktury danych i algorytmy plasterkowania dla programów imperatywnych analiza zależności w programach obiektowych reprezentacja metod, klas i obiektów plasterki spełniające różne kryteria zastosowania

3 Definicje Plasterkowanie polega na takim okrojeniu analizowanego programu, żeby w zadanym miejscu programu oryginalnego i okrojonego, zadane zmienne miały te same wartości. Zastosowania: –debugowanie, –testowanie, –analiza, zrozumienie programu, –porównywanie programów, –bezpieczeństwo, –zrównoleglanie. Plasterkowanie programu wprowadził Mark Weiser. Publikacja z 1979 roku

4 Kryterium plasterkowania jest parą, gdzie p jest punktem programu, a V zbiorem zmiennych z p. Backward slice stanowi podzbiór programu, który wpływa na p. Forward slice stanowi podzbiór programu, na który wpływa p. Chop, pomiędzy punktami programu p i q, stanowi podzbiór programu zależny od p, i który wpływa na q.

5 Backward slice Backward slice dla wyrażenia printf(%d\n, i) void main () { int sum = 0; int i = 1; while (i < 11) { sum = sum + i; i = i + 1; } printf (%d\n, sum); printf (%d\n, i); }

6 Backward slice Backward slice dla wyrażenia printf(%d\n, i) void main () { int sum = 0; int i = 1; while (i < 11) { sum = sum + i; i = i + 1; } printf (%d\n, sum); printf (%d\n, i); }

7 Forward slice Forward slice dla wyrażenia sum = 0 void main () { int sum = 0; int i = 1; while (i < 11) { sum = sum + i; i = i + 1; } printf (%d\n, sum); printf (%d\n, i); }

8 Forward slice Forward slice dla wyrażenia sum = 0 void main () { int sum = 0; int i = 1; while (i < 11) { sum = sum + i; i = i + 1; } printf (%d\n, sum); printf (%d\n, i); }

9 Chop Chop pomiędzy wyrażeniem sum = 0 i wyrażeniem printf(%d\n, i) void main () { int sum = 0; int i = 1; while (i < 11) { sum = sum + i; i = i + 1; } printf (%d\n, sum); printf (%d\n, i); }

10 Chop Chop pomiędzy wyrażeniem sum = 0 i wyrażeniem printf(%d\n, i) void main () { int sum = 0; int i = 1; while (i < 11) { sum = sum + i; i = i + 1; } printf (%d\n, sum); printf (%d\n, i); } Brak przepływu informacji

11 Program Dependence Graph graf skierowany, reprezentujący procedurę wierzchołki –wierzchołki Control Flow Graph krawędzie –zależności kontrolne –zależności przepływu danych Backward slice dla punktu p jest podgrafem uzyskanym przez przejście grafu PDG przeciwnie do kierunku, rozpoczynając z wierzchołka p Forward slice dla punktu p jest podgrafem uzyskanym przez przejście grafu PDG z wierzchołka p. Chop dla punktów p i q jest podgrafem PDG zawartym pomiędzy wierzchołkami p i q.

12

13

14

15

16

17

18

19

20

21

22 System Dependence Graph –PDG dla każdej procedury –krawędzie pomiędzy procedurami łączą: wywołania procedur (calls) z wejściami procedur (entries) przekazywane parametry (actual parameters) z otrzymywanymi parametrami (formal parameters) wyniki procedury (results) ze zmiennymi pobierającymi rezultat (call-site return values) wyznaczenie plasterka jest problemem przejścia grafu

23 Backward slice Backward slice dla wyrażenia printf(%d\n, i) void main () { int sum = 0; int i = 1; while (i < 11) { sum = add(sum,i); i = add(i,1); } printf (%d\n, sum); printf (%d\n, i); } int add (int x, int y) { return x + y; }

24 Backward slice Backward slice dla wyrażenia printf(%d\n, i) void main () { int sum = 0; int i = 1; while (i < 11) { sum = add(sum,i); i = add(i,1); } printf (%d\n, sum); printf (%d\n, i); } int add (int x, int y) { return x + y; }

25

26

27

28

29

30

31

32

33

34

35

36

37 Plasterkowanie programów obiektowych Class Dependency Graph (ClDG) L.D. Larsen, M.J. Harrold, rozszerza SDG zawiera wejściowy wierzchołek dla każdej klasy, z którego wychodzą krawędzie do wierzchołków wejściowych metod każdy wierzchołek wejściowy rozrasta się poprzez dodanie wierzchołków reprezentujących parametry i atrybuty Object-Oriented Program Dependency Graph J.L. Chen, F.J. Wang, Y.L. Chen dwa rodzaje plasterków: state slice i behaviour slice. State slice dla obiektu jest zbiorem komunikatów i wyrażeń kontrolnych, które mogą wpływać na stan obiektu. Behaviour slice jest zbiorem atrybutów i metod zdefiniowanych w powiązanych klasach, które mogą wpływać na zachowanie obiektu.

38 PDG metody Reprezentowana przez control flow graph (CFG) CFG= E={ | s 1,s 2 S i po wykonaniu s 1 można wykonać s 2 }. Def(s) zmienne, których wartości są zdefiniowane (modyfikowane) w punkcie s. (Parametry formalne in są związane z wierzchołkiem wejścia.) Ref(s) zmienne, do których wartości jest odwołanie w punkcie s. Def(s,x) zmienne użyte do zdefiniowania zmiennej x. Dep_D(s,x)={(x,s,y) | y Def(s,x) y Def(s) ścieżka z s do s, na której y nie jest przedefiniowane. Dep_R(s)={(x,s,x) | jeśli s jest wyrażeniem kontrolnym (if, while), x jest zmienną warunkową użytą w s i x Def(s) istnieje ścieżka z s od s, na której x nie jest przedefiniowany}.

39 public class Point { int X; int Y; public Point (int x, int y) { 1: X=x; 2: Y=y; } public void Move (int z) { 3: X=X+z; 4: Y=Y+z; } public void Trans (int z) { 5: if (z>0) 6: Move(z); else 7: System.out.println (error); } Def(12)={P1.X, P2.X} Ref(12)={P1.X, P2.X} Def(12, P2.X)={P2.X} Def(12, P1.X)={P1.X, P2.X} Dep_D(14,P2.X)={P2.X,12,P2.X} Dep_R(5)={wejście Trans} public class Main { public void main (String[] args) { 8: Point P1=new Point(10,20); 9: Point P2=new Point(0,0); 10: P1.Trans(10); 11: P2.Move(100); 12: P1.X=P1.X+P2.X++; 13: System.out.println (P1.X); 14: System.out.println (P2.X); }

40 Definicja 1 Program Dependence Graph dla metody M jest grafem skierowanym ze znacznikami. PDG=, gdzie S=S (S jest zbiorem wierzchołków grafu CFG), krawędzie E=E 1 E 2, gdzie E 1 zbiór krawędzi wyrażających zależności kontrolne, E 2 ={ | (x,s 2,y) Dep_D(s 1,x) (x,s 2,x) Dep_R(s 1 )} jest zbiorem krawędzi wyrażających zależności danych. T jest zbiorem znaczników. public void Move (int z) { 3: X=X+z; 4: Y=Y+z; } Entry 3 4 (X,X) (X,z)(Y,z) (Y,Y) PDG Move Znacznik na krawędzi : (*,*), jeśli E 1, (x,y), jeśli (x,s 2,y) Dep_D(s 1 ), (x,x), jeśli (x,s 2,x) Dep_R(s 1 ).

41 Analiza zależności Rodzaje parametrów: in, out, in out, formalne, aktualne. Zależności pomiędzy parametrami opisane są za pomocą zbiorów zależności parametrów. Metody mogą współdziałać ze sobą tylko za pomocą parametrów. Call Graph – graf skierowany, opisuje powiązania pomiędzy metodami –wierzchołki – metody –krawędzie – komunikaty, jeśli metoda p wywołuje q, to należy do grafu. Def(M) = In(S exit ) – {v|v jest zmienną lokalną lub parametrem typu in}; if v Def(M) then if v jest parametrem formalnym then Def(s)=Def(s) {a}; a jest odpowiadającym parametrem aktualnym. else Def(s)=Def(s) {v}; // v jest zmienną globalną if y Dep_PM(M,x) then a i b są parametreami aktualnymi odpowiadającymi zmiennym x i y Def(s,a)=Def(s) {b};

42 Analiza zależności (polimorfizm) W Javie polimorfizm jest wspierany przez abstrakcyjne metody. Obiekt, których typ może zmienić się podczas wykonania programu jest nazywany obiektem polimorficznym Polimorficzny obiekt jest reprezentowany jako drzewo, w którym korzeń reprezentuje polimorficzny obiekt, a liście reprezentują obiekty możliwych typów. Java jest językiem typowanym statycznie. Polimorfizm jest reprezentowany przez zbiory zależności parametrów. Kiedy obiekt wywołuje metodę to rozważamy następujące przypadki: Obiekt ma określony typ.Obiekt nie ma określonego typu. Metoda nie polimorficzna. Koniec.Bierzemy wszystkie możliwe metody. Metoda polimorficzna. Zamieniamy na odpowiadającą metodę. Dla wszystkich możliwych typów obiektu zmieniamy polimorficzną metodę na jej odpowiedniki.

43 PDG klasy Klasa: pola danych PDG dla każdej metody podklasa dziedziczy PDG rodzica Reprezentacja obiektu: pola danych obiektu jako parametry drzewo –korzeń - obiekt –dzieci - pola danych PDG MovePDG Trans PDG Point PDG klasy Point

44 Partial Slicing Dla podanego kryterium plasterkowania partial slicing plasterkuje tylko wybrane części programu (klasę, kilka metod, obiekt). Użyteczny w dużych systemach, lub gdy mamy niekompletny kod. Plasterkujemy metodę, pomijając wywołania innych metod. Analizujemy je w drugiej fazie. Plasterkowanie metody sprowadza się do plasterkowania kilku pojedyńczych metod. Tylko parametry out i in out mają wpływ na stronę wywołującą. Zależności pomiędzy parametrami można wyznaczyć przez interfejsy.

45 Input: Program P, kryterium plasterkowania. Output: Plasterek spełniający kryterium plasterkowania : Dep_S. Init: W={(s0, v)}; Dep_S = ; PL = ; Algorithm: repeat Usuń element (s, x) z W; for all krawędź, która nie była wybrana do Zaznacz jako wybraną krawędź ; Niech T będzie znacznikiem dla ; if T=(x, y) then // data dependence W = W {(s, y)}; Dep_S = Dep_S {s}; if y jest nazwą metody then PL = PL {(y, y)}; if y jest aktualnym parametrem metody M then Niech y będzie odpowiadającym parametrem formalnym. PL = PL {(M,y)}; if T=(*,*) then // control dependence Dep_S = Dep_S {s}; for all y i Ref(s) do W = W {(s,y)}; if y jest nazwą metody then PL {(y,y)}; while W != ; while PL != do Usuń element (P,x) z PL; if P jest interesującą nas częścią then Dep_S = Dep_S plasterek P dla x; if plasterek P dla x zawiera plasterek M i dla z then PL = PL {(M i,z)}; end;

46 Kryterium plasterkowania metody Move i Trans public class Point { int X; int Y; public Point (int x, int y) { 1: X=x; 2: Y=y; } public void Move (int z) { 3: X=X+z; 4: Y=Y+z; } public void Trans (int z) { 5: if (z>0) 6: Move(z); else 7: System.out.println (error); } public class Main { public void main (String[] args) { 8: Point P1=new Point(10,20); 9: Point P2=new Point(0,0); 10: P1.Trans(10); 11: P2.Move(100); 12: P1.X=P1.X+P2.X++; 13: System.out.println (P1.X); 14: System.out.println (P2.X); }

47 Object Slicing Głównie użyteczny przy debugowaniu i analizie programu. Kryterium plasterkowania Wyznacza wyrażenia metod wybranego obiektu spełniające kryterium Korzystamy z algorytmu dla częściowego plasterkowania. Wyznaczamy plasterki metod obiektu Object (mogą być wywoływane pośrednio lub bezpośrednio) Wynikiem jest suma wszystkich tych plasterków.

48 Kryterium plasterkowania public class Point { int X; int Y; public Point (int x, int y) { 1: X=x; 2: Y=y; } public void Move (int z) { 3: X=X+z; 4: Y=Y+z; } public void Trans (int z) { 5: if (z>0) 6: Move(z); else 7: System.out.println (error); } public class Main { public void main (String[] args) { 8: Point P1=new Point(10,20); 9: Point P2=new Point(0,0); 10: P1.Trans(10); 11: P2.Move(100); 12: P1.X=P1.X+P2.X++; 13: System.out.println (P1.X); 14: System.out.println (P2.X); }

49 Class Slicing Kryterium plasterkowania Wyznacza pola danych i wyrażenia metod należących do klasy Class, które spełniają kryterium plasterkowania Algorytm: –plasterkujemy każdą instancję, zaznaczając użyte pola danych (kosztowne) –plasterkujemy z punktu s, w trakcie zaznaczając wyrażenia i pola danych klasy Class.

50 Kryterium plasterkowania public class Point { int X; int Y; public Point (int x, int y) { 1: X=x; 2: Y=y; } public void Move (int z) { 3: X=X+z; 4: Y=Y+z; } public void Trans (int z) { 5: if (z>0) 6: Move(z); else 7: System.out.println (error); } public class Main { public void main (String[] args) { 8: Point P1=new Point(10,20); 9: Point P2=new Point(0,0); 10: P1.Trans(10); 11: P2.Move(100); 12: P1.X=P1.X+P2.X++; 13: System.out.println (P1.X); 14: System.out.println (P2.X); }

51 Zastosowania Zrozumienie programu –Co wpływa na co? Zrównoleglanie (dekompozycja) –Odzielenie osobnie wyliczanych zadań Specjalizacja –plasterek = wyspecjalizowany program Porównywanie programów –Wykrywanie rożnic semantycznych Testowanie –Które fragmenty nie wymagają powtórnego testowania? Bezpieczeństwo –Wykrywanie niebezpiecznych fragmentów programu.

52 Aplikacje i projekty

53 Bibliografia Z. Chen, B. Xu, Slicing Object-Oriented Java Programs Andrea De Lucia, Program Slicing: Methods and Applications

54 Dekompozycja void char_count(FILE *f) { int lines = 0; int chars; BOOL eof_flag = FALSE; int n; extern void scan_line(FILE *f, BOOL *bp, int *ip); scan_line(f, &eof_flag, &n); chars = n; while (eof_flag == FALSE) { lines = lines + 1; scan_line(f, &eof_flag, &n); chars = chars + n; } printf(lines = %d\n, lines); printf(chars = %d\n, chars); } void line_count(FILE *f) { int lines = 0; int chars; BOOL eof_flag = FALSE; int n; extern void scan_line(FILE *f, BOOL *bp, int *ip); scan_line(f, &eof_flag, &n); chars = n; while (eof_flag == FALSE) { lines = lines + 1; scan_line(f, &eof_flag, &n); chars = chars + n; } printf(lines = %d\n, lines); printf(chars = %d\n, chars); }


Pobierz ppt "Plasterkowanie Leszek Mierzejewski. Cel referatu kilka definicji struktury danych i algorytmy plasterkowania dla programów imperatywnych analiza zależności."

Podobne prezentacje


Reklamy Google