ca5-1
Les 5: controletransfer-
instructies en optimalisatie
Software gets slower faster than hardware gets faster(Niklaus Wirth)
ca5-2
Controletransferinstructies
i1i2i3i4i5i6i7i8i9
i10
Instructies die een nieuwe waarde toekennen aan de instructiewijzer
ca5-3
Overzicht• Sprongen
• Lussen
• Procedure-oproep en -terugkeer
• Onderbrekingen
• Instructiecodering
• Compilers, linkers, en laders
• Codeoptimalisatie
ca5-4
Sprongen
• Onvoorwaardelijke sprongen
• Voorwaardelijke sprongen
• Berekende sprongen
ca5-5
Onvoorwaardelijke sprongen
i1jmp 30
i3i4i5i6i7i8
jmp 26i10
jmp adresjmp adres
10141822263034384246
reg[eip] = adres
Sprong: onvoorwaardelijkeInstructie: jmp
ca5-6
Voorwaardelijke sprongen
i1jle 30
i3i4
jmp 38i6i7i8i9
i10
i1jle 30
i1jle 30
i3i4
jmp 38
i3i4
jmp 38
i6i7i6i7
i8i9
i10
i8i9
i10Basis-
blokkenBasis-
blokken
10141822263034384246
Sprong: voorwaardelijke
ca5-7
Sprongcondities (1)instructie sprongjz jump if zero
jc jump if carry
jo jump if overflow
jp jump if parity
js jump if sign
jnz jump if not zero
jnc jump if not carry
jno jump if not overflow
jnp jump if not parity
jns jump if not sign
Sprong: condities
ca5-8
Sprongcondities (2)instructie sprong
jg jnle jump if greater
jge jnl jump if greater or equal
jl jnge jump if less
jle jng jump if less or equal
je jump if equal
jne jump if not equal
ja jnbe jump if above
jae jnb jump if above or equal
jb jnae jump if below
jbe jna jump if below or equal
bina
ir2-
com
plem
ent
ca5-9
Statisch vs. berekend adres
jmp 100jmp 100
mov ebx,100
jmp ebx
mov ebx,100
jmp ebx
reg[eip] = 100 reg[eip] = reg[ebx]
Sprong: berekende
ca5-10
switch (a) { case 0: b += 3; break; case 2: b -= 4; break; case 3: b -= 3; break; default: b += 7;}
Switch: implementatie 1
if (a == 0) b += 3;else if (a == 2) b -= 4; else if (a == 3) b -= 3; else b += 7;
mov ebx,a mov edx,b cmp ebx,0 jne $23 add edx,3 jmp $20$23: cmp ebx,2 jne $24 sub edx,4 jmp $20$24: cmp ebx,3 jne $25 sub edx,3 jmp $20$25: add edx,7$20: mov b, edx
mov ebx,a mov edx,b cmp ebx,0 jne $23 add edx,3 jmp $20$23: cmp ebx,2 jne $24 sub edx,4 jmp $20$24: cmp ebx,3 jne $25 sub edx,3 jmp $20$25: add edx,7$20: mov b, edx
ca5-11
Switch: implementatie 1
$20: mov b, edx$20: mov b, edx
mov ebx,amov edx,bcmp ebx,0jne $23
mov ebx,amov edx,bcmp ebx,0jne $23
$23: cmp ebx,2 jne $24
$23: cmp ebx,2 jne $24
sub edx,4jmp $20
sub edx,4jmp $20
$24: cmp ebx,3 jne $25
$24: cmp ebx,3 jne $25
sub edx,3jmp $20
sub edx,3jmp $20
$25: add edx,7$25: add edx,7
add edx,3jmp $20
add edx,3jmp $20
ca5-12
mov ebx,a mov edx,b
cmp ebx,0jl $25cmp ebx,3jg $25mov eax,[tabel+ebx*4]jmp eax
$22: add edx,3jmp $20
$23: sub edx,4jmp $20
$24: sub edx,3jmp $20
$25: add edx,7$20: mov b, edx
mov ebx,a mov edx,b
cmp ebx,0jl $25cmp ebx,3jg $25mov eax,[tabel+ebx*4]jmp eax
$22: add edx,3jmp $20
$23: sub edx,4jmp $20
$24: sub edx,3jmp $20
$25: add edx,7$20: mov b, edx
tabel: .long $22.long $25.long $23.long $24
if (a < 0) b += 7;else if (a > 3) b += 7;else switch (a) { case 0: b += 3; break; case 1: b += 7; break; case 2: b -= 4; break; case 3: b -= 3; break; }
Switch: implementatie 2
ca5-13
$25: add edx,7
Switch: implementatie 2mov ebx,amov edx,bcmp ebx,0jl $25
cmp ebx,3jg $25
mov eax,[tabel+ebx*4]jmp eax
$22: add edx,3 jmp $20
$23: sub edx,4 jmp $20
$24: sub edx,3 jmp $20
$20: mov b, edx
ca5-14
mov ebx,a mov edx,b
cmp ebx,0jl $25cmp ebx,3jg $25add edx,[tabel+ebx*4]jmp $20
$25: add edx,7$20: mov b, edx
mov ebx,a mov edx,b
cmp ebx,0jl $25cmp ebx,3jg $25add edx,[tabel+ebx*4]jmp $20
$25: add edx,7$20: mov b, edx tabel: .long 3
.long 7
.long -4
.long -3
int tabel[4] = {3,7,-4,-3};
if (a < 0) b += 7;else if (a > 3) b += 7;else b += tabel[a];
Switch: implementatie 3
ca5-15
$25: add edx,7
Switch: implementatie 3
mov ebx,amov edx,bcmp ebx,0jl $25
cmp ebx,3jg $25
add edx,[tabel+ebx*4]jmp $20
$20: mov b, edx
ca5-16
Absoluut vs. Relatief adres
• Absoluutspring naar adres n
• Relatiefspring n bytes verder/terug
i1jmp 30
i3i4i5i6i7i8
jmp eip-20i10
10141822263034384246
reg[eip] = reg[eip] + n
ca5-17
Positie-onafhankelijke code
i1jmp 30
i3i4i5i6i7i8
jmp eip-20i10
10141822263034384246
i1jmp 30
i3i4i5i6i7i8
jmp eip-20i10
101418222630343842465054
38
ca5-18
Overzicht
• Sprongen• Lussen • Procedure-oproep en -terugkeer• Onderbrekingen• Instructiecodering• Compilers, linkers, en laders• Codeoptimalisatie
ca5-19
Lusinstructie
i1i2
mov ecx,5 i4i5i6i7i8
loop 22i10
10141822263034384246
loop adresloop adres
Decrementeer reg[ecx]
Spring naar adres indien reg[ecx] != 0
lus
Instructie: loop
ca5-20
Geprogrammeerde lus
i1i2
mov ecx,5 i4i5i6i7i8
sub ecx,1jnz 22
10141822263034384246
lus
ca5-21
lusimplementaties
jmp
cmpjnz
cmpjnz
cmpjz
jmp
jmpcmp
jz
jmp
while/forwhile/for do-while do-while
n
n-1
1
n-1
1
1
n-11
ca5-22
Overzicht• Sprongen
• Lussen
• Procedure-oproep en –terugkeer
• Onderbrekingen
• Instructiecodering
• Compilers, linkers, en laders
• Codeoptimalisatie
ca5-23
Functieoproep
i1i2
call 34i4i5i6i7i8i9
i10ret
1014182226303438424650
call adrescall adres
retret
reg[esp] = reg[esp]-4mem[reg[esp]] = reg[eip] reg[eip] = adres
reg[eip] = mem[reg[esp]];reg[esp] = reg[esp] + 4
ca5-24
Controleverloopgraaf van functie-oproep
i1i2
call 34i4i5i6i7i8i9
i10ret
1014182226303438424650
i1i2
call 34
i1i2
call 34 i7i8i9
i10ret
i7i8i9
i10ret
i4i5i6
i4i5i6
ca5-25
Functie-oproep
i1i2
call r,34i4i5i6i7i8i9
i10jmp r
1014182226303438424650
call r,adrescall r,adres
jmp rjmp r
reg[r] = reg[eip] reg[eip] = adres
reg[eip] = reg[r]
bal r, adresbal r, adres
Instructie: call
Instructie: retInstructie: bal
ca5-26
int vijfvoud(int n) { if (n > 0) return n * 5; else return 0; } int g; main() { g = vijfvoud(6); }
int vijfvoud(int n) { if (n > 0) return n * 5; else return 0; } int g; main() { g = vijfvoud(6); }
Functie-oproep en -terugkeer
ca5-27
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
????????eax
????????ebx
????????edx
00000108esp
????????
????????
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000315eip
s=? z=?
cont
role
stap
el
ca5-28
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000006eax
????????ebx
????????edx
00000108esp
????????
????????
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000320eip
s=? z=?
push 325jmp 300
ca5-29
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000006eax
????????ebx
????????edx
00000104esp
????????
00000325
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000300eip
s=? z=?
ca5-30
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000006eax
????????ebx
????????edx
00000104esp
????????
00000325
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000302eip
s=0 z=0
ca5-31
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000006eax
????????ebx
????????edx
00000104esp
????????
00000325
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000307eip
s=0 z=0
ca5-32
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000006eax
00000005ebx
????????edx
00000104esp
????????
00000325
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000312eip
s=0 z=0
ca5-33
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000030eax
00000005ebx
00000000edx
00000104esp
????????
00000325
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000314eip
s=0 z=0
ca5-34
Codevijfvoud: cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000030eax
00000005ebx
00000000edx
00000108esp
????????
00000325
????????
100
104
108
300:302:304:306:
307:312:314:
315:320:325:
00000325eip
s=0 z=0
ca5-35
Bewaren registersvijfvoud: push edx cmp eax,0 jg positief xor eax, eax pop edx retpositief: mov ebx, 5 imul ebx pop edx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000030eax
00000005ebx
????????edx
00000108esp
edx
00000328
????????
100
104
108
300:301:303:305:307:308
309:314:316:317:
318:323:328:
???????? 96
s=0 z=0
Registers: bewaren
ca5-36
Bew
aren
reg
iste
rsvijfvoud: push edx push ebx cmp eax,0 jg positief xor eax, eax pop ebx pop edx retpositief: mov ebx, 5 imul ebx pop ebx pop edx ret
main: mov eax, 6 call vijfvoud mov g, eax
00000030eax
????????ebx
????????edx
????????092
edx
t.k. adres
????????
100
104
108
ebx096
s=0 z=0
ca5-37
Controleverloopgraaf
vijfvoud: push edx push ebx cmp eax,0 jg positief
positief: mov ebx, 5 imul ebx pop ebx pop edx ret
xor eax, eax pop ebx pop edx ret
mov eax,6
call vijfvoud
mov g, eax
ca5-38
Controleverloopgraaf
positief: push edx push ebx mov ebx, 5 imul ebx pop ebx pop edx ret
xor eax, eax ret
vijfvoud: cmp eax,0 jg positief
mov eax,6
call vijfvoud
mov g, eax
ca5-39
Controleverloopgraaf
positief: push edx mov edx, 5 imul edx pop edx ret
xor eax, eax ret
vijfvoud: cmp eax,0 jg positief
mov eax,6
call vijfvoud
mov g, eax
ca5-40
Parameterdoorgave via stapel 1vijfvoud:
mov eax,[esp+4] cmp eax,0 jg positief xor eax, eax retpositief: mov ebx, 5 imul ebx ret
main: push 6 call vijfvoud add esp,4 mov g, eax
t.k. adres
00000006
????????
100
104
108
????????096
esp
Parameterdoorgave
ca5-41
Parameterdoorgave via stapel 2
t.k. adres
00000006
????????
100
104
108
????????096
esp
vijfvoud: mov eax,[esp+4] cmp eax,0 jg positief xor eax, eax ret 4positief: mov ebx, 5 imul ebx ret 4
main: push 6 call vijfvoud add esp,4 mov g, eax
ca5-42
Lokale veranderlijken int vijfvoud(int n) { int resultaat;
if (n > 0) resultaat = n * 5; else resultaat = 0; return resultaat; } int g; main() { g = vijfvoud(6); }
int vijfvoud(int n) { int resultaat;
if (n > 0) resultaat = n * 5; else resultaat = 0; return resultaat; } int g; main() { g = vijfvoud(6); }
ca5-43
Lokale veranderlijken
vijfvoud: sub esp,4 cmp eax,0 jg positief xor eax,eax mov [esp], eax jmp eindepositief: mov ebx, 5 imul ebx mov [esp], eaxeinde: mov eax,[esp] add esp,4 retprogramma: mov eax, 6 call vijfvoud mov g, eax
????????
t.k. adres
????????
100
104
108
????????096
esp
ca5-44
Controleverloopgraaf
vijfvoud: sub esp,4 cmp eax,0 jg positief
positief: mov ebx, 5 imul ebx mov [esp],eax
xor eax, eax mov [esp],eax jmp end
end: mov eax,[esp] add esp,4 ret
mov eax,6
call vijfvoud
mov g, eax
ca5-45
Compleet beeldvijfvoud: sub esp,4 push ebx push edx mov eax, [esp+16] cmp eax,0 jg positief xor eax,eax mov [esp+8], eax jmp eindepositief: mov ebx, 5 imul ebx mov [esp+8], eaxeinde: mov eax,[esp+8] pop edx pop ebx add esp, 4 ret
programma: push 6 call vijfvoud add esp,4 mov g, eax
resultaat
edxebx
t.k. adres00000006
espesp+4esp+8
esp+12
esp+16
stack frame
ca5-46
Overzicht• Sprongen
• Lussen
• Procedure-oproep en -terugkeer
• Onderbrekingen
• Instructiecodering
• Compilers, linkers, en laders
• Codeoptimalisatie
ca5-47
Onderbrekingen
• Sprong naar een routine via een nummer i.p.v. via een adres
• Adressen van routines opgeslagen in een tabel van adressen (vectortabel)
• Gebruikt voor het opvangen van fouten, of als interface naar het besturingssysteem
ca5-48
Onderbrekingi1i2i3i4i5i6i7i8
int 2i10i11
int 3
t
01234
i1i2i3i4i5i6
Onderbrekings-routine 3
vectortabel
ca5-49
Systeemoperaties
• Controle van de machine: manipulatie van de processortoestand– onderbrekingen aan/uit– veranderen van privilegeniveau– halt-instructie– omschakeling big-endian naar little-endian– geheugenbeheer (caches, virtueel
geheugen, enz.)
ca5-50
Overzicht• Sprongen
• Lussen
• Procedure-oproep en -terugkeer
• Onderbrekingen
• Instructiecodering
• Compilers, linkers, en laders
• Codeoptimalisatie
ca5-51
Instructiedecodering
05 02 00
0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
w word
1
data2
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
opcodeadd immediate to accumulator
0 0 0 0 0 1 0
add ax,2
ca5-52
Instructiebeschrijving
SUB subtract O D I T S Z A P C 001010dwoorrrmmm disp * * * * * *
ea=514 sub r,r sub r,m sub m,r8088 3 13+ea 24+ea8086 3 9+ea 16+ea80286 2 7 780386 2 7 680486 1 2 3Pentium 1 2 3
ca5-53
ca5-54
ca5-55
Overzicht• Sprongen
• Lussen
• Procedure-oproep en -terugkeer
• Onderbrekingen
• Instructiecodering
• Compilers, linkers, en laders
• Codeoptimalisatie
ca5-56
Programma-ontwikkeling
broncode compilercompiler Object-bestand
linkerlinkerbibliotheken
uitvoerbaarbestand
ca5-57
Compiler
• Verschillende fasen– Lexicale analyse: a, 12, then, (, while– Syntactische analyse: if (a>b) then …– Semantische analyse (type-controle,…)– Optimalisatie – Codegeneratie– Scheduling
ca5-58
Objectbestand
object-bestand
instructies
extra informatie
globale veranderlijken
ca5-59
Linker
linkerlinker
ca5-60
Lader
laderlader
stapel
Grabbel-geheugen
geheugen
Dynamisch gealloceerd geheugen
ca5-61
Overzicht• Sprongen
• Lussen
• Procedure-oproep en -terugkeer
• Onderbrekingen
• Instructiecodering
• Compilers, linkers, en laders
• Codeoptimalisatie
ca5-62
Voorbeeld
int max(int n1, int n2) { return n1 > n2 ? n1 : n2;}
int max4(int n1, int n2, int n3, int n4) { return max(max(n1,n2),max(n3,n4));}
int g;
main () { g = max4(15,10,9,4);}
int max(int n1, int n2) { return n1 > n2 ? n1 : n2;}
int max4(int n1, int n2, int n3, int n4) { return max(max(n1,n2),max(n3,n4));}
int g;
main () { g = max4(15,10,9,4);}
ca5-63
Hoofdprogramma
main:push 4 ; n4push 9 ; n3push 10 ; n2push 15 ; n1call max4add esp,16mov g, eax
main:push 4 ; n4push 9 ; n3push 10 ; n2push 15 ; n1call max4add esp,16mov g, eax
return
n1
n2
n3
n4
ca5-64
max4:pushebpmov ebp,esppushesipushedipush[ebp+12]push[ebp+8]call maxadd esp,8mov edi,eax
n1
n2
edi
esi
ebp
return
n1
n2
n3
n4
ebp
ca5-65
max:pushebpmov ebp,esppushebxpushedimov edi,[ebp+12]cmp [ebp+8],edijle $14mov ebx,[ebp+8]jmp $15
$14: mov ebx,[ebp+12]$15: mov eax,ebx
pop edipop ebxpop ebpret
ediebxebp
returnn1n2ediesiebp
returnn1n2n3n4
ebp
Sta
ck fr
ames
ca5-66
Enter/Leave
enter nenter n push ebp
mov ebp,esp
sub esp,n
push ebp
mov ebp,esp
sub esp,n
leaveleave mov esp,ebp
pop ebp
mov esp,ebp
pop ebp
lok 2
lok 1
ebp
return
arg
ebp
ca5-67
Stack frames
p1
p2
p3
p4activatieboom
ParametersTerugkeeradres
Bewaarde registersLokale veranderlijken
Stack frame pointer
ca5-68
Oproepconventies
• Verzameling conventies die de oproep van procedures/functies regelt– Argumenten op stapel of in registers– Volgorde van de argumenten– Welk register is stapelwijzer– Registers bewaard door oproeper (caller saved) of
de oproepeling (callee saved)– Terugkeeradres op de stapel, of in een register (zgn.
link register)
ca5-69
max4:pushebpmov ebp,esppushesipushedipush[ebp+12]push[ebp+8]call maxadd esp,8mov edi,eax
push [ebp+20]push[ebp+16]
call maxadd esp,8mov esi,eaxpushesipushedicall maxadd esp,8pop edipop esipop ebpret
ca5-70
max:pushebpmov ebp,esppushebxpushedimov edi,[ebp+12]cmp [ebp+8],edijle $14mov ebx,[ebp+8]jmp $15
$14: mov ebx,[ebp+12]$15: mov eax,ebx
pop edipop ebxpop ebpret
eax
eax
Optimalisatie
Kopiepropagatie op eax en ebx.
ca5-71
max:pushebpmov ebp,esppushedimov edi,[ebp+12]cmp [ebp+8],edijle $14mov eax,[ebp+8]jmp $15
$14: mov eax,[ebp+12]$15: pop edi
pop ebpret
ebp = esp+4
esp+16esp+12
esp+12
esp+16
Optimalisatie
edi
ebp
ret
arg1
arg2
ebp
esp
constantenpropagatie
ca5-72
max:pushebpmov ebp,esppushedimov edi,[esp+16]cmp [esp+12],edijle $14mov eax,[esp+12]jmp $15
$14: mov eax,[esp+16]$15: pop edi
pop ebpret
dode waardeOptimalisatie
ca5-73
max:pushebppushedimov edi,[esp+16]cmp [esp+12],edijle $14mov eax,[esp+12]jmp $15
$14: mov eax,[esp+16]$15: pop edi
pop ebpret
Optimalisatie
Idempotente code
edi
ret
arg1
arg2
esp12
12
8
8
ca5-74
max:pushedimov edi,[esp+12]cmp [esp+8],edijle $14mov eax,[esp+8]jmp $15
$14: mov eax,[esp+12]$15: pop edi
ret
eaxeax
Optimalisatie
ret
arg1
arg2
esp
8
8
4 4
Register-herallocatie
ca5-75
max:mov eax,[esp+8]cmp [esp+4],eaxjle $14mov eax,[esp+4]jmp $15
$14: mov eax,[esp+8]$15: ret
Idempotente code
Optimalisatie
ca5-76
max:mov eax,[esp+8]cmp [esp+4],eaxjle $14mov eax,[esp+4]jmp $15
$14:$15: ret
Optimalisatie
Sprong naar doorvalpad
ca5-77
max:mov eax,[esp+8]cmp [esp+4],eaxjle $14mov eax,[esp+4]
$14: ret
Optimalisatie
ca5-78
max4:pushebpmov ebp,esppushesipushedipush[ebp+12]push[ebp+8]call maxadd esp,8mov edi,eax
push [ebp+20]push[ebp+16]
call maxadd esp,8mov esi,eaxpushesipushedicall maxadd esp,8pop edipop esipop ebpret
Optimalisatie
ca5-79
max:mov eax,[esp+8]cmp [esp+4],eaxjle $14mov eax,[esp+4]
$14: ret
Optimalisatie
max:cmp esi,eaxjle $14mov eax,esi
$14: ret
ca5-80
max4:pushebpmov ebp,esppushesipushedimov eax, [ebp+12]mov esi, [ebp+8]call maxmov edi,eax
mov eax, [ebp+20]mov esi, [ebp+16] call maxmov esi,edicall maxpop edipop esipop ebpret
Optimalisatie
ca5-81
max4:pushebpmov ebp,esppushesipushedimov eax, [ebp+12]mov esi, [ebp+8]cmp esi,eaxjle $14mov eax,esi
$14:mov edi,eax
mov eax, [ebp+20]mov esi, [ebp+16] cmp esi,eaxjle $15mov eax,esi
$15:mov esi,edicmp esi,eaxjle $16mov eax,esi
$16:pop edipop esipop ebpret
Substitutie
kopiepropagatie
kop
iep
ropa
gatie
ca5-82
max4:pushebpmov ebp,esppushesipushedimov edi, [ebp+12]mov esi, [ebp+8]cmp esi,edijle $14mov edi,esi
$14:mov edi,eax
Registerallocatie mov eax, [ebp+20]mov esi, [ebp+16] cmp esi,eaxjle $15mov eax,esi
$15:mov esi,edicmp edi,eaxjle $16mov eax,edi
$16:pop edipop esipop ebpret
ca5-83
max4:pushebpmov ebp,esppushesipushedimov edi, [ebp+12]mov esi, [ebp+8]cmp esi,edijle $14mov edi,esi
$14:
Registerallocatie mov eax, [ebp+20]mov esi, [ebp+16] cmp esi,eaxjle $15mov eax,esi
$15:cmp edi,eaxjle $16mov eax,edi
$16:pop edipop esipop ebpret
ca5-84
max4:pushebpmov ebp,esppushesipushedipushebxmov edi, [ebp+12]mov esi, [ebp+8]cmp esi,edijle $14mov edi,esi
$14:
Registerallocatie mov eax, [ebp+20]mov ebx, [ebp+16] cmp ebx,eaxjle $15mov eax,ebx
$15:cmp edi,eaxjle $16mov eax,edi
$16:pop ebxpop edipop esipop ebpret
ca5-85
Hoofdprogramma
main: push 9 ; n4 push 4 ; n3 push 10 ; n2 push 15 ; n1 call max4 add esp,16 mov g, eax
main: push 9 ; n4 push 4 ; n3 push 10 ; n2 push 15 ; n1 call max4 add esp,16 mov g, eax
main: mov eax,9 ; n4 mov ebx,4 ; n3 mov edi,10 ; n2 mov esi,15 ; n1 call max4
mov g, eax
main: mov eax,9 ; n4 mov ebx,4 ; n3 mov edi,10 ; n2 mov esi,15 ; n1 call max4
mov g, eax
ca5-86
max4:pushebpmov ebp,esppushesipushedipushebxmov edi, [ebp+12]mov esi, [ebp+8]cmp esi,edijle $14mov edi,esi
$14:
Optimalisatie mov eax, [ebp+20]mov ebx, [ebp+16] cmp ebx,eaxjle $15mov eax,ebx
$15:cmp edi,eaxjle $16mov eax,edi
$16:pop ebxpop edipop esipop ebpret
ca5-87
max4:pushedicmp esi,edijle $14mov edi,esi
$14:
Registerallocatie
cmp ebx,eaxjle $15mov eax,ebx
$15:cmp edi,eaxjle $16mov eax,edi
$16:pop ediret
ca5-88
Geoptimaliseerdprogramma
main: mov eax,9 ; n4 mov ebx,4 ; n3 mov edi,10 ; n2 mov esi,15 ; n1 call max4 mov g, eax
main: mov eax,9 ; n4 mov ebx,4 ; n3 mov edi,10 ; n2 mov esi,15 ; n1 call max4 mov g, eax
max4:cmp esi,edijle $14mov edi,esi
$14: cmp ebx,eaxjle $15mov eax,ebx
$15: cmp edi,eaxjle $16mov eax,edi
$16: ret
max4:cmp esi,edijle $14mov edi,esi
$14: cmp ebx,eaxjle $15mov eax,ebx
$15: cmp edi,eaxjle $16mov eax,edi
$16: ret
ca5-89
Geoptimaliseerdprogramma
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 call max4
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 call max4
mov eax,edimov eax,edi
mov g, eaxmov g, eax
max4: cmp esi,edijle $14
max4: cmp esi,edijle $14
mov edi,esimov edi,esi
$14: cmp ebx,eaxjle $15
$14: cmp ebx,eaxjle $15
mov eax,ebxmov eax,ebx
$15: cmp edi,eaxjle $16
$15: cmp edi,eaxjle $16
$16: ret$16: ret
eax=9ebx=4edi=10esi=15
eax=9ebx=4edi=15esi=15
eax=9ebx=4edi=15esi=15
eax=15ebx=4edi=15esi=15
ca5-90
Geoptimaliseerdprogramma
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 call max4
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 call max4
mov eax,edimov eax,edi
mov g, eaxmov g, eax
max4: cmp esi,edimax4: cmp esi,edi
mov edi,esimov edi,esi
$14: cmp ebx,eax$14: cmp ebx,eax
$15: cmp edi,eax$15: cmp edi,eax
$16: ret$16: ret
ca5-91
Geoptimaliseerdprogramma
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 call max4
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 call max4
mov g, eaxmov g, eax
mov edi,esimov eax,ediret
mov edi,esimov eax,ediret
ca5-92
Geoptimaliseerdprogramma
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 mov edi,esi mov eax,edi mov g, eax
main: mov eax,9 mov ebx,4 mov edi,10 mov esi,15 mov edi,esi mov eax,edi mov g, eax
Dode-waarde-eliminatieKopiepropagatie
mov g, 15mov g, 15
Algoritmische optimalisaties
ca5-93
int main(){ int i, j; int a[1000000]; float b[1000000]; float r = 0.0;
for (i=0; i<1000000; i++) for (j=0; j<1000000; j++) { unsigned int pattern = a[i] ^ a[j]; if (popcount(pattern) == 2) r += b[i] * b[j]; }}
i
j
a b
Algoritmische optimalisaties
ca5-94
int main(){ int i, j; int a[1000000]; float b[1000000]; float r = 0.0;
for (i=0; i<1000000; i++) for (j=j+1; j<1000000; j++) { unsigned int pattern = a[i] ^ a[j]; if (popcount(pattern) == 2) r += 2 * b[i] * b[j]; }}
i
j
a b
Popcount
ca5-95
int popcount(unsigned int x){ int c = 0; for (; x > 0; x &= x -1) c++; return c;}
for (i=0; i < (1<<16); i++) { _popcount[i] = popcount(i);
+
Algoritmische optimalisaties
ca5-96
int main(){ int i, j; int a[1000000]; float b[1000000]; float r = 0.0;
for (i=0; i<1000000; i++) for (j=j+1; j<1000000; j++) { unsigned int pattern = a[i] ^ a[j]; if (_popcount[pattern] == 2) r += 2 * b[i] * b[j]; }}
i
j
a b
Algoritmische optimalisaties
ca5-97
int main(){ for (i=0; i<N; i++) for (j=j+1; j<N; j++) { unsigned int pattern = a_pat[i] ^ a_pat[j]; if (_popcount[pattern] == 2) { for (x=0; x<a_pat[i].len; x++) for (y=0; y<a_pat[j].len; y++) r += 2 * a_pat[i].b[x] * a_pat[j].b[y]; } }}
i
j
a_patb
b
Algoritmische optimalisaties
ca5-98
int main(){ for (i=0; i<N; i++) for (j=j+1; j<N; j++) { unsigned int pattern = a_pat[i] ^ a_pat[j]; if (_popcount[pattern] == 2) { for (x=0; x<a_pat[i].len; x++) r += 2 * a_pat[i].b[x] * a_pat[j].som_b; } }}
i
j
a_patb
b
Algoritmische optimalisaties
ca5-99
int main(){ for (i=0; i<N; i++) for (p=0; p<120; p++) unsigned int pat2 = a_pat[i] ^ tweebits[p]; j = a_bitpat[pat2]; if (j >= 0) { for (x=0; x<a_pat[i].len; x++) r += 2 * a_pat[i].b[x] * a_pat[j].som_b; } }}
i
pat2
a_patb
b
a_bitpat
j
Iteraties: N * 120 * (1000000/N) = 120 x 106
ca5-100
Pauze