Fordítás Kódoptimalizálás

Fordítás Kódoptimalizálás Kód visszafejtés. Izsó Tamás 2015. október 15. Izsó Tamás Fordítás Kódoptimalizálás / 1

Aktív változók Angol irodalomban a Live Variables kifejezést használják, míg az azt felhasználó elemzést Liveness Analysis-nek hívják. Az aktív változók ismeretében lehet a felesleges utasításokat megszüntetni. Egy változó a program egy pontján aktív, ha később az értéke felhasználásra kerül. Izsó Tamás Fordítás Kódoptimalizálás / 2

Aktív változók előállítása A feldolgozás az alapblokk végétől az eleje felé halad. A blokk végén lévő aktív változók halmazát az algoritmus alapján mi határozzuk meg. Amikor az a = b + c 1 kifejezéshez érünk: az a változót ki kell venni; a b és c változókat be kell tenni az az aktív változók halmazába. 1 Összeadás helyett tetszőleges egy és kétoperandusú kifejezés is szerepelhet. Izsó Tamás Fordítás Kódoptimalizálás / 3

Aktív változó v=x+y; c=v+5; v=z+w Izsó Tamás Fordítás Kódoptimalizálás / 4

Aktív változó v=x+y; v változó definiálása c=v+5; v=z+w Izsó Tamás Fordítás Kódoptimalizálás / 4

Aktív változó v=x+y; v változó definiálása v változó használata c=v+5; v=z+w Izsó Tamás Fordítás Kódoptimalizálás / 4

Aktív változó v=x+y; v változó definiálása v változó használata v változó újradefiniálása c=v+5; v=z+w Izsó Tamás Fordítás Kódoptimalizálás / 4

Aktív változó v=x+y; v változó definiálása v változó használata v változó újradefiniálása v változó értéke felesleges c=v+5; v=z+w Izsó Tamás Fordítás Kódoptimalizálás / 4

Aktív változó globális analízise v változó aktív a p pontban start v változó nem aktív a p pontban start v változó aktív a p pontban start v=x+y; p v=x+y; p p a=v+5; v=x+5; v=v+5; end end end Izsó Tamás Fordítás Kódoptimalizálás / 5

Aktív változók előállítása a = b; c = a; d = a + b; e = d; d = a; f = e; Izsó Tamás Fordítás Kódoptimalizálás / 6

Aktív változók előállítása a = b; c = a; d = a + b; e = d; d = a; f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 6

Aktív változók előállítása a = b; c = a; d = a + b; e = d; d = a; { b, d, e} f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 6

Aktív változók előállítása a = b; c = a; d = a + b; e = d; { a, b, e} d = a; { b, d, e} f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 6

Aktív változók előállítása a = b; c = a; d = a + b; { a, b, d } e = d; { a, b, e} d = a; { b, d, e} f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 6

Aktív változók előállítása a = b; c = a; { a, b } d = a + b; { a, b, d } e = d; { a, b, e} d = a; { b, d, e} f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 6

Aktív változók előállítása a = b; { a, b } c = a; { a, b } d = a + b; { a, b, d } e = d; { a, b, e} d = a; { b, d, e} f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 6

Aktív változók előállítása { b } a = b; { a, b } c = a; { a, b } d = a + b; { a, b, d } e = d; { a, b, e} d = a; { b, d, e} f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 6

Felesleges kód törlése { b } a = b; { a, b } c = a; { a, b } d = a + b; { a, b, d } e = d; { a, b, e} d = a; { b, d, e} f = e; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 7

Felesleges kód törlése { b } a = b; { a, b } c = a; { a, b } d = a + b; { a, b, d } e = d; { a, b, e} d = a; { b, d, e} {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 7

Felesleges kód törlése { b } a = b; { a, b } { a, b } d = a + b; { a, b, d } e = d; { a, b, e} d = a; { b, d, e} {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 7

Felesleges kód törlése a = b; d = a + b; e = d; d = a; Izsó Tamás Fordítás Kódoptimalizálás / 7

Aktív változók előállítása II a = b; d = a + b; e = d; d = a; Izsó Tamás Fordítás Kódoptimalizálás / 8

Aktív változók előállítása II a = b; d = a + b; e = d; d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 8

Aktív változók előállítása II a = b; d = a + b; e = d; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 8

Aktív változók előállítása II a = b; d = a + b; {a, b, d } e = d; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 8

Aktív változók előállítása II a = b; {a, b } d = a + b; {a, b, d } e = d; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 8

Aktív változók előállítása II { b } a = b; {a, b } d = a + b; {a, b, d } e = d; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 8

Felesleges kód törlése { b } a = b; {a, b } d = a + b; {a, b, d } e = d; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 9

Felesleges kód törlése { b } a = b; {a, b } d = a + b; {a, b, d } {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 9

Felesleges kód törlése a = b; d = a + b; d = a; Izsó Tamás Fordítás Kódoptimalizálás / 9

Aktív változók előállítása III a = b; d = a + b; d = a; Izsó Tamás Fordítás Kódoptimalizálás / 10

Aktív változók előállítása III a = b; d = a + b; d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 10

Aktív változók előállítása III a = b; d = a + b; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 10

Aktív változók előállítása III a = b; {a, b } d = a + b; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 10

Aktív változók előállítása III { b } a = b; {a, b } d = a + b; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 10

Felesleges kód törlése { b } a = b; {a, b } d = a + b; {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 11

Felesleges kód törlése { b } a = b; {a, b } {a, b } d = a; {b, d } Izsó Tamás Fordítás Kódoptimalizálás / 11

Felesleges kód törlése a = b; d = a; Izsó Tamás Fordítás Kódoptimalizálás / 11

Aktív változók előállításának a formalizálása In n = n Kill n ) Gen n (Out { Out n = BI n az utolsó blokk végén. x succ(n) In x máskülönben. A kimenet van összehuzalozva az n után következő bemenetek uniójával. -ból következik, hogy az inicializálás az üres halmazzal történik, kivéve a kezdő állapotot. Out n alapján számítjuk az In n -t, tehát a számítás visszafele halad. Izsó Tamás Fordítás Kódoptimalizálás / 12

Reaching Definition analízis Az analízis megadja, hogy a program egy adott pontján az x változó hol kapott értéket. Elágazások és ciklusok miatt több ponton is definiálva 2 lehet. RD entry (p) = { RDinit kezdetben. p pred(p) RD exit(p ) máskülönben. RD exit (p) = (RD entry (p)\kill RD (p)) Gen RD (p) 2 Itt a definíciót bővebb értelemben használjuk. Minden pont, ahol egy változó értéket kap definíciós pontnak hívjuk. Izsó Tamás Fordítás Kódoptimalizálás / 13

Reaching Definition jelölések Ha az x változót a p pontban definiálva van, akkor ezt a tényt a (x, p) párral fejezzük ki. Az RD entry (p) és az RD exit (p) ezeknek a pároknak a halmazát tartalmazza. Inicializálás RD init = {(x,?) x programváltozó.} A kérdőjel azt jelenti, hogy még nem lett inicializálva a változó. Izsó Tamás Fordítás Kódoptimalizálás / 14

Példa Reaching Definition-ra [m := 2] 1 ; while [ n > 1] 2 do [m := m n ] 3 ; [ n := n 1] 4 end while [ stop ] 5 RD entry (1) = {(m,?), (n,?)} RD exit (1) = {(m, 1), (n,?)} RD entry (2) = RD exit (1) RD exit (4) Izsó Tamás Fordítás Kódoptimalizálás / 15

RD végeredmény RD entry RD exit 1 {(m,?),(n,?)} {(m,1),(n,?)} 2 {(m,1),(m,3),(n,?),(n,4)} {(m,1),(m,3),(n,?),(n,4)} 3 {(m,1),(m,3),(n,?),(n,4)} {(m,3),(n,?),(n,4)} 4 {(m,3),(n,?),(n,4)} {(m,3),(n,4)} 5 {(m,1),(m,3),(n,?),(n,4)} {(m,1),(m,3),(n,?),(n,4)} Izsó Tamás Fordítás Kódoptimalizálás / 16

Konstans kiértékelés fordítási időben I RD [x := a] l [x := a[y n]] l y FV (a) (y,?) / RD entry (l) ha (y, l ) RD entry (l) y = y [...] l = [y := n] l RD [x := a] l [x := n] l { FV (a) = a nem konstans ha a kifejezés értéke n Izsó Tamás Fordítás Kódoptimalizálás / 17

Konstans kiértékelés fordítási időben II RD S 1 S 1 RD S 1 ; S 2 S 1 ; S 2 RD S 2 S 2 RD S 1 ; S 2 S 1 ; S 2 RD S 1 S 1 RD if[b l ] then S 1 else S 2 if[b l ] then S 1 else S 2 RD S 2 S 2 RD if[b l ] then S 1 else S 2 if[b l ] then S 1 else S 2 RD S S RD while[b l ] do S while[b l ] do S Izsó Tamás Fordítás Kódoptimalizálás / 18

Konstans kiértékelés példa I. Program: [ x :=10] 1 ; [ y := x +10] 2 ; [ z := y +10] 3 ; RD analízis eredménye: RD entry (1) = {(x,?), (y,?), (z,?)} RD exit (1) = {(x, 1), (y,?), (z,?)} RD entry (2) = {(x, 1), (y,?), (z,?)} RD exit (2) = {(x, 1), (y, 2), (z,?)} RD entry (3) = {(x, 1), (y, 2), (z,?)} RD exit (2) = {(x, 1), (y, 2), (z, 3)} Izsó Tamás Fordítás Kódoptimalizálás / 19

Konstans kiértékelés példa II. RD [x := 10] 1 ; [y := x + 10] 2 ; [z := y + 10] 3 ; [x := 10] 1 ; [y := 10 + 10] 2 ; [z := y + 10] 3 ; [x := 10] 1 ; [y := 20] 2 ; [z := y + 10] 3 ; [x := 10] 1 ; [y := 20] 2 ; [z := 20 + 10] 3 ; [x := 10] 1 ; [y := 20] 2 ; [z := 30] 3 ; Izsó Tamás Fordítás Kódoptimalizálás / 20

Konstans kiértékelés példa II. Visual Studio C eredménye 1 int funcion() { 2 int x,y,z; 3 x=1; 4 y=100*x; 5 z=100*y-y; 6 while( x < 4 ) { 7 z = z +y; 8 y = 2*x; 9 x++; 10 } 11 return z; 12 } Lefordított kód: _funcion : 00000000: mov eax,2710h 00000005: r e t Izsó Tamás Fordítás Kódoptimalizálás / 21

Section 1 Vezérlésfolyam analízis Izsó Tamás Fordítás Kódoptimalizálás / 22

Domináns alapblokk A B i alapblokk akkor domináns B j felett, ha az entry pontból a j-edik blokkig minden lehetséges úton eljutva érinteni kell a B i blokkot. Minden blokk domináns önmagával. (a dom b) (b dom c) (a dom c). Közvetlen, vagy szomszédos dominanciáról akkor beszélünk, ha a dom b és a b esetén nem létezik olyan c, hogy (a dom c) (c dom b). Posztdominanciáról akkor beszélünk, ha a B j blokkból az exit, blokk fele haladva minden úton érintjük a B k blokkot. Izsó Tamás Fordítás Kódoptimalizálás / 23

Struktúrális analízis dominancia Entry Entry B1 fib(m) f0=0 B1 B2 f1=1 m<=1 B2 exit B3 return 1 f1=1 B3 B4 B4 m >= 1 B5 B6 B5 return f2 f2=f0+f1 f0=f1 exit B6 f1=f2 m=m-1 Izsó Tamás Fordítás Kódoptimalizálás / 24

Domináns alapblokk m n D(n) az n-re domináns alapblokkok halmaza Pred(n) az irányított vezérlési folyamatgráf alapján az n-be menő élek forrás csomópontjai D(n) = {n} p pred(n) D(p) Izsó Tamás Fordítás Kódoptimalizálás / 25

Dominancia meghatározása procedure Dom_Comp( N, Pred, r ) N : in set of Node; Pred : in Node set of Node; r : in Node; begin D, T : set of Node; n, p : Node; change:=true: boolean; Domin : Node set of Node; for each n N - {r} do Domin(n):=N; repeat change := false; for each n N - {r} do T:=N; for each p Pred(n) do T = Domin(p) ; od; D := { n } T; if D Domin(n) then change := true; Domin(n) := D; fi; od; until!change return Domin Izsó Tamás Fordítás Kódoptimalizálás / 26

Depth-First Search Mélységi keresés A A B F B F C G hátra C G keresztbe D H előre D H Jelölés: PRE: A POST: A E A B C D E E D C B A F G H H G F A A F D E E D F G H H G F A B C C B A E Izsó Tamás Fordítás Kódoptimalizálás / 27

DFS algoritmus N : in set of Node; r, x : Node i:=1, j:=1 : integer; Pre, Post : Node integer; Visit: Node boolean; Etype: (Node x Node ) enum{ tree, forward, back, cross }; procedure Deap_First_Search( N, Succ, x ) N : in set of Node; Succ : in Node set of Node; x : in Node; begin y : Node; Visit(x) := true; Pre(x) := j; j = j + 1; for each y Succ(x) do if!visit(y) then Deep_First_Search(N,Succ,y); EType(x y) := tree; elif Pre(x) < Pre(y) then EType(x y) := forward; elif Post(y) = 0 then EType(x y) := back; else EType(x y) := cross; fi; od; Post(x) := i; i :+= 1; end begin for each x N do; Visit(x) := false; Pre(x) := Post(x) := 0; od Deep_First_Search(N,Succ,r); end Izsó Tamás Fordítás Kódoptimalizálás / 28

Section 2 Kód struktúra visszafejtése Izsó Tamás Fordítás Kódoptimalizálás / 29

CFG struktúrájának az analízis célja felismerni a magasszintű vezérlési szerkezeteket if... then..., if... then... else..., switch... case... for, while, repeat; nem struktúrált részben lévő blokkok számának a minimalizálása. Izsó Tamás Fordítás Kódoptimalizálás / 30

Gráf alapfogalmak B A F G irányított gráf, N csomópontok halmaza, E élek halmaza; G = N, E ; N = {A, B, C, D, E, F, G, H} C D G H E N N = {A B, A F, B C, C B, C D, C E, D E, F D, F G, G H, G H} E Succ(b) = {n N e E hogy e = b n} Pred(b) = {n N e E hogy e = n b} Izsó Tamás Fordítás Kódoptimalizálás / 31

Aciklikus struktúrák B1 B4 B4 B2 B3 B2 B3 B2 B4 B5 if-the-else if-then B6 B7 B1 blokk B2 B3 B4 B5 B6 case-switch Izsó Tamás Fordítás Kódoptimalizálás / 32

Ciklikus struktúrák B1 B0 B2 self-loop while-loop B1 B1 B2 B2 B3 természetes loop (improper) nem struktúrált szerkezet Izsó Tamás Fordítás Kódoptimalizálás / 33

Struktúra meghatározása Globális adatok: Succ, Pred : Node set of Node; RegionType = enum { Block, IfThen, IfThenElse, Case, Proper, SelfLoop, WhileLoop, NaturalLoop, Improper } ; // Blokk hozzárendelése az őt tartalmazó összevont struktúrához StructOf: Node Node; // Összevont struktúra típusa (pl. if-then) StructType: Node RegionType; // Összevont struktúrák halmaza Structures: set of Node; // Összevont struktúra alá tartozó blokkok StructNodes : Node set of Node; // Összevont struktúra hierarchiája CTNodes: set of Node; CTEdges : set of Node x Node; PostCtr, PostMax:integer; Post: integer Node; Visit: Node boolean; Izsó Tamás Fordítás Kódoptimalizálás / 34

Ciklus keresés n vissza k m Izsó Tamás Fordítás Kódoptimalizálás / 35

Ciklus keresés n vissza n pont a ciklus kezdete; k m Izsó Tamás Fordítás Kódoptimalizálás / 35

Ciklus keresés n k vissza n pont a ciklus kezdete; k N pont, ahol Pred(n) = k; m Izsó Tamás Fordítás Kódoptimalizálás / 35

Ciklus keresés n k vissza m n pont a ciklus kezdete; k N pont, ahol Pred(n) = k; olyan m pont, hogy n-ből m-be és m-ből k-ba van út. Izsó Tamás Fordítás Kódoptimalizálás / 35

Strukturális analízis Procedure StructuralAnalysis(N, E, entry) N : in set of Node; E: in set of (Node x Node); entry: in Node; begin m, n, p : Node; rtype : RegionType; NodeSet, ReachUnder: set of Node; StuctOf := StructType := ; Stuctures := StructNodes := ; CTNodes := N; CTEdges := ; repeat Post := ; Visit := PostMax := 0; PostCtr := 1 DFS_Postorder(N, E, entry ); while N > 1 PostCtr PostMax do n := Post(PostCtr) ; rtype :=AcyclicRType(N,E,rtype,NodeSet); if rtype nil then p:= Reduce(N,E,rtype,NodeSet) ; if entry NodeSet then entry := p; fi; else ReachUnder := {n}; for each n N do // k amely vissza élen eljut n-be és, // m pont, amihez van n m, // és m k-ba él. if PathBack(m,n) then ReachUnder = {m}; fi; od; rtype :=CyclicRType(N,E,rtype, ReachUnder); if rtype nil then p:= Reduce(N,E,rtype,ReachUnder) ; if entry ReachUnder then entry := p; fi else PostCtr += 1; fi fi od; until N = 1; end Izsó Tamás Fordítás Kódoptimalizálás / 36

Blokkok DFS bejárása Procedure DFS_Postorder(N, E, x) N : in set of Node; E: in set of (Node x Node); x: in Node; begin y : Node; Visit(x):=true; for each y Succ(x) do if!visit(y) then DFS_Postorder(N,E,y); if; od; PostMax+= 1; Post(PostMax) := x; end Izsó Tamás Fordítás Kódoptimalizálás / 37

Aciklikus struktúrák feltérképezése Procedure AcyclicRType(N,E,node,nset) : RegionType N : in set of Node; E: in set of (Node x Node); node: inout Node; nset: out set of Node; begin m, n : Node; p, s: boolean; nset := ; n := node; p := true; s := Succ(n) = 1; while p s do nset = {n}; n := Succ(n); p := Pred(n) = 1; s := Succ(n) = 1; od; if p then nset = {n}; fi n := node; p := Pred(n) = 1; s:=true; while p s do nset = {n}; n := Pred(n); p := Pred(n) = 1; s := Succ(n) = 1; od if s then nset = {n}; fi node := n; if nset 2 then return Block; elif Succ(node) = 2 then m := Succ(node); n:= (Succ(node)-{m}); if Succ(m) = Succ(n) Succ(m) = 1 Succ(n) = 1 Pred(m) = 1 Pred(n) = 1 then nset := {node, m, n}; return IfThenElse; elif...... else return nil; fi; fi; end Izsó Tamás Fordítás Kódoptimalizálás / 38

Ciklikus struktúrák feltérképezése Procedure CyclicRType(N,E,node,nset) : RegionType N : in set of Node; E: in set of (Node x Node); node: in Node; nset: inout set of Node; begin m : Node; if nset = 1 then if node node E then return SelfLoop; else return nil; fi; fi; if m nset!path(node,m,n) then nset := MinimizeImproper(N,E,node,nset); return Improper; fi m := (nset - { node }); if Succ(node) = 2 Succ(m) = 1 Pred(node) = 2 Pred(m) = 1 then return WhileLoop; else return NaturalLoop; fi; end Izsó Tamás Fordítás Kódoptimalizálás / 39

Redukció Entry Entrya Entryb B1 B2 B2a Entryb B3 B3 B3 Entryc B4 B5 B4 B5a B4 B5b B3a B6 exit B7 B7 exit exit exit Izsó Tamás Fordítás Kódoptimalizálás / 40

Improper struktúrák kezelése Fubo Zhang és Erik H. D Hollander bebizonyították, hogy az általuk definiált három elemi programtranszformációs lépés Forward Copy, Backward Copy, Cut segítségével minden nem strukturált programrész strukturált formává alakítható. Módszerüket magasszintű blokk strukturált programozási nyelvre alkalmazták. Haicheng Wu és társai kisebb átalakításokkal a módszert assembly szintű programra is alkalmazhatóvá tették. Cikkek: Fubo Zhang and Erik H. D Hollander. Using hammock graphs to structure programs. IEEE Trans. Software Eng., 30(4):231-245, 2004. Haicheng Wu, Gregory Diamos, Jin Wang, Si Li, and Sudhakar Yalamanchili. Characterization and transformation of unstructured control flow in bulk synchronous gpu applications. Int. J. High Perform. Comput. Appl., 26(2):170-185, May 2012. Izsó Tamás Fordítás Kódoptimalizálás / 41

Forward Copy A következő ábrán a {B1, B2} és a {B3, B4} blokkok IfThen szerkezetet alkotnának, ha az E1 és E2 szaggatott élek nem szerepelnének. Forward Copy transzformáció: 1 Forward copy transzformáció során az IfThen szerkezetet alkotó {B1, B2} részgráf közös pontja B3 és az E2 él között található gráfot le kell másolni. 2 A (B2, B3) él végpontját a megismételt struktúra B 3 pontjára állítani. Az így kapott jobb oldali ábra {B3, B4} szerkezetére a forward copy transzformációt megismételve a gráf reducibilissé válik. Izsó Tamás Fordítás Kódoptimalizálás / 42

Forward Copy transzformáció Entry Entry B1 B1 B2 B2 B3 B3 B'3 B4 B4 B'4 B5 E1 E2 B5 E1 E2 B'5 E'1 Exit Exit Izsó Tamás Fordítás Kódoptimalizálás / 43

Backward Copy A következő ábrán található ciklus improper, mivel a belsejébe a B1 blokkokból az E1 élen keresztül be tudunk ugrani. Backward Copy transzformáció: 1 A ciklust alkotó blokkokat meg kell ismételni (backward copy). Ezzel megszüntethetjük a ciklus belsejébe történő ugrást. 2 A C1 élet a megismételt ciklusra kell állítani. A struktúra továbbra is irreducibilis maradt, mivel a {B1, B2, B3} IfThen szerkezetnek két kilépési pontja van, de ezt már az előbb ismertetett forward copy transzformációval megszüntethetjük. Izsó Tamás Fordítás Kódoptimalizálás / 44

Backward Copy transzformáció Entry Entry B1 B1 B2 B2 B'2 B3 E1 B3 E1 B'3 C1 B4 B4 B'4 C'1 B5 B5 C1 B'5 Exit Exit Izsó Tamás Fordítás Kódoptimalizálás / 45

Cut A következő ábrán a ciklus belsejéből az E1 és az E2 éleken keresztül is kiléphetünk, tehát ciklust több kilépési ponttal is rendelkezik. 1 Ciklus végét és a kilépés okát tartalmazó változók bevezetése. 2 "compare cycle" blokk bevezetése. A ciklus szervezését erre kell építeni. 3 "compare from" blokk bevezetése. Kilépés okának megfelelő folytatás elkészítése. Izsó Tamás Fordítás Kódoptimalizálás / 46

Cut transzformáció Entry Entry B1 B1 B2 B2 B3 cycle==true B3 E1 cycle==true B5 E1 B4 B5 B4 cycle:=true from:=b5 cycle:=false from:=b5 cycle:=false from:=b4 cycle==false B6 E2 cycle==false compare cycle Exit from==b4 compare from from==b5 B6 Exit Izsó Tamás Fordítás Kódoptimalizálás / 47

Gondolatok a strukturált programozásról improper keresztél irreducibilis nem struktúrált Dahl Dijkstra Hoare, Strukturált programozás 7. fejezet, A programok megértéséről www.hit.bme.hu/~izso/struct_prog.pdf Donald E. Knuth, Stuctured Programming with goto Statesments Linux: Using goto In Kernel Code C-ben a break, continue valóban megsérti a strukturált programozás elvét, avagy irreducibilis lesz a CFG (vezérlésfolyan gráf)? Izsó Tamás Fordítás Kódoptimalizálás / 48

Regiszter hozzárendelés Intel x86 processzor utasításkészlete kevés regisztert tartalmaz; néhány regiszter használata korlátozott; a gyors futás érdekében az adatokat érdemes a regiszterben tartani; ha nincs elég regiszter, ki kell menteni a memóriába; minimalizálni kell az egyidejűleg használt regiszterek számát; általában színezési problémára vezethető vissza. Izsó Tamás Fordítás Kódoptimalizálás / 49

Regiszter hozzárendelés s1 s2 s3 s4 s5 s6 s1 = 2 s2 = 4 s3 = s1 + s2 s4 = s3 + 1 s5 = s1 * s2 s6 = s4 * s5 Izsó Tamás Fordítás Kódoptimalizálás / 50

Regiszter hozzárendelés s1 s2 s3 s4 s5 s6 s1 = 2 s2 = 4 s1 s3 s6 s3 = s1 + s2 s4 = s3 + 1 s5 = s1 * s2 s2 s4 s5 s6 = s4 * s5 Izsó Tamás Fordítás Kódoptimalizálás / 50

Egyéb optimalizálási eljárások aritmetikai egyszerűsítés: x = 4 * a; x = a «2; konstans kifejezés kiértékelése: 4 * 1024 4096 Izsó Tamás Fordítás Kódoptimalizálás / 51

Optimalizált kód visszafejthetősége megjegyzések elvesznek; szimbólikus nevek elvesznek; adattípusok elvesznek; ciklus átrendezés, és kifejtés (unrolling); különböző lokális változók azonos regiszterekben cserélik egymást ; algebrai átírás; kódmozgás; Izsó Tamás Fordítás Kódoptimalizálás / 52