Fordítás – Kódoptimalizálásizso/rec/ea05.pdf · |Vezérlésfolyam analízisKód struktúra visszafejtése Aktív változók Angol irodalomban a Live Variables kifejezést használják,

| Vezérlésfolyam analízis Kód struktúra visszafejtése

Fordítás – KódoptimalizálásKó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-nekhívják.Az aktív változók ismeretében lehet a feleslegesutasításokat megszüntetni.Egy változó a program egy pontján aktív, ha késobb azértéke felhasználásra kerül.



Aktív változók eloállítása

A feldolgozás az alapblokk végétol az eleje felé halad.A blokk végén lévo aktív változók halmazát az algoritmusalapján mi határozzuk meg.Amikor az a = b + c1 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ókhalmazába.

1Összeadás helyett tetszoleges egy és kétoperandusú kifejezés isszerepelhet.



Aktív változó

v változó definiálásav változó használatav változó újradefiniálásav változó értéke felesleges

v=x+y;

c=v+5;

v=z+w



Aktív változó

v változó definiálása

v változó használatav változó újradefiniálásav változó értéke felesleges

v=x+y;

c=v+5;

v=z+w



Aktív változó

v változó definiálásav változó használata

v változó újradefiniálásav változó értéke felesleges

v=x+y;

c=v+5;

v=z+w



Aktív változó

v változó definiálásav változó használatav változó újradefiniálása

v változó értéke felesleges

v=x+y;

c=v+5;

v=z+w



Aktív változó

v változó definiálásav változó használatav változó újradefiniálásav változó értéke felesleges

v=x+y;

c=v+5;

v=z+w



Aktív változó globális analízise

start

p

v=x+y;

a=v+5;

end

v változó aktíva p pontban

start

p

v=x+y;

v=x+5;

end

v változó nem aktíva p pontban

start

p

v=v+5;

end

v változó aktíva p pontban




a = b;

c = a;

d = a + b;

e = d;

d = a;

f = e;




a = b;

c = a;

d = a + b;

e = d;

d = a;

f = e;{b , d }




a = b;

c = a;

d = a + b;

e = d;

d = a;{ b, d, e}

f = e;{b , d }




a = b;

c = a;

d = a + b;

e = d;{ a, b, e}

d = a;{ b, d, e}

f = e;{b , d }




a = b;

c = a;

d = a + b;{ a, b, d }

e = d;{ a, b, e}

d = a;{ b, d, e}

f = e;{b , d }




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 }




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 }




{ 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 }



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 }




{ 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 }




{ 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 }




{ 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 }




{ 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 }




a = b;

d = a + b;

e = d;

d = a;



Aktív változók eloállítása II

a = b;

d = a + b;

e = d;

d = a;




a = b;

d = a + b;

e = d;

d = a;

{b , d }




a = b;

d = a + b;

e = d;{a , b }d = a;

{b , d }




a = b;

d = a + b;{a , b, d }

e = d;{a , b }d = a;

{b , d }




a = b;

{a , b }d = a + b;{a , b, d }

e = d;{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }d = a + b;{a , b, d }

e = d;{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }d = a + b;{a , b, d }

e = d;{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }d = a + b;{a , b, d }

e = d;{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }d = a + b;{a , b, d }

{a , b }d = a;

{b , d }




a = b;

d = a + b;

d = a;



Aktív változók eloállítása III

a = b;

d = a + b;

d = a;




a = b;

d = a + b;

d = a;

{b , d }




a = b;

d = a + b;

{a , b }d = a;

{b , d }




a = b;

{a , b }d = a + b;

{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }d = a + b;

{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }d = a + b;

{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }d = a + b;

{a , b }d = a;

{b , d }




{ b }a = b;

{a , b }

{a , b }d = a;

{b , d }




a = b;

d = a;



Aktív változók eloállításának a formalizálása

Inn = (Outn − Killn) ∪Genn

Outn =

{BI n az utolsó blokk végén .

∪x∈succ(n)Inx máskülönben.

A kimenet van összehuzalozva az n után következobemenetek uniójával.∪-ból következik, hogy az inicializálás az üres halmazzaltörténik, kivéve a kezdo állapotot.Outn alapján számítjuk az Inn-t, tehát a számítás visszafelehalad.



Reaching Definition analízis

Az analízis megadja, hogy a program egy adott pontján az xváltozó hol kapott értéket. Elágazások és ciklusok miatt többponton is definiálva2 lehet.

RDentry(p) =

{RDinit kezdetben .

∪p′∈pred(p) RDexit(p′) máskülönben.

RDexit(p) = (RDentry(p)\KillRD(p)) ∪GenRD(p)

2Itt a definíciót bovebb értelemben használjuk. Minden pont, ahol egyváltozó értéket kap definíciós pontnak hívjuk.



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 RDentry(p) és az RDexit(p) ezekneka pároknak a halmazát tartalmazza.

Inicializálás

RDinit = {(x , ?)|x ∈ programváltozó.}

A kérdojel azt jelenti, hogy még nem lett inicializálva a változó.



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

RDentry(1) = {(m, ?), (n, ?)}RDexit(1) = {(m,1), (n, ?)}

RDentry(2) = RDexit(1) ∪ RDexit(4)



RD végeredmény

RDentry RDexit1 {(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)}



Konstans kiértékelés fordítási idoben I

RD ` [x := a]` B [x := a[y 7→ n]]`

ha

y ∈ FV (a) ∧ (y , ?) /∈ RDentry(`) ∧∀(y ′

, `′) ∈ RDentry(`) ∧

y′= y ⇒ [. . .]`

′= [y := n]`

′

RD ` [x := a]` B [x := n]`

ha

{FV (a) = ∅ ∧ a nem konstans ∧a kifejezés értéke n



Konstans kiértékelés fordítási idoben II

RD ` S1 B S′

1

RD ` S1;S2 B S′1;S2

RD ` S2 B S′

2

RD ` S1;S2 B S1;S′2

RD ` S1 B S′

1

RD ` if[b`] then S1 else S2 B if[b`] then S′1 else S2

RD ` S2 B S′

2

RD ` if[b`] then S1 else S2 B if[b`] then S1 else S′2

RD ` S B S′

RD ` while[b`] do S Bwhile[b`] do S′



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:

RDentry(1) = {(x , ?), (y , ?), (z, ?)}RDexit(1) = {(x ,1), (y , ?), (z, ?)}

RDentry(2) = {(x ,1), (y , ?), (z, ?)}RDexit(2) = {(x ,1), (y ,2), (z, ?)}

RDentry(3) = {(x ,1), (y ,2), (z, ?)}RDexit(2) = {(x ,1), (y ,2), (z,3)}



Konstans kiértékelés példa II.

RD ` [x := 10]1; [y := x + 10]2; [z := y + 10]3;

B [x := 10]1; [y := 10 + 10]2; [z := y + 10]3;

B [x := 10]1; [y := 20]2; [z := y + 10]3;

B [x := 10]1; [y := 20]2; [z := 20 + 10]3;

B [x := 10]1; [y := 20]2; [z := 30]3;



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:_func ion :

00000000: mov eax ,2710h00000005: r e t



Section 1

Vezérlésfolyam analízis



Domináns alapblokk

A Bi alapblokk akkor domináns Bj felett, ha az entrypontból a j-edik blokkig minden lehetséges úton eljutvaérinteni kell a Bi blokkot.Minden blokk domináns önmagával.(a dom b) ∧ (b dom c)→ (a dom c).Közvetlen, vagy szomszédos dominanciáról akkorbeszélünk, ha a dom b és a 6= b esetén nem létezik olyanc, hogy (a dom c) ∧ (c dom b).Posztdominanciáról akkor beszélünk, ha a Bj blokkból azexit, blokk fele haladva minden úton érintjük a Bk blokkot.



Struktúrális analízis – dominancia

fib(m)

f1=1

f0=0

m<=1

return f2

f1=1

m >= 1

f2=f0+f1

f0=f1

f1=f2

m=m-1

return 1

Entry

exit

B1

B2

B3

B4

B5

B6

Entry

B1

B2 exit B3

B4

B5 B6



Domináns alapblokk

m

n

D(n) az n-re domináns alapblokkokhalmazaPred(n) az irányított vezérlésifolyamatgráf alapján az n-be meno élekforrás csomópontjai

D(n) = {n} ∪⋂

p∈pred(n)

D(p)



Dominancia meghatározása

procedure Dom_Comp( N, Pred, r )N : in set of Node;Pred : in Node→ set of Node;r : in Node;

beginD, 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 6= Domin(n) then

change := true;Domin(n) := D;

fi;od;

until !changereturn Domin



Depth-First Search

Mélységi keresés

A

B

C

D

E

F

G

H

A

B

C

D

E

F

G

H

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

előre

hátra

keresztbe

Jelölés:PRE: APOST: A



DFS algoritmusN : in set of Node;r, x : Nodei:=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;

beginy : Node;Visit(x) := true;Pre(x) := j;j = j + 1;

for each y ∈ Succ(x) doif !Visit(y) then

Deep_First_Search(N,Succ,y);EType(x→ y) := tree;

elif Pre(x) < Pre(y) thenEType(x→ y) := forward;

elif Post(y) = 0 thenEType(x→ y) := back;

elseEType(x→ y) := cross;

fi;od;Post(x) := i; i :+= 1;

end

beginfor each x ∈ N do;

Visit(x) := false;Pre(x) := Post(x) := 0;

odDeep_First_Search(N,Succ,r);

end



Section 2

Kód struktúra visszafejtése



CFG struktúrájának az analízis

célja felismerni a magasszintu vezérlési szerkezeteketif ... then ..., if ... then ... else ..., switch ... case ...for, while, repeat;

nem struktúrált részben lévo blokkok számának aminimalizálása.



Gráf alapfogalmak

A

B

C

D

E

F

G

H

G – irányított gráf, N –csomópontok halmaza, E – élekhalmaza;G = 〈N,E〉 ;N = {A,B,C,D,E ,F ,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}Succ(b) = {n ∈ N|∃e ∈ E hogye = b → n}Pred(b) = {n ∈ N|∃e ∈ E hogye = n→ b}



Aciklikus struktúrák

B1

B3

B2B3

B4

B5

B6

B7

B2

B4

B2

B4

B1

B2 B3 B4 B5 B6blokk

if-the-else if-then

case-switch



Ciklikus struktúrák

B1

B0

self-loop

B2

while-loop

B1

B2

természetes loop

B1

B2

(improper) nem struktúrált szerkezet

B3



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 ot tartalmazó összevont struktúráhozStructOf: Node→ Node;// Összevont struktúra típusa (pl. if-then)StructType: Node→ RegionType;// Összevont struktúrák halmazaStructures: set of Node;// Összevont struktúra alá tartozó blokkokStructNodes : Node→ set of Node;// Összevont struktúra hierarchiájaCTNodes: set of Node;CTEdges : set of Node x Node;PostCtr, PostMax:integer;Post: integer→ Node;Visit: Node→ boolean;



Ciklus keresés

k

n

m

vissza

n pont a ciklus kezdete;∃k ∈ N pont, ahol

Pred(n) = k ;∃ olyan m pont, hogy n-bolm-be és m-bol k -ba van út.



Ciklus keresés

k

n

m

vissza n pont a ciklus kezdete;

∃k ∈ N pont, aholPred(n) = k ;∃ olyan m pont, hogy n-bolm-be és m-bol k -ba van út.



Ciklus keresés

k

n

m

vissza n pont a ciklus kezdete;∃k ∈ N pont, ahol

Pred(n) = k ;

∃ olyan m pont, hogy n-bolm-be és m-bol k -ba van út.



Ciklus keresés

k

n

m

vissza n pont a ciklus kezdete;∃k ∈ N pont, ahol

Pred(n) = k ;∃ olyan m pont, hogy n-bolm-be és m-bol k -ba van út.



Strukturális analízis

Procedure StructuralAnalysis(N, E, entry)N : in set of Node;E: in set of (Node x Node);entry: in Node;

beginm, n, p : Node;rtype : RegionType;NodeSet, ReachUnder: set of Node;StuctOf := StructType := ∅;Stuctures := StructNodes := ∅;CTNodes := N; CTEdges := ∅;repeat

Post := ∅; Visit := ∅PostMax := 0; PostCtr := 1DFS_Postorder(N, E, entry );while |N| > 1∧ PostCtr ≤ PostMax do

n := Post(PostCtr) ;rtype :=AcyclicRType(N,E,rtype,NodeSet);if rtype 6= 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 6= nil then

p:= Reduce(N,E,rtype,ReachUnder) ;if entry ∈ ReachUnder then

entry := p;fi

elsePostCtr += 1;

fifiod;

until |N| = 1;end



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;

beginy : Node;Visit(x):=true;for each y ∈ Succ(x) do

if !Visit(y) thenDFS_Postorder(N,E,y);

if;od;PostMax+= 1;Post(PostMax) := x;

end



Aciklikus struktúrák feltérképezése

Procedure AcyclicRType(N,E,node,nset) : RegionTypeN : in set of Node;E: in set of (Node x Node);node: inout Node;nset: out set of Node;

beginm, 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};fin := 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 thennset ∪ = {n};

finode := 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| thennset := {node,m,n};return IfThenElse;

elif . . .. . .

elsereturn nil;

fi;fi;

end



Ciklikus struktúrák feltérképezése

Procedure CyclicRType(N,E,node,nset) : RegionTypeN : in set of Node;E: in set of (Node x Node);node: in Node;nset: inout set of Node;

beginm : Node;if |nset | = 1 then

if node→ node ∈ E thenreturn SelfLoop;

elsereturn 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| thenreturn WhileLoop;

elsereturn NaturalLoop;

fi;end



Redukció

B1

Entry

B2

exit

B3

B4 B5

B6

B7

Entrya

B2a

exit

B3

B4 B5a

B7

Entryb

exit

B3

B4 B5b

Entryb

exit

B3a

Entryc



Improper struktúrák kezelése

Fubo Zhang és Erik H. D’Hollander bebizonyították, hogy az általuk definiálthá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 magasszintu blokk strukturált programozási nyelvre alkalmazták.

Haicheng Wu és társai kisebb átalakításokkal a módszert assembly szintuprogramra is alkalmazhatóvá tették.

Cikkek:Fubo Zhang and Erik H. D’Hollander. Using hammock graphs to structureprograms. 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 bulksynchronous gpu applications. Int. J. High Perform. Comput. Appl.,26(2):170-185, May 2012.



Forward CopyA következo ábrán a {B1,B2} és a {B3,B4} blokkok IfThenszerkezetet alkotnának, ha az E1 és E2 szaggatott élek nemszerepelné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ötttalá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 forwardcopy transzformációt megismételve a gráf reducibilissé válik.



Forward Copy transzformáció

E'1E2E1E2E1

B'3

B'4

B'5

Exit

Entry

B4

B5

B3

B2

B1

Exit

Entry

B4

B5

B3

B2

B1



Backward CopyA következo ábrán található ciklus improper, mivel a belsejébe aB1 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éno 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 elobbismertetett forward copy transzformációval megszüntethetjük.



Backward Copy transzformáció

C'1

C1

C1

B'2B2

E1

Exit

Entry

B4

B5

B3

B1

B'5

B'3

B'4

B2

E1

Exit

Entry

B4

B5

B3

B1



CutA következo ábrán a ciklus belsejébol az E1 és az E2 élekenkeresztül is kiléphetünk, tehát ciklust több kilépési ponttal isrendelkezik.

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 megfelelo

folytatás elkészítése.



Cut transzformáció

from==B5

from==B4 B6

compare from

B6 cycle==false

cycle:=falsefrom:=B5

cycle:=truefrom:=B5

B5

cycle==true

cycle:=falsefrom:=b4

cycle==false

E2

B2

E1

Exit

Entry

B4

compare cycle

B3

B1

cycle==true

B2

E1

Exit

Entry

B4B5

B3

B1



Gondolatok a strukturált programozásról

improper — keresztél — irreducibilis — nem struktúráltDahl – Dijkstra – Hoare , Strukturált programozás 7.fejezet, A programok megértésérolwww.hit.bme.hu/~izso/struct_prog.pdf

Donald E. Knuth, Stuctured Programming with gotoStatesmentsLinux: Using goto In Kernel CodeC-ben a break, continue valóban megsérti a strukturáltprogramozás elvét, avagy irreducibilis lesz a CFG(vezérlésfolyan gráf) ?


www.hit.bme.hu/~izso/struct_prog.pdf


Regiszter hozzárendelés

Intel x86 processzor utasításkészlete kevés regiszterttartalmaz;néhány regiszter használata korlátozott;a gyors futás érdekében az adatokat érdemes aregiszterben tartani;ha nincs elég regiszter, ki kell menteni a memóriába;minimalizálni kell az egyidejuleg használt regiszterekszámát;általában színezési problémára vezetheto vissza.




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6

s1

s2

s3

s4

s6

s5




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6

s1

s2

s3

s4

s6

s5




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6

s1

s2

s3

s4

s6

s5




s1 = 2

s2 = 4

s3 = s1 + s2

s4 = s3 + 1

s5 = s1 * s2

s6 = s4 * s5

s1 s2 s3 s4 s5 s6

s1

s2

s3

s4

s6

s5



Egyéb optimalizálási eljárások

aritmetikai egyszerusítés: x = 4 * a;→ x = a « 2;konstans kifejezés kiértékelése: 4 * 1024→ 4096



Optimalizált kód visszafejthetosége

megjegyzések elvesznek;szimbólikus nevek elvesznek;adattípusok elvesznek;ciklus átrendezés, és kifejtés (unrolling);különbözo lokális változók azonos regiszterekben cserélikegymást ;algebrai átírás;kódmozgás;


Documents

Fordítás – Kódoptimalizálásizso/rec/ea05.pdf · |Vezérlésfolyam analízisKód struktúra visszafejtése Aktív változók Angol irodalomban a Live Variables kifejezést használják,