Miért is kell(ene) az AGLU a Bulldozer-be?
"And two which handle address generation and simple ALU operations (AGLU)."

Nézzük ezt az egyszerű for-ciklust:
@decrease_free_row:
mov edx,[edi+ecx*04h+__COLROWMARK]
xor edx,eax
or edx,[esi+ecx]
mov edx,00000000h
cmovns edx,eax
sub [esi+ecx],edx
add ecx,04h
jnz @decrease_row_free

Tegyük fel, hogy rendesen igazított a kód, azaz teljesen belefér egy 32 byte-os aligned memóriaterületre, így a dekódolás nem szűk keresztmetszet.

A következő lefutási képe van 4 cikluslefutásnak K10-en (K10-en kénytelen azon az ALU/AGU-n futni az utasítás, amelyre a dekódolás során esik az adott órajelben dekódolt utasításhármasban):
decode:
00 (1)mov edx,[edi+ecx*04h+__COLROWMARK] (1)xor edx,eax (1)or edx,[esi+ecx]
01 (1)mov edx,00000000h (1)cmovns edx,eax (1)sub [esi+ecx],edx
02 (1)add ecx,04h (1)jnz @decrease_row_free (1)
03 (2)mov edx,[edi+ecx*04h+__COLROWMARK] (2)xor edx,eax (2)or edx,[esi+ecx]
04 (2)mov edx,00000000h (2)cmovns edx,eax (2)sub [esi+ecx],edx
05 (2)add ecx,04h (2)jnz @decrease_row_free (2)
06 (3)mov edx,[edi+ecx*04h+__COLROWMARK] (3)xor edx,eax (3)or edx,[esi+ecx]
07 (3)mov edx,00000000h (3)cmovns edx,eax (3)sub [esi+ecx],edx
08 (3)add ecx,04h (3)jnz @decrease_row_free (3)
09 (4)mov edx,[edi+ecx*04h+__COLROWMARK] (4)xor edx,eax (4)or edx,[esi+ecx]
10 (4)mov edx,00000000h (4)cmovns edx,eax (4)sub [esi+ecx],edx
11 (4)add ecx,04h (4)jnz @decrease_row_free (4)

exec:
clk 1. ALU 1.AGU | 2. ALU 2.AGU | 3. ALU 3.AGU
---------------------------------------- | ------------------------------------- | -----------------------------------
01 (1)mov edx,[esi+ecx*4] | | (1)ld x1,[esi+ecx]
02 (1)mov edx,0 | | (1)ld y1,[esi+ecx]
03 (1)add ecx,4 | |
04 (2)mov edx,[esi+ecx*4] | (1)xor edx,eax | (2)ld x2,[esi+ecx]
05 (2)mov edx,0 | (1)jnz @decrease_free_row | (1)or edx,x1 (2)ld y2,[esi+ecx]
06 (2)add ecx,4 | (1)cmovns edx,eax |
07 (3)mov edx,[esi+ecx*4] | (2)xor edx,eax | (1)sub y1,edx (3)ld x3,[esi+ecx]
08 (3)mov edx,0 | (2)jnz @decrease_free_row | (2)or edx,x2 (1)st [esi+ecx],y1
09 (3)add ecx,4 | (2)cmovns edx,eax | (3)ld y3,[esi+ecx]
10 (4)mov edx,[esi+ecx*4] | (3)xor edx,eax | (2)sub y2,edx (4)ld x4,[esi+ecx]
11 (4)mov edx,0 | (3)jnz @decrease_free_row | (3)or edx,x3 (2)st [esi+ecx],y1
12 (4)add ecx,4 | (3)cmovs edx,eax | (4)ld y4,[esi+ecx]
13 | (4)xor edx,eax | (3)sub y3,edx
14 | (4)jnz @decrease_free_row | (4)or edx,x4 (3)st [esi+ecx],y3
15 | (4)cmovns edx,eax |
16 | | (4)sub y4,edx
17 | | (4)st [esi+ecx],y4

A következő lefutási képe van 4 cikluslefutásnak Bulldozer-en (itt már egységes ütemező van a 4 végrehajtóra):
decode:
00 (1)mov edx,[edi+ecx*04h+__COLROWMARK] (1)xor edx,eax (1)or edx,[esi+ecx] (1)mov edx,00000000h
01 (1)cmovns edx,eax (1)sub [esi+ecx],edx (1)add ecx,04h (1)jnz @decrease_row_free
02 (2)mov edx,[edi+ecx*04h+__COLROWMARK] (2)xor edx,eax (2)or edx,[esi+ecx] (2)mov edx,00000000h
03 (2)cmovns edx,eax (2)sub [esi+ecx],edx (2)add ecx,04h (2)jnz @decrease_row_free
04 (3)mov edx,[edi+ecx*04h+__COLROWMARK] (3)xor edx,eax (3)or edx,[esi+ecx] (3)mov edx,00000000h
05 (3)cmovns edx,eax (3)sub [esi+ecx],edx (3)add ecx,04h (3)jnz @decrease_row_free
06 (4)mov edx,[edi+ecx*04h+__COLROWMARK] (4)xor edx,eax (4)or edx,[esi+ecx] (4)mov edx,00000000h
07 (4)cmovns edx,eax (4)sub [esi+ecx],edx (4)add ecx,04h (4)jnz @decrease_row_free

exec:
clk ALU0 | ALU1 | AG0 | AG1
| | |
01 (1)mov edx,0 | | (1)mov edx,[esi+ecx*4] | (1)ld x1,[esi+ecx]
02 (1)add ecx,4 | | (1)ld y1,[esi+ecx] |
03 (2)mov edx,0 | (1)jnz @decrease_free_row | (2)mov edx,[esi+ecx*4] | (2)ld x2,[esi+ecx]
04 (2)add ecx,4 | | (2)ld y2,[esi+ecx] |
05 (1)xor edx,eax | (2)jnz @decrease_free_row | (3)mov edx,[esi+ecx*4] | (3)ld x3,[esi+ecx]
06 (1)or edx,x1 | (3)mov edx,0 <<< +1 | (3)ld y3,[esi+ecx] |
07 (1)cmovns edx,eax | (2)xor edx,eax | |
08 (1)sub y1,edx | (2)or edx,x2 | |
09 (2)cmovns edx,eax | (3)xor edx,eax | (1)st [esi+ecx],y1 |
10 (2)sub y2,edx | (3)or edx,x3 | |
11 (3)cmovns edx,eax | (3)add ecx,4 <<< +5 | (2)st [esi+ecx],y2 |
12 (3)sub y3,edx | (3)jnz @decrease_free_row | (4)mov edx,[esi+ecx*4] | (4)ld x4,[esi+ecx]
13 | | (3)st [esi+ecx],y3 |
14 | | (4)ld y4,[esi+ecx] <<< +1 |
15 | | |
16 (4)xor edx,eax | | |
17 (4)or edx,x4 | | |
18 (4)cmovns edx,eax | | |
19 (4)sub y4,edx | | |
20 | | (4)st [esi+ecx],y3 |

AGLU-val (ADD + logic képesség az AGU-knak) felszerelt esetben ez lenne a lefutási kép (a decode azonos):

exec:
clk ALU0 | ALU1 | AG0 | AG1
| | |
01 (1)mov edx,0 | | (1)mov edx,[esi+ecx*4] | (1)ld x1,[esi+ecx]
02 (1)add ecx,4 | | (1)ld y1,[esi+ecx] |
03 (2)mov edx,0 | (1)jnz @decrease_free_row | (2)mov edx,[esi+ecx*4] | (2)ld x2,[esi+ecx]
04 (2)add ecx,4 | | (2)ld y2,[esi+ecx] |
05 (1)xor edx,eax | (2)jnz @decrease_free_row | (3)mov edx,[esi+ecx*4] | (3)ld x3,[esi+ecx]
06 (1)or edx,x1 | (3)mov edx,0 <<< +1 | (3)ld y3,[esi+ecx] | (3)add ecx,4
07 (1)cmovns edx,eax | (2)xor edx,eax | (4)mov edx,[esi+ecx*4] | (4)ld x4,[esi+ecx]
08 (1)sub y1,edx | (2)or edx,x2 | (4)ld y4,[esi+ecx] | (4)add ecx,4
09 (2)cmovns edx,eax | (3)xor edx,eax | (1)st [esi+ecx],y1 |
10 (2)sub y2,edx | (3)or edx,x3 | |
11 (3)cmovns edx,eax | (3)jnz @decrease_free_row | (2)st [esi+ecx],y2 |
12 (3)sub y3,edx | (4)jnz @decrease_free_row | (4)xor edx,eax |
13 (4)or edx,x4 | | (3)st [esi+ecx],y3 |
14 (4)cmovns edx,eax | | |
15 (4)sub y4,edx | | |
16 | | (4)st [esi+ecx],y4 |

K10-en a 17. órajelben indul az utolsó utasítás, Bulldozeren a 20. órajelben, AGLU esetén pedig a 16. órajelben.

A cikluslefutásoknak függetlenek egymástól, csakis az ADD ECX,00000004h utasítás lefutásán múlik, hogy mikor indulhatnak el a következő ciklusmag utasításai. Az ütemező erről mit sem tud, szabálya, hogy ha több utasításnak áll készen az összes bemeneti paramétere, akkor kötelező neki a programsorrendben korábbiakat indítani.
Viszont mivel a Bulldozerben csak két végrehajtó képes az ADD műveletet fogadni, ezért a 3. cikluslefutás ADD ECX,4 művelete 5 órajellel később indul, mint mire ismert a bemenő paramétere, annyi végrehajtható utasítás gyűlik össze a két ALU számára; emiatt viszont a 13-15. órajelben egy buborék keletkezik az ALU-kban, nincs mit csinálniuk, meg kell várniuk az L1-ból az adatokat.
Ha az AGU-k képesek lennének végrehajtani csak az összeadást, akkor 20 helyett 17 órajel alatt elindulhatna az összes utasítás; ha a logikai (XOR) műveletet is végre tudják hajtani, akkor 16 órajelre csökken ez az érték: ez egyenlő vagy gyorsabb, mint a K10 3 ALU + 3 AGU + 3 clock L1 load-to-use latency sebessége, 2 ALU + 2 AGLU + 4 clock L1 load-to-use latency felépítés mellett is.

[ Szerkesztve ]

Egy év eltelt, kissé változott a kódolás, de még fontosabb, hogy elkészült a hozzá tartozó egy szálas kiszolgáló kód - amely előkészíti a kiszámolandó mátrixokat - végleges(?) 32 bites változata. Ennek teljes kidolgozása +8-9% sebességnövekedést okozott K10-en.

jmp @@NEXTMATRIX
@terminate:
{ x1 } nop
jmp @@READY
@@NEXTMATRIX:
{align $34} nop; mov eax,[APPLICATION]; call TAPPLICATION.PROCESSMESSAGES
{align $40} mov [ebx+TTSP30.COLLECTOR],edi
or ecx,-1
mov eax,[ebx+TTSP30.MEMORY]
test cl,[ebx+TTSP30.CIRCLESTOP]
jnz @terminate
add [ebx+TTSP30.GLOBALSIZE],eax
{align $50} mov [ebx+TTSP30.MEMORY],ecx
mov edx,esi
mov ebp,[esi+TCIRCLE.NEXT]
cmovc edx,ebp
mov eax,[edi+TCIRCLE.NEXT]
cmovc ebp,eax
{align $5F} mov [ebx+TTSP30.ENTRY],edx
{align $62} cmovc eax,esi
mov [esi+TCIRCLE.NEXT],ebp
mov [edi+TCIRCLE.NEXT],eax
lea esi,[ebx+TTSP30.RESULTS]
cmp edx,ebp
jz @terminate
{align $70} mov ebx,[edx+TCIRCLE.QUANTITY]
add dword ptr [edx+TCIRCLE.QUANTITY],02h
mov ebp,[esp+_ROWSIZE4]
mov edi,[esp+_CMTX]
shr ebx,03h
@createBASE:
{align $81} mov eax,[edx+ebx*08h+04h]
mov [esp+_BASEELEMENT+ebx*08h+04h],eax
mov eax,[edx+ebx*08h+00h]
mov [esp+_BASEELEMENT+ebx*08h+00h],eax
{align $90} dec ebx
jnz @createBASE
{align $93} add edx,offset(TCIRCLE.SUGGESTED)
movzx eax,al
mov [esp+_BASEELEMENT+TCIRCLE.NEXT],edx
cmp [edx+eax],bl
{align $A0} jl @matrix0
mov [esp+_CDEST],ebx
@INVALIDmatrix:
{align $A6} mov dword ptr [esi+TRESULT.OPTIMUM],0FFFFFFFFh
inc ebx
mov ecx,eax
@create_matrixes:
{align $B0} movzx eax,byte ptr [esp+_BASEELEMENT+TCIRCLE.SHORTEST+ebx+00h]
cmp al,byte ptr [edx-TCIRCLE.SUGGESTED+TCIRCLE.SHORTEST+00h]
jz @@CHECKRESULTS
mov [edx+ecx],al
add esi,TRESULTSIZE
{align $C0} cmp byte ptr [edx+eax],0FFh
jnz @INVALIDmatrix
@matrix0:
movzx ebx,byte ptr [esp+_BASEELEMENT+TCIRCLE.SHORTEST+ebx+01h]
mov ecx,[esp+_SIZE2BYTE]
imul eax,ebp
shl ebx,02h
mov [esp+_CDEST],esi
sub ebx,eax
mov eax,[esp+_SAVEMTX]
mov [esi+TRESULT.NXTILTED],ebx
@copyMTX:
{align $E2} mov esi,[eax+ecx+04h]
mov [edi+ecx+04h],esi
mov esi,[eax+ecx]
mov [edi+ecx],esi
{align $F0} sub ecx,08h
jns @copyMTX
{align $F5} lea ecx,[esp+_BASEELEMENT+TCIRCLE.TILTEDS]
mov eax,[esp+_COUNT386]
@tilt:
{align $00} mov [edi+ebx],ebp
movzx ebx,word ptr [ecx]
add ecx,02h
test ebx,ebx
jnz @tilt
jmp eax
{ x1 } nop
@VALIDmatrix:
{align $10} mov ebx,[esi+TRESULTSIZE+TRESULT.IVALUE]
mov [esi+TRESULT.OPTIMUM],edx
mov [esi+TRESULT.CCIRCLE],ecx
mov edx,[esp+_BASEELEMENT+TCIRCLE.NEXT]
{align $20} movzx ecx,byte ptr [esp+_BASEELEMENT+TCIRCLE.SHORTEST+ebx-01h]
jmp @create_matrixes
{ x2 } nop; nop
@@CHECKRESULTS:
{align $29} add [CIRCLEVAR],ebx
mov ebx,offset(TSP30)
mov ebp,offset(TSP30.RESULTS)
mov edi,[ebx+TTSP30.COLLECTOR]
@@AFTERCIRCLE:
mov eax,[esp+_BASEELEMENT+TCIRCLE.QUANTITY]
{ x1 } nop
@@HEADMATRIX:
{align $40} mov esi,[ebx+TTSP30.ENTRY]
@next:
cmp ebp,[esp+_CDEST]
ja @@NEXTMATRIX
mov ecx,[ebp+TRESULT.OPTIMUM]
{align $50} add ebp,TRESULTSIZE
{ x1 } nop
cmp ecx,[ebx+TTSP30.GLOBALOPTIMUM]
jae @next
mov edx,[ebp-TRESULTSIZE+TRESULT.CCIRCLE]
cmp edx,[esp+_MTXSIZE]
{align @60} jz @@CIRCLE0
{ x1 } nop
cmp dword ptr [edi+TCIRCLE.NEXT],00h
jz @@PLUSMEM
@enqueue:
add dword ptr [ebx+TTSP30.MEMORY],01h
{align $70} cmovnz esi,[edi+TCIRCLE.NEXT]
{ x1 } nop
cmovnz edi,esi
mov [esi+TCIRCLE.RESULT],ecx
movzx ecx,dl
shr edx,08h
{align $80} lea ebx,[esi+TCIRCLE.SHORTEST+ecx]
neg ecx
mov [ebx],dl
@shortest:
mov [ebx+ecx],dl
movzx edx,byte ptr [ebp-TRESULTSIZE+TRESULT.ORDERSET+edx]
{align $90} add ecx,01h
jnz @shortest
movzx edx,byte ptr [esp+_BASEELEMENT+TCIRCLE.SHORTEST+00h]
lea ebx,[eax-TCIRCLE.QUANTITY]
shr ebx,03h
@clone:
{align $A0} mov eax,[esp+_BASEELEMENT+ebx*08h+04h+TCIRCLE.QUANTITY]
mov [esi+ebx*08h+04h+TCIRCLE.QUANTITY],eax
mov eax,[esp+_BASEELEMENT+ebx*08h+00h+TCIRCLE.QUANTITY]
mov [esi+ebx*08h+00h+TCIRCLE.QUANTITY],eax
{align $B0} dec ebx
jns @clone
mov ebx,[ebp-TRESULTSIZE+TRESULT.NXTILTED]
mov [esi+eax-02h],ebx
lea ebx,[TSP30]
@suggest:
{align $C0} cmp ecx,[ebp-TRESULTSIZE+TRESULT.IVALUE]
jae @@HEADMATRIX
movzx ebx,byte ptr [esp+_BASEELEMENT+TCIRCLE.SHORTEST+ecx+01h]
add ecx,01h
mov byte ptr [esi+TCIRCLE.SUGGESTED+edx],bl
mov edx,ebx
mov ebx,offset(TSP30)
jmp @suggest
{align $DE} { x3 } nop; nop; nop
{ x8 } nop; nop; nop; nop; nop; nop; nop; nop
@@PLUSMEM:
{align $E9} lea eax,[ebx+TTSP30.WORKAREAS]; xor edx,edx; call _ADDINT
mov edx,[ebx+TTSP30.STRUCTURESIZE]; mov ecx,3000; call _REALLO
{align $00} add [ebx+TTSP30.COLLECTED],ecx
dec ecx
@setmem:
{align $04} mov [eax+edx+TCIRCLE.NEXT],eax
add eax,edx
sub ecx,01h
jnz @setmem
{align $0E} mov edx,[ebp-TRESULTSIZE+TRESULT.CCIRCLE]
mov ecx,[ebp-TRESULTSIZE+TRESULT.OPTIMUM]
mov [edi+TCIRCLE.NEXT],eax
mov eax,[esp+_BASEELEMENT+TCIRCLE.QUANTITY]
jmp @enqueue
{ x1 } nop
@@CIRCLE0:
...

A mátrixokat kiszámoló algoritmus is kis átszervezésen esett át.

AMD CPU-k 2 órajelenként tudnak végrehajtani egy ugrást, így a 3 utasításból álló ciklusok nem hatékonyak, egy-egy ciklus ugyanúgy legalább 2 órajel alatt fog lefutni, mint a 4-5-6 utasításból állóak; így érdemes ezekbe beletuszkolni további műveleteket, pl. hogy a ciklus feleannyiszor fusson le.

Továbbá Intel processzorokon nem mindegy, hogy a kizárólag align-ra szolgáló, soha le nem futó átugrott kódrészek NOP-ból vagy más, nagyobb utasításból állnak (pl. 8 NOP vagy csak 3 utasítás, mint mov esi,esi; nop; mov eax,7FFFFFFFh): The maximum throughput of the predecoders is 16 bytes or 6 instructions per clock cycle, whichever is smallest. The throughput of the rest of the pipeline is typically 4 instructions per clock cycle, or 5 in case of macro-op fusion.[...] The predecoder throughput can also be reduced if there are more than 6 instructions in a 16-bytes block of code. The reason for this is that the predecoder will not load a new 16-bytes block of code until the previous block is exhausted. If there are 7 instructions in a 16-bytes block then the predecoders will process the first 6 instructions in the first clock cycle and 1 instruction in the next clock cycle.
Emellett az uop-cache-sel rendelkező Intel CPU-knál 1-1 32 byte-os kódrészhez maximum 3x6 uop tartozhat; amely kódrész ebben nem fér bele (pl. mert 16-nál több - akár le nem futó - NOP-ot tartalmaz), az nem kerül be ebbe a cache-be. Nem tisztázott, hogy ezek a NOP-ok beleszámítanak-e itt a 3x6 uop-számba.

xor ebx,ebx
mov esi,ebp
mov ecx,ebp
and esi,-8
{@F1} @mark0:
{0} mov [edi+esi*04h+00h+__0STARROW],ebx
{1} mov [edi+esi*04h+10h+__0STARROW],ebx
{2*} add esi,08h
{0*} jnz @mark0
{ x2 } nop; nop
@@ARGUMENT:
{@00} movsx esi,byte ptr [edx]
{1} cmp esi,ebx
{2} lea esi,[ebp+esi*04h]
{0} mov [edi+esi*04h+__0STARROW],ecx
{1} cmovs esi,ebx
{@10} mov [edi+ecx*04h+__COLROWMARK],esi
{0} inc edx
{1} mov [edi+ecx*04h+__0STAR],esi
{2*} add ecx,04h
{0*} jnz @@ARGUMENT
{ x1 } nop
mov eax,edi
{@20} lea edx,[ebp-04h]
jmp @@REDUCE_ROWS
{ x3 } nop; nop; nop
{@28} @subrow:
{0} sub [eax+ecx],esi
{1*} add ecx,04h
{2*} jnz @subrow
@@REDUCE_ROWS:
{0*} add edx,04h
{1*} jz @@REDUCE_COLUMNS
{2} sub eax,ebp
{0} or esi,-1
{1*} cmp [edi+edx*04h+__0STAR],ecx
{2*} jnz @@REDUCE_ROWS
{@40} mov ecx,ebp
@findrowmin:
{@42} mov ebx,[eax+ebp]
{1} or ebx,[edi+ebp*04h+__0STARROW]
{2} cmp esi,ebx
{0} cmova esi,ebx
{1*} add ebp,04h
{2*} jnz @findrowmin
{0} mov ebp,ecx
{1*} test esi,esi
{2*} jns @subrow
@@ABNORMAL_EXIT:
{@59} mov esi,[esp+__MARKS]
or edx,-1
{@60} mov [esi+TRESULT.OPTIMUM],edx
mov ebx,[esi+TRESULT.NEXTIVALUE]
jmp dword ptr [esp+_INVALIDRESULT]
{ x2 } mov edi,edi
@@REDUCE_COLUMNS:
{@6C} sub edx,04h
{1} sub eax,04h
{2*} cmp edx,ebp
{0*} jb @@1ST_STEP
{1*} cmp [edi+edx*04h+__0STARROW],ecx
{2*} jnz @@REDUCE_COLUMNS
{@80} or esi,-1
{@83} @findcolmin:
{0} mov ebx,[eax]
{1} or ebx,[edi+ecx*04h-10h+__COLROWMARK]
{2} sub ecx,04h
{0} cmp esi,ebx
{1} cmova esi,ebx
{2} add eax,ebp
{0*} cmp ecx,ebp
{1*} jnz @findcolmin
xor ebx,ebx
sub ecx,04h
test esi,esi
js @@ABNORMAL_EXIT
{@A0} @subcol:
{0*} add ecx,04h
{1*} jz @@REDUCE_COLUMNS
{2} sub eax,ebp
{0} sub [eax],esi
{1} jnz @subcol
cmp ebx,[edi+ecx*04h+__0STAR]
{@AF} jnz @subcol
{@B1} mov [edi+edx*04h+__0STARROW],ecx
not ebx
mov [edi+ecx*04h+__0STAR],edx
jmp @subcol
{@BD} { x3 } nop; nop; nop
{@C0} { x11 } mov eax,7FFFFFFFh; add edx,00h; add ecx,00h
{ x12 } mov eax,7FFFFFFFh; add edx,00h; lea esi,[esi+00h]

@@3RD_STEP:
{0} mov [edi+ebx*04h+__COLON],ecx
{1} or eax,-1
{2} mov ecx,ebp
@markrow:
{@E0} mov byte ptr [edi+ebx*04h+__ROWMARK],0FFh
mov byte ptr [edi+esi*04h+__COLMARK],00h
@@2ND_STEP:
sub ecx,04h
@chk2mtx:
{@EC} mov esi,edi
mov ebx,ebp
{@F0} @check2col:
{0*} add ecx,04h
{1*} jz @@5TH_STEP
{2} cmp byte ptr [edi+ecx*04h+__COLMARK],00h
{0} jnz @check2col
{0} sub ecx,ebp
{1} add esi,ecx
{@00} push ecx
{@01} @zeroincol:
{0} movsx ecx,byte ptr [edi+ebx*04h+__ROWMARK]
{1} or ecx,[esi]
{2} jz @zero
{0} cmp ecx,eax
{1} cmovb eax,ecx
{2} cmovb edx,ebx
{0} sub esi,ebp
{1*} add ebx,04h
{2*} jnz @zeroincol
{@18} @zero:
{0} pop esi
{1} lea ecx,[esi+ebp]
{2} shl esi,10h
{0} cmp edx,00h
{1} mov si,dx
{2} cmovs edx,esi
{0*} test ebx,ebx
{1*} jz @chk2mtx
{2} mov esi,[edi+ebx*04h+__0STAR]
{@30*} test esi,esi
{1*} jz @@4TH_STEP
{2} cmp esi,ecx
{0} mov [edi+ebx*04h+__COLON],ecx
{1} cmovl ecx,esi
{2} cmp dx,bx
{@40} cmovz ecx,ebp
{1} cmovz eax,ebp
{2} jmp @markrow
{ x8 } mov esi,esi; nop; mov eax,7FFFFFFFh
@@5TH_STEP:
{@50} push edx
{@51} @nx5row:
{0} movsx edx,byte ptr [edi+ebx*04h+__ROWMARK]
{1} sub esi,ebp
{2} sub ecx,eax
{0} xor edx,eax
{1} cmovs eax,ecx
{2} mov ecx,ebp
{@60} @decrease_row_free:
{0} mov edx,[edi+ecx*04h+__COLROWMARK]
{1} xor edx,eax
{2} or edx,[esi+ecx]
{0} mov edx,00000000h
{1} cmovns edx,eax
{@70} sub [esi+ecx],edx
{0*} add ecx,04h
{1*} jnz @decrease_row_free
{0*} add ebx,04h
{1*} jnz @nx5row
{@7D} pop ecx
{ x2 } nop; nop
{@80} movsx ebx,cx
shr ecx,10h
add ecx,ebp
mov esi,[edi+ebx*04h+__0STAR]
test esi,esi
{@8E} jnz @@3RD_STEP
@@4TH_STEP:
{0} mov [edi+ebx*04h+__0STAR],ecx
{1} mov edx,ebx
{2} mov ebx,[edi+ecx*04h+__0STARROW]
{0} test ebx,ebx
{@A0} mov [edi+ecx*04h+__0STARROW],edx
{2} mov ecx,[edi+ebx*04h+__COLON]
{0} jnz @@4TH_STEP
@@1ST_STEP:
{@AA} mov ecx,ebp
@restructure:
{0} mov ebx,[edi+ebp*04h+__0STARROW]
{@B0} and edx,ebx
{2} movsx bx,byte ptr [edi+ebp*04h+__FIXEDROW]
{0} mov [edi+ebp*04h+__COLROWMARK],ebx
{1*} add ebp,04h
{2*} jnz @restructure
{@C0} mov ebp,ecx
or eax,-1
test edx,edx
jns @@2ND_STEP

{@CD} mov ebx,[esp+__SAVE]
{@D1} xor edx,edx
mov esi,[esp+__MARKS]
@@results:
{@D7} mov eax,[edi+ecx*04h+__0STAR]
{1} sub ebx,ebp
{2} add edx,[ebx+eax]
{@E0} sub eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{0} lea esi,[esi+01h]
{1*} add ecx,04h
{2*} jnz @@results
{@F0} ...

[ Szerkesztve ]

SSE1 line algoritmus azonos stílusú vonalak láncolt listájára, a #39-hez képest megtáltosítva; align/cím- és Northwood + Merom + K10 portelemzéssel.

Intel processzorokon Core2 óta a MOVD reg,mmreg (2 órajel) gyorsabb, mint az L1D-olvasás (3-4 órajeé), a Sandy Bridge óra pedig kvázi +regiszterkészletként használhatóak az MMX és XMM regiszterek (1 órajel a MOVD oda-vissza). K10-en sem lassabb a MOVD reg,mmreg, mint az L1D-hozzáférés.

{@31} lea edi,[esi+TBITMAPFILE.IDATA+_ADDER] // p01 d (1) alu p0 1 (1) p012 1 (1) ALU
xorps xmm1,xmm1 // p1 2 (1) mmxalu p015 1 (1) p34 2 (1) FA/M
mov eax,[esi+TBITMAPFILE.IDATA+_DX] // p2 2 (1) load p2 2 (1) p012 3 (1) MEM
{@40} cvtpi2ps xmm3,[edi-_ADDER+_TOPLEFT0] // p1+2 10 (4) mmx+load p1+2 (1) p34+5 7 (2) FPU+MEM
pcmpeqd xmm4,xmm4 // p1 2 (1) mmxalu p01 1 (1) p34 2 (1) FA/M
cvtpi2ps xmm2,[edi-_ADDER+_RIGHT] // p1+2 10 (4) mmx+load p1+2 (1) p34+5 7 (2) FPU+MEM
pcmpeqd xmm7,xmm7 // p1 2 (1) mmxalu p01 1 (1) p34 2 (1) FA/M
{@50} mov ecx,[edi-_ADDER+_PEN] // p2 2 (1) load p2 2 (1) p012 3 (1) MEM
pslld xmm4,25 // p1 2 (1) mmxshf p0 1 (1) p34 3 (1) FA/M
mov esi,[esi+TBITMAPFILE.BITS] // p2 2 (1) load p2 2 (1) p012 3 (1) MEM
pslld xmm7,1Fh // p1 2 (1) mmxshf p0 1 (1) p34 3 (1) FA/M
{@60} movd mm2,[edi-_ADDER+_COLOR] // p2 8 (1) mmxalu p2 2 (1) p345 4 (1) FANY
shl eax,10h // p1 4 (1) mmxshf p05 1 (1) p012 1 (1) ALU
movlhps xmm3,xmm2 // p1 2 (1) mmxshf p0 1 (1) p34 3 (1) FA/M
add eax,01h // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
sub edi,ecx // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
{@6F} psrld xmm4,02h // p1 2 (1) mmxshf p0 1 (1) p34 3 (1) FA/M
movd mm0,eax // p1 2 (2) mmxalu p05 2 (1) p012 6 (2) ALU
jmp @1stline // p1 0 (1) branch p5 1 (1) p012 2 (1) ALU
{ x7 } mov eax,00000000h; mov edx,ecx //
@reorder: //
{@80} shufps xmm0,xmm0,11011000b // p1 4 (1) mmxshf p1 3 (3) p34 3 (1) FA/M
@setpixels: //
{@84} cvtps2pi mm1,xmm5 // p0+1 7 (3) fp-mmx p1 3 (1) p5 4 (1) FMISC
movaps xmm2,xmm3 // p0 6 (1) mov p015 1 (1) p345 2 (1) FANY
mov ebx,ecx // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
pshufw mm1,mm1,11011000b // p1 2 (1) mmxshf p5 1 (1) p34 2 (1) FA/M
{@90} cmpltps xmm2,xmm5 // p1 4 (1) fpadd p1 3 (1) p3 (1) FADD
addps xmm5,xmm0 // p1 4 (1) fpadd p1 3 (1) p3 4 (1) FADD
pmaddwd mm1,mm0 // p1 6 (1) fpmul p1 3 (1) p4 3 (1) FMUL
movmskps edx,xmm2 // p1 6 (2) fp p0 1 (1) p34 3 (1) FA/M
cmp edx,03h // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
{@A0} jnz @continueLINE // p0 2 (1) alu p5 1 (1) p012 1 (1) ALU
movd edx,mm1 // p0 5 (2) fp p015 2 (1) p3 3 (1) FADD
@round: //
add edx,[edi+ebx] // p01+2 d+2(2) alu+load p015+2 (1) p012 4 (1) ALU+MEM
mov [esi+edx],al // p0+3 2 (3) store p 34 3 (1) p012 3 (1) MEM
add ebx,04h // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
js @round // p0 0 (1) branch p5 1 (1) p012 1 (1) ALU
@continueLINE: //
{@B0} sub ebp,01h // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
jge @setpixel // p0 0 (1) branch p5 1 (1) p012 1 (1) ALU
@nxline: //
{@B5} movd ebx,mm3 // p0 5 (2) fp p015 2 (1) p3 3 (1) FADD
@1stline: //
{@B8} cmp ebx,00h // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
jz @return // p0 0 (1) branch p5 1 (1) p012 1 (1) ALU
mov eax,[ebx+TMAPRECORD.REF] // p2 2 (1) load p2 2 (1) p012 3 (1) MEM
{@C0} mov edx,[ebx+TMAPRECORD.SELF] // p2 2 (1) load p2 2 (1) p012 3 (1) MEM
mov ebp,[eax+TMAPHEADER.YCOOR] // p2 2 (1) load p2 2 (1) p012 3 (1) MEM
cvtpi2ps xmm5,[edx+TMAPHEADER.XCOOR] // p1+2 10+2(4) mmx+load p1+2 (1) p34+5 7 (2) FPU+MEM
mov eax,[eax+TMAPHEADER.XCOOR] // p2 2 (1) load p2 2 (1) p012 3 (1) MEM
sub ebp,[edx+TMAPHEADER.YCOOR] // p01+2 d+2(2) alu+load p015+2 (1) p012 4 (1) ALU+MEM
sub eax,[edx+TMAPHEADER.XCOOR] // p01+2 d+2(2) alu+load p015+2 (1) p012 4 (1) ALU+MEM
{@D0} xor edx,edx // p0 d (1) logic p015 1 (1) p012 1 (1) ALU
movlhps xmm5,xmm5 // p1 2 (1) mmxshf p0 1 (1) p34 3 (1) FA/M
movd mm3,ds:[ebx+TMAPRECORD.NX] // p2 8 (1) mmxalu p2 2 (1) p345 4 (1) FANY
xor ebx,ebx // p0 d (1) logic p015 1 (1) p012 1 (1) ALU
sub edx,ebp // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
cmovs edx,ebp // p0+1 6 (3) alu p015 2 (2) p012 1 (1) ALU
{@E0} sub ebx,eax // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
cmovs ebx,eax // p0+1 6 (3) alu p015 2 (2) p012 1 (1) ALU
cmp edx,ebx // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
mov ebx,ebp // p01 d (1) alu p015 1 (1) p012 1 (1) ALU
cmovb ebx,eax // p0+1 6 (3) alu p015 2 (2) p012 1 (1) ALU
cmovb eax,ebp // p0+1 6 (3) alu p015 2 (2) p012 1 (1) ALU
cmovb ebp,ebx // p0+1 6 (3) alu p015 2 (2) p012 1 (1) ALU
{@F2} sbb edx,edx // p1 5 (3) alu p015 2 (2) p012 1 (1) ALU
neg ebx // p0 d (1) alu0 p015 1 (1) p012 1 (1) ALU
mov ecx,ecx //
cvtsi2ss xmm0,eax // p1 10 (3) fp-mmx p1 4 (1) p345 14 (v) FPU+ALU
cvtsi2ss xmm1,ebp // p1 10 (3) fp-mmx p1 4 (1) p345 14 (v) FPU+ALU
{@00} movaps xmm2,xmm1 // p0 6 (1) mov p015 1 (1) p345 2 (1) FANY
divss xmm0,xmm1 // p1 23 (1) fpdiv p0 17 (1) p4 16 (1) FMUL
cmovns ebp,ebx // p0+1 6 (3) alu p015 2 (2) p012 1 (1) ALU
shufps xmm2,xmm2,00000000b // p1 4 (1) mmxshf p1 3 (3) p34 3 (1) FA/M
test edx,edx // p0 d (1) logic p015 1 (1) p012 1 (1) ALU
{@10} andps xmm2,xmm7 // p1 2 (1) mmxalu p015 1 (1) p34 2 (1) FA/M
shufps xmm0,xmm4,00000000b // p1 4 (1) mmxshf p1 3 (3) p34 3 (1) FA/M
movd eax,mm2 // p0 5 (2) fp p015 2 (1) p3 3 (1) FADD
xorps xmm0,xmm2 // p1 2 (1) mmxalu p015 1 (1) p34 2 (1) FA/M
{@1D} jz @reorder // p0 0 (1) branch p5 1 (1) p012 2 (1) ALU
{@23} shufps xmm0,xmm0,01110010b // p1 4 (1) mmxshf p1 3 (3) p34 3 (1) FA/M
jmp @setpixels // p1 0 (1) branch p5 1 (1) p012 2 (1) ALU
@return:
popad
emms

[ Szerkesztve ]

A vonalakhoz tartozó koordináták kiszámolása (a gráf sajátosságai szerint) és a látható pontok összegyűjtése:

push eax
or ebp,-1
mov edx,00000001h
xorps xmm2,xmm2
{@4F} mov ebx,[source]
cvtsi2ss xmm1,edx
movlps xmm2,[eax+TMAP.NX]
xorps xmm3,xmm3
{@60} mov esi,[destination]
divss xmm1,[eax+TMAP.ZOOM]
xorps xmm0,xmm0
mov edi,[ebx+04h]
{@70} cvtpi2ps xmm3,[eax+TMAP.BITMAP+TBITMAPFILE.XSIZE]
shufps xmm1,xmm1,10100000b
jmp @storecoor
{ x6 } add eax,00h; add edx,00h
{ x1 } nop
@SSEcoor:
{@81}{0}movlps xmm0,[edi+HEADER.X]
{1}movzx eax,byte ptr [edi+HEADER.FIELD0]
{2}movaps xmm5,xmm1
{0}movzx ebx,word ptr [edi+HEADER.SIZE]
{@90}{1}mulps xmm5,xmm0
{2}movaps xmm4,xmm3
{0}subps xmm5,xmm2
{1}add eax,eax
{2}sub ebx,01h
{0}movlhps xmm4,xmm5
{@A1}{1}movsx ebp,al
{2}or ebp,ebx
{0}cvtps2pi mm0,xmm5
{1}sar ebp,1Fh
{2}cmp byte ptr [edi+HEADER.FIELD1],01h
{@B0}{0}subps xmm4,xmm5
{1}mov [esi],edi
{2}movmskps edx,xmm4
{0}sbb ebp,edx
{1}movq [edi+HEADER.XCOOR],mm0
{2}sar ebp,1Fh
{@C0}{0}rcr al,01h
{1}mov [edi+HEADER.FIELD0],al
{2}lea edi,[edi+ebx+HEADERSIZE+01h]
@storecoor:
{0}lea esi,[esi+ebp*04h+04h]
{1}sub ecx,01h
{@D0}{2}jnle @SSEcoor
pop eax
xor ecx,ecx
emms
mov [esi],ecx

{@50} { x1 } nop
@ENTRY:
{@51} mov ebp,[esi-08h+_PRIO]
movd edi,mm4
mov ecx,[esi-08h+_DIST]
or eax,-1
mov edi,[edi+ebp*04h]
{@60} movq mm1,[esi+ebx*08h]
sub ebx,eax
jg @finish
movd mm2,[esi-08h+_DIST]
jz @descriptor
{@6E} prefetchnta [edi]
{@71} jmp @down
@movedown:
{0}mov ebp,[esi+eax*08h+_PRIO]
{1}mov [esi+ecx*08h+_DIST],edx
{2}mov [esi+ecx*08h+_PRIO],ebp
@down:
{0}mov [esi+ebp*04h+_CONN],ecx
{@80}{1}mov ecx,eax
{2}add eax,eax
{0}cmp eax,ebx
{1}jb @INSERTDOWN
{2}mov edx,[esi+eax*08h-00h+_DIST]
{0}cmp [esi+eax*08h-08h+_DIST],edx
{@90}{1}cmovb edx,[esi+eax*08h-08h+_DIST]
{2}sbb eax,00h
{0}cmp edx,[esi+ebx*08h-08h+_DIST]
{1}jb @movedown
{2}{ x2 } xor eax,eax
@INSERTDOWN:
{@A0} movd ebp,mm1
movq [esi+ecx*08h],mm1
@descriptor:
movzx edx,word ptr [edi+HEADER.RCSIZE]
lea edx,ds:[edi+HEADERSIZE+edx-RECORDSIZE]
{@B0} add edi,HEADERSIZE
mov [esi+__COUNTER],edx
mov [esi+ebp*04h+_CONN],ecx
jmp @nxrecord
{ x6 } mov eax,00000000h; nop
@INSERTUP:
{@C0} mov [esi+ebp*08h+_PRIO],ecx
mov [esi+ebp*08h+_DIST],edx
movd ebx,mm0
mov [esi+ecx*04h+_CONN],ebp
@CONNECTS:
cmp edi,[esi+__COUNTER]
{@CF} jae @entry
{@D1} add edi,TMAPRECORDSIZE
@nxrecord:
{@D4} mov ecx,ds:[edi+RECORD.LINKED]
mov eax,[esi+ecx*04h+_CONN]
cmp eax,01h
jge @connects
{@E0} movzx edx,word ptr [edi+RECORD.FIELD0]
movd ebp,mm2
lea edx,ds:[ebp+edx]
sbb ebp,ebp
xor edx,ebp
{@EF} cmp edx,[esi+eax*08h+_DIST]
{@F3} jge @connects
add ebx,ebp
xor edx,ebp
and ebp,ebx
add eax,ebp
movd mm0,ebx
@moveup:
{@00}{0}mov ebp,eax
{1}sar eax,01h
{2}adc eax,00h
{0}cmp edx,[esi+eax*08h+_DIST]
{1}jae @INSERTUP
{2}mov ebx,[esi+eax*08h+_PRIO]
{@10}{0}movq mm1,[esi+eax*08h]
{1}movq [esi+ebp*08h],mm1
{2}mov [esi+ebx*04h+_CONN],ebp
{0}jmp @moveup

A gulács megszá'tta a lélkömet, oszt' ezör fontosabb dolgom volt eddig, mint hajlítani ezen a programon.

De "új év, új szemlélet", hülyébbek meg nem lettünk, szóval ugyan kisebb IPC, de okosabb megközelítés.

Van benne egy csomó NOP is, az arra fogékonyak kedvéért.

Sebességnövekedés:
Pentium 4: +6%
K10: +20,5%
Core2 +32,4%

xor ebx,ebx
mov esi,ebp
mov ecx,ebp
and esi,-8
add esp,ebp
mov eax,edi
{@F1} @mark0:
{0} mov [edi+esi*04h+00h+__0STARROW],ebx
{1} mov [edi+esi*04h+10h+__0STARROW],ebx
{2*} add esi,08h
{0*} jnz @mark0
{ x2 } nop; nop
@@ARGUMENT:
{@00} movsx esi,byte ptr [edx]
{1} cmp esi,ebx
{2} lea esi,[ebp+esi*04h]
{0} mov [edi+esi*04h+__0STARROW],ecx
{1} cmovs esi,ebx
{@10} mov [edi+ecx*04h+__COLROWMARK],esi
{0} inc edx
{1} mov [edi+ecx*04h+__0STAR],esi
{2*} add ecx,04h
{0*} jnz @@ARGUMENT
{ x1 } nop
mov edx,ebp
{@20} jmp @freerow
{ x3 } add eax,00h
{@25} @subrow:
{0} sub [eax+ecx],esi
{1*} add ecx,04h
{2*} jnz @subrow
{ x3 } add ebx,00h
@@REDUCE_ROWS:
{0*} add edx,04h
{1*} jz @@REDUCE_COLUMNS
@freerow:
{2} sub eax,ebp
{0**} cmp [edi+edx*04h+__0STAR],ecx
{1**} jnz @@REDUCE_ROWS
{2} or esi,-1
{@40-} mov ecx,ebp
@findrowmin:
{@42} mov ebx,[eax+ebp]
{1} or ebx,[edi+ebp*04h+__0STARROW]
{2} cmp esi,ebx
{0} cmova esi,ebx
{1*} add ebp,04h
{2*} jnz @findrowmin
{0-} mov ebp,ecx
{1**} cmp esi,00h
{2**} jns @subrow
@@ABNORMAL_EXIT:
{@5A} sub esp,ebp
mov esi,[esp+__MARKS]
or edx,-1
{@60} mov [esi+TRESULT.OPTIMUM],edx
mov ebx,[esi+TRESULT.NEXTIVALUE]
jmp dword ptr [esp+_INVALIDRESULT]
{ x3 } add ebp,00h
@@REDUCE_COLUMNS:
{0} sub edx,04h
{1} sub eax,04h
{2**} cmp edx,ebp
{0**} jb @@1ST_STEP
{1**} cmp [edi+edx*04h+__0STARROW],ecx
{2**} jnz @@REDUCE_COLUMNS
{@80-} mov esi,ebp
{@82} @findcolmin:
{0} mov ebx,[eax]
{1} or ebx,[edi+ecx*04h-10h+__COLROWMARK]
{2} sub ecx,04h
{0} cmp esi,ebx
{1} cmova esi,ebx
{@90} add eax,ebp
{0**} cmp ecx,ebp
{1**} jnz @findcolmin
{0-} xor ebx,ebx
{1} sub ecx,04h
{2**} cmp esi,00h
{0**} js @@ABNORMAL_EXIT
{@A0} @subcol:
{0*} add ecx,04h
{1*} jz @@REDUCE_COLUMNS
{2} sub eax,ebp
{0} sub [eax],esi
{1} jnz @subcol
{0**} cmp ebx,[edi+ecx*04h+__0STAR]
{@AF**} jnz @subcol
{@B1} mov [edi+edx*04h+__0STARROW],ecx
not ebx
mov [edi+ecx*04h+__0STAR],edx
jmp @subcol


@@3RD_STEP:
{@C0} mov [edi+ebx*04h+__COLON],ecx
@re2start:
{@C4-} mov edx,ebp
lea ecx,[ebp-04h]
@mark2row:
{@C9} mov byte ptr [edi+ebx*04h+__ROWMARK],0FFh
{?-} xor ebx,ebx
mov [edi+esi*04h+__COLMARK],bl
@@2ND_STEP:
{@D3} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*04h+__COLROWMARK],ebp
{0**} js @@2ND_STEP
push ecx
mov ebx,ebp
{@E0} sub ecx,ebp
{@E2} @zeroincol:
{0} movsx esi,byte ptr [edi+ebx*04h+__ROWMARK]
{1} or esi,[edi+ecx]
{2} jz @zero
{0} cmp esi,edx
{1} cmovb edx,esi
{@F0} cmovb eax,ebx { >= EBP }
{0} sub ecx,ebp
{1*} add ebx,04h
{2*} jnz @zeroincol
{@FA} @zero:
{0} pop esi
{1-} mov ecx,esi
{2} shl esi,10h
{@00} cmp eax,ebp
{1} mov si,ax { ESI < EBP }
{2} cmovge eax,esi
{0**} test ebx,ebx
{1**} jz @@2ND_STEP
{2} mov esi,[edi+ebx*04h+__0STAR]
{@10**} test esi,esi
{1**} jz @@4TH_STEP
{2} cmp esi,ecx
{0} mov [edi+ebx*04h+__COLON],ecx
{1} cmovl ecx,esi
{2**} cmp ax,bx
{@20**} jz @re2start
{1} sub ecx,04h
{2} jmp @mark2row
@@5TH_STEP:
{0} mov [edi+00h*04h+__COLROWMARK],eax { matrix[0,
{1-} mov esi,ebp
{2F} @markedrows:
{0} sub ecx,ebp
{@31} movsx eax,byte ptr [edi+esi*04h+__ROWMARK]
{2} mov [esp+ebx*04h+04h],ecx
{0} sub ebx,eax
{1*} add esi,04h
{2*} jnz @markedrows
{@40} mov [esp+00h],ebx
{1} lea esi,[edi+ebp-04h]
{2} jmp @chk5col
@increase:
{@49-} xor ecx,ecx
{1} test [esi+ebx],ebp
{2} cmovns ecx,edx
{0} add [esi+ebx],ecx
{1} mov ebx,[esp+eax*04h]
@increase_marked_col:
{2*} sub eax,01h
{0*} jns @increase
{1-2} { x4 } xor eax,eax; xor ecx,ecx
@chk5col:
{@60} sub esi,edi
{1-} mov eax,ebx
{2} mov ecx,[edi+esi*04h+04h*04h+__COLROWMARK]
{0} mov ebx,[esp+ebx*04h]
{1*} add esi,04h
{2*} jz @zero5item
{@70} add esi,edi
{1} sar ecx,1Fh
{2} js @increase_marked_col
@decrease_free_col: { IPC: 2.6 }
{@77} sub ecx,ebp
{1} { x5 } mov eax,00000000h
{2-} mov ebx,ebp
@decrease:
{@80} movsx eax,byte ptr [edi+ebx*04h+__ROWMARK]
{1} or eax,[esi+ecx]
{2} mov eax,00000000h
{0} cmovns eax,edx
{1} sub [esi+ecx],eax
{2} sub ecx,ebp
{0*} add ebx,04h
{1*} jnz @decrease
{0} mov ebx,[esp+00h]
{1} jmp @chk5col
@zero5item:
{@9E} mov edx,ebp
{@A0} movsx ebx,cx
sar ecx,10h
add esi,[edi+ebx*04h+__0STAR]
jnz @@3RD_STEP
@@4TH_STEP:
{0} mov [edi+ebx*04h+__0STAR],ecx
{1-} mov edx,ebx
{2} mov ebx,[edi+ecx*04h+__0STARROW]
{0} mov [edi+ecx*04h+__0STARROW],edx
{1} mov ecx,[edi+ebx*04h+__COLON]
{2**} test ebx,ebx
{0**} jnz @@4TH_STEP
@@1ST_STEP:
{@86-} mov ebx,ebp
@restructure:
{@88} mov esi,[edi+ebx*04h+__0STARROW]
{1} and edx,esi
{2} movsx si,byte ptr [edi+ebx*04h+__FIXEDROW]
{0} mov [edi+ebx*04h+__COLROWMARK],esi
{1*} add ebx,04h
{2*} jnz @restructure
xor edx,ebp
{9E} lea ecx,[ebp-04h]
js @@2ND_STEP


xor edx,edx
sub esp,ebp
mov ecx,ebp
mov ebx,[esp+__SAVE]
mov esi,[esp+__MARKS]
@@results:
{@B5} mov eax,[edi+ecx*04h+__0STAR]
{1} sub ebx,ebp
{2} add edx,[ebx+eax]
{0} sub eax,ebp
{@C0} shr eax,02h
{2} mov [esi],al
{1} add esi,01h
{2*} add ecx,04h
{0*} jnz @@results

[ Szerkesztve ]

Tovább zajlik az ötletcunami, az egy héttel ezelőtti verzió óta ennyivel gyorsult (már 60x60-as mátrixokon tesztelem, kisebben okafogyottá válik; 60 másodpercnyi számítási ideje van):

Core2 (2.5 GHz): +9% (60 sec alatt 266000 -> 290000 mátrix)
K10 (2.9 GHz): +8% (60 sec alatt 360000 -> 390000 mátrix)
Ivy Bridge (3.8 GHz): +6% (60 sec alatt 450000 -> 480000 mátrix)

(a * jelölés a lehetséges macro-fusion min. Sandy Bridge-n, a ** jelölés a lehetséges macro-fusion Core2-n ill. Bulldozeren, a - jelölésű utasítások nem igényelnek végrehajtót min. Sandy Bridge-en)

xor ebx,ebx
mov esi,ebp
mov ecx,ebp
and esi,-8
add esp,ebp
mov eax,edi
{@F1} @mark0:
{0} mov [edi+esi*04h+00h+__0STARROW],ebx
{1} mov [edi+esi*04h+10h+__0STARROW],ebx
{2*} add esi,08h
{0*} jnz @mark0
push edi
@@ARGUMENT:
{ EDX: ARGUMENT memory address
{@00} movsx esi,byte ptr [edx]
{1} cmp esi,ebx
{2} lea esi,[ebp+esi*04h]
{0} mov [edi+esi*04h+__0STARROW],ecx
{1} cmovs esi,ebx
{@10} mov [edi+ecx*04h+__COLROWMARK],esi
{0} inc edx
{1} mov [edi+ecx*04h+__0STAR],esi
{2*} add ecx,04h
{0*} jnz @@ARGUMENT
mov edx,ebp
{@20} jmp @freerow
{@25} @subrow:
{0} sub [eax+ecx],esi
{1*} add ecx,04h
{2*} jnz @subrow
@@REDUCE_ROWS:
{0*} add edx,04h
{1*} jz @@REDUCE_COLUMNS
@freerow:
{2} sub eax,ebp
{0**} cmp [edi+edx*04h+__0STAR],ecx
{1**} jnz @@REDUCE_ROWS
{2} or esi,-1
{@40-} mov ecx,ebp
{@42} @findrowmin:
{0} mov ebx,[eax+ebp]
{1} or ebx,[edi+ebp*04h+__0STARROW]
{2} cmp esi,ebx
{0} cmova esi,ebx
{1*} add ebp,04h
{2*} jnz @findrowmin
{0-} mov ebp,ecx
{1**} cmp esi,00h
{2**} jns @subrow
@@ABNORMAL_EXIT:
{@5A} pop esi
mov edx,0FFFFFFFFh
{@60} sub esp,ebp
mov esi,[esp+__MARKS]
mov [esi+TRESULT.OPTIMUM],edx
mov ebx,[esi+TRESULT.NEXTIVALUE]
jmp dword ptr [esp+_INVALIDRESULT]
@@REDUCE_COLUMNS:
{0} sub edx,04h
{1} sub eax,04h
{2**} cmp edx,ebp
{0**} jb @@1ST_STEP
{1**} cmp [edi+edx*04h+__0STARROW],ecx
{2**} jnz @@REDUCE_COLUMNS
{@A0-} mov esi,ebp
{@A2} @findcolmin:
{0} mov ebx,[eax]
{1} or ebx,[edi+ecx*04h-10h+__COLROWMARK]
{2} sub ecx,04h
{0} cmp esi,ebx
{1} cmova esi,ebx
{@B0} add eax,ebp
{0**} cmp ecx,ebp
{1**} jnz @findcolmin
{0-} xor ebx,ebx
{1} sub ecx,04h
{2**} cmp esi,00h
{0**} js @@ABNORMAL_EXIT
{@C0} @subcol:
{0*} add ecx,04h
{1*} jz @@REDUCE_COLUMNS
{2} sub eax,ebp
{0} sub [eax],esi
{1} jnz @subcol
{0**} cmp ebx,[edi+ecx*04h+__0STAR]
{@CF**} jnz @subcol
{@D1} mov [edi+edx*04h+__0STARROW],ecx
not ebx
mov [edi+ecx*04h+__0STAR],edx
jmp @subcol

@@3RD_STEP:
{@E0} mov [edi+ebx*04h+__COLON],ecx
{1-} mov edx,ebp
{2} lea ecx,[ebp-04h]
{@E9} @mark2row:
{0} mov byte ptr [edi+ebx*04h+__ROWMARK],80h
{1-} xor ebx,ebx
{2} mov [edi+esi*04h+__COLMARK],bl
@@2ND_STEP:
{@F3*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*04h+__COLROWMARK],ebp
{0**} js @@2ND_STEP
{0} push ecx
{1-} mov ebx,ebp
{@00} sub ecx,ebp
{@02} @zeroincol:
{0} movsx esi,byte ptr [edi+ebx*04h+__ROWMARK]
{1} or esi,[edi+ecx]
{2} jz @zero
{0} cmp esi,edx
{1} cmovb edx,esi
{@10} cmovb eax,ebx { >= EBP }
{0} sub ecx,ebp
{1*} add ebx,04h
{2*} jnz @zeroincol
{@1A} @zero:
{0} pop esi
{1-} mov ecx,esi
{2} shl esi,10h
{@20} cmp eax,ebp
{1} mov si,ax { ESI < EBP }
{2} cmovge eax,esi
{0**} test ebx,ebx
{1**} jz @@2ND_STEP
{2} mov esi,[edi+ebx*04h+__0STAR]
{@30**} test esi,esi
{1**} jz @@4TH_STEP
{2**} cmp ax,bx
{0**} jz @@3RD_STEP
{1} cmp esi,ecx
{2} mov [edi+ebx*04h+__COLON],ecx
{0} cmovl ecx,esi
{1} sub ecx,04h
{2} jmp @mark2row
@@5TH_STEP:
{0} mov [edi+00h*04h+__COLROWMARK],eax
{1-} mov ecx,edi
{2-} mov esi,ebp
{@66} @markedrows:
{0} sub ecx,ebp
{1-} xor eax,eax
{2} cmp [edi+esi*04h+__ROWMARK],ax
{0} setg al
{1} mov [esp+__OFFS+ebx*04h],ecx
{2} add ebx,eax
{0*} add esi,04h
{1*} jnz @markedrows
{0} mov [esp+__SIZE],ebx
{@80} lea esi,[ebp-04h]
{2} jmp @check5column
{@8A} @inc5mark:
{0-} xor ecx,ecx
{1} test [esi+ebx],ebp
{2} cmovns ecx,edx
{@92} add [esi+ebx],ecx
{1-} mov ebx,edi
@inc5_marked_col:
{2} mov edi,[esp+eax*04h]
{0*} sub eax,01h
{1*} jns @inc5mark
{@A0} @check5column:
{0-} mov eax,ebx
{1} mov ecx,[edi+esi*04h+10h+__COLROWMARK]
{2} mov ebx,[esp+__SIZE+ebx*04h]
{0*} { x3 } db $81,$C6,$04,$00,$00,$00 { add esi,00000004h }
{@B0*} jz @zero5item
{2**} { x4 } test ecx,80000000h
{0**} js @inc5_marked_col
{@BA} @dec5_free_col:
{0-} mov ecx,edi
{1-} mov ebx,ebp
{2} sub ecx,ebp
{@C0} @dec5free:
{0} movsx eax,byte ptr [edi+ebx*04h+__ROWMARK]
{1} or eax,[esi+ecx]
{2} mov eax,00000000h
{0} cmovns eax,edx
{1} sub [esi+ecx],eax
{@D2} sub ecx,ebp
{0*} add ebx,04h
{1*} jnz @dec5free
{0} mov ebx,[esp+__SIZE]
{1} jmp @check5column
{@E0} @zero5item:
{0} movsx ebx,cx
{1} sar ecx,10h
{2*} add esi,[edi+ebx*04h+__0STAR]
{0*} jnz @@3RD_STEP
@@4TH_STEP:
{0} mov [edi+ebx*04h+__0STAR],ecx
{1-} mov edx,ebx
{2} mov ebx,[edi+ecx*04h+__0STARROW]
{0} mov [edi+ecx*04h+__0STARROW],edx
{1} mov ecx,[edi+ebx*04h+__COLON]
{2**} test ebx,ebx
{0**} jnz @@4TH_STEP
@@1ST_STEP:
{ EDX: negative
{@07-} mov ebx,ebp
{@09} @restructure:
{0} mov esi,[edi+ebx*04h+__0STARROW]
{1} and edx,esi
{2} add ebx,04h
{0} movsx si,byte ptr [edi+ebx*04h-10h+__FIXEDROW]
{1} mov [edi+ebx*04h-10h+__COLROWMARK],esi
{2} jnz @restructure { clears EBX register }
{0} xor edx,ebp
{@20} lea ecx,[ebp-04h]
{2} js @@2ND_STEP

{0} sub esp,ecx
{1-} xor edx,edx
{2-} mov ecx,ebp
{0} mov ebx,[esp+__SAVE]
{1} mov esi,[esp+__MARKS]
@@results:
{@37} mov eax,[edi+ecx*04h+__0STAR]
{1} sub ebx,ebp
{2} add edx,[ebx+eax]
{@40} sub eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{0} add esi,01h
{1*} add ecx,04h
{2*} jnz @@results

A legutolsó mért eredmény 25x25-ös mátrixra 71000/sec, a fenti kód most 105000 mátrix/sec az azonos tesztadatra (+47,8%).

[ Szerkesztve ]

.

[ Szerkesztve ]

Mint a zipzár, az alábbi kód úgy zárt össze a K10 és a Core2 fogaskerekeivel.

Core2 (2.5 GHz): 60 sec alatt 290000 -> 308000 mátrix
K10 (2.9 GHz): 60 sec alatt 390000 -> 428000 mátrix
Ivy Bridge (3.8 GHz): 60 sec alatt 480000 -> 497000 mátrix

A tesztfeladat teljes lefutásához ~565000 mátrix megoldására van szükség; már nincs messze, hogy valamelyiken 60 sec alatt meglegyen.
Sikerült újra elérni a K10-en a lefutás alatti folyamatos 2.3-2.4 IPC-t, illetve Core2-n a 2.2 IPC-t (ami a ciklusonkénti legalább 1 cmovcc miatt ~2.5-2.6 fused uop/clock); illetve a Core2 miatt eliminálásra került az összes load-op-store művelet a ciklusokból, meg is hálálta.

A K10-ben rengeteg potenciál van (3 ALU, 2 L1D-olvasás/clock, cmovcc=1 uop, 3 clock L1D-latency), csak nagyon nehéz eltalálni a megfelelő decode miatti utasításelrendezést (a K8-on 2 db 16 byte-os instruction buffer volt az L1C után, a K10-ben viszont egyetlen 32 byte-os buffer van), illetve azt, hogy a "számítási" utasítások ne ütközzenek a 3 ALU-ban a statikus leosztás miatt (itt főleg a sok movsx reg,mem okoz gondot).
A Core2 attól szenved, hogy a cmovcc utasítások nemcsak hogy 2 végrehajtót igényelnek, de az utasításdekódolást is befolyásolják, mert ezen utasítások csak az első dekóderbe mehetnek, a 4-1-1-1 minta szerint, ezért a legtöbb 8 utasításos ciklus is csak 3 órajel alatt dekódolható.
A Bulldozer-alapú CPU-k is szenvednek a K10-hez képest, ott viszont az a gond, hogy magonként csak 2 számítási végrehajtó (EX0 és EX1) van a két AGU mellett (míg K7-ben, K8-ban, K10-ben, Core2-Ivy Bridge-ben 3, Haswell-ben 4), ebbe kell beletuszkolni a 8 utasításos ciklusok 7-8 számítási uop-ját, ezért ezek lefutása nem tud kevesebb lenni, mint 4 órajel; ehhez viszont kevés a ~4 GHz órajel, 1.5x akkora frekvencia kellene, mint a K10-nél (vagy legalább egy igazi AGLU).
Az Ivy Bridge kiegyensúlyozottan teljesít, az uop-cache miatt a dekódolás nem szűk keresztmetszet és a kódban elég sok macro-op fusion is van, de azért a folyamatos, garantált 4 uop/clock kicsit sovány a Core 2 4-1-1-1 mintájából kinyerhető 7 uop/clock-hoz képest. Mindenesetre itt a legkisebb a nyereség, mi azt mutatja, hogy alapvetően itt volt a legnagyobb a hatékonyság.

{0-} mov ecx,esp
{1-} xor ebx,ebx
{2} add esp,ebp
{0-} mov esi,ebp
{1} or eax,-1
{2} add esp,ebp
{@F1} @mark0:
{0} mov [edi+esi*04h+__0STARROW],ebx
{1} mov [ecx+esi*02h],eax
{2*} add esi,04h
{0*} jnz @mark0
mov eax,ebp
{ x1 } nop
@@ARGUMENT:
{@00} movsx ecx,byte ptr [edx]
{1} mov [esp+ecx*08h],ebx
{2} cmp ecx,ebx
{0} lea ecx,[eax+ecx*04h]
{1} mov [edi+ecx*04h+__0STARROW],ebp
{@0F} cmovs ecx,ebx
{0} mov [edi+ebp*04h+__COLROWMARK],ecx
{1} inc edx
{2} mov [edi+ebp*04h+__0STAR],ecx
{0*} add ebp,04h
{1*} jnz @@ARGUMENT
{0 } push eax
{@20-} mov ebp,eax
{2-} mov edx,eax
{0-} mov eax,edi
{1} jmp @chk0row
{@28} @subrow:
{0} sub [eax+esi],ecx
{1*} add esi,04h
{2*} jnz @subrow
@@REDUCE_ROWS:
{0*} add edx,04h
{1*} jz @@REDUCE_COLUMNS
@chk0row:
{2} sub eax,ebp
{0**} cmp [edi+edx*04h+__0STAR],esi
{1**} jnz @@REDUCE_ROWS
{2} or ecx,-1
{@40-} mov esi,ebp
{@42} @findrowmin:
{0} mov ebx,[eax+ebp]
{1} or ebx,[edi+ebp*04h+__0STARROW]
{2} cmp ecx,ebx
{0} cmova ecx,ebx
{1*} add ebp,04h
{2*} jnz @findrowmin
{0-} mov ebp,esi
{1} test ecx,0FFFFFFFFh { JS/JNS can only fuse with TEST }
{2} jns @subrow
@@ABNORMAL_EXIT:
{@5D} pop esi
sub esp,ebp
{@60} or edx,-1
sub esp,ebp
mov esi,[esp+__MARKS]
mov [esi+TRESULT.OPTIMUM],edx
mov ebx,[esi+TRESULT.NEXTIVALUE]
jmp dword ptr [esp+_INVALIDRESULT]
{@83} @initcol:
mov [esp+00h*08h+__FIXCOL],ecx
jmp @@1ST_STEP
{ x2 } xor ecx,ecx
@@REDUCE_COLUMNS:
mov esi,ebp
{@90} lea ecx,[edx-04h]
@chk0col:
{0} sub edx,04h
{1**} cmp edx,ebp
{2**} jb @initcol
{0**} test [edi+edx*04h+__0STARROW],ebp
{1**} js @chk0col
{@A0} { x1 } xor ecx,ecx; nop
@findcolmin:
{0} { x1 } db $8B,$5C,$02,$00 { mov ebx,[eax+edx+00h] }
{1} or ebx,[edi+ecx*04h-10h+__COLROWMARK]
{2} sub ecx,04h
{0} cmp esi,ebx
{@B0} cmova esi,ebx
{2} add eax,ebp
{0**} cmp ecx,ebp
{1**} jnz @findcolmin
{0-} xor ebx,ebx
{1} sub ecx,04h
{2} test esi,0FFFFFFFFh { JS/JNS can only fuse with TEST }
{0} js @@ABNORMAL_EXIT
{@C6} @subcol:
{0*} add ecx,04h
{1*} jz @@REDUCE_COLUMNS
{2} sub eax,ebp
{0} sub [eax+edx],esi
{@D0} jnz @subcol
{0**} cmp ebx,[edi+ecx*04h+__0STAR]
{1**} jnz @subcol
{2} mov [edi+edx*04h+__0STARROW],ecx
{0} mov [edi+ecx*04h+__0STAR],edx
{@E0} not ebx
{2} jmp @subcol
{ x2 } cmp edi,edi

@3RD_STEP_rowaddr:
{0} lea eax,[ebp-04h]
{1} sub eax,ebx
{2} mov [edi+ebx*04h+__COLON],ecx
{0} imul eax,ebp
{@F2} sar eax,02h
{2} add eax,edi
@@3RD_STEP:
{@F7-} mov edx,ebp
{1} mov ecx,[esp+00h*08h+__FIXCOL]
{@FD} @mark2row:
{0} mov byte ptr [edi+esi*04h+__COLMARK],000h
{@02} mov esi,[esp+__SIZE]
{2} mov byte ptr [edi+ebx*04h+__ROWMARK],0FFh
{0} mov [esp+__OFFS+esi*08h],eax
{1} add esi,01h
{@11-} { x1 } nop
@@2ND_STEP:
{@12} mov [esp+__SIZE],esi
@chk2col:
{@16*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*04h+__COLROWMARK],ebp
{0**} js @chk2col
{@20} lea eax,[ecx+edi]
{1} sal ecx,10h
{2-} mov ebx,ebp
{0} sub eax,ebp
{@2A} @zeroincol:
{0} movsx esi,byte ptr [edi+ebx*04h+__ROWMARK]
{1} or esi,[eax]
{@30} jz @zero
{0} cmp esi,edx
{1} cmovb edx,esi
{2} cmovb cx,bx
{0} sub eax,ebp
{1*} add ebx,04h
{@40*} jnz @zeroincol
{@42} @zero:
{0-} mov esi,ecx
{1} sar ecx,10h
{2} cmovnc esi,[edi+00h]
{0} mov [edi+00h],esi
{1**} test ebx,ebx
{2**} jz @chk2col
{@50} mov esi,[edi+ebx*04h+__0STAR]
{1**} test esi,esi
{2**} jz @@4TH_STEP
{0} mov [edi+ebx*04h+__COLON],ecx
{@60} sub eax,ecx
{2**} { x1 } db $66,$39,$5F,$00 { cmp word [edi+00h],bx
{0**} jz @@3RD_STEP
{1} cmp esi,ecx
{2} cmovl ecx,esi
{0*} sub ecx,04h
{@70*} jnz @mark2row
@@5TH_STEP:
{0} mov esi,[esp+00h*08h+__FIXCOL]
{1} mov ebx,[esp+__SIZE]
{2} push dword ptr [edi+00h]
{0} jmp @chk5col
{ x2 } xor eax,eax
{@80} @inc5mark:
{0} mov eax,[esi+ebx]
{1} add eax,edx
{2} cmovc eax,[esi+ebx]
{0} mov [esi+ebx],eax
{1-} mov ebx,ebp
@inc5_marked_col:
{2} mov ebp,[esp+ecx*08h+__PUSHED]
{@92*} sub ecx,01h
{1*} jnc @inc5mark
{@97} @chk5col:
{0} lea eax,[esi+04h]
{1-} mov esi,eax
{2**} test eax,eax
{0**} jz @zero5item
{@A0} mov ecx,[edi+eax*04h+__COLROWMARK]
{2} sub eax,ebp
{0**} test [esp+eax*02h+__FIXCOL+__PUSHED],esi
{1**} jns @chk5col
{2} cmp ecx,00h
{0-} mov ecx,ebx
{@B0} mov ebx,[esp+__SIZE+ebx*08h+__PUSHED]
{2} js @inc5_marked_col
{0} movsx ebx,byte ptr [edi+ebp*04h+__ROWMARK]
{1} add eax,edi
{2-} mov ecx,ebp
{0} neg edx
{@C0} @dec5free:
{0} or ebx,[eax]
{1} lea ebx,[ebx+edx]
{2} cmovs ebx,[eax]
{0} mov [eax],ebx
{1} movsx ebx,byte ptr [edi+ecx*04h+04h*04h+__ROWMARK]
{2} sub eax,ebp
{@D1*} add ecx,04h
{1*} jnz @dec5free
{0} neg edx
{1} mov ebx,[esp+__SIZE+__PUSHED]
{2} jmp @chk5col
{ x1 } nop
{@DF} @zero5item:
{0} pop ecx
{@E0} movsx ebx,cx
{2} sar ecx,10h
{0*} add esi,[edi+ebx*04h+__0STAR]
{1*} jnz @3RD_STEP_rowaddr
@@4TH_STEP:
{0} mov [edi+ebx*04h+__0STAR],ecx
{1-} mov edx,ebx
{2} mov ebx,[edi+ecx*04h+__0STARROW]
{0} mov [edi+ecx*04h+__0STARROW],edx
{@FE} mov ecx,[edi+ebx*04h+__COLON]
{@02**} test ebx,ebx
{0**} jnz @@4TH_STEP
mov ecx,[esp+00h*08h+__FIXCOL]
mov esi,ebp
@@1ST_STEP:
{@0C} mov ebx,[edi+esi*04h+__0STARROW]
{1} and edx,ebx
{2} movsx bx,byte ptr [edi+esi*04h+__FIXEDROW]
{1} mov [edi+esi*04h+__COLROWMARK],ebx
{0*} add esi,04h
{2*} jnz @@1ST_STEP
{@20-} xor edx,ebp
{1} { x5 } mov edx,0FFFFFFFFh
{2} js @@2ND_STEP

{0} lea eax,[ebp-04h]
{1-} xor edx,edx
{2-} mov ecx,ebp
{0} sub esp,eax
{1} sub esp,ebp
{2} mov ebx,[esp+__SAVE]
{0} mov esi,[esp+__MARKS]
@@results:
{@40} mov eax,[edi+ecx*04h+__0STAR]
{1} sub ebx,ebp
{2} add edx,[ebx+eax]
{0} sub eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@50} add esi,01h
{1*} add ecx,04h
{2*} jnz @@results

[ Szerkesztve ]

Titkon, álmomban reméltem, hogy eljön ez a pillanat, de nem volt valós alapja. De(!) eljött.

Core2 (2.5 GHz): 60 sec alatt 344000 mátrix
K10 (2.9 GHz): 60 sec alatt 450000 mátrix
Ivy Bridge (3.8 GHz): nem mérhető, 53 sec alatt megoldja a feladatot (a teljes lefutást 510000 mátrix kiszámolása jelenti); ez több, mint 13%-os gyorsulás a legutóbbi programhoz képest; számításaim szerint 60 sec alatt kb. 570000 mátrixot oldana meg a 3770K.
Nem kérdés, új tesztfeladatot kell keresni, most jöhet a többszálú algoritmus újraelkészítése.

A store-to-load forwarding kulcskérdéssé vált, az @@5TH_STEP két egymást követő ciklusa részben azonos elemeken dolgozik, mindkettő load-op-store műveletekkel.

Ez a program nagyon meghálálja, ha órajelenként két jcc feltételes ugrás kerülhet végrehajtásra; erre a K8/K10-en kívül egyedül a Haswell képes. El se merem képzelni, ott mit mutatna...

A Pentium 4-eken természetesen lassult így a program a write-through L1D miatt; a 3.8 GHz-es Kaveri-n (ugyancsak write-through L1D) legutóbb 425000 mátrix volt az eredmény 60 sec alatt, tehát hozta a 2.9 GHz-es K10 sebességét 31%-kal nagyobb órajelen, 2 EX végrehajtóval; azt, hogy az ez a kód mit tud, még nem tiszta, de első látásra gyorsabb nem lett.

Mint látható, számos utasítás mellékhatása erőteljesen ki van használva (egy ciklus nulláz egy regisztert, shift utasítás CF-be teszi az utolsó kitolt bitet, jmp helyett feltételes ugrás egy sosem létrejövő értékre, ...) az utasításszám csökkentése végett. Ez most így K10-en 2.2 IPC.

{0-} xor eax,eax
{1-} mov esi,ebp
{2} { x1 } lea ebx,[ebp+ebp+00h]
{0} and esi,-8
{1} movsx ecx,byte ptr [edx]
{2} add esp,ebx
{@F0} @mark0:
{0} mov [edi+esi*04h+00h+__0STARROW_COLMARK],eax { __0STARROW = -1 means FIXEDCOL }
{1} mov [edi+esi*04h+10h+__0STARROW_COLMARK],eax { __0STARROW = -1 means FIXEDCOL }
{2*} add esi,08h
{0*} jnz @mark0
{ -} mov ebx,ebp
{ } not eax
@@ARGUMENT: { initialize __0COUNTER variable to -1 }
{@00} sub edx,eax
{1} cmp ecx,esi
{2} lea ecx,[ebx+ecx*04h]
{0} mov [edi+ecx*04h+__0STARROW_COLMARK],eax { __0STARROW = -1 means FIXEDCOL }
{1} cmovs ecx,esi
{2} mov [edi+ebp*04h+__FIXEDROW],ecx
{0} mov [edi+ebp*04h+__0STAR],ecx
{1} movsx ecx,byte ptr [edx]
{2*} add ebp,04h
{0*} jnz @@ARGUMENT
{ } push ebx
{ -} mov ebp,ebx
{@20-} mov edx,ebx
{ -} mov eax,edi
{ } jmp @chk0row
{@26} @subrow:
{0} sub [eax+ebx],ecx { maximum data value = 00FFFFFFh -> marked elements stay negative }
{1*} add ebx,04h
{2*} jnz @subrow
{0-} mov ebx,ebp
@@REDUCE_ROWS:
{@30*} add edx,04h
{1*} jz @@REDUCE_COLUMNS
@chk0row:
{2} sub eax,ebp
{0**} test [edi+edx*04h+__0STAR],ebp
{1**} js @@REDUCE_ROWS
{2} or ecx,-1
{@40} @findrowmin:
{0} mov esi,[eax+ebp]
{1} or esi,[edi+ebp*04h+__0STARROW_COLMARK]
{2} cmp ecx,esi
{0} cmova ecx,esi
{1*} add ebp,04h
{2*} jnz @findrowmin
{@50-} mov ebp,ebx
{1**} test ecx,ecx { JS/JNS can only fuse with TEST }
{2**} jns @subrow
@@ABNORMAL_EXIT:
{@56} pop esi
sub esp,ebp
or edx,-1
sub esp,ebp
mov esi,[esp+__MARKS]
mov [esi+TRESULT.OPTIMUM],edx
mov ebx,[esi+TRESULT.NEXTIVALUE]
jmp dword ptr [esp+_INVALIDRESULT]
{@6C} @initcol:
{0} mov [edi+ebp*04h+__INITCOL],ecx
{@70} or esi,-1
{2-} mov ebx,ebp
{0} jmp @@1ST_STEP
{ x2 } xor eax,eax
{@7C} @0counter:
{ } sub [edi+ebp*04h+__0COUNTER],ebx
@@REDUCE_COLUMNS:
{@80} lea ecx,[edx-04h]
{@83} @chk0col:
{0} sub edx,04h
{1**} cmp edx,ebp
{2**} jb @initcol { EDX and EBP always negative } { jb = jl for 2 negative numbers }
{0**} test [edi+edx*04h+__0STARROW_COLMARK],ebp
{1**} js @chk0col
{ -} { x1 } nop
{@90-} xor ecx,ecx
{ -} mov esi,ebp
{@94} @findcolmin:
{0} mov ebx,[eax+edx]
{1} or ebx,[edi+ecx*04h-10h+__FIXEDROW]
{2} sub ecx,04h
{0} cmp esi,ebx
{@A0} cmova esi,ebx
{2} add eax,ebp
{0**} cmp ecx,ebp
{1**} jnz @findcolmin
{0} sub ecx,04h
{1**} test esi,esi { JS/JNS can only fuse with TEST }
{2**} js @@ABNORMAL_EXIT
{@B0-} or ebx,-1
{@B3} @subcol:
{0*} add ecx,04h
{1*} jz @0counter
{2} sub eax,ebp
{0} sub [eax+edx],esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{1} jnz @subcol
{ } { x1 } nop
{@C0**} cmp [edi+ecx*04h+__0STAR],ebx
{1**} jle @subcol
{2} mov [edi+edx*04h+__0STARROW_COLMARK],ecx
{0} mov [edi+ecx*04h+__0STAR],edx
{1} xor ebx,-1
{@D0} jmp @subcol
{ x14 } lea edi,[ebp+ebp+00h]; mov eax,00000000h; mov edx,00000000h
{@E0} { x9 } lea edi,[ebp+ebp+00h]; mov ecx,00000000h


@@3RD_STEP:
{@E9} lea eax,[ebp-04h]
{1} sub eax,edx
{2} mov [edi+edx*04h+__0COLON___ROWMARK],ecx
{0} imul eax,ebp
{1} sar eax,02h
{2} add eax,edi
@re3start:
{@FA-} mov edx,ebp
{1} mov ecx,[edi+ebp*04h+__INITCOL]
{@00} @mark3row:
{0} and dword ptr [edi+esi*04h+__0STARROW_COLMARK],00FFFFFFh
{1} mov [esp+__OFFS+ebx*08h],eax
{2} add ebx,01h
{0-} { x2 } xor esi,esi
@@2ND_STEP:
{@10} mov [esp+__SIZE],ebx
@chk2col:
{@14*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*04h+__0STARROW_COLMARK],ebp
{0**} js @chk2col
{0-} mov ebx,ebp
{@20} lea eax,[ecx+edi]
{1} sal ecx,10h
{2} sub eax,ebp
{@28} @zeroincol: { 2 AGU + 8 EX uops on Kaveri }
{0} mov esi,[edi+ebx*04h+__0COLON___ROWMARK]
{1} or esi,[eax]
{2} jz @zero
{@30} cmp esi,edx
{1} cmovb edx,esi
{2} cmovb cx,bx
{0} sub eax,ebp
{1*} add ebx,04h
{2*} jnz @zeroincol
{@40} @zero:
{0-} mov esi,ecx
{1} sar ecx,10h
{2} cmovnc esi,[edi+00h] { matrix[0,0] }
{0} mov [edi+00h],esi { matrix[0,0] }
{1**} test ebx,ebx
{2**} jz @chk2col
{@4E} mov esi,[edi+ebx*04h+__0STAR]
{1**} test esi,esi
{2**} jz @4TH_STEP
{0} mov [edi+ebx*04h+__0COLON___ROWMARK],ecx
{1} sub eax,ecx
{@60} mov ebx,[esp+__SIZE]
{0**} { x1 } db $66,$39,$5F,$00 { cmp word [edi+00h],bx { matrix[0,0] } { STORE FORWARDED }
{1**} jz @re3start
{2} cmp esi,ecx
{0} cmovl ecx,esi
{1*} sub ecx,04h
{2*} jnz @mark3row { forced conditional jump for Sandy Bridge }
@@5TH_STEP:
{ STACK: [2N:offs]...[6:offs] [4:offs] [2:size] [0:EBP]
[2N+1:colN] ... [5:col2] [3:col1] [1:col0]
{@74} mov esi,[edi+ebp*04h+__INITCOL]
{1} mov ebx,[esp+__SIZE]
{01} push dword ptr [edi+00h]
{1} jmp @chk5col
{@80} @recover:
{0} sub [esi+ecx],edx
{1-} mov ecx,ebp
{2} jmp @INC5_column
{@87} @inc5col: { 4 AGU + 5 EX uops on Kaveri }
{0} add [esi+ecx],edx
{1} jc @recover
{2-} mov ecx,ebp
@INC5_column:
{@8E} mov ebp,[esp+ebx*08h+__PUSHED]
{@92*} sub ebx,01h
{1*} jge @inc5col
{ } cmp eax,00h
{ -} mov ebx,ecx
{ -} mov eax,ebp
{ } jns @DEC5_free_col
@CHK5col:
{@A0} mov eax,[edi+esi*04h+04h*04h+__0STARROW_COLMARK]
{1*} add esi,04h
{2*} jz @zero5item { clears ESI register }
{0**} db $3D,$FF,$FF,$FF,$FF { cmp eax,-1 } { __0STARROW = -1 means FIXEDCOL }
{1**} jz @chk5col
{@B0} mov ecx,[esp+__SIZE+ebx*08h+__PUSHED]
{0} jmp @INC5_column
@DEC5_free_col:
{@B6} imul eax,ebp
{1-} mov ecx,ebp
{2} add esi,edi
{0} sar eax,02h
{@C0} add eax,esi
{2} add ecx,ecx
{@C4} @dec5row: { 4 AGU + 8 EX uops on Kaveri }
{0} sub [eax],edx
{1} jo @recover_
@dec5_1:
{2} sub [eax+ebp],edx
{0} jo @recover__
@dec5_2:
{1} add eax,ecx
{2**} cmp eax,esi
{@D1**} ja @dec5row
{ } jz @basestate
{ } sub eax,ebp
{ } add [eax],edx
@basestate:
{ *} sub esi,edi
{ *} jnz @chk5col { forced conditional jump for Sandy Bridge }
{ } { x3 } cmp edi,00h
{@E0} @recover_:
add [eax],edx
jmp @dec5_1
@recover__:
add [eax+ebp],edx
jmp @dec5_2
{ x6 } mov eax,00000000h; nop
@zero5item:
{@EF} pop ecx
{@F0} movsx edx,cx
{2} sar ecx,10h
{0*} add esi,[edi+edx*04h+__0STAR]
{1*} jnz @@3RD_STEP
@@4TH_STEP: { 5 AGU + 4 EX uops on Kaveri }
{@E0-} mov ebx,edx
@4TH_STEP:
{@E2} movsx edx,word ptr [edi+ecx*04h+__0STARROW_COLMARK]
{2} mov [edi+ebx*04h+__0STAR],ecx
{0} mov [edi+ecx*04h+__0STARROW_COLMARK],ebx
{1} mov ecx,[edi+edx*04h+__0COLON___ROWMARK]
{2**} test edx,edx
{0**} jnz @@4TH_STEP
{ } dec esi
{ } mov ecx,[edi+ebp*04h+__INITCOL]
{ -} mov ebx,ebp
{ } add [edi+ebp*04h+__0COUNTER],esi
@@1ST_STEP: { 4 AGU + 5 EX uops on Kaveri }
{@00} movsx eax,word ptr [edi+ebx*04h+__0STARROW_COLMARK]
{1} mov [edi+ebx*04h+__0STARROW_COLMARK],eax
{2} add ebx,04h
{0} mov eax,[edi+ebx*04h-10h+__FIXEDROW]
{1} mov [edi+ebx*04h-10h+__0COLON___ROWMARK],eax
{2} jnz @@1ST_STEP { clears EBX register }
{ -} mov edx,ebp
{ **} cmp [edi+ebp*04h+__0COUNTER],esi {= -1 }
{ **} jnz @@2ND_STEP { ===>>> EBX:00h EDX:negative ECX:initcol (>= EBP-4) }


{@20} lea eax,[ebp+ebp-04h]
{1-} xor ecx,ecx
{0} sub esp,eax
{1} mov ebx,[esp+__SAVE]
{2} mov esi,[esp+__MARKS]
@@results:
{@30} mov eax,[edi+edx*04h+__0STAR]
{1} sub ebx,ebp
{2} add ecx,[ebx+eax]
{0} sub eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@40} add esi,01h
{1*} add edx,04h
{2*} jnz @@results

[ Szerkesztve ]

A géphez legközelebb levő ASM-től látszatra a lehető legtávolabb áll a Java, de a látszat csal: mivel a Java is gépen - csak virtuális gépen - alapul, virtuális architektúrával, arra is lehet optimalizálni; sőt, eléggé jól (meghálálja).
Csak úgy említem: HSA...
Viszont meglehetősen nehéz egy ósdi, regiszter nélküli, stack-rendszerű (~x87, csak itt a regiszterek kizárólag az aktuális műveletekhez szükséges értékeket tudják tárolni (azaz minden művelet pop is egyben) és nincs "FXCH").

Az alábbi kód kitömörít, olyasmi fajtát, amifélét felhasználók vagy programok elég gyakran szoktak kitömöríteni.
Egy szálas algoritmus, egy Samsung Galaxy SIII egy 1.4 GHz-es magján kb. fele olyan gyors, mint a W****r ugyanerre a file-ra egy 2.26 GHz-es Prescott-on.

A fő cél az volt, hogy a lefordított Java bytecode minél kevesebb utasításból álljon, ezen ok miatt több utasítás is egy sorba került a Java bytecode LINENUMBER "utasítása" miatt (val'szeg egy számlálót állít be annak érdekében, hogy hiba/exception esetén meg tudja mondani, hanyadik sorban történt a hiba).

Ezen fő cél elérése nem öncélú, mivel a lefutás is egyre gyorsult. Így a leggyorsabb, kb. fél év ráfordított szabadidő elteltével:

for(--pos;;)
if ((type&0x00000001) == 0) {
if (bpos < 3) { s+=((data[++pos]&bFF)<<bpos); bpos+=b8; }
if ((type=s&((1<<3)-1)) >= 3<<1) { return invalid_encoding; }
bpos-=3; s>>=3;
if (type >= 2<<1) {
for (;;) if (bpos < 5+5+4 +3) { s+=((data[++pos]&bFF)<<bpos); bpos+=b8; } else break;
HLIT=257+(movelen=(s&((1<<5)-1))); HDIST=(s>>5+0)&((1<<5)-1); clen=4+((s>>5+5)&((1<<4)-1)); bpos-=(5+5+4); s>>=(5+5+4);
cMAXBITS=maxLENVALUE; i=maxLENVALUE; do { count[--i]=0; } while (i > 0); // a ciklus után i=0
j=maxLENGTHCODE-1; do { clens[j]=0; } while (--j >= 0); // a ciklus után j=-1
for (;;)
if (--clen >= 0) {
count[clens[zigzag[++j]]=(s&((1<<3)-1))]++; s>>=3;
if ((bpos-=3) < 3) { s+=(data[++pos]&bFF)<<bpos; bpos+=b8; } }
else { break; }
for (;count[++i] == 0;); for (;count[--cMAXBITS] == 0;); j=cMAXBITS-(cMINBITS=(--i)); lookupsize=0; symbol=0; clen=0;
do { dmin[++i]=symbol-lookupsize; dmax[i]=(symbol=(symbol+(clen=count[i])))<<(--j); symbol<<=1; count[i]=(lookupsize+=clen); } while (j > 0);
for (dmax[i+1]=(1<<16)-1, count[0]=maxLENGTHCODE, i=maxLENGTHCODE; (lookup032[--count[clens[--i]]]=i) > 0;);

aMAXBITS=alphabetMAXencodeLENGTH; i=alphabetMAXencodeLENGTH; do { count[--i]=0; } while (i > 0); // a ciklus után i=0;
j=HLIT-1; do { clens[j]=0; } while (--j >= 0); // a ciklus után j=-1;
for (crepMAXBITS=cMAXBITS+repMAXBITS, dMAX8=b8-cMAXBITS;;)
if (++j < HLIT) {
for (;;) if (bpos < crepMAXBITS) { s+=((data[++pos]&bFF)<<bpos); bpos+=b8; } else break;
for (symbol=t[s&bFF]>>dMAX8, clen=cMINBITS; (symbol >= dmax[++clen]);); bpos-=clen; s>>=clen;
if ((symbol=lookup032[(symbol>>(cMAXBITS-clen))-dmin[clen]]) <= 15) { ++count[clens[j]=symbol]; }
else if (symbol == 17) { j+=(03-1)+(s&((1<<3)-1)); bpos-=3; s>>=3; }
else if (symbol == 18) { j+=(11-1)+(s&((1<<7)-1)); bpos-=7; s>>=7; }
else {
count[clen=clens[--j]]+=(i=3+(s&((1<<2)-1))); bpos-=2; s>>=2;
do { clens[++j]=clen; } while (--i > 0); } }
else { break; }
for (;count[++i] == 0;); for (;count[--aMAXBITS] == 0;); j=aMAXBITS-(aMINBITS=(--i)); lookupsize=0; symbol=0; clen=0;
do { amin[++i]=symbol-lookupsize; amax[i]=(symbol=(symbol+(clen=count[i])))<<(--j); symbol<<=1; count[i]=(lookupsize+=clen); } while (j > 0);
for (amax[i+1]=(1<<16)-1, count[0]=maxALPHA;;) if (movelen > 0) { lookup288[--count[clens[--HLIT]]]=lengthdata[--movelen]; } else break;
for (;(lookup288[--count[clens[--HLIT]]]=HLIT) > 0;);

dMAXBITS=alphabetMAXencodeLENGTH; i=alphabetMAXencodeLENGTH; do { count[--i]=0; } while (i > 0); // a ciklus után i=0;
j=HDIST; ++HDIST; do { clens[j]=0; } while (--j >= 0); // a ciklus után j=-1;
for (;;)
if (++j < HDIST) {
for (;;) if (bpos < crepMAXBITS) { s+=((data[++pos]&bFF)<<bpos); bpos+=b8; } else break;
for (symbol=t[s&bFF]>>dMAX8, clen=cMINBITS; (symbol >= dmax[++clen]);); bpos-=clen; s>>=clen;
if ((symbol=lookup032[(symbol>>(cMAXBITS-clen))-dmin[clen]]) <= 15) { ++count[clens[j]=symbol]; }
else if (symbol == 17) { j+=(03-1)+(s&((1<<3)-1)); bpos-=3; s>>=3; }
else if (symbol == 18) { j+=(11-1)+(s&((1<<7)-1)); bpos-=7; s>>=7; }
else {
count[clen=clens[--j]]+=(i=3+(s&((1<<2)-1))); bpos-=2; s>>=2;
do { clens[++j]=clen; } while (--i > 0); } }
else { break; }
for (; count[++i] == 0;); for (;count[--dMAXBITS] == 0;); j=dMAXBITS-(dMINBITS=(--i)); lookupsize=0; symbol=0; clen=0;
do { dmin[++i]=symbol-lookupsize; dmax[i]=(symbol=(symbol+(clen=count[i])))<<(--j); symbol<<=1; count[i]=(lookupsize+=clen); } while (j > 0);
dmax[i+1]=(1<<16)-1; count[0]=maxDISTANCE; do lookup032[--count[clens[--HDIST]]]=distancedata[HDIST]; while (HDIST > 0);
for (alenMAXBITS=aMAXBITS+lenMAXBITS, aMAXhi=b8-(aMAX8=aMAXBITS-b8), dMAXhi=b8-(dMAX8=dMAXBITS-b8);;) {
for(;;) if (bpos < alenMAXBITS) { s+=(bFF&data[++pos])<<bpos; bpos+=b8; } else break;
symbol=(aMAX8 > 0) ? (t[bFF&s]<<aMAX8)+(t[bFF&(s>>b8)]>>aMAXhi) : t[bFF&s]>>(-aMAX8);
for (clen=aMINBITS; (amax[++clen] <= symbol);); s>>=clen; bpos-=clen;
if ((symbol=lookup288[(symbol>>(aMAXBITS-clen))-amin[clen]]) <= 255) { dest[++dpos]=(byte)(symbol); continue; }
if ((movelen=(symbol>>16)) > 0) {
if ((symbol=(byte)symbol) > 0) { movelen+=s&((-1)>>>(32-symbol)); bpos-=symbol; s>>=symbol; }
for (;;) if (bpos < dMAXBITS) { s+=(bFF&data[++pos])<<bpos; bpos+=b8; } else break;
symbol=(dMAX8 > 0) ? (t[bFF&s]<<dMAX8)+(t[bFF&(s>>b8)]>>dMAXhi) : t[bFF&s]>>(-dMAX8);
for (clen=dMINBITS; (dmax[++clen] <= symbol);); bpos-=clen; s>>=clen;
i=dpos-(char)(clen=lookup032[(symbol>>(dMAXBITS-clen))-dmin[clen]]);
if ((clen>>=16) > 0) {
for (;;) if (bpos < clen) { s+=(bFF&data[++pos])<<bpos; bpos+=b8; } else break;
i-=s&((-1)>>>(32-clen)); bpos-=clen; s>>=clen; }
do { dest[++dpos]=dest[++i]; } while (--movelen > 0); }
else { break; } } }

else if (type >= 1<<1) {
for (;;) {
for (;;) if (bpos < (ZFIX_aMAXBITS+lenMAXBITS+ZFIX_dBITS)) { s+=((data[++pos]&bFF)<<bpos); bpos+=b8; } else break;
symbol=(t[s&bFF]<<(ZFIX_aMAXBITS-b8))+(t[(s>>b8)&bFF]>>(b8-(ZFIX_aMAXBITS-b8)));
for (clen=ZFIX_aMINBITS-1; (amaxFIX[++clen] <= symbol);); bpos-=clen; s>>=clen;
if ((symbol=lookupFIX[(symbol>>(ZFIX_aMAXBITS-clen))-aminFIX[clen]]) <= 255) { dest[++dpos]=(byte)(symbol); continue; }
if ((movelen=(symbol>>16)) > 0) {
if ((symbol=(byte)symbol) > 0) { movelen+=s&((-1)>>>(32-symbol)); bpos-=symbol; s>>=symbol; }
i=dpos-(char)(clen=distancedata[t[s&bFF]>>(b8-ZFIX_dBITS)]); s>>=ZFIX_dBITS; bpos-=ZFIX_dBITS;
if ((clen>>=16) > 0) {
for (;;) if (bpos < clen) { s+=((data[++pos]&bFF)<<bpos); bpos+=b8; } else break;
i-=s&((-1)>>>(32-clen)); bpos-=clen; s>>=clen; }
do { dest[++dpos]=dest[++i]; } while (--movelen > 0); }
else { break; } } }

else {
pos-=(bpos>>3);
if ((clen=(bFF&data[++pos])|((bFF&data[++pos])<<8)) == ((~(((bFF&data[++pos])<<16)|(data[++pos]<<24)))>>16)) {
System.arraycopy(data,pos+1,dest,dpos+1,clen); pos+=clen; dpos+=clen; bpos=0; s=0; } }
} else break;

[ Szerkesztve ]

Újabb, még gyorsabb változat.

Core2 (2.5 GHz): 60 sec alatt 370000 mátrix
K10 (2.9 GHz): 60 sec alatt 483000 mátrix
Ivy Bridge (3.8 GHz): immár 50 sec alatt oldja meg a feladatot (60 sec alatt kb. 600000 mátrixot oldana meg)

{0-} xor eax,eax
{1-} mov esi,ebp
{2} { x1 } lea ebx,[ebp+ebp+00h]
{0} and esi,-8
{1} movsx ecx,byte ptr [edx]
{2} add esp,ebx
{@F0} @mark0:
{0} mov [edi+esi*04h+00h+__0STARROW_COLMARK],eax { __0STARROW = -1 means FIXEDCOL }
{1} mov [edi+esi*04h+10h+__0STARROW_COLMARK],eax { __0STARROW = -1 means FIXEDCOL }
{2*} add esi,08h
{0*} jnz @mark0
{ -} mov ebx,ebp
{ } not eax
@@ARGUMENT: { initialize __0COUNTER variable to -1 }
{@00} sub edx,eax
{1} cmp ecx,esi
{2} lea ecx,[ebx+ecx*04h]
{0} mov [edi+ecx*04h+__0STARROW_COLMARK],eax { __0STARROW = -1 means FIXEDCOL }
{1} cmovs ecx,esi
{2} mov [edi+ebp*04h+__FIXEDROW],ecx
{0} mov [edi+ebp*04h+__0STAR],ecx
{1} movsx ecx,byte ptr [edx]
{2*} add ebp,04h
{0*} jnz @@ARGUMENT
{0} push ebx
{1-} mov ebp,ebx
{@20-} mov edx,ebx
{0-} mov eax,edi
{1} jmp @chk0row
@@ABNORMAL_LEAVE:
{0} mov [esi+TRESULT.OPTIMUM],edx
{1} mov ebx,[esi+TRESULT.NEXTIVALUE]
{2} jmp dword ptr [esp+_INVALIDRESULT]
@@REDUCE_ROWS:
{0*} add edx,04h
{1*} jz @@REDUCE_COLUMNS
@chk0row:
{2} sub eax,ebp
{0**} test [edi+edx*04h+__0STAR],ebp
{1**} js @@REDUCE_ROWS
{2} or ecx,-1
{@40} @findrowmin:
{0} mov esi,[eax+ebp]
{1} or esi,[edi+ebp*04h+__0STARROW_COLMARK]
{2} cmp ecx,esi
{0} cmova ecx,esi
{1*} add ebp,04h
{2*} jnz @findrowmin
{@50-} mov ebp,ebx
{1**} { x4 } test ecx,0FFFFFFFFh { JS/JNS can only fuse with TEST }
{2**} js @@ABNORMAL_EXIT
{0} sar ebx,03h
{1} jc @oddrow
{2} { x1 } nop
@subrow:
{@60} sub [eax+ebx*08h+00h],ecx { max. data value = 00FFFFFFh -> marked elements stay negative }
@oddrow:
{1} sub [eax+ebx*08h+04h],ecx { max. data value = 00FFFFFFh -> marked elements stay negative }
{2*} add ebx,01h
{0*} jnz @subrow
{ -} mov ebx,ebp
{ } jz @@REDUCE_ROWS { forced conditional jump for Sandy Bridge }
@@ABNORMAL_EXIT:
{@70} pop esi
{1} sub esp,ebp
{2} or edx,-1
{0} sub esp,ebp
{1} mov esi,[esp+__MARKS]
{2} jmp @@ABNORMAL_LEAVE
{ } { x2 } xor ecx,ecx
{@80} { x12 } mov eax,00000000h; mov edx,00000000h; xor ecx,ecx
{@6C} @initcol:
{0} mov [edi+ebp*04h+__INITCOL],ecx
{@70-} mov ebx,ebp
{2} or esi,-1
{0} jnz @@1ST_STEP { forced conditional jump for Sandy Bridge }
{ x1 } nop
{@7C} @0counter:
{ } sub [edi+ebp*04h+__0COUNTER],ebx
@@REDUCE_COLUMNS:
lea ecx,[edx-04h]
{@83} @chk0col:
{0} sub edx,04h
{1**} cmp edx,ebp
{2**} jb @initcol { EDX always negative } { jb = jl for 2 negative numbers }
{0**} test [edi+edx*04h+__0STARROW_COLMARK],ebp
{1**} js @chk0col
{ -} { x1 } nop
{@90-} xor ecx,ecx
{ -} mov esi,ebp
{@94} @findcolmin:
{0} mov ebx,[eax+edx]
{1} or ebx,[edi+ecx*04h-10h+__FIXEDROW]
{2} sub ecx,04h
{0} cmp esi,ebx
{@A0} cmova esi,ebx
{2} add eax,ebp
{0**} cmp ecx,ebp
{1**} jnz @findcolmin
{0} sub ecx,04h
{1**} test esi,esi { JS/JNS can only fuse with TEST }
{2**} js @@ABNORMAL_EXIT
{@B0-} or ebx,-1
{@B3} @subcol:
{0*} add ecx,04h
{1*} jz @0counter
{2} sub eax,ebp
{0} sub [eax+edx],esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{1} jnz @subcol
{ } { x1 } nop
{@C0**} cmp [edi+ecx*04h+__0STAR],ebx
{1**} jle @subcol
{2} mov [edi+edx*04h+__0STARROW_COLMARK],ecx
{0} mov [edi+ecx*04h+__0STAR],edx
{1} xor ebx,-1 { clears CF }
{@D0} jnc @subcol
{ x1 } nop
@@3RD_STEP:
{0} movsx edx,cx
{1} lea eax,[ebp-04h]
{2} sar ecx,10h
{0} mov esi,[edi+edx*04h+__0STAR]
{@00} sub eax,edx
{2**} { x4 } test esi,0FFFFFFFFh
{0**} jz @@4TH_STEP
{1} sar eax,02h
{2} mov [edi+edx*04h+__0COLON___ROWMARK],ecx
{0} imul eax,ebp
{1} add eax,edi
@re3start:
{@FA-} mov ecx,[edi+ebp*04h+__INITCOL] { lea ecx,[ebp-04h] }
{1} mov edx,ebp
{@00} @mark3row:
{0} and dword ptr [edi+esi*04h+__0STARROW_COLMARK],00FFFFFFh { clear __0STARROW_COLMARK sign }
{1} mov [esp+__OFFS+ebx*08h],eax
{2} add ebx,01h
{0-} { x2 } xor esi,esi
@@2ND_STEP:
{@10} mov [esp+__SIZE],ebx
@chk2col:
{@14*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*04h+__0STARROW_COLMARK],ecx
{0**} js @chk2col
{0-} mov ebx,ebp
{@20} lea eax,[ecx+edi]
{1} sal ecx,10h
{2} sub eax,ebp
{@28} @zeroincol: { IPC: 3.0 } { 2 AGU + 8 EX uops on Kaveri }
{0} mov esi,[edi+ebx*04h+__0COLON___ROWMARK]
{1} or esi,[eax]
{2} jz @zero
{@30} cmp esi,edx
{1} cmovb edx,esi
{2} cmovb cx,bx
{0} sub eax,ebp
{1*} add ebx,04h
{2*} jnz @zeroincol
{@40} @zero:
{0-} mov esi,ecx
{1} sar ecx,10h
{2} cmovnc esi,[edi+00h] { matrix[0,0] }
{0} mov [edi+00h],esi { matrix[0,0] }
{1**} test ebx,ebx
{2**} jz @chk2col
{@4E} mov esi,[edi+ebx*04h+__0STAR]
{1**} test esi,esi
{2**} jz @4TH_STEP
{0} mov [edi+ebx*04h+__0COLON___ROWMARK],ecx { set row mark }
{1} sub eax,ecx
{@60} mov ebx,[esp+__SIZE]
{0**} { x1 } db $66,$39,$5F,$00 { cmp word [edi+00h],bx { matrix[0,0] } { STORE FORWARDED }
{1**} jz @re3start
{2} cmp esi,ecx
{0} cmovl ecx,esi
{1*} sub ecx,04h { never clears ECX register }
{2*} jnz @mark3row { forced conditional jump for Sandy Bridge }
@@5TH_STEP:
{ STACK: [2N:offs]...[6:offs] [4:offs] [2:size] [0:EBP]
[2N+1:colN] ... [5:col2] [3:col1] [1:col0] }
{0} mov eax,[esp+__SIZE]
{1} mov esi,[edi+ebp*04h+__INITCOL] { lea esi,[ebp-04h] }
{01} push dword ptr [edi+00h]
{1} jmp @INC5_marked_row
{@80} @row5parity: { IPC: 2.3 }
{0} mov ecx,ebp
{1} sar ecx,03h
{2} jc @odd5row
@inc5row: { 4 AGU + 8 EX uops on Kaveri }
{0} add [ebx+ecx*08h+00h],edx
{1} jc @restore_
@odd5row:
{2} add [ebx+ecx*08h+04h],edx
{0} jc @restore__
@even5row:
{@90*} add ecx,01h
{2*} jnz @inc5row
@INC5_marked_row:
{0} mov ebx,[esp+__SIZE+eax*08h+__PUSHED]
{1*} dec eax { sub eax,01h }
{2*} jge @row5parity
{0-} mov ecx,ebp
{@A0*} add ebp,ebp
{2*} jnz @CHK5col { forced conditional jump for Sandy Bridge }
@restore_:
{@A4} sub [ebx+ecx*08h+00h],edx
jc @odd5row { forced conditional jump for Sandy Bridge }
@restore__:
{@A9} sub [ebx+ecx*08h+04h],edx
jc @even5row { forced conditional jump for Sandy Bridge }
@CHK5col:
{@AF*} add esi,04h
{1*} jz @zero5item { clears ESI register }
{2**} test [edi+esi*04h+__0STARROW_COLMARK],esi { __0STARROW = -1 means FIXEDCOL [NOT USED] }
{0**} js @CHK5col
{1} add esi,edi
{2-} mov eax,ecx
@DEC5_free_col: { IPC: 2.3 }
{0} imul eax,eax
{@C0} add ecx,esi
{2} sar eax,02h
{@C5} @dec5row: { 4 AGU + 8 EX uops on Kaveri }
{0} sub [esi+eax],edx
{1} jo @recover_
@dec5_1:
{2} sub [ecx+eax],edx
{0} jo @recover__
{1*} add eax,ebp
{@D1*} jg @dec5row
{0} sub ecx,esi
{1} sub esi,edi
{2**} cmp eax,ebp
{0**} jc @CHK5col
{1} add [esi+edi],edx
{2} jmp @CHK5col
{@E0} @recover_:
mov dword ptr [esi+eax],0FF000000h { leave OF }
jo @dec5_1
@recover__:
{@E9} add [ecx+eax],edx
{1*} add eax,ebp
{2*} jg @dec5row
{@F0} sub ecx,esi
{1*} sub esi,edi { never clears ESI register }
{2*} jnz @CHK5col { forced conditional jump for Sandy Bridge }
@zero5item:
{@F4} pop ecx
{1} sar ebp,01h
{2-} xor esi,esi
{0} jmp @@3RD_STEP
@@4TH_STEP: { 5 AGU + 4 EX uops on Kaveri }
{@E0-} mov ebx,edx
@4TH_STEP:
{@E2} movsx edx,word ptr [edi+ecx*04h+__0STARROW_COLMARK]
{2} mov [edi+ebx*04h+__0STAR],ecx
{0} mov [edi+ecx*04h+__0STARROW_COLMARK],ebx
{1} mov ecx,[edi+edx*04h+__0COLON___ROWMARK]
{2**} test edx,edx
{0**} jnz @@4TH_STEP
{ } dec esi
{ } mov ecx,[edi+ebp*04h+__INITCOL] { lea ecx,[ebp-04h] }
{ -} mov ebx,ebp
{ } add [edi+ebp*04h+__0COUNTER],esi
@@1ST_STEP: { IPC: 3.0 } { 4 AGU + 5 EX uops on Kaveri }
{@00} movsx eax,word ptr [edi+ebx*04h+__0STARROW_COLMARK]
{1} mov [edi+ebx*04h+__0STARROW_COLMARK],eax
{2} add ebx,04h
{0} mov eax,[edi+ebx*04h-10h+__FIXEDROW]
{1} mov [edi+ebx*04h-10h+__0COLON___ROWMARK],eax
{2} jnz @@1ST_STEP { clears EBX register }
{ -} mov edx,ebp
{ **} cmp [edi+ebp*04h+__0COUNTER],esi {= -1 }
{ **} jnz @@2ND_STEP { ===>>> EBX:00h EDX:negative ECX:initcol (>= EBP-4) }
{@20} lea eax,[ebp+ebp-04h]
{1-} xor ecx,ecx
{0} sub esp,eax
{1} mov ebx,[esp+__SAVE]
{2} mov esi,[esp+__MARKS]
@@results:
{@30} mov eax,[edi+edx*04h+__0STAR]
{1} sub ebx,ebp
{2} add ecx,[ebx+eax]
{0} sub eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@40} add esi,01h
{1*} add edx,04h
{2*} jnz @@results

[ Szerkesztve ]

Kaveri (3.8 GHz): 60 sec alatt 448000 mátrix

Innen már csak apróbb simítások maradnak egy szálon, tényleg jöhet a többszálas megvalósítás.

- a kód negyede eltűnt, felesleges, mivel:
- a write-through L1D-vel ellátott microarch-ok kedvéért a program mindent fejben számol, magába a mátrixba semmit sem ír vissza; n*n méretű mátrix esetén két db n méretű vektor az írt terület
- a ciklusok utasítássorrendjében kiemelkedő fontosságú, hogy a ciklusszámláló és a pointer-aritmetika (a következő cikluslefutáshoz) ne legyen akadályozva a ciklustörzs számításai által; a.k.a. a lehető leghamarabb megtörténjenek.

K10 (2.9 GHz): 55 sec alatt oldja meg a teljes feladatot
Kaveri (3.8 GHz): 54 sec alatt végez a teljes feladattal
Core2 (2.5 GHz): 60 sec alatt 472000 mátrix
P4 Northwood (2.4 GHz): 60 sec alatt 218000 mátrix (megvan az 1.0 IPC)

{0-} xor eax,eax
{1-} mov esi,ebp
{2-} mov ebx,ebp
{0} add ebp,ebp
{1} movsx ecx,byte ptr [edx]
@mark0:
{0} mov [edi+esi*08h+__0STARROW],eax
{1} mov [edi+esi*08h+__COLMODIFIER],eax
{2*} add esi,04h
{1*} jnz @mark0 { clears ESI register }
{ -} { x5 } mov eax,00000000h
{ } add esp,ebp
{ -} mov ebp,ebx
@@ARGUMENT:
{@20} cmp ecx,esi
{1} lea eax,[ebx+ecx*04h]
{2} movsx ecx,[edx+01h]
{0} mov [edi+eax*08h+__0STARROW],ebx
{1} cmovs eax,esi
{2} inc edx
{@30} mov [edi+ebp*08h+__FIXEDROW],eax
{1} mov [edi+ebp*08h+__0STAR],eax
{2*} add ebp,04h
{0*} jnz @@ARGUMENT
{0} { x1 } nop
{1-} mov ebp,ebx
{@40-} mov edx,ebx
{0-} mov eax,edi
{1} jz @chk0row { forced conditional jump for Sandy Bridge }
{ x1 } nop
@@REDUCE_ROWS:
{@47} neg ecx
{1} mov [edi+edx*08h+__ROWMODIFIER],ecx
{2*} add edx,04h
{@50*} jz @@REDUCE_COLUMNS
@chk0row:
{0-} xor ecx,ecx
{1} sub eax,ebp
{2**} test [edi+edx*08h+__0STAR],ebp
{0**} js @@REDUCE_ROWS
{1} or ecx,-1
{2-} { x1 } nop
{@60} @findrowmin:
{0} mov esi,[eax+ebp]
{1} or esi,[edi+ebp*08h+__0STARROW]
{2} cmp ecx,esi
{0} cmova ecx,esi
{1*} add ebp,04h
{2*} jnz @findrowmin
{@70-} mov ebp,ebx
{1**} test ecx,ecx { JS/JNS can only fuse with TEST }
{2**} jns @@REDUCE_ROWS
push ebx
{ x3 } cmp edi,00h
@@ABNORMAL_EXIT:
{@7A} pop eax
{1} sub esp,ebp
{2} or edx,-1
{@80} sub esp,ebp
{1} mov esi,[esp+__MARKS]
{0} mov [esi+TRESULT.OPTIMUM],edx
{1} mov ebx,[esi+TRESULT.NEXTIVALUE]
{2} jmp dword ptr [esp+_INVALIDRESULT]
{@90} @initcol:
{0} push ebp
{1-} mov eax,ebp
{2} mov [edi+ebp*08h+__INITCOL],ecx
{0} jmp @@1ST_STEP
{@9C} { x4 } lea eax,[ebp+ebp+00h]
{@A0} { x1 } nop
{@A1} @setcolmod:
{ } pop eax
{ } mov [edi+edx*08h+__COLMODIFIER],ecx
@@REDUCE_COLUMNS:
{@A6} lea ecx,[edx-04h] { negative for minimum }
{@A9} @chk0col:
{0} sub edx,04h
{1**} cmp edx,ebp
{2**} jb @initcol { EDX always negative } { jb = jl for 2 negative numbers }
{@B0**} test [edi+edx*08h+__0STARROW],ebp
{1**} js @chk0col
{ -} mov ebx,eax
{ } mov esi,0FFFFFFFCh { -4 }
{ } push eax
{ } { x3 } cmp edi,00h
{@C0} @findcolmin:
{0} mov eax,[ebx+edx]
{1} add eax,[edi+esi*08h+__ROWMODIFIER]
{2} or eax,[edi+esi*08h+__FIXEDROW]
{0} cmp ecx,eax
{1} cmova ecx,eax
{@D0} sub esi,04h
{0} add ebx,ebp
{1**} cmp esi,ebp
{2**} jge @findcolmin
{0} { x3 } cmp esi,00h
{1**} test ecx,ecx { JS/JNS can only fuse with TEST }
{2**} js @@ABNORMAL_EXIT
{@E0} @subcol:
{0*} add esi,04h
{1*} jz @setcolmod
{2} sub ebx,ebp
{1} mov eax,[ebx+edx]
{0} add eax,[edi+esi*08h+__ROWMODIFIER]
{2**} cmp eax,ecx { maximum data value = 00FFFFFFh -> marked elements stay negative }
{@F0**} jnz @subcol
{1**} test [edi+esi*08h+__0STAR],ebp
{2**} js @subcol
{0} mov [edi+edx*08h+__0STARROW],esi
{1} { x1 } mov es:[edi+esi*08h+__0STAR],edx
{@00} jns @setcolmod { forced conditional jump for Sandy Bridge }
{ ----------------------------------------------------------------------------------------------}
{@02} @DEC5_free_col: { 3 AGU + 6 EX uops on Kaveri }
{0} mov ebp,[edi+esi*08h+__COLMARK]
{1} mov ecx,[edi+esi*08h+__COLMODIFIER]
{2} cmp ebp,00h
{0} lea ebp,[ecx+edx]
{@10} cmovs ebp,ecx
{2} mov [edi+esi*08h+__COLMODIFIER],ebp
{0*} add esi,04h
{1*} jnz @DEC5_free_col { clears ESI register }
{ x1 } mov ecx,[edi+esi+__MINCOLROW]
@INC5_marked_row: { 4 AGU + 5 EX uops on Kaveri }
{@20} mov ebp,[esp+ebx*08h]
{1*} sub ebx,01h
{2*} jnge @@3RD_STEP
{0} add [edi+eax*08h+__ROWMODIFIER],edx
{1-} mov eax,ebp
{2} jmp @INC5_marked_row
@@5TH_STEP:
{@30} mov esi,[edi+ebp*08h+__INITCOL]
{1-} mov ebx,eax
{2} mov eax,[esp+__SIZE+eax*08h]
{0*} add esi,04h
{1*} jnz @DEC5_free_col { forced conditional jump for Sandy Bridge }
{ x1 } nop
{@40} { x6 } test ebp,0FFFFFFFFh
@@3RD_STEP:
{@46} movsx ebx,cx
{1} sar ecx,10h
{2*} add esi,[edi+ebx*08h+__0STAR]
{@50*} jz @4TH_STEP { long jump instruction }
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{@5A} @re3start:
{0} mov ecx,[edi+ebp*08h+__INITCOL]
{1-} mov edx,ebp
{@60} @mark3row:
{0} mov [edi+esi*08h+__COLMARK],eax
{1} mov [esp+__OFFS+eax*08h],ebx
{2} { x2 } db $2D,$FF,$FF,$FF,$FF { add eax,01h }
@@2ND_STEP:
{@6D} mov [esp+__SIZE],eax
@chk2col:
{@71*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*08h+__COLMARK],ecx { STORE FORWARDED from @mark3row }
{0**} js @chk2col
{12} push dword ptr [edi+ecx*08h+__COLMODIFIER]
{@80-} mov ebx,ebp
{0-} mov eax,ecx
{1} sal ecx,10h
{2} sub eax,ebp
{@89} @ZERO2col: { 4 AGU + 11 EX uops on Kaveri }
{0} mov esi,[edi+ebx*08h+__ROWMODIFIER]
{1} sub esi,[esp+00h]
{@90} add esi,[edi+eax]
{0} jo @overflow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{1} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{2} jz @zero
{0} sub eax,ebp
{1} cmp esi,edx
{@9F} cmovb edx,esi
{@A2} cmovb cx,bx
@over2flow:
{1*} add ebx,04h
{2*} jnz @ZERO2col
{@AB} @zero:
{0} add esp,04h
{1-} mov eax,ecx
{@B0} sar ecx,10h
{0} cmovnc eax,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],eax
{2} mov eax,[esp+__SIZE]
{0**} test ebx,ebx
{@C0**} jz @chk2col
{2*} add esi,[edi+ebx*08h+__0STAR] { zero found -> ESI=0 }
{0*} jz @4TH_STEP
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2**} cmp word [edi+__MINCOLROW],bx { STORE FORWARDED }
{@D0**} jz @re3start
{1} cmp esi,ecx
{2} cmovl ecx,esi
{0*} sub ecx,04h { never clears ECX register }
{1*} jnz @mark3row { forced conditional jump for Sandy Bridge }
@overflow:
sub eax,ebp
jmp @over2flow
@@4TH_STEP: { 5 AGU + 3 EX uops on Kaveri }
{@E0-} mov ebx,edx
@4TH_STEP:
{@E2} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{1} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{@F0**} cmp edx,00h
{0**} jnz @@4TH_STEP
{ } mov ecx,[edi+ebp*08h+__INITCOL]
{ -} mov eax,ebp
{ } { x3 } mov edx,0FFFFFFFFh
@@1ST_STEP: { 4 AGU + 6 EX uops on Kaveri }
{@00} mov ebx,[edi+eax*08h+__0STARROW]
{1} mov [edi+eax*08h+__COLMARK],ebx
{2} and edx,ebx
{0} mov ebx,[edi+eax*08h+__FIXEDROW]
{1} cmovs ecx,eax
{@10} mov [edi+eax*08h+__0COLON___ROWMARK],ebx
{0*} add eax,04h
{1*} jnz @@1ST_STEP { clears EAX register }
{ } xor edx,-1
{ } js @@2ND_STEP { ===>>> EAX:00h EDX:negative ECX:initcol (>= EBP-4) }
{@22} lea eax,[ebp+ebp-04h]
{1-} mov edx,ebp
{2-} xor ecx,ecx
{0} sub esp,eax
{1-} mov ebx,edi { work matrix unmodified }
{2} mov esi,[esp+__MARKS]
@@results:
{@32} mov eax,[edi+edx*08h+__0STAR]
{1} sub ebx,ebp
{2} add ecx,[ebx+eax]
{0} sub eax,ebp
{1} shr eax,02h
{@40} mov [esi],al
{0} add esi,01h
{1*} add edx,04h
{2*} jnz @@results

Simitgatva:

K10 (2.9 GHz): 53 sec alatt oldja meg a teljes feladatot
Ivy Bridge (3.8 GHz): 45 sec alatt végez a teljes feladattal
Core2 (2.5 GHz): 60 sec alatt 479000 mátrix
P4 Northwood (2.4 GHz): 60 sec alatt 221000 mátrix

Core-családhoz kis adalék:

PerfMonitor Record file
Counter 0 : Non-halted clock cycles
Counter 1 : Instructions per cycle (IPC)
Counter 2 : Retired fused uops
Counter 3 : Retired non-fused uops

T(ms) c0(M/s) c1(i/c) c2(M/s) c3(M/s)
50 2500.0 2.2 1323.7 4871.0
100 2500.0 2.1 1312.8 4842.1
150 2500.0 2.1 1312.8 4843.9
200 2500.0 2.1 1305.8 4808.1
250 2500.0 2.2 1322.9 4882.0
300 2500.0 2.2 1324.7 4874.4
350 2500.1 2.1 1301.2 4800.0
400 2499.9 2.1 1317.3 4851.5
450 2500.0 2.1 1317.9 4858.3
500 2500.0 2.1 1316.3 4849.7

Ez a 2.5 GHz-es Core2 mérése:
- ami nem látszik, 2.1 IPC mellett 2.5 uop/cycle (cmovcc...)
- ami látszik: stabilan 4800 feletti non-fused és 1300 feletti fused uop/cycle (utóbbi 2 végrehajtót dolgoztat), azaz 4800+1300*2 = 7400, a branch misprediction-ok mellett is minden órajelben 3 feldolgozó dolgozik a 6-ból.

{@08} { x1 } and eax,00h
{1-} mov esi,ebp
{2} movsx ecx,byte ptr [edx]
@init:
{@10} mov [edi+esi*08h+__0STARROW],eax
{1} mov [edi+esi*08h+__COLMODIFIER],eax
{2*} add esi,04h
{0*} jnz @init { clears ESI register }
inc edx
{ x1 } lea ebx,[ebp+00h]
@@ARGUMENT:
{@20} cmp ecx,esi { 5 AGU + 10 EX uops on Kaveri }
{1} lea eax,[ebx+ecx*04h]
{2} movsx ecx,[edx]
{0} mov [edi+eax*08h+__0STARROW],ebx { __0COUNTER <- EBP }
{1} cmovs eax,esi
{2} inc edx
{0} mov [edi+ebp*08h+__FIXEDROW],eax
{1} mov [edi+ebp*08h+__0STAR],eax
{2*} add ebp,04h
{0*} jnz @@ARGUMENT { clears EBP register }
{ -} mov edx,ebx
{ -} mov eax,edi
{@40*} add ebp,ebx
{ *} jnz @chk0row { forced conditional jump for Sandy Bridge }
{ x5 } mov ecx,00000000h
@@REDUCE_ROWS:
{@49} mov [edi+edx*08h+__ROWMODIFIER],ecx
{1*} add edx,04h
{@50*} jz @@REDUCE_COLUMNS
@chk0row:
{0-} xor ecx,ecx
{1} sub eax,ebp
{2**} test [edi+edx*08h+__0STAR],ebp
{0**} js @@REDUCE_ROWS
{ -} mov ebx,ebp
{ } not ecx
{@60} @findrowmin: { 2 AGU + 5 EX uops on Kaveri }
{0} mov esi,[eax+ebx]
{1} or esi,[edi+ebx*08h+__0STARROW]
{2} cmp esi,ecx
{0} cmovb ecx,esi
{1*} add ebx,04h
{2*} jnz @findrowmin
{@70-} neg ecx
{1} jle @@REDUCE_ROWS
@@ABNORMAL_EXIT:
{@74} { x2 } mov edx,0FFFFFFFFh
{1} mov esi,[esp+__MARKS]
{2-} { x3 } cmp edi,00h
{@80} { x6 } test ebp,0FFFFFFFFh
{1} mov [esi+TRESULT.OPTIMUM],edx
{2} mov ebx,[esi+TRESULT.NEXTIVALUE]
{0} jmp dword ptr [esp+_INVALIDRESULT]
{@90} @initcol:
{0} mov [edi+ebp*08h+__INITCOL],ecx
{1} add esp,ebp
{2-} mov eax,ebp
{0} push ebp
{1} jmp @@1ST_STEP { long jump instruction }
{ x2 } xor edx,edx
{@A0} { x6 } test ebp,0FFFFFFFFh
{@A6} @setcolmod:
{ } mov [edi+edx*08h+__COLMODIFIER],ecx
@@REDUCE_COLUMNS:
{@AA} lea ecx,[edx-04h] { negative for minimum }
{@AD} @chk0col:
{0} sub edx,04h
{@B0**} cmp edx,ebp
{2**} jb @initcol { EDX always negative } { jb = jl for 2 negative numbers }
{0**} test [edi+edx*08h+__0STARROW],ebp
{1**} js @chk0col
{ } lea ebx,[edi+edx]
{ -} mov esi,ebp
{ } sub ebx,ebp
{@C0} @findcolmin:
{0} mov eax,[ebx] { 3 AGU + 7 EX uops on Kaveri }
{1} add eax,[edi+esi*08h+__ROWMODIFIER]
{2} or eax,[edi+esi*08h+__FIXEDROW]
{0} sub ebx,ebp
{1} cmp eax,ecx
{2} cmovb ecx,eax
{0*} add esi,04h
{1*} jnz @findcolmin
{ } lea esi,[ebp-04h]
{ } lea ebx,[edi+edx]
{ **} test ecx,ecx { JS/JNS can only fuse with TEST }
{ **} js @@ABNORMAL_EXIT
{@E0} @subcol:
{0*} add esi,04h
{1*} jz @setcolmod
{2} sub ebx,ebp
{0} mov eax,[ebx]
{1} add eax,[edi+esi*08h+__ROWMODIFIER]
{2**} cmp eax,ecx
{@EF**} jnz @subcol
{ **} test [edi+esi*08h+__0STAR],ebp
{ **} js @subcol
{ } mov [edi+edx*08h+__0STARROW],esi
{ } mov [edi+esi*08h+__0STAR],edx
{ } jmp @setcolmod
{ --------------------------------------------------------------------------------------------- }
{@00} { x16 } ...
@@5TH_STEP:
{@10} mov ebx,[edi+ebp*08h+__INITCOL]
{1-} xor eax,eax
{2} mov esi,[esp+__SIZE]
{0-} xor ebp,ebp
{1} mov ecx,[edi+__MINCOLROW]
{2-} { x1 } nop
{@20} @DEC5_free_col: { 4 AGU + 6 EX uops on Kaveri }
{0} add [edi+ebx*08h+__COLMODIFIER],ebp
{1-} mov ebp,eax
{2} test [edi+ebx*08h+04h*08h+__COLMARK],ebx
{0} cmovns ebp,edx
{1*} add ebx,04h
{@30*} jnz @DEC5_free_col { clears EBX register }
{ } mov eax,[esp+__SIZE+esi*04h]
{ } movsx ebx,cx
{ } sar ecx,10h
{ } jmp @INC5_marked_row
{ x2 } nop; nop
{@40} @inc5row:
{0} add [edi+eax*08h+__ROWMODIFIER],edx
{1-} mov eax,ebp
@INC5_marked_row: { 4 AGU + 4 EX uops on Kaveri }
{2} mov ebp,[esp+esi*04h]
{0*} sub esi,01h
{1*} jge @inc5row { sets ESI to 0FFFFFFFFh }
@@3RD_STEP:
{@4E*} and esi,[edi+ebx*08h+__0STAR]
{@52*} jz @4TH_STEP { long jump instruction }
{0} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{@5C} @re3start:
{0} mov ecx,[edi+ebp*08h+__INITCOL] { lea ecx,[ebp-04h] }
{@60-} mov edx,ebp
{@62} @mark3row:
{0} mov [esp+__OFFS+eax*04h],ebx
{1} mov [edi+esi*08h+__COLMARK],eax { clear __COLMARK sign = store positive value to __COLMARK}
{2} add eax,01h
@@2ND_STEP:
{@6D} mov [esp+__SIZE],eax
@chk2col:
{@71*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*08h+__COLMARK],ecx { STORE FORWARDED from @mark3row }
{0**} js @chk2col
{12} push dword ptr [edi+ecx*08h+__COLMODIFIER]
{@80-} mov ebx,ebp
{0-} mov eax,ecx
{1} sal ecx,10h
{2} sub eax,ebp
{@89} @ZERO2col: { 4 AGU + 11 EX uops on Kaveri }
{0} mov esi,[edi+ebx*08h+__ROWMODIFIER]
{1} sub esi,[esp+00h]
{@90} add esi,[edi+eax]
{0} jo @overflow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{1} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{2} jz @zero
{0} sub eax,ebp
{1} cmp esi,edx
{@9F} cmovb edx,esi
{@A2} cmovb cx,bx
@over2flow:
{1*} add ebx,04h
{2*} jnz @ZERO2col
{@AB} @zero:
{0} add esp,04h
{1-} mov eax,ecx
{@B0} sar ecx,10h
{0} cmovnc eax,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],eax
{2**} test ebx,ebx
{0**} jz @chk2col
{@BE*} add esi,[edi+ebx*08h+__0STAR] { zero found -> ESI=0 }
{@C2*} jz @4TH_STEP
{0} mov eax,[esp+__SIZE]
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2**} cmp word [edi+__MINCOLROW],bx { STORE FORWARDED }
{@D0**} jz @re3start
{1} cmp esi,ecx
{2} cmovl ecx,esi
{0*} sub ecx,04h { never clears ECX register }
{1*} jnz @mark3row { forced conditional jump for Sandy Bridge }
@overflow:
sub eax,ebp
jmp @over2flow
@@4TH_STEP: { 5 AGU + 3 EX uops on Kaveri }
{@E0-} mov ebx,edx
@4TH_STEP:
{@E2} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{1} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{@F0**} cmp edx,00h
{0**} jnz @@4TH_STEP
{ } mov ecx,[edi+ebp*08h+__INITCOL] { lea ecx,[ebp-04h] }
{ -} mov eax,ebp
{ } { x2 } mov edx,0FFFFFFFFh
@@1ST_STEP: { 4 AGU + 6 EX uops on Kaveri }
{@00} mov ebx,[edi+eax*08h+__0STARROW]
{1} mov [edi+eax*08h+__COLMARK],ebx
{2} and edx,ebx
{0} mov ebx,[edi+eax*08h+__FIXEDROW]
{1} cmovs ecx,eax
{@10} mov [edi+eax*08h+__0COLON___ROWMARK],ebx
{0*} add eax,04h
{1*} jnz @@1ST_STEP { clears EAX register }
{ } xor edx,ebp { long jump instruction }
{ } js @@2ND_STEP { ===>>> EAX:00h EDX:negative ECX:initcol (>= EBP-4) }
{@21} lea eax,[ebp-04h]
{1-} mov edx,ebp
{2-} xor ecx,ecx
{0} sub esp,eax
{1-} mov ebx,edi { work matrix unmodified } { [esp+__SAVE] }
{2} mov esi,[esp+__MARKS]
@@results:
{@30} mov eax,[edi+edx*08h+__0STAR]
{1} sub ebx,ebp
{2} add ecx,[ebx+eax]
{0} sub eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@40} add esi,01h
{1*} add edx,04h
{2*} jnz @@results

[ Szerkesztve ]

A "simítások" célja - ha nem lenne egyértelmű - az IPC növelése; ez jórészt sikerült is. Ezen szakaszban az algoritmikus megoldások már tisztázottak, a lényeg, a minél kevesebb utasítás + minél több mellékhatás = minél kevesebb órajel alatt tegye meg ugyanazt a CPU. És itt jönnek ki leginkább a microarch. különbségek és főleg a gyengeségek. Azaz az utasítássorrend.

Szem előtt mindig azt tartom, hogy a kód legyen mindenen jó, ne legyen egy kiszemelt microarch, amin jól fut, a többi rovására, de a lehető legkevesebb kompromisszummal.

Ivy Bridge (3.8 GHz): 43 sec alatt végez a teljes feladattal
P4 Northwood (2.4 GHz): 60 sec alatt 225000 mátrix
Kaveri (3.8 GHz): 54 sec alatt végez a teljes feladattal
Core2 (2.5 GHz): 60 sec alatt 463000 mátrix
K10 (2.9 GHz): 48 sec alatt oldja meg a teljes feladatot

Mint látható, Ivy Bridge-en és a Northwood-on gyorsabb lett a program, a Kaveri-n nem változott a lefutás sebessége (a fő korlátozó tényező még mindig a 2 db EX);

Core2-n lassabb lett, K10-en viszont "fénysebességre" kapcsolt, folyamatos 2.6 IPC-vel fut le a korábbi 2.4-gyel szemben. Az ok is megvan: az utasítássorrend. A program "mindent vivő", fő meghatározó ciklusa:

@ZERO2col:
sub esi,[esp+00h]
add esi,[eax+ebp]
{C2} lea eax,[eax+ebp]
jo @over2flow
or esi,[edi+ebx*08h+__0COLON___ROWMARK]
jz @zero
{K10} lea eax,[eax+ebp]
cmp esi,edx
cmovb edx,esi
cmovb cx,bx
@over2flow:
mov esi,[edi+ebx*08h+(04h*08h)+__ROWMODIFIER]
add ebx,04h
jnz @ZERO2col

A ciklus Core2 CPU-kon 13 ALU műveletet jelent (a cmovcc-k duplázása miatt), K10-en 11-et; a dekódolás sebessége mindkettőn 4 clock/ciklus.
A lea eax,[eax+ebp] utasítás felső elhelyezése esetén a Core2-n 2.2 IPC (= 2.6 uop/clock) mérhető és 60 sec alatt 492000 mátrixot számol ki, viszont a K10 visszaesik 2.5 IPC-re és 50 sec alatt végez a feladattal. Az említett utasítás alsó elhelyezésével a fent írt eredmények jönnek ki.

K10 esetén nem nagy talány, hogy az utasítássorrend adja, hogy mely utasítás mely pipeline-ra kerülhet, és ezek akadályozhatják egymást, viszont Core2 esetén annál inkább, mivel a lea utasítást csakis az 1. ALU tudja végrehajtani (ahogy az ugrásokat csak az 5.). Nem kizárt, hogy a ciklus első 4 utasításával a Core2 ROB-read korlátozásába (3 reg/clock, ebből az egyik kötelezően index-regiszter) sikerült belefutni.
Bár a Sandy/Ivy Bridge is a Core2-éhez hasonló pipe-elrendezéssel rendelkezik, ott nem akadályozó tényező ez, mivel egyrészt a cikluszáró add+jnz egyetlen belső művelet (macro-fusion), másrészt ROB-read korlátja nem létezik.

{@04-} xor eax,eax
{1-} mov esi,ebp
{2} { x1 } movsx ecx,byte ptr es:[edx]
{0} and esi,-8
@init:
{@0F} mov [edi+esi*08h+(00h*08h)+__0STARROW],eax
{1} mov [edi+esi*08h+(04h*08h)+__0STARROW],eax
{2*} add esi,08h
{0*} jnz @init { clears ESI register }
{ } add edx,01h
{ -} mov ebx,ebp
@@ARGUMENT:
{@20} cmp ecx,esi { 5 AGU + 10 EX uops on Kaveri }
{1} lea eax,[ebx+ecx*04h]
{2} movsx ecx,[edx]
{0} mov [edi+eax*08h+__0STARROW],ebx { __0COUNTER <- EBP }
{1} cmovs eax,esi
{2} inc edx
{0} mov [edi+ebp*08h+__FIXEDROW],eax
{1} mov [edi+ebp*08h+__0STAR],eax
{2*} add ebp,04h
{0*} jnz @@ARGUMENT { clears EBP register }
{ -} mov eax,edi
{ -} mov ebp,ebx
{@40} { x1 } lea edx,es:[ebx-04h]
{ } { x1 } and ecx,00h
{ } add esp,ebx
@@REDUCE_ROWS:
{@49} mov [edi+edx*08h+__ROWMODIFIER],ecx
{1*} add edx,04h
{@50*} jz @@REDUCE_COLUMNS
{0-} xor ecx,ecx
{1} sub eax,ebp
{2**} test [edi+edx*08h+__0STAR],ebp
{0**} js @@REDUCE_ROWS
{ -} mov ebx,ebp
{ -} mov ecx,ebp
{@60} @findrowmin: { 2 AGU + 5 EX uops on Kaveri }
{0} mov esi,[eax+ebx]
{1} or esi,[edi+ebx*08h+__0STARROW]
{2} cmp esi,ecx
{0} cmovb ecx,esi
{1*} add ebx,04h
{2*} jnz @findrowmin
{@70-} neg ecx
{1} jle @@REDUCE_ROWS
@@ABNORMAL_EXIT:
{@74} or edx,-1
{1} sub esp,ebp
{2-} { x3 } cmp edi,00h
{0} mov esi,[esp+__MARKS]
{@80} { x6 } test ebp,0FFFFFFFFh
{2} mov [esi+TRESULT.OPTIMUM],edx
{0} mov ebx,[esi+TRESULT.NEXTIVALUE]
{1} jmp dword ptr [esp+_INVALIDRESULT]
{@90} @initcol:
{0} { x1 } mov es:[edi+__INITCOL],ecx
{1-} mov eax,ebp
{2} neg ebp
{0} push ebp
{1-} xor ebx,ebx
{2} jmp @@1ST_STEP { long jump instruction }
{@A0} { x2 } xor eax,eax
{@A2} @free0col:
{ } lea ecx,[edx-04h]
{@A5} @setcolmod:
{ } mov [edi+edx*08h+__COLMODIFIER],esi
@@REDUCE_COLUMNS: { no need to initialize -initcol in ECX }
{0**} cmp edx,ebp
{1**} jz @initcol
{0} sub edx,04h
{@B0-} xor esi,esi
{1**} test [edi+edx*08h+__0STARROW],ebp
{2**} js @setcolmod
{ } lea ebx,[edi+edx]
{ -} mov ecx,ebp
{ -} mov esi,ebp
{ } sub ebx,ebp
{@C0} @findcolmin:
{0} mov eax,[ebx] { 3 AGU + 7 EX uops on Kaveri }
{1} add eax,[edi+ecx*08h+__ROWMODIFIER]
{2} or eax,[edi+ecx*08h+__FIXEDROW]
{0} sub ebx,ebp
{1} cmp eax,esi
{2} cmovb esi,eax
{0*} add ecx,04h
{1*} jnz @findcolmin
{ } lea ecx,[ebp-04h]
{ } lea ebx,[edi+edx]
{ **} test esi,esi { JS/JNS can only fuse with TEST }
{ **} js @@ABNORMAL_EXIT
{@E0} @findcol0:
{0*} add ecx,04h
{1*} jz @free0col
{2} sub ebx,ebp
{0} mov eax,[ebx]
{1} add eax,[edi+ecx*08h+__ROWMODIFIER]
{2**} cmp eax,esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{@EF**} jnz @findcol0
{ **} test [edi+ecx*08h+__0STAR],ebp
{ **} js @findcol0
{ } mov [edi+edx*08h+__0STARROW],ecx
{ } mov [edi+ecx*08h+__0STAR],edx
{ } jmp @free0col
{ --------------------------------------------------------------------------------------------- }
{@00} { x16 } test ebp,0FFFFFFFFh; cmp edx,00h; cmp ecx,00h; xor eax,eax; xor edi,edi
{@10} { x3 } cmp ebp,00h
@@5TH_STEP:
{@13} mov ebx,[edi+__INITCOL] { lea ebx,[ebp-04h] }
{1} mov esi,[esp+__SIZE]
{2-} xor ebp,ebp
{0} mov eax,[esp+__SIZE+esi*04h]
{@20} @DEC5_free_col: { 4 AGU + 6 EX uops on Kaveri }
{0} add [edi+ebx*08h+__COLMODIFIER],ebp
{1-} mov ebp,ecx
{2} test [edi+ebx*08h+(04h*08h)+__COLMARK],ebx
{0} cmovns ebp,edx
{1*} add ebx,04h
{@30*} jnz @DEC5_free_col { clears EBX register }
{ } mov ecx,[edi+__MINCOLROW]
{ } movsx ebx,cx
{ } sar ecx,10h
{ } jmp @INC5_marked_row
{ x3 } xor ebp,ebp; nop
{@40} @inc5row:
{0} add [edi+eax*08h+__ROWMODIFIER],edx
{1-} mov eax,ebp
@INC5_marked_row: { 4 AGU + 4 EX uops on Kaveri }
{2} mov ebp,[esp+esi*04h]
{0*} sub esi,01h
{1*} jge @inc5row { sets ESI to 0FFFFFFFFh }
@@3RD_STEP:
{@4E*} and esi,[edi+ebx*08h+__0STAR]
{@52*} jz @4TH_STEP { long jump instruction }
{@58} @re3start:
{ } mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{ } { x1 } mov ecx,es:[edi+__INITCOL] { lea ecx,[ebp-04h] }
{@60-} mov edx,esi
{@62} @mark3row:
{ } mov [esp+__OFFS+eax*04h],ebx
{ } mov [edi+esi*08h+__COLMARK],eax { clear _COLMARK sign = store positive value to _COLMARK }
{ } inc eax { add eax,01h }
{ -} xor ebx,ebx
@@2ND_STEP:
{@6D} mov [esp+__SIZE],eax
@chk2col:
{@71*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*08h+__COLMARK],ecx { STORE FORWARDED from @mark3row }
{0**} js @chk2col
{12} push dword ptr [edi+ecx*08h+__COLMODIFIER]
{@80} sub ebx,ebp
{ } lea eax,[ecx+edi]
{ } mov esi,[edi+ebx*08h+__ROWMODIFIER]
{ } sal ecx,10h
{@8C} @ZERO2col: { 4 AGU + 11 EX uops on Kaveri }
{0} sub esi,[esp+00h]
{@8F} add esi,[eax+ebp]
{0} jo @over2flow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{1} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{2} jz @zero
{K10} lea eax,[eax+ebp]
{0} cmp esi,edx
{@9F} cmovb edx,esi
{@A2} cmovb cx,bx
@over2flow:
{0} mov esi,[edi+ebx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ebx,04h
{2*} jnz @ZERO2col
{@AF} @zero:
{0} pop eax
{@B0-} mov eax,ecx
{2} sar ecx,10h
{0} cmovnc eax,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],eax
{2**} test ebx,ebx
{0**} jz @chk2col
{@C0*} add esi,[edi+ebx*08h+__0STAR] { zero found -> ESI=0 }
{2*} jz @4TH_STEP
{0} mov eax,[esp+__SIZE]
{1**} cmp word ptr [edi+__MINCOLROW],bx { STORE FORWARDED }
{2**} jz @re3start
{@D0} cmp esi,ecx
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2} cmovl ecx,esi
{0*} sub ecx,04h { never clears ECX register }
{1*} jnz @mark3row { forced conditional jump for Sandy Bridge }
{ x2 } xor esi,esi
@@4TH_STEP: { 5 AGU + 3 EX uops on Kaveri }
{@E0-} mov ebx,edx
@4TH_STEP:
{@E2} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{1} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{@F0**} cmp edx,00h
{0**} jnz @@4TH_STEP
{ -} mov eax,esi
{ } mov ecx,[edi+__INITCOL] { lea ecx,[ebp-04h] }
{ } sub edx,ebp
{ } sub eax,ebp
{ -} mov ebx,esi
@@1ST_STEP: { 4 AGU + 6 EX uops on Kaveri }
{@00} mov esi,[edi+eax*08h+__0STARROW]
{1} mov [edi+eax*08h+__COLMARK],esi
{2} and edx,esi
{0} mov esi,[edi+eax*08h+__FIXEDROW]
{1} cmovs ecx,eax
{@10} mov [edi+eax*08h+__0COLON___ROWMARK],esi
{0*} add eax,04h
{1*} jnz @@1ST_STEP { clears EAX register }
{ } xor edx,ecx { long jump instruction }
{ } js @@2ND_STEP { ===>>> EBX: 00h EAX:00h EDX:negative ECX:initcol (>= EBP-4) }
{@21} pop esi
{ } neg ebp
{ -} xor ecx,ecx
{ -} mov edx,ebp
{ } sub esp,ebp
{ -} mov ebx,edi
{ } mov esi,[esp+__MARKS]
@@results:
{@30} mov eax,[edi+edx*08h+__0STAR] { 3 AGU + 8 EX uops on Kaveri }
{1} sub ebx,ebp
{2} add ecx,[ebx+eax]
{0} sub eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@40} add esi,01h
{1*} add edx,04h
{2*} jnz @@results

[ Szerkesztve ]

Egy újabb lépcsőfok, még több shortcut-tal és mellékhatással.

K10 (2.9 GHz): Core2-nek tetsző ciklusverzióval 48 sec, K10-essel 47 sec alatt oldja meg a feladatot
Core2 (2.5 GHz): 60 sec alatt 506000 mátrix? vagy több
Ivy Bridge (3.8 GHz): 42 sec alatt végez a teljes feladattal (a K10-es ciklusverzió a gyorsabb rajta 1%-kal, de azonos másodperc-eredményt ad)

Egyre jobban körvonalazódik, hogy - akármilyen hajmeresztő, - átszámolás szerint azonos órajel mellett a Merom/Penryn (Core 2) gyorsabb ebben a programban, mint a Sandy/Ivy Bridge, kb 8%-kal. Egyetlen tényező indokolja ezt, a Core2 loop predictor-a: ez a számolt/for ciklusokat 64 lefutásig jól becsli (a program legfeljebb 60x60-as mátrixokat kezel, ennek megfelelőek a számolt ciklusai is), de ilyen csak a Core 2-kben van; se a későbbi Core-okban, se az AMD CPU-iban nincs.

{@04-} xor eax,eax
{1-} mov esi,ebp
{2} { x1 } movsx ecx,byte ptr es:[edx]
{0} and esi,-8
@init:
{@0F} mov [edi+esi*08h+(00h*08h)+__0STARROW],eax
{1} mov [edi+esi*08h+(04h*08h)+__0STARROW],eax
{2*} add esi,08h
{0*} jnz @init { clears ESI register }
{ } add edx,01h
{ -} mov ebx,ebp
@@ARGUMENT:
{@20} cmp ecx,esi { 5 AGU + 10 EX uops on Kaveri }
{1} lea eax,[ebx+ecx*04h] { 3 clk 8 ALU ops on Core 2 }
{2} movsx ecx,[edx]
{0} mov [edi+eax*08h+__0STARROW],ebx { __0COUNTER <- EBP }
{1} cmovs eax,esi
{2} inc edx
{0} mov [edi+ebp*08h+__FIXEDROW],eax
{1} mov [edi+ebp*08h+__0STAR],eax
{2*} add ebp,04h
{0*} jnz @@ARGUMENT { clears EBP register }
{ -} mov eax,edi
{ -} mov ebp,ebx
{@40} { x1 } lea edx,es:[ebx-04h]
{ } { x1 } and ecx,00h
{ } add esp,ebx
@@REDUCE_ROWS:
{@49} mov [edi+edx*08h+__ROWMODIFIER],ecx
{1*} add edx,04h
{@50*} jz @@REDUCE_COLUMNS
{0-} xor ecx,ecx
{1} sub eax,ebp
{2**} test [edi+edx*08h+__0STAR],ebp
{0**} js @@REDUCE_ROWS
{ -} mov ebx,ebp
{ -} mov ecx,ebp
{@60} @findrowmin: { 2 AGU + 5 EX uops on Kaveri }
{0} mov esi,[eax+ebx] { 2 clk 6 ALU ops on Core 2 }
{1} or esi,[edi+ebx*08h+__0STARROW]
{2} cmp esi,ecx
{0} cmovb ecx,esi
{1*} add ebx,04h
{2*} jnz @findrowmin
{@70} neg ecx
{1} jle @@REDUCE_ROWS
@@ABNORMAL_EXIT:
{@74} or edx,-1
{1} sub esp,ebp
{2-} { x3 } cmp edi,00h
{0} mov esi,[esp+__MARKS]
{@80} { x6 } test ebp,0FFFFFFFFh
{2} mov [esi+TRESULT.OPTIMUM],edx
{0} mov ebx,[esi+TRESULT.NEXTIVALUE]
{1} jmp dword ptr [esp+_INVALIDRESULT]
{@90} @initcol:
{0} mov [edi+__INITCOL],ecx
{1-} mov esi,ebp
{2} neg ebp
{0} push ebp
{1} or ebx,-1
{2} jmp @@1ST_STEP { long jump instruction }
{@A0} { x2 } xor eax,eax
{@A2} @free0col:
{ } lea ecx,[edx-04h]
{@A5} @setcolmod:
{ } mov [edi+edx*08h+__COLMODIFIER],esi
@@REDUCE_COLUMNS: { no need to initialize -initcol in ECX }
{0**} cmp edx,ebp
{1**} jz @initcol
{0} sub edx,04h
{@B0-} xor esi,esi
{1**} test [edi+edx*08h+__0STARROW],ebp
{2**} js @setcolmod
{ } lea ebx,[edi+edx]
{ -} mov ecx,ebp
{ -} mov eax,ebp
{ } sub ebx,ebp
{@C0} @findcolmin:
{0} mov esi,[ebx] { 3 AGU + 8 EX uops on Kaveri }
{1} add esi,[edi+ecx*08h+__ROWMODIFIER] { 3 clk 9 ALU ops on Core 2 }
{2} or esi,[edi+ecx*08h+__FIXEDROW]
{0} jz @test0row
{1} sub ebx,ebp
{2} cmp esi,eax
{@D0} cmovb eax,esi
{1*} add ecx,04h
{2*} jnz @findcolmin
{ } lea ecx,[ebp-04h]
{ -} mov esi,eax
{ } lea ebx,[edi+edx]
{@E0**} test eax,eax { JS/JNS can only fuse with TEST }
{ **} js @@ABNORMAL_EXIT
{@E4} @seekcol0:
{0*} add ecx,04h
{1*} jz @free0col
{2} sub ebx,ebp
{0} mov eax,[ebx]
{@ED} add eax,[edi+ecx*08h+__ROWMODIFIER]
{@F1**} cmp eax,esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{ **} jnz @seekcol0
@test0row:
{ **} test [edi+ecx*08h+__0STAR],ebp
{ **} js @seekcol0
{ } mov [edi+edx*08h+__0STARROW],ecx
{@FE} mov [edi+ecx*08h+__0STAR],edx
{@02} jns @free0col { forced conditional jump for Sandy Bridge }

{ --------------------------------------------------------------------------------------------- }

{@04} { x12 } mov eax,00000000h; mov edx,00000000h; xor ecx,ecx
{@10} { x3 } cmp ebp,00h
@@5TH_STEP:
{@13} mov ebx,[edi+__INITCOL] { lea ebx,[ebp-04h] }
{1} mov esi,[esp+__SIZE]
{2-} xor ebp,ebp
{0} mov eax,[esp+__SIZE+esi*04h]
{@20} @DEC5_free_col: { 3 AGU + 6 EX uops on Kaveri }
{0} add [edi+ebx*08h+__COLMODIFIER],ebp { 2 clk 6 ALU ops on Core 2 }
{1} mov ebp,[edi+ebx*08h+(04h*08h)+__COLMARK]
{2} xor ebp,edx { EDX > 0 EBP <= 0 }
{0} cmovs ebp,ecx
{1*} add ebx,04h
{@30*} jnz @DEC5_free_col { clears EBX register }
{ } mov ecx,[edi+__MINCOLROW]
{ } movsx ebx,cx
{ } sar ecx,10h
{ } jmp @INC5_marked_row
{ x3 } xor ebp,ebp; nop
{@40} @inc5row:
{0} add [edi+eax*08h+__ROWMODIFIER],edx { 4 AGU + 4 EX uops on Kaveri }
{1-} mov eax,ebp
@INC5_marked_row:
{2} mov ebp,[esp+esi*04h]
{0*} sub esi,01h
{1*} jge @inc5row { sets ESI to 0FFFFFFFFh }
@@3RD_STEP:
{@4E*} and esi,[edi+ebx*08h+__0STAR]
{@52*} jz @4TH_STEP { long jump instruction }
{@58} @re3start:
{ } mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{ } { x1 } mov ecx,es:[edi+__INITCOL] { lea ecx,es:[ebp-04h] }
{@60-} mov edx,ebx
{@62} @mark3row:
{ } mov [esp+__OFFS+eax*04h],ebx
{ -} xor ebx,ebx
{ } add dword ptr [esp+__SIZE],01h
{ } mov [edi+esi*08h+__COLMARK],ebx { unmark column with ZERO }
{@71} @chk2col:
{0*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*08h+__COLMARK],ecx { STORE FORWARDED from @mark3row }
{0**} js @chk2col
@@2ND_STEP:
{12} push dword ptr [edi+ecx*08h+__COLMODIFIER]
{@80} lea eax,[ecx+edi]
{ } sub ebx,ebp
{ } sal ecx,10h
{ } mov esi,[edi+ebx*08h+__ROWMODIFIER]
{@8C} @ZERO2col: { 4 AGU + 11 EX uops on Kaveri }
{0} sub esi,[esp+00h] { 4 clk 13 ALU ops on Core 2 }
{@8F} add esi,[eax+ebp]
{C2D} lea eax,[eax+ebp]
{2} jo @over2flow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{0} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{1} jz @zero
{K10}// lea eax,[eax+ebp]
{0} cmp esi,edx
{@9F} cmovb edx,esi
{@A2} cmovb cx,bx
@over2flow:
{0} mov esi,[edi+ebx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ebx,04h
{2*} jnz @ZERO2col
{@AF} @zero:
{0} pop eax { add esp,04h } { enforce ESP handling from to AGU/memory pipe on P4/Kaveri/Core }
{@B0-} mov eax,ecx
{2} sar ecx,10h
{0} cmovnc eax,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],eax
{2**} test ebx,ebx
{0**} jz @chk2col
{@C0*} add esi,[edi+ebx*08h+__0STAR] { zero found -> ESI=0 }
{2*} jz @4TH_STEP
{0} mov eax,[esp+__SIZE]
{1**} cmp word ptr [edi+__MINCOLROW],bx { STORE FORWARDED }
{2**} jz @re3start
{@D0} cmp esi,ecx
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2} cmovl ecx,esi
{0*} sub ecx,04h { never clears ECX register }
{1*} jnz @mark3row { forced conditional jump for Sandy Bridge }
{ x2 } xor esi,esi
{@E0} { x4 } lea eax,[ebp+ebp+00h]
@@4TH_STEP: { 5 AGU + 3 EX uops on Kaveri }
{@E4-} mov ebx,edx
@4TH_STEP:
{@E6} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{@F0} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{2**} cmp edx,00h
{0**} jnz @@4TH_STEP
{ } sub esi,ebp
{ } sub edx,ebp
{ } lea ecx,[esi-04h] { mov ecx,[edi+__INITCOL] }
@@1ST_STEP: { 4 AGU + 6 EX uops on Kaveri }
{@00} mov eax,[edi+esi*08h+__0STARROW]
{1} mov [edi+esi*08h+__COLMARK],eax
{2} and ebx,eax
{0} mov eax,[edi+esi*08h+__FIXEDROW]
{1} cmovs ecx,esi
{@10} mov [edi+esi*08h+__0COLON___ROWMARK],eax
{0*} add esi,04h
{1*} jnz @@1ST_STEP { clears ESI register }
{ } { x1 } mov ss:[esp+__SIZE],esi
{ -} xor ebx,ebx
{@20*} add ecx,04h { long jump instruction }
{ *} jnz @@2ND_STEP { ===>>> EBX: 00h EDX:negative ECX:initcol (>= EBP) }
{ } mov esi,[esp+ebp+04h+__MARKS]
{ -} mov ebx,edi { work matrix unmodified }
{ } pop eax
@@results:
{@30} mov eax,[edi+edx*08h+__0STAR] { 3 AGU + 8 EX uops on Kaveri }
{1} add ebx,ebp
{2} add ecx,[ebx+eax]
{0} add eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@40} add esi,01h
{1*} add edx,04h
{2*} jnz @@results { clears EDX register ( DL=0 as head, DH=0 as length ) }

[ Szerkesztve ]

Core2-n továbbra is 506000 mátrix oldódik meg 60 sec alatt. Meg is van a magyarázat, pipeline szimuláció szerint, a fő ciklusra, 5 db lefutás (tárolás nincs benne, azaz 4 pipe dolgozik csak):

sub esi,[esp+00h] add esi,[eax+ebp] lea eax,[eax+ebp] jo @over2flow
or esi,[...+__0COLON___ROWMARK] jz @zero cmp esi,edx
cmovb edx,esi
cmovb cx,bx mov esi,[...+__ROWMODIFIER] add ebx,04h jnz @ZERO2col


clk -- ALO 0 -- | -- ALU 1 -- | -- ALU 5 -- | -- LOAD --
00 | lea eax,[eax+ebp] | | ld x,esp+00h
01 | | | ld y,eax+ebp
02 | | | ld z,rowmark
03 sub esi,x | add ebx,04h | | mov esi,rowmodifier
04 add esi,y | lea eax,[eax+ebp] | jnz @zeroincol | ld x,esp+00h
05 or esi,z | | jo overflow | ld y,eax+ebp
06 cmp esi,edx | | jz zero | ld z,rowmark
07 cmovb cx,bx | cmovb edx,esi | sub esi,x | mov esi,rowmodifier
08 cmovb cx,bx | cmovb edx,esi | add esi,y | ld x,esp+00h
09 or esi,z | add ebx,04h +2 | jz @zero | ld y,eax+ebp
10 cmp esi,edx | cmovb edx,esi | jo @overflow | ld z,rowmark
11 cmovb cx,bx | cmovb edx,esi | jnz @zeroincol +4 | mov esi,rowmodifier
12 sub esi,x +1 | lea eax,[eax+ebp] +1 | | ld x,esp+00h
13 add esi,x +1 | add ebx,04h +2 | | ld y,eax+ebp
14 or esi,z +1 | | jo overflow +1 | ld z,rowmark
15 cmp esi,edx | sub esi,x | jz @zero +1 | mov esi,rowmodifier
16 cmovb cx,bx | cmovb esi,edx | jnz @zeroincol +4 | ld x,esp+00h
17 cmovb cx,bx | cmovb esi,edx | add esi,y |
18 or esi,z | lea eax,[eax+ebp] +2 | jo overflow |
19 cmp esi,edx | add ebx,04h +4 | jz @zero | ld y,eax+ebp
20 cmovb cx,bx | cmovb esi,edx | jnz @zeroincol | ld z,rowmark
21 cmovb cx,bx | cmovb esi,edx | sub esi,x +2 | mov esi,rowmodifier
22 add esi,y | lea eax,[eax+ebp] +2 | |
23 or esi,z | add ebx,04h | jo overflow |
24 cmp edx,esi | | jz @zero |
25 cmovb cx,bx | cmovb esi,edx | jnz @zeroincol |
26 cmovb cx,bx | cmovb esi,edx | |

27 órajel alatt indul el az 5 ciklus 60 utasítása, ez 2,22 IPC; pontosan annyi, amennyi a programon mérhető (a szimuláció 3 clock/load-dal történt). A "+x" jelölés azt jelenti, hogy az adott uop hány órajellel később indul el ahhoz képest , hogy a paraméterei rendelkezésre állnak, mivel van öregebb lefuttatni való uop, ami akadályozza. Nem csoda a 2,2 IPC és a "röcögés", mert főleg az add ebx,04h és kisebb mértékben a lea eax,[eax+ebp] az érintett, amelyek épp a következő ciklusmag lefutását késleltetik (a jcc utasítások ilyen szempontből lényegtelenek, mivel a decode fázisban "kezeli le" őket a branch prediction).

Ha az X*X méretű munkamátrix végére egy plusz sor kerülne, amely csupa nullát tartalmaz, akkor az add ebx,04h + jnz @zeroincol párosnak nem kellene lezárónak lennie a ciklusban, a felső jz @zero kiléptetné, így az add ebx,04h bárhol elhelyezhető lenne a ciklusban, ezzel az add ebx,04h "öregebb" lenne, így nagyobb IPC érhető el.
Meglátjuk.

[ Szerkesztve ]

Nem ez a gond; bár a szimuláció a végrehajtásra jó, a Core-ok utasításdekódolása teljesen másképp működik, mint az AMD-knél a fixen egymás után következő 3 (K7/K8/K10) vagy 4 (Bulldozer-family) utasítás mint egy egység.

Az említett 12 utasításos (14 uop, ebből 13 ALU-érintett) ciklusmag 2.5 IPC-vel (2.9 uop/clk) fut (2.5 GHz mellett 1500 fused + 5600 non-fused uop = 3,44 művelet/órajel; tekintve, hogy tárolás nincs benne, azaz 4 pipe-ot mozgat (p2 mint load és a p015 3 ALU), ez nagyon közel van az elméleti maximumhoz; ennél több nehezen hozható ki belőle).

Nem is kellene említem, hogy K10-en a K10-utasítássorrendű ciklus természetesen 3.0 IPC-vel megy.

Bár még programot egyelőre nehéz írni/átrendezni rá, kezd kézzelfoghatóvá válni, hogy mit és hogyan dekódol a Core2 (és miért kellett a garantált 4 uop/clock a későbbi Core-verziókba). Pl. ezt a ciklusmagot 3 órajel alatt dekódolja a Core 2 (IPC 2.6, 3.0 uop/cycle), pedig ránézésre ráhúzható a 4-1-1-1 + 4-1-1-1 minta:

mov eax,[edi+esi*08h+__0STARROW]
mov [edi+esi*08h+__COLMARK],eax
and ebx,eax
mov eax,[edi+esi*08h+__FIXEDROW]
cmovs ecx,esi
mov [edi+esi*08h+__0COLON___ROWMARK],eax
add esi,04h
jnz @@1ST_STEP

Érdekesebb, hogy ezt is 3 órajel alatt dekódolja (IPC 2.3, 2.9 uop/cycle), pedig 2-1-1 + 2-1-1 a mintája:

add [edi+ebx*08h+__COLMODIFIER],ebp
mov ebp,[edi+ebx*08h+(04h*08h)+__COLMARK]
xor ebp,edx
cmovs ebp,ecx
add ebx,04h
jnz @DEC5_free_col

A cmovcc, a load-op-store mindenképpen a 0. dekóderre kell kerüljön, illetve csak egymás utáni utasításokat tud dekódolni a Core2.

[ Szerkesztve ]

Továbbra is egy szálas program.

Core2 (2.5 GHz): 60 sec alatt 507000 mátrix
Sandy Bridge (G1620 2.7 GHz): a K10-es ciklusverzióval 59 sec, a Core2-essel 60 sec

Akkor is meg fogja oldani 2500 MHz-en bármely Core egy szálon ezt a feladatot; ha kell, fél évig mászok fel hetente 1000 mátrixot, de meg fogja.

{@04-} { x1 } movsx ecx,byte ptr es:[edx]
{1-} xor eax,eax
{2-} mov esi,ebp
{0} and esi,-8
@init:
{@0F} mov [edi+esi*08h+(00h*08h)+__0STARROW],eax
{1} mov [edi+esi*08h+(04h*08h)+__0STARROW],eax
{2*} add esi,08h
{0*} jnz @init { clears ESI register }
{ } add edx,01h
{ -} mov ebx,ebp
@@ARGUMENT: { K10:2.6 Core2:2.9 - 3.3 uop/clk - 1640*2+6550 }
{@20} cmp ecx,esi { 4 AGU + 9 EX uops on Kaveri }
{1} lea eax,[ebx+ecx*04h] { 3 clk 8 ALU ops on Core 2 }
{2} movsx ecx,[edx]
{0} lea edx,[edx+01h] { db $8D,$52,$00 }
{1} mov [edi+eax*08h+__0STARROW],ebx { __0COUNTER <- EBP }
{2} cmovs eax,esi
{0} mov [edi+ebp*08h+__FIXEDROW],eax
{1*} add ebp,04h
{2*} jnz @@ARGUMENT { clears EBP register }
{ -} mov eax,edi
{ -} mov ebp,ebx
{ -} xor ecx,ecx
{@40} add esp,ebx
{ } lea edx,[ebx-04h]
@@REDUCE_ROWS:
{@45} mov [edi+edx*08h+__ROWMODIFIER],ecx
{1} mov esi,[edi+edx*08h+(04h*08h)+__FIXEDROW]
{2*} add edx,04h
{0*} jz @@REDUCE_COLUMNS
{1} mov [edi+edx*08h+__0STAR],esi
{2-} xor ecx,ecx
{0} sub eax,ebp
{1**} test esi,esi
{2**} js @@REDUCE_ROWS
{0-} mov ecx,ebp
{@60} @findrowmin: { 2 AGU + 5 EX uops on Kaveri }
{0} mov esi,[eax+ebx] { 2 clk 6 ALU ops on Core 2 }
{1} or esi,[edi+ebx*08h+__0STARROW]
{2} cmp esi,ecx
{0} cmovb ecx,esi
{1*} add ebx,04h
{2*} jnz @findrowmin
{@70-} mov ebx,ebp
{ } neg ecx
{ } jle @@REDUCE_ROWS
@@ABNORMAL_EXIT:
{@76} or edx,0FFFFFFFFh
{1} sub esp,ebp
{@7E} mov esi,[esp+__MARKS]
{0} mov [esi+TRESULT.OPTIMUM],edx
{1} mov ebx,[esi+TRESULT.NEXTIVALUE]
{2} jmp dword ptr [esp+_INVALIDRESULT]
{ x4 } xor eax,eax; xor edx,edx
{@90} @initcol:
{0} mov [edi+__INITCOL],ecx
{1-} mov esi,ebp
{2} neg ebp
{0} push ebp
{1} or ebx,-1
{2} jmp @@1ST_STEP { long jump instruction }
{@A0} { x2 } xor eax,eax
{@A2} @free0col:
{ } lea ecx,[edx-04h]
{@A5} @setcolmod:
{ } mov [edi+edx*08h+__COLMODIFIER],esi
@@REDUCE_COLUMNS: { no need to initialize -initcol in ECX }
{0**} cmp edx,ebp
{1**} jz @initcol
{0} sub edx,04h
{@B0-} xor esi,esi
{1**} test [edi+edx*08h+__0STARROW],ebp
{2**} js @setcolmod
{ } lea ebx,[edi+edx]
{ -} mov ecx,ebp
{ -} mov eax,ebp
{ } sub ebx,ebp
{@C0} @findcolmin:
{0} mov esi,[ebx] { 3 AGU + 8 EX uops on Kaveri }
{1} add esi,[edi+ecx*08h+__ROWMODIFIER] { 3 clk 9 ALU ops on Core 2 }
{2} or esi,[edi+ecx*08h+__FIXEDROW]
{0} jz @test0row
{1} sub ebx,ebp
{2} cmp esi,eax
{@D0} cmovb eax,esi
{1*} add ecx,04h
{2*} jnz @findcolmin
{ } lea ecx,[ebp-04h]
{ -} mov esi,eax
{ } lea ebx,[edi+edx]
{@E0**} test eax,eax { JS/JNS can only fuse with TEST }
{ **} js @@ABNORMAL_EXIT
{@E4} @seekcol0:
{0} mov eax,[edi+ecx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ecx,04h
{2*} jz @free0col
{0} sub ebx,ebp
{1} add eax,[ebx]
{@F1**} cmp eax,esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{0**} jnz @seekcol0
@test0row:
{ **} test [edi+ecx*08h+__0STAR],ebp
{ **} js @seekcol0
{ } mov [edi+edx*08h+__0STARROW],ecx
{@FE} mov [edi+ecx*08h+__0STAR],edx
{@02} jns @free0col { forced conditional jump for Sandy Bridge }
{ ----------------------------------------------------------------------------------------------- }
{@04} { x12 } mov eax,00000000h; mov edx,00000000h; xor ecx,ecx
{@10} { x2 } xor ebp,ebp
@@5TH_STEP: { K10:2.5 Core2:2.4 - 2.8 uop/clk - 1900*2+4800
{@12} mov eax,[edi+__INITCOL] { lea ebx,[ebp-04h] }
{1} mov esi,[esp+__SIZE]
{2} add eax,04h
{0} movsx ebx,word ptr [edi+__MINCOLROW]
{@20} @DEC5_free_col: { 3 AGU + 6 EX uops on Kaveri }
{0} mov ebp,[edi+eax*08h+__COLMARK] { 2 clk 5 ALU ops on Core 2 }
{1} sar ebp,1Fh
{2} and ebp,edx
{0} add [edi+eax*08h+__COLMODIFIER],ebp
{1*} add eax,04h
{@30*} jnz @DEC5_free_col { clears EAX register }
{ } mov eax,[esp+__SIZE+esi*04h]
{ } movsx ecx,word ptr [edi+__MINCOLROW+02h]
{ } jmp @INC5_marked_row
{ x4 } xor ebp,ebp; xor esi,esi
{@40} @inc5row:
{0} add [edi+eax*08h+__ROWMODIFIER],edx { 4 AGU + 4 EX uops on Kaveri }
{1-} mov eax,ebp
@INC5_marked_row:
{2} mov ebp,[esp+esi*04h]
{0*} sub esi,01h
{1*} jge @inc5row { sets ESI to 0FFFFFFFFh }
@@3RD_STEP:
{@4E*} and esi,[edi+ebx*08h+__0STAR]
{@52*} jz @4TH_STEP { long jump instruction }
{@58} @re3start:
{ } mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{ } { x1 } mov ecx,es:[edi+__INITCOL] { lea ecx,es:[ebp-04h] }
{@60-} mov edx,ebx
{@62} @mark3row:
{ } mov [esp+__OFFS+eax*04h],ebx
{ -} xor ebx,ebx
{ } mov [edi+esi*08h+__COLMARK],esi { unmark column with negative }
{ } add dword ptr [esp+__SIZE],01h
{@71} @chk2col:
{0*} add ecx,04h
{1*} jz @@5TH_STEP
{2**} test [edi+ecx*08h+__COLMARK],ecx { STORE FORWARDED from @mark3row }
{0**} jns @chk2col
@@2ND_STEP:
{12} push dword ptr [edi+ecx*08h+__COLMODIFIER]
{@80} lea eax,[ecx+edi]
{ } sub ebx,ebp
{ } sal ecx,10h
{ } mov esi,[edi+ebx*08h+__ROWMODIFIER]
{@8C} @ZERO2col: { K10:3.0 Core2:2.5 - 2.9 uop/clk - 1500*2+5600 { 4 AGU + 11 EX uops on Kaveri }
{0} sub esi,[esp+00h] { 4 clk 13 ALU ops on Core 2 }
{@8F} add esi,[eax+ebp]
{C2D} lea eax,[eax+ebp]
{2} jo @over2flow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{0} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{1} jz @zero
{K10}// lea eax,[eax+ebp]
{0} cmp esi,edx
{@9F} cmovb edx,esi
{@A2} cmovb cx,bx
@over2flow:
{0} mov esi,[edi+ebx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ebx,04h
{2*} jnz @ZERO2col
{@AF} @zero:
{0} pop eax { add esp,04h } { forces ESP handling to AGU/memory pipe on Kaveri/Core }
{@B0-} mov eax,ecx
{2} sar ecx,10h
{0} cmovnc eax,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],eax
{2**} test ebx,ebx
{0**} jz @chk2col
{@C0*} add esi,[edi+ebx*08h+__0STAR] { zero found -> ESI=0 }
{2*} jz @4TH_STEP
{0} mov eax,[esp+__SIZE]
{1**} cmp word ptr [edi+__MINCOLROW],bx { STORE FORWARDED }
{2**} jz @re3start
{@D0} cmp esi,ecx
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2} cmovl ecx,esi
{0*} sub ecx,04h { never clears ECX register }
{1*} jnz @mark3row { forced conditional jump for Sandy Bridge }
{ x2 } xor esi,esi
{@E0} { x4 } lea eax,[ebp+ebp+00h]
@@4TH_STEP: { 5 AGU + 3 EX uops on Kaveri }
{@E4-} mov ebx,edx
@4TH_STEP:
{@E6} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{@F0} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{2**} cmp edx,00h
{0**} jnz @@4TH_STEP
{ } sub esi,ebp
{ } sub edx,ebp
{ } lea ecx,[esi-04h] { mov ecx,[edi+__INITCOL] }
@@1ST_STEP: { K10:2.8 Core2:2.9 - 3.2 uop/clk - 1500*2+6100 }
{@00} mov eax,[edi+esi*08h+__0STARROW] { 4 AGU + 7 EX uops on Kaveri }
{1} and ebx,eax { 2 clk 6 ALU ops on Core 2 }
{2} not eax
{0} mov [edi+esi*08h+__COLMARK],eax
{1} mov eax,[edi+esi*08h+__FIXEDROW]
{2} cmovs ecx,esi
{0} mov [edi+esi*08h+__0COLON___ROWMARK],eax
{1*} add esi,04h
{2*} jnz @@1ST_STEP { clears ESI register }
{ } mov [esp+__SIZE],esi
{ -} xor ebx,ebx
{@21*} add ecx,04h { long jump instruction }
{ *} jnz @@2ND_STEP { ===>>> EBX: 00h EDX:negative ECX:initcol (>= EBP) }
{ } mov esi,[esp+ebp+04h+__MARKS]
{ -} mov ebx,edi { work matrix unmodified } { [esp+__SAVE] }
@@results:

[ Szerkesztve ]

Eheti 1000-mátrix-hetente rovat

Core2 (2.5 GHz): 60 sec alatt 510000 mátrix

{@04-} { x1 } movsx ebx,byte ptr es:[edx]
{1-} xor eax,eax
{2-} mov esi,ebp
{0} and esi,-8
@init:
{@0F} mov [edi+esi*08h+(00h*08h)+__0STARROW],eax
{1} mov [edi+esi*08h+(04h*08h)+__0STARROW],eax
{2*} add esi,08h
{0*} jnz @init { clears ESI register }
{ } add edx,01h
{ -} mov ecx,ebp
@@ARGUMENT: { K10:2.6 Core2:2.9 - 3.3 uop/clk - 1640*2+6550 }
{@20} cmp ebx,esi { 4 AGU + 9 EX uops on Kaveri }
{1} lea eax,[ebp+ebx*04h+00h] { 3 clk 8 ALU ops on Core 2 }
{2} movsx ebx,[edx]
{0} lea edx,[edx+01h]
{1} mov [edi+eax*08h+__0STARROW],ebp { __0COUNTER <- EBP }
{2} cmovs eax,esi
{0} mov [edi+ecx*08h+__FIXEDROW],eax
{1*} add ecx,04h
{2*} jnz @@ARGUMENT { clears ECX register }
{ } add esp,ebp
{ -} mov eax,edi
{ -} push ebp
{@40-} lea edx,[ebp-04h]
@@REDUCE_ROWS:
{@43} mov [edi+edx*08h+__ROWMODIFIER],ecx
{1} mov esi,[edi+edx*08h+(04h*08h)+__FIXEDROW]
{2*} add edx,04h
{0*} jz @@REDUCE_COLUMNS
{@50} mov [edi+edx*08h+__0STAR],esi
{2-} xor ecx,ecx
{0} sub eax,ebp
{1**} test esi,esi { JS/JNS can only fuse with TEST }
{2**} js @@REDUCE_ROWS
{ -} mov ebx,ebp { EBX < 0 for even minimum }
{ } mov ecx,[eax+ebp]
{@61} or ecx,[edi+ebp*08h+__0STARROW]
{ } and ebp,04h
{ } add ebp,ebx
{@69} @findrowmin: { K10:2.8 Core2:2.2 - 2.6 uop/clk - 1100*2+5000 }
{0} mov esi,[eax+ebp+00h] { 4 AGU + 8 EX uops on Kaveri }
{1} or esi,[edi+ebp*08h+(00h*08h)+__0STARROW] { 3 clk 10 ALU ops on Core 2 }
{2} add ebp,08h
{@72} cmp esi,ebx
{1} cmovb ebx,esi
{2} mov esi,[eax+ebp-04h]
{0} or esi,[edi+ebp*08h-(04h*08h)+__0STARROW]
{1} cmp esi,ecx
{@81} cmovb ecx,esi
{0**} test ebp,ebp
{1**} jnz @findrowmin
{ } mov ebp,[esp+00h]
{ } cmp ebx,ecx
{ } cmovb ecx,ebx
{@90} neg ecx
{ } jle @@REDUCE_ROWS
@@ABNORMAL_EXIT:
{@94} pop eax
{1} sub esp,ebp
{2} mov edx,0FFFFFFFFh
{0} mov esi,[esp+__MARKS]
{@A0} mov [esi+TRESULT.OPTIMUM],edx
{2} mov ebx,[esi+TRESULT.NEXTIVALUE]
{0} jmp dword ptr [esp+_INVALIDRESULT]
{ } { x6 } test ebp,0FFFFFFFFh
{@90} @initcol:
{0} neg dword ptr [esp+00h]
{1-} mov esi,ebp
{2} neg ebp
{0} mov [edi+__INITCOL],ecx
{1} or ebx,-1
{2} jmp @@1ST_STEP { long jump instruction }
{@A2} @free0col:
{ } lea ecx,[edx-04h]
{@A5} @setcolmod:
{ } mov [edi+edx*08h+__COLMODIFIER],esi
@@REDUCE_COLUMNS:
{1**} jz @initcol
{0} sub edx,04h
{@B0-} xor esi,esi
{1**} test [edi+edx*08h+__0STARROW],ebp
{2**} js @setcolmod
{ } lea ebx,[edi+edx]
{ -} mov ecx,ebp
{ -} mov eax,ebp
{ } sub ebx,ebp
{@C0} @findcolmin: { K10:3.0 Core2:_._ - _._ uop/clk - ____*2+____
{0} mov esi,[ebx] { 3 AGU + 8 EX uops on Kaveri }
{1} add esi,[edi+ecx*08h+__ROWMODIFIER] { 3 clk 9 ALU ops on Core 2 }
{2} or esi,[edi+ecx*08h+__FIXEDROW]
{0} jz @test0row
{1} sub ebx,ebp
{2} cmp esi,eax
{@D0} cmovb eax,esi
{1*} add ecx,04h
{2*} jnz @findcolmin
{ } lea ecx,[ebp-04h]
{ -} mov esi,eax
{ } lea ebx,[edi+edx]
{@E0**} test eax,eax { JS/JNS can only fuse with TEST }
{ **} js @@ABNORMAL_EXIT
{@E4} @seekcol0:
{0} mov eax,[edi+ecx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ecx,04h
{2*} jz @free0col
{0} sub ebx,ebp
{1} add eax,[ebx]
{@F1**} cmp eax,esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{0**} jnz @seekcol0
@test0row:
{ **} test [edi+ecx*08h+__0STAR],ebp
{ **} js @seekcol0
{ } mov [edi+edx*08h+__0STARROW],ecx
{@FE} mov [edi+ecx*08h+__0STAR],edx
{@02} jns @free0col { forced conditional jump for Sandy Bridge }
{ ----------------------------------------------------------------------------------------------- }
{@04} { x12 } mov eax,00000000h; mov edx,00000000h; xor ebp,ebp
{@10} { x5 } mov ecx,00000000h
@@5TH_STEP: { K10:2.6 Core2:2.4 - 2.8 uop/clk - 2000*2+5100
{@15} mov eax,[edi+__INITCOL] { lea eax,[ebp+04h]; neg eax }
{1} mov esi,[esp+__SIZE]
{2} movsx ebx,word ptr [edi+__MINCOLROW]
{@20} @DEC5_free_col: { 3 AGU + 6 EX uops on Kaveri }
{0} add [edi+eax*08h+__COLMODIFIER],ecx { 2 clk 5 ALU ops on Core 2 }
{1} mov ecx,[edi+eax*08h+(04h*08h)+__COLMARK]
{2} sar ecx,1Fh
{0} and ecx,edx
{1*} add eax,04h
{@30*} jnz @DEC5_free_col { clears EAX register [NOT USED] }
{ } mov eax,[esp+__SIZE+esi*04h]
{ } movsx ecx,word ptr [edi+__MINCOLROW+02h]
{ } jmp @INC5_marked_row
{ x4 } xor ebp,ebp; xor esi,esi
{@40} @inc5row:
{0} add [edi+eax*08h+__ROWMODIFIER],edx { 4 AGU + 4 EX uops on Kaveri }
{1-} mov eax,ebp
@INC5_marked_row:
{2} mov ebp,[esp+esi*04h]
{0*} sub esi,01h
{1*} jge @inc5row { sets ESI to 0FFFFFFFFh }
@@3RD_STEP:
{@4E*} and esi,[edi+ebx*08h+__0STAR]
{@52*} jz @4TH_STEP { long jump instruction }
{@58} @re3start:
{ } mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{ } { x1 } mov ecx,es:[edi+__INITCOL] { lea ecx,es:[ebp-04h] }
{@60-} mov edx,ebx
{@62} @mark3row:
{ } mov [esp+__OFFS+eax*04h],ebx
{ -} xor ebx,ebx
{ } mov [edi+esi*08h+__COLMARK],esi { unmark column with negative }
{ } inc eax
{ } mov [esp+__SIZE],eax
{@71} @chk2col:
{0*} add ecx,04h
{1*} jz @@5TH_STEP { clears ECX register }
{2**} test [edi+ecx*08h+__COLMARK],ecx { STORE FORWARDED from @mark3row }
{0**} jns @chk2col
@@2ND_STEP:
{12} push dword ptr [edi+ecx*08h+__COLMODIFIER]
{@80} lea eax,[ecx+edi]
{ } sub ebx,ebp
{ } sal ecx,10h
{ } mov esi,[edi+ebx*08h+__ROWMODIFIER]
{@8C} @ZERO2col: { K10:3.0 Core2:2.5 - 2.9 uop/clk - 1500*2+5600 { 4 AGU + 11 EX uops on Kaveri }
{0} sub esi,[esp+00h] { 4 clk 13 ALU ops on Core 2 }
{@8F} add esi,[eax+ebp]
{C2D} lea eax,[eax+ebp] { Core 2, Kaveri }
{2} jo @over2flow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{0} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{1} jz @zero
{K10}// lea eax,[eax+ebp] { K10, Sandy Bridge, Ivy Bridge }
{0} cmp esi,edx
{@9F} cmovb edx,esi
{@A2} cmovb cx,bx
@over2flow:
{0} mov esi,[edi+ebx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ebx,04h
{2*} jnz @ZERO2col { clears EBX register }
{@AF} @zero:
{0} pop eax { add esp,04h } { forces ESP handling to AGU/memory pipe on Kaveri/Core }
{@B0-} mov eax,ecx
{2} sar ecx,10h
{0} cmovnc eax,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],eax
{2**} test ebx,ebx
{0**} jz @chk2col
{@C0*} add esi,[edi+ebx*08h+__0STAR] { zero found -> ESI=0 }
{2*} jz @4TH_STEP
{0} cmp ax,bx
{1} { x1 } mov eax,ss:[esp+__SIZE]
{2} jz @re3start
{@D0} cmp esi,ecx
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2} cmovl ecx,esi
{0*} sub ecx,04h { never clears ECX register }
{1*} jnz @mark3row { forced conditional jump for Sandy Bridge }
{ x2 } xor esi,esi
{@E0} { x4 } lea eax,[ebp+ebp+00h]
@@4TH_STEP: { 5 AGU + 3 EX uops on Kaveri }
{@E4-} mov ebx,edx { 2 clk 2 ALU ops on Core 2 }
@4TH_STEP:
{@E6} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{@F0} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{2**} cmp edx,00h
{0**} jnz @@4TH_STEP { clears EDX register }
{ } sub esi,ebp
{ } sub edx,ebp
{ } lea ecx,[esi-04h] { mov ecx,[edi+__INITCOL] }
@@1ST_STEP: { K10:2.8 Core2:2.9 - 3.2 uop/clk - 1500*2+6100 }
{@00} mov eax,[edi+esi*08h+__0STARROW] { 4 AGU + 7 EX uops on Kaveri }
{1} and ebx,eax { 3 clk 6 ALU ops on Core 2 }
{2} not eax
{0} mov [edi+esi*08h+__COLMARK],eax
{1} mov eax,[edi+esi*08h+__FIXEDROW]
{2} cmovs ecx,esi
{0} mov [edi+esi*08h+__0COLON___ROWMARK],eax
{1*} add esi,04h
{2*} jnz @@1ST_STEP { clears ESI register }
{ } mov [esp+__SIZE],esi
{ -} xor ebx,ebx
{@21*} add ecx,04h { long jump instruction }
{ *} jnz @@2ND_STEP { ===>>> EBX: 00h EDX:negative ECX:initcol (>= EBP) }
{ } mov esi,[esp+ebp+04h+__MARKS]
{ -} mov ebx,edi { work matrix unmodified } { [esp+__SAVE] }
@@results:
{@30} mov eax,[edi+edx*08h+__0STAR] { 3 AGU + 8 EX uops on Kaveri }
{1} add ebx,ebp
{2} add ecx,[ebx+eax]
{0} add eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@40} add esi,01h
{1*} add edx,04h
{2*} jnz @@results { clears EDX register ( DL=0 as head, DH=0 as length ) }
{0} pop eax
{1} add esp,ebp
{2} neg ebp
{0} or eax,-1
{@50} lea ebx,[edi+ebp*04h]
{1} sar ebp,02h
{2} mov [esi+ebp+TRESULT.OPTIMUM],ecx
{0} add esi,ebp
{1-} xor ecx,ecx
{2} jmp @onchain

[ Szerkesztve ]

Core2 (2.5 GHz): 59 sec alatt megoldja a feladatot
K10 (2.9 GHz): Core2-nek tetsző ciklusverzióval 46 sec oldja meg a feladatot
Prescott (2.26 GHz): 60 sec alatt 220000 mátrix

{@04-} { x1 } movsx ebx,byte ptr es:[edx]
{1-} xor eax,eax
{2-} mov esi,ebp
{0} and esi,-8
@init:
{@0F} mov [edi+esi*08h+(00h*08h)+__0STARROW],eax
{1} mov [edi+esi*08h+(04h*08h)+__0STARROW],eax
{2*} add esi,08h
{0*} jnz @init { clears ESI register }
{ } add edx,01h
{ -} mov ecx,ebp
@@ARGUMENT: { K10:2.6 Core2:2.9 - 3.3 uop/clk - 1640*2+6550 }
{@20} cmp ebx,esi { 4 AGU + 9 EX uops on Kaveri }
{1} lea eax,[ebp+ebx*04h+00h] { 3 clk 8 ALU ops on Core 2 }
{2} movsx ebx,[edx]
{0} lea edx,[edx+01h]
{1} mov [edi+eax*08h+__0STARROW],ebp { __0COUNTER <- EBP }
{2} cmovs eax,esi
{0} mov [edi+ecx*08h+__FIXEDROW],eax
{1*} add ecx,04h
{2*} jnz @@ARGUMENT { clears ECX register }
{ -} { x2 } xor ecx,ecx
{ -} mov eax,edi
{ -} push ebp
{@40-} lea edx,[ebp-04h]
@@REDUCE_ROWS:
{@43} mov [edi+edx*08h+__ROWMODIFIER],ecx
{1} mov esi,[edi+edx*08h+(04h*08h)+__FIXEDROW]
{2*} add edx,04h
{0*} jz @@REDUCE_COLUMNS
{@50} mov [edi+edx*08h+__0STAR],esi
{2-} xor ecx,ecx
{0} sub eax,ebp
{1**} test esi,esi { JS/JNS can only fuse with TEST }
{2**} js @@REDUCE_ROWS
{ -} mov ebx,ebp { EBX < 0 for even minimum }
{ } mov ecx,[eax+ebp]
{@61} or ecx,[edi+ebp*08h+__0STARROW]
{ } and ebp,04h
{ } add ebp,ebx
{@69} @findrowmin: { K10:2.8 Core2:2.2 - 2.6 uop/clk - 1100*2+5000 }
{0} mov esi,[eax+ebp+00h] { 4 AGU + 8 EX uops on Kaveri }
{1} or esi,[edi+ebp*08h+(00h*08h)+__0STARROW] { 3 clk 10 ALU ops on Core 2 }
{2} add ebp,08h
{@72} cmp esi,ebx
{1} cmovb ebx,esi
{2} mov esi,[eax+ebp-04h]
{0} or esi,[edi+ebp*08h-(04h*08h)+__0STARROW]
{1} cmp esi,ecx
{@81} cmovb ecx,esi
{0**} test ebp,ebp
{1**} jnz @findrowmin
{ } mov ebp,[esp+00h]
{ } cmp ebx,ecx
{ } cmovb ecx,ebx
{@90} neg ecx
{ } jle @@REDUCE_ROWS
{ -} nop
@@ABNORMAL_EXIT:
{@95} pop eax
{1} or edx,-1
{2} mov esi,[esp+__MARKS]
{0} mov [esi+TRESULT.OPTIMUM],edx
{@A0} mov ebx,[esi+TRESULT.NEXTIVALUE]
{2} jmp dword ptr [esp+_INVALIDRESULT]
{ } { x6 } test ebp,0FFFFFFFFh
{@AD} @init0col:
{0} mov [edi+__INITCOL],ecx
{@B0-} mov esi,ebp
{2} neg ebp
{0} or ebx,-1
{1*} sub ecx,04h
{2*} jnz @@1ST_STEP { long jump instruction } { forced conditional jump for Sandy Bridge }
{@C0} { x3 } cmp ebp,00h
{@C3} @free0col:
{ -} mov ecx,edx
{@C5} @setcolmod:
{ } mov [edi+edx*08h+__COLMODIFIER],esi
@@REDUCE_COLUMNS: { no need to initialize -initcol in ECX }
{0**} cmp edx,ebp
{1**} jz @init0col
{0} sub edx,04h
{@D0-} xor esi,esi
{1**} test [edi+edx*08h+__0STARROW],ebp
{2**} js @setcolmod
{ } lea ebx,[edi+edx]
{ -} mov ecx,ebp
{ -} mov eax,ebp
{ } sub ebx,ebp
{@E0} @findcolmin: { K10:3.0 Core2:_._ - _._ uop/clk - ____*2+____
{0} mov esi,[ebx] { 3 AGU + 8 EX uops on Kaveri }
{1} add esi,[edi+ecx*08h+__ROWMODIFIER] { 3 clk 9 ALU ops on Core 2 }
{2} or esi,[edi+ecx*08h+__FIXEDROW]
{0} jz @test0row
{1} sub ebx,ebp
{2} cmp esi,eax
{@F0} cmovb eax,esi
{1*} add ecx,04h
{2*} jnz @findcolmin
{ } lea ecx,[ebp-04h]
{ -} mov esi,eax
{ } lea ebx,[edi+edx]
{@00**} test eax,eax { JS/JNS can only fuse with TEST }
{ **} js @@ABNORMAL_EXIT
{@04} @seekcol0:
{0} mov eax,[edi+ecx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ecx,04h
{2*} jz @free0col
{0} sub ebx,ebp
{1} add eax,[ebx]
{@11**} cmp eax,esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{0**} jnz @seekcol0
@test0row:
{ **} test [edi+ecx*08h+__0STAR],ebp
{ **} js @seekcol0
{ } mov [edi+edx*08h+__0STARROW],ecx
{@1E} mov [edi+ecx*08h+__0STAR],edx
{@22} jns @free0col { forced conditional jump for Sandy Bridge }
{ ----------------------------------------------------------------------------------------------- }
{@24} { x12 } test ebp,0FFFFFFFFh; test edi,0FFFFFFFFh
{@30} { x9 } mov ecx,00000000h; xor esi,esi; xor edi,edi
@@5TH_STEP: { K10:2.6 Core2:_._ - _._ uop/clk - ____*2+____
{@39} mov ecx,[edi+__MINCOLROW]
{ } sub ebx,ebp
{ } neg edx
{@40} @DEC5_free_col: { 5 AGU + 11 EX uops on Kaveri }
{0} mov eax,[edi+ebx*08h+__COLMARK] { 3 clk 8 ALU ops on Core 2 }
{1} sar eax,1Fh
{2} mov [edi+ebx*08h+__COLMARK],eax
{0} and eax,edx
{1} sub [edi+ebx*08h+__COLMODIFIER],eax
{@51} mov eax,[edi+ebx*08h+__0COLON___ROWMARK]
{0} sar eax,1Fh
{1} and eax,edx
{2} sub [edi+ebx*08h+__ROWMODIFIER],eax
{0*} add ebx,04h
{@61*} jnz @DEC5_free_col { clears EBX register [NOT USED] }
{@63} movsx ebx,cx
{1} sar ecx,10h
{2} mov esi,[edi+ebx*08h+__0STAR]
{0**} cmp esi,00h
{@70**} jz @4TH_STEP { long jump instruction }
{2} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{0} mov dword ptr [edi+esi*08h+__COLMARK],0FFFFFFFFh { unmark column with -1 }
{1} mov esi,[edi+__INITCOL]
{@85} @mark3row:
{ -} xor ebx,ebx
{ } lea ecx,[esi-04h]
{ } jmp @chk2col
@pass2col:
{ } mov [edi+ecx*08h+__COLMARK],ecx { re-mark column with column index <> -1 }
{@90} @chk2col:
{0*} add ecx,04h
{1*} jz @@5TH_STEP { clears ECX register }
{2**} cmp [edi+ecx*08h+__COLMARK],ecx
{0**} jbe @chk2col
@@2ND_STEP:
{ } lea eax,[ecx+edi]
{ } sub ebx,ebp
@continue:
{@A0} { x1 } push dword ptr es:[edi+ecx*08h+__COLMODIFIER]
{ } sal ecx,10h
{ } mov esi,[edi+ebx*08h+__ROWMODIFIER]
{@AC} @ZERO2col: { K10:3.0 Core2:2.5 - 2.9 uop/clk - 1500*2+5600 { 4 AGU + 11 EX uops on Kaveri }
{0} sub esi,[esp+00h] { 4 clk 13 ALU ops on Core 2 }
{@AF} add esi,[eax+ebp]
{C2D} lea eax,[eax+ebp]
{2} jo @over2flow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{0} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{1} jz @@3RD_STEP
{K10}// lea eax,[eax+ebp]
{0} cmp esi,edx
{@BF} cmovb edx,esi
{@C2} cmovb cx,bx
@over2flow:
{0} mov esi,[edi+ebx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ebx,04h
{2*} jnz @ZERO2col { clears EBX register }
@@3RD_STEP:
{@CF} pop esi { add esp,04h } { enforces ESP handling to AGU/load pipe on Kaveri/Core }
{@D0-} mov esi,ecx
{2} sar ecx,10h
{0} cmovnc esi,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],esi
{2**} test ebx,ebx
{0**} jz @pass2col
{@E0} mov esi,[edi+ebx*08h+__0STAR]
{2**} test esi,esi
{0**} jz @4TH_STEP
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2} or dword ptr [edi+esi*08h+__COLMARK],-1 { unmark column with -1 }
{@F1**} cmp word ptr [edi+__MINCOLROW],bx
{1**} jz @re2start
{2**} cmp esi,ecx { jb = jl for 2 negative numbers }
{0**} jb @mark3row
{1*} add ebx,04h
{2*} jnz @continue
{@00} jmp @pass2col
{1} { x2 } xor eax,eax
{@04} @re2start:
{0} mov ecx,[edi+__INITCOL]
{1-} mov ebx,ebp
{2} neg ebx
@initcol:
{0} sar dword ptr [edi+ebx*08h+__COLMARK],1Fh
{@10*} add ebx,04h
{2*} jnz @initcol { clears EBX register }
{ } or edx,-1
{ *} sub ecx,04h
{ *} jnz @chk2col { long jump instruction }
{@20} { x4 } lea eax,[ebp+ebp+00h]
@@4TH_STEP: { 5 AGU + 3 EX uops on Kaveri }
{@24-} mov ebx,edx { 2 clk 2 ALU ops on Core 2 }
@4TH_STEP:
{@26} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{@30} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{2**} cmp edx,00h
{0**} jnz @@4TH_STEP { clears EDX register }
{ } sub esi,ebp
{ } sub edx,ebp
{ } lea ecx,[esi-04h]
@@1ST_STEP: { K10:2.8 Core2:2.9 - 3.2 uop/clk - 1500*2+6100 }
{@40} mov eax,[edi+esi*08h+__0STARROW] { 4 AGU + 7 EX uops on Kaveri }
{1} and ebx,eax { 3 clk 6 ALU ops on Core 2 }
{2} not eax
{0} mov [edi+esi*08h+__COLMARK],eax
{1} mov eax,[edi+esi*08h+__FIXEDROW]
{2} cmovs ecx,esi
{0} mov [edi+esi*08h+__0COLON___ROWMARK],eax
{1*} add esi,04h
{2*} jnz @@1ST_STEP { clears ESI register }
{ } { x3 } mov ebx,00000000h
{@60*} add ecx,04h { long jump instruction }
{ *} jnz @@2ND_STEP { ===>>> EBX: 00h EDX:negative = -EBP ECX:initcol (>= EBP) }
{ } { x1 } mov esi,ss:[esp+04h+__MARKS]
{ -} mov ebx,edi { work matrix unmodified } { [esp+__SAVE] }
@@results:
{@70} mov eax,[edi+edx*08h+__0STAR] { 3 AGU + 8 EX uops on Kaveri }
{1} add ebx,ebp
{2} add ecx,[ebx+eax]
{0} add eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{@80} add esi,01h
{1*} add edx,04h
{2*} jnz @@results { clears EDX register ( DL=0 as head, DH=0 as length ) }

[ Szerkesztve ]

Több, mint 1 Kbyte-os (1124 karakter) Java utasítás: arg egész pozitív számot szöveggé konvertálja dest tömbbe i pozíciótól kezdődően, legfejlebb size karakter méretben; 0-k helyett space-ekkel felvezetve, ha a szám kevesebb karakterből áll, mint size.

public static byte[] inttoSPACEstr(int arg, int size, int i, byte[] dest) {
int x, j, nr, z;


dest[(i=(i=(i=(i=(i=(i=(i=(
i+=((dest[i]=(byte)((((z =(j=((nr=1+(int)(((x=(int)(((arg=(arg^(x=arg>>31))-x)*0x00000000A7C5AC47L)>>>32)>>>16)*0x00000000D1B71759L)>>>30))>>>15)))-1)&0xFFFFFFF0)+j+48)) | (10-1-size))>>>31)
+(((dest[i]=(byte)((((z|=(j=((nr=(nr&0x00007FFF)*5)>>>14)))-1)&0xFFFFFFF0)+j+48)) | (10-2-size)) >>>31))
+(((dest[i]=(byte)((((z|=(j=((nr=(nr&0x00003FFF)*5)>>>13)))-1)&0xFFFFFFF0)+j+48)) | (10-3-size)) >>>31))
+(((dest[i]=(byte)((((z|=(j=((nr=(nr&0x00001FFF)*5)>>>12)))-1)&0xFFFFFFF0)+j+48)) | (10-4-size)) >>>31))
+(((dest[i]=(byte)((((z|=(j=(( (nr&0x00000FFF)*5)>>>11)))-1)&0xFFFFFFF0)+j+48)) | (10-5-size)) >>>31))
+(((dest[i]=(byte)((((z|=(j=((nr=1+((int)(((arg-x*100000)*0x00000000D1B71759L)>>>30)))>>>15)))-1)&0xFFFFFFF0)+j+48)) | (10-6-size)) >>>31))
+(((dest[i]=(byte)((((z|=(j=((nr=(nr&0x00007FFF)*5)>>>14)))-1)&0xFFFFFFF0)+j+48)) | (10-7-size)) >>>31))
+(((dest[i]=(byte)((((z|=(j=((nr=(nr&0x00003FFF)*5)>>>13)))-1)&0xFFFFFFF0)+j+48)) | (10-8-size)) >>>31))
+(((dest[i]=(byte)((((z| (j=((nr=(nr&0x00001FFF)*5)>>>12)))-1)&0xFFFFFFF0)+j+48)) | (10-9-size)) >>>31)]
=(byte)((((nr&0x00000FFF)*5)>>>11)+48);


return dest; }

[ Szerkesztve ]

Nincs többé külön K10-nek tetsző és külön Core2-nek tetsző verzió: egyetlen van, amely mindkettőn jó, kb. 0.5% veszteséggel.

Core2 (2.5 GHz): 58 sec alatt megoldja a feladatot
K10 (2.9 GHz): 44 sec alatt megoldja a feladatot
Prescott (2.26 GHz): 60 sec alatt 220000 mátrix
Northwood (2.4 GHz): 60 sec alatt 248000 mátrix

{@04-} { x1 } movsx ebx,byte ptr es:[edx]
{1-} mov esi,ebp
{2-} xor eax,eax
{0} and esi,-8
@init:
{@0F} mov [edi+esi*08h+(00h*08h)+__0STARROW],eax
{1} mov [edi+esi*08h+(04h*08h)+__0STARROW],eax
{2*} add esi,08h
{0*} jnz @init { clears ESI register }
{ } add edx,01h
{ -} mov ecx,ebp
@@ARGUMENT: { K10:2.6 Core2:2.9 - 3.3 uop/clk - 1640*2+6550 }
{@20} cmp ebx,esi { 4 AGU + 9 EX uops on Kaveri }
{1} lea eax,[ebp+ebx*04h+00h] { 3 clk 8 ALU ops on Core 2 }
{2} movsx ebx,byte ptr [edx]
{0} lea edx,[edx+01h] { db $8D,$52,$00 }
{1} mov [edi+eax*08h+__0STARROW],ebp { __0COUNTER <- EBP }
{2} cmovs eax,esi
{0} mov [edi+ecx*08h+__FIXEDROW],eax
{1*} add ecx,04h
{2*} jnz @@ARGUMENT { clears ECX register }
{ -} { x2 } xor ecx,ecx
{ -} mov eax,edi
{ -} push ebp
{@40-} lea edx,[ebp-04h]
@@REDUCE_ROWS:
{@43} mov [edi+edx*08h+__ROWMODIFIER],ecx
{1} mov esi,[edi+edx*08h+(04h*08h)+__FIXEDROW]
{2*} add edx,04h
{0*} jz @@REDUCE_COLUMNS
{@50} mov [edi+edx*08h+__0STAR],esi
{2-} xor ecx,ecx
{0} sub eax,ebp
{1**} test esi,esi { JS/JNS can only fuse with TEST }
{2**} js @@REDUCE_ROWS
{ -} mov ebx,ebp { EBX < 0 for even minimum }
{ } mov ecx,[eax+ebp]
{@61} or ecx,[edi+ebp*08h+__0STARROW]
{ } and ebp,04h
{ } add ebp,ebx
{@69} @findrowmin: { K10:2.8 Core2:2.2 - 2.6 uop/clk - 1100*2+5000 }
{0} mov esi,[eax+ebp] { 4 AGU + 8 EX uops on Kaveri }
{1} or esi,[edi+ebp*08h+(00h*08h)+__0STARROW] { 3 clk 10 ALU ops on Core 2 }
{2} add ebp,08h
{@72} cmp esi,ebx
{1} cmovb ebx,esi
{2} mov esi,[eax+ebp-04h]
{0} or esi,[edi+ebp*08h-(04h*08h)+__0STARROW]
{1} cmp esi,ecx
{@81} cmovb ecx,esi
{0**} test ebp,ebp
{1**} jnz @findrowmin
{ } mov ebp,[esp+00h]
{ } cmp ebx,ecx
{ } cmovb ecx,ebx
{@90} neg ecx
{ } jle @@REDUCE_ROWS
{ -} { x1 } nop
@@ABNORMAL_EXIT:
{@95} pop eax
{1} { x3 } or edx,0FFFFFFFFh
{2} mov esi,[esp+__MARKS]
{@A0} mov [esi+TRESULT.OPTIMUM],edx
{1} mov ebx,[esi+TRESULT.NEXTIVALUE]
{2} jmp dword ptr [esp+_INVALIDRESULT]
{ x1 } nop
{@AB} @init0col:
{0} mov [edi+__INITCOL],ecx
{1-} mov esi,ebp
{@B0} neg ebp
{0} mov ebx,0FFFFFFFFh
{1*} sub ecx,04h
{2*} jnz @@1ST_STEP { long jump instruction } { forced conditional jump for Sandy Bridge }
{@C0} { x2 } xor eax,eax
{@C2} @free0col:
{ } mov [edi+edx*08h+__COLMODIFIER],esi { no need to initialize __COLMODIFIER of fixed column }
{ -} mov ecx,edx
{@C8} @next0col:
{ **} cmp edx,ebp
{ **} jz @init0col
@@REDUCE_COLUMNS: { no need to initialize -initcol in ECX }
{0} mov eax,[edi+edx*08h-(04h*08h)+__0STARROW]
{@D0} sub edx,04h
{2*} sub eax,01h
{0*} jnc @next0col
{ } { x1 } lea ebx,es:[edi+edx]
{ -} mov ecx,ebp
{ } sub ebx,ebp
{@E0} @findcolmin: { K10:3.0 Core2:_._ - _._ uop/clk - ____*2+____
{0} mov esi,[ebx] { 3 AGU + 8 EX uops on Kaveri }
{1} add esi,[edi+ecx*08h+__ROWMODIFIER] { 3 clk 9 ALU ops on Core 2 }
{2} or esi,[edi+ecx*08h+__FIXEDROW]
{0} jz @test0row
{1} sub ebx,ebp
{2} cmp esi,eax
{@F0} cmovb eax,esi
{1*} add ecx,04h
{2*} jnz @findcolmin
{ } lea ecx,[ebp-04h]
{ -} mov esi,eax
{ } lea ebx,[edi+edx]
{@00**} test eax,eax { JS/JNS can only fuse with TEST }
{ **} js @@ABNORMAL_EXIT
{@04} @seekcol0:
{0} mov eax,[edi+ecx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ecx,04h
{2*} jz @free0col
{0} sub ebx,ebp
{1} add eax,[ebx]
{@11**} cmp eax,esi { maximum data value = 00FFFFFFh -> marked elements stay negative }
{0**} jnz @seekcol0
@test0row:
{ **} test [edi+ecx*08h+__0STAR],ebp { JS/JNS can only fuse with TEST }
{ **} js @seekcol0
{ } mov [edi+edx*08h+__0STARROW],ecx
{@1E} mov [edi+ecx*08h+__0STAR],edx
{@22} jns @free0col { forced conditional jump for Sandy Bridge }
{ ----------------------------------------------------------------------------------------------- }
{@24} { x12 } mov eax,00000000h; mov edx,00000000h; xor ecx,ecx
{@30} { x5 } mov esi,00000000h
@@5TH_STEP: { K10:2.2 Core2:2.2 - 2.7 uop/clk - 3050*2+3700 }
{@35} movsx esi,word ptr [edi+__MINCOLROW+00h]
{ } sub ebx,ebp
{ } movsx eax,word ptr [edi+ebx*08h+__SIGN-(04h*08h)+__COLMARK]
{@40} @5th_step: { 5 AGU + 11 EX uops on Kaveri }
{0} movsx ecx,word ptr [edi+ebx*08h+__SIGN+__0COLON___ROWMARK] { 4 clk 6 ALU ops on Core 2 }
{1} mov [edi+ebx*08h-(04h*08h)+__COLMARK],eax
{2} and eax,edx
{0} add [edi+ebx*08h+__COLMODIFIER],eax
{@4F} and ecx,edx
{2} movsx eax,word ptr [edi+ebx*08h+__SIGN-(04h*08h)+(04h*08h)+__COLMARK] { __MINCOLROW col }
{0} add [edi+ebx*08h+__ROWMODIFIER],ecx
{1*} add ebx,04h
{2*} jnz @5th_step { clears EBX register }
{@5F} mov ecx,[edi+__INITCOL]
{1-} mov edx,esi
{2} mov esi,[edi+esi*08h+__0STAR]
{0**} test esi,esi
{1**} jz @@4TH_STEP { long jump instruction }
{@70} mov [edi+edx*08h+__0COLON___ROWMARK],eax { set row mark }
{0} mov dword ptr [edi+esi*08h-(04h*08h)+__COLMARK],-1 { unmark column with -1 }
{1} jmp @test2col
{ x2 } xor esi,esi
{@80} { x2 } xor eax,eax
{@82} @fast2forward:
{ *} add ebx,04h
{ *} jnz @continue
{@87} @pass2col:
{ } mov [edi+ecx*08h-(04h*08h)+__COLMARK],ecx { re-mark column with its index != -1 }
{@8B} @next2col:
{0*} add ecx,04h
{1*} jz @@5TH_STEP { clears ECX register }
@test2col:
{@90**} cmp [edi+ecx*08h-(04h*08h)+__COLMARK],ecx
{0**} jbe @next2col
@@2ND_STEP:
{ } sub ebx,ebp { ordered for Core2 }
{ } lea eax,[ecx+edi] { ordered for Core2 }
{@9B} @continue:
{ } mov esi,[edi+ecx*08h+__COLMODIFIER]
{ } push esi
{@A0} sal ecx,10h
{ } mov esi,[edi+ebx*08h+__ROWMODIFIER]
{@A7} @ZERO2col: { K10:3.0 Core2:2.5 - 2.9 uop/clk - 1500*2+5600 { 4 AGU + 11 EX uops on Kaveri }
{0} sub esi,[esp+00h] { 4 clk 13 ALU ops on Core 2 }
{1} add esi,[eax+ebp]
{2} lea eax,[eax+ebp]
{@B0} jo @over2flow { overflow: (-x)+(-y)=(+z) or (+x)+(+y)=(-z) }
{1} or esi,[edi+ebx*08h+__0COLON___ROWMARK]
{2} jz @@3RD_STEP
{0} cmp esi,edx
{1} cmovb edx,esi
{2} cmovb cx,bx
{@C1} @over2flow:
{0} mov esi,[edi+ebx*08h+(04h*08h)+__ROWMODIFIER]
{1*} add ebx,04h
{2*} jnz @ZERO2col { clears EBX register }
@@3RD_STEP:
{@CA} pop esi { add esp,04h } { enforces ESP tracking to AGU/load pipe on Bulldozer/Core }
{1-} mov esi,ecx
{2} sar ecx,10h
{@D0} cmovnc esi,[edi+__MINCOLROW]
{1} mov [edi+__MINCOLROW],esi
{2**} { x1 } cmp ebx,00h
{0**} jz @pass2col
{1} mov esi,[edi+ebx*08h+__0STAR]
{@E0**} test esi,esi
{0**} jz @4TH_STEP
{1} mov [edi+ebx*08h+__0COLON___ROWMARK],ecx { set row mark }
{2} mov dword ptr [edi+esi*08h-(04h*08h)+__COLMARK],-1 { unmark column with -1 }
{@F0**} cmp word ptr [edi+__MINCOLROW],bx { STORE FORWARDED }
{1**} jz @re2start
{2**} cmp esi,ecx { jb = jl for 2 negative numbers }
{0**} jae @fast2forward
{1-} xor ebx,ebx
{2-} mov ecx,esi
{0} jmp @@2ND_STEP
{@00} @re2start:
{0} mov ecx,[edi+__INITCOL]
{1-} mov edx,ebx
{2-} mov ebx,ebp
{0} neg ebx
{@09} @init2col:
{0} movsx eax,word ptr [edi+ebx*08h+__SIGN-(04h*08h)+__COLMARK]
{1} mov [edi+ebx*08h-(04h*08h)+__COLMARK],eax
{2*} add ebx,04h
{0*} jnz @init2col { clears EBX register }
{ } jmp @test2col { long jump instruction }
{ } { x4 } lea eax,[ebp+ebp+00h]
{@20} { x2 } test edi,edi
@@4TH_STEP:
{@22-} mov ecx,eax
@re4order:
{@24-} mov ebx,edx
@4TH_STEP:
{@26} mov edx,[edi+ecx*08h+__0STARROW]
{2} mov [edi+ebx*08h+__0STAR],ecx
{0} mov [edi+ecx*08h+__0STARROW],ebx
{@30} mov ecx,[edi+edx*08h+__0COLON___ROWMARK]
{2**} { x1 } cmp edx,00h
{0**} jnz @re4order { clears EDX register }
{ } sub esi,ebp
{ } sub edx,ebp
{ } lea ecx,[esi-04h]
@@1ST_STEP: { K10:2.8 Core2:2.9 - 3.2 uop/clk - 1500*2+6100 }
{@40} mov eax,[edi+esi*08h+__0STARROW] { 4 AGU + 7 EX uops on Kaveri }
{1} and ebx,eax { clears EBX at uncomplete calculation } { 3 clk 6 ALU ops on Core 2 }
{2} not eax
{0} mov [edi+esi*08h-(04h*08h)+__COLMARK],eax
{1} mov eax,[edi+esi*08h+__FIXEDROW]
{2} cmovs ecx,esi
{0} mov [edi+esi*08h+__0COLON___ROWMARK],eax
{1*} add esi,04h
{2*} jnz @@1ST_STEP { clears ESI register [NOT USED] }
{ *} add ecx,04h { long jump instruction }
{ *} jnz @@2ND_STEP { ===>>> EBX: 00h EDX:negative = -EBP ECX:initcol (>= EBP) }
{ -} mov ebx,edi { work matrix unmodified } { [esp+__SAVE] }
{ } mov esi,[esp+04h+__MARKS]
@@results:
{@6A} mov eax,[edi+edx*08h+__0STAR] { 3 AGU + 8 EX uops on Kaveri }
{1} add ebx,ebp
{@70} add ecx,[ebx+eax]
{0} add eax,ebp
{1} shr eax,02h
{2} mov [esi],al
{0} add esi,01h
{1*} add edx,04h
{@80*} jnz @@results { clears EDX register ( DL=0 as head, DH=0 as length ) }

Egy Pentium 4 1 nagyságrenddel nagyobb teljesítményre képes, mint egy Java-ban írt program ARM-on (legalábbis mert léteznek pointerek, nincs szigorú típusosság, nincs byte-nál automatikus előjeles kiterjesztés 4 byte-ra, amit le kell küzdeni, stb.); még úgy is, hogy a branch prediction success rate 87% körüli.

A fő ciklus ASM-ben:

@character:
{@65} { } mov [edi],al
{ } add edi,01h
@@DECODE:
{@6A} { } mov eax,[esp+_aMAXMINBITS]
@read_raw: { BPOS may be 20h since decreased soon }
{ } movzx ebp,byte ptr [esi]
{@70} { -} mov ecx,edx
{ } sub edx,(24+1)
{ } shl ebp,cl
{ } shr edx,1Fh
{ } add esi,edx
{ } lea edx,[ecx+edx*08h]
{ } or ebx,ebp
{@81} { **} cmp dl,al
{ **} jb @read_raw
@createABCcode:
{ } movzx ebp,bl
{ } movzx ecx,bh
{ } shr eax,10h
{ } { x1 } mov ebp,dword ptr es:[REVERSE2hi+ebp*04h]
{ } { x1 } add ebp,dword ptr es:[REVERSE2lo+ecx*04h]
{ -} mov ecx,eax
{@A0} { } mov eax,offset(EXT_AMINMAXCODE)
@seekABC:
{@A5} {0**} cmp [eax+ecx*08h+00h+_MAX],ebp
{1**} jnbe @foundABC
{2} cmp [eax+ecx*08h-08h+_MAX],ebp
{0} lea ecx,[ecx-02h]
{@B1} {1} jbe @seekABC
{ } add ecx,01h
@foundABC:
{@B6} {0} mov eax,[eax+ecx*08h+_MIN]
{1} shr ebp,cl
{2} { x1 } mov eax,es:[eax+ebp*04h]
{@C0} {0} neg ecx
{1} add ecx,10h
{2} sub edx,ecx
{0} shr ebx,cl
{1**} cmp eax,255
{2**} jna @character { SHORT jump instruction offset: -6Bh }
@repeatABC:
{@D0} {0-} mov ecx,eax
{1} movzx ebp,ah
{2} shr eax,10h
{0} jz @@SECTION
{1} sub dl,cl
{@E0} {2} and ebp,ebx
{0} shr ebx,cl
{1} add ebp,eax
{2} { x1 } mov eax,ss:[esp+_dMAXMINBITS]
{0} add edi,ebp
{1} neg ebp
{2} mov [esp+_MOVELEN],ebp
@read__raw: { BPOS may be 20h since decreased soon }
{@F3} {0} movzx ebp,byte ptr [esi]
{1-} mov ecx,edx
{2} sub edx,(24+1)
{0} shl ebp,cl
{1} shr edx,1Fh
{@00} {2} add esi,edx
{0} lea edx,[ecx+edx*08h]
{1} or ebx,ebp
{2**} cmp dl,al
{0**} jb @read__raw
@createDISTcode:
{ } movzx ebp,bl
{ } movzx ecx,bh
{@11} { } shr eax,10h
{ } { x1 } mov ebp,dword ptr es:[REVERSE2hi+ebp*04h]
{ } { x1 } add ebp,dword ptr es:[REVERSE2lo+ecx*04h]
{@24} { -} mov ecx,eax
{ } mov eax,offset(EXT_DMINMAXCODE)
@seekDIST:
{0**} cmp [eax+ecx*08h+00h+_MAX],ebp
{1**} jnbe @foundDIST
{@90} {2} cmp [eax+ecx*08h-08h+_MAX],ebp
{0} lea ecx,[ecx-02h]
{1} jbe @seekDIST
{ } add ecx,01h
@foundDIST:
{0} mov eax,[eax+ecx*08h+_MIN]
{@A0} {1} shr ebp,cl
{2} mov eax,[eax+ebp*04h]
{0} neg ecx
{1} add ecx,10h
{2} sub edx,ecx
{0} shr ebx,cl
{1**} cmp al,00h
{@70} {2**} js @xxx
{0} jz @yyy
@DISTbits: { BPOS may be 20h since decreased soon }
{0} movzx ebp,byte ptr [esi]
{1-} mov ecx,edx
{2} sub edx,(24+1)
{@80} {0} shr edx,1Fh
{1} add esi,edx
{2} lea edx,[ecx+edx*08h]
{0} shl ebp,cl
{1} or ebx,ebp
{2**} cmp edx,16
{0**} jb @DISTbits
@srcposition:
{@91} {1} movzx ecx,ax
{2} sar eax,10h
{0} mov ebp,dword ptr [OFF+ecx*04h]
{1} sub edx,ecx
{@A0} {2} add eax,edi
{0} and ebp,ebx
{1} shr ebx,cl
@copy: ...

[ Szerkesztve ]

és befele:

@program:
{0} movzx ecx,byte ptr [esi+00h]
@x:
{0**} cmp edx,ebp
{1**} jae @init
{2} add edx,01h
{0**} cmp cl,[esi+edx]
{1**} jz @x
@init:
{ **} cmp edx,(03+01)
{ **} jae @long_jump
{ -} xor ebp,ebp
{ } mov [esp+_Q],edi
{ } mov ch,cl
@repeat:
{0-} mov edi,eax
{1} and eax,(__WINDOW-1)
{2} sub edi,ebx
{0} mov eax,[esp+_PREV+eax*04h]
{1**} cmp edi,-(__WINDOW)
{2**} jbe @pre_encode { JLE = JBE for 2 negative numbers }
{0} add edi,esi
{1**} cmp ch,[edi+ebp]
{2**} jnz @repeat
{0**} cmp cl,[edi+00h]
{1**} jnz @repeat
{2-} xor edx,edx
@length:
{0**} cmp edx,[esp+...]
{1**} jae @QQ
{2} movzx ecx,byte ptr [esi+edx+01h]
{0} cmp cl,[edi+edx+01h]
{1} lea edx,[edx+01h]
{2} jz @length
{0} movzx ecx,byte ptr [esi+00h]
{1} sub edi,esi
{2} cmp edx,ebp
{0} cmova ebp,edx
{1} mov ch,[esi+ebp]
{2} jbe @repeat
{0} mov [esp+...],edi
{1} jmp @repeat
@QQ:
{0} movzx ecx,byte ptr [esi+00h]
{1} sub edi,esi
{2} mov ebp,00000028
{0} mov [esp+...],edi
{1} mov edi,[esp+_Q]
{2-} xor eax,eax
{0**} cmp edx,???
{1**} jz @QQQ
{2-} mov ebp,edx
@pre_encode:
{0} mov edi,[esp+_Q]
{1-} xor eax,eax
{2*} sub ebp,03h
{0*} jb @encode_alpha
{1} lea edx,[ebp+03h]
@QQQ:
{ } mov [esp+...],ebx
{ -} mov ebx,eax
{ } jz @indexed
{---} bsr ecx,ebp
{0*} sub ecx,02h
{1*} jle @indexed
{2} mov ebx,dword ptr [...+ecx*04h]
{0-} mov eax,ecx
{1} and ebx,ebp
{2} shr ebp,cl
{0} lea ebp,[ebp+ecx*04h+00h]
@indexed:
{0} mov ecx,dword ptr [...+ebp*04h]
{1} mov ebp,[esp+_ZIPPED]
{2} add al,cl
{0} shl ebx,cl
{1} shr ecx,10h
{2} or ebx,ecx
{0-} mov ecx,edi
{1} and ecx,07h
{2} shr edi,03h
{0} shl ebx,cl
{1} or bl,[edi+ebp]
{2} add ecx,eax
{0} mov eax,[esp+...]
@write:
{0} mov [edi+ebp],bl
{1} add edi,01h
{2} shr ebx,08h
{0*} sub ecx,08h
{1*} jge @write
{ } xor eax,-1
{ } mov ebp,00000005h
{ } lea edi,[edi*08h+ecx]
{ } jz @distindexed
{---} bsr ecx,eax
{0*} sub ecx,01h
{1*} js @distindexed
{2} mov ebx,dword ptr [...+ecx*04h]
{0} add ebp,ecx
{1} and ebx,eax
{2} shr eax,cl
{0} lea eax,[ecx*02h+eax]
{1} shl ebx,05h
@distindexed:
{0-} mov ecx,edi
{1} or ebx,dword ptr [...+eax*04h]
{2} mov eax,[esp+_ZIPPED]
{0} shr edi,03h
{1} and ecx,07h
{2} shl ebx,cl
{0} add ecx,ebp
{1} or bl,[edi+eax+00h]
{2} mov ebp,[esp+_HASH]
@write:
{0} mov [edi+eax],bl
{1} add edi,01h
{2} shr ebx,08h
{0*} sub ecx,08h
{1*} jge @write
{ } add esi,edx
{ } neg edx
{ } mov ebx,[esp+...]
{ -} mov eax,ebp
{ } lea edi,[edi*08h+ecx]
{ } jmp @administration
@encode_alpha:
{0} mov ebp,[esp+_ZIPPED]
{1} movzx edx,cl
{2-} mov ecx,edi
{1} mov edx,dword ptr [...+edx*04h]
{0} shr edi,03h
{2} and ecx,07h
{0-} mov eax,edx
{1} shr edx,10h
{2} shl edx,cl
{0} add cl,al
{1} mov eax,[esp+_HASH]
{2} or dl,[edi+ebp]
@write:
{0} mov [edi+ebp],dl
{1} add edi,01h
{2} shr edx,08h
{0*} sub ecx,08h
{1*} jge @write
{ } xor edx,-1
{ } mov ebp,eax
{ } add esi,01h
{ } lea edi,[edi*08h+ecx]
@administration:
{0} shl eax,__BITS
{1} and eax,__LOOKUP-1
{2} xor al,[esi+edx+03h]
{0} mov ecx,[esp+_LAST+ebp*04h]
{1} mov [esp+_LAST+ebp*04h],ebx
{2-} mov ebp,ebx
{0} add ebx,01h
{1} and ebp,(__WINDOW-1)
{2} mov [esp+_PREV+ebp*04h],ecx
{1} add edx,01h
{0-} mov ebp,eax
{2} jnz @administration
{ } mov [esp+_HASH],eax
{ } mov ebp,[esp+_LEN]
{ } mov eax,[esp+_LAST+eax*04h]
{ *} sub ebp,ebx
{ *} jz @finalize
{ **} cmp ebp,???
{ **} jae @program
{ } mov [esp+...],ebp
{ } jmp @program
@long_jump:

[ Szerkesztve ]

Production code. P4 ready. Core2-n, K10-en, Bulldozeren, P4-en 2.5x gyorsabb, mint a W..R.r.

@FIX_character:
{@A1} {0} mov [edi],al
{1} add edi,01h
@@FIX_DECODE: { bpos >= 9 }
{2} mov eax,[esi]
{0-} mov ecx,edx
{1} mov ebp,((-1 shl ZFIX_aMAXBITS) xor -1)
{@AF} {2} shr edx,03h
{@B2} {0} xor edx,03h
{1} and ebp,ebx
{2} shl eax,cl
{0} add esi,edx
{1} lea edx,[ecx+edx*08h]
{2} or ebx,eax
@FIX_code:
{@C0} {0} mov eax,dword ptr [ZFIXED_RELOC+ebp*08h+_CODE]
{1} mov ecx,dword ptr [ZFIXED_RELOC+ebp*08h+_SIZE]
{2} sub edx,ecx
{@D0} {0} shr ebx,cl
{1**} cmp eax,00000100h
{2**} jb @FIX_character
@FIX_length:
{0-} mov ecx,eax
{1-} movzx ebp,ah
{2} jz @SECTION { short jump instruction }
{@E0} {0} and ebp,ebx
{1} shr eax,10h
{2} add ebp,eax
{0-} mov eax,ebx
{1} add edi,ebp
@FIX_distance:
{2} shr eax,cl
{0} add cl,ZFIX_dBITS
{@F0} {1} neg ebp
{2} sub dl,cl
{0} and eax,((-1 shl ZFIX_dBITS) xor -1)
{1} shr ebx,cl
{2} mov eax,dword ptr [ZFIXED_DIST+eax*04h]
@FIX_load:
{@00} {0} mov [esp+_MOVELEN],ebp
{1} mov ebp,[esi]
{2-} mov ecx,edx
{0} shr edx,03h
{1} xor edx,03h
{2} shl ebp,cl
{@10} {0} add esi,edx
{1} lea edx,[ecx+edx*08h]
{2} or ebx,ebp
{0} mov ebp,[esp+_MOVELEN]
{1**} test al,0FFh
{2**} js @FIX_movechar
{@20} {0} jz @FIX_moveword
@FIX_movedword:
{1} mov ebp,00000001h
{2-} mov ecx,eax
{0} sub dl,al
{1} sar eax,10h
{2} shl ebp,cl
{@30} {0} xor ebp,0FFFFFFFFh
{1} add eax,edi
{2} and ebp,ebx
{0} shr ebx,cl
{1} mov ecx,[esp+_MOVELEN]
{@40} {2} sub eax,ebp
@FIX_move4byte:
{0} mov ebp,dword ptr [ecx+eax+00h]
{1} mov [edi+ecx+00h],ebp
{2} mov ebp,dword ptr [ecx+eax+04h]
{0} mov [edi+ecx+04h],ebp
{@50} {1*} add ecx,08h
{2*} js @FIX_move4byte
{ } jmp @@FIX_DECODE
{ x6 } cmp esi,00h; cmp edx,00h
@FIX_moveword:
{@60} {0} sar eax,10h
{1} add eax,edi
@FIX_move2byte:
{@65} {0} movzx ecx,word ptr [eax+ebp+00h]
{1} mov [edi+ebp+00h],cx
{@6D} {2} movzx ecx,word ptr [eax+ebp+02h]
{@72} {0} mov [edi+ebp+02h],cx
{1*} add ebp,04h
{2*} js @FIX_move2byte
{ } jmp @@FIX_DECODE
@FIX_movechar:
{@81} {1} movzx eax,byte ptr [ebp+edi-01h]
@FIX_repeat:
{@86} {0} mov [edi+ebp+00h],al
{1} mov [edi+ebp+01h],al
{2*} add ebp,02h
{@90} {0*} js @FIX_repeat
{ } jmp @@FIX_DECODE

[ Szerkesztve ]

Procuction Code. P4 ready. Core2-n, K10-en, Bulldozeren, P4-en 12%-kal gyorsabb, mint a W..R.r.

@samechar:
{@80} {0**} cmp edx,ebp
{1**} jae @initrepeat
@compression:
{2} cmp cl,[esi+edx+01h]
{0} lea edx,[edx+01h]
{1} jz @samechar
@initrepeat:
{ } { x1 } and ebp,00h
{@90} { **} cmp edx,(03+01)
{ **} jae @special { long jump instruction }
{ } mov ch,cl
{ } { x1 } mov ss:[esp+_ENCODED],edi
@repeat:
{@A0} {0-} lea edi,[eax+ebx]
{1} and eax,(__WINDOW-1)
{2**} cmp edi,-(__WINDOW)
{0**} jbe @pre_encode
{@B0} {1} add edi,esi
{2} mov eax,[esp+_PREV+eax*04h]
{0**} cmp ch,[edi+ebp]
{1**} jnz @repeat
{2**} cmp cl,[edi+00h]
{0**} jnz @repeat
{@C0} {1-} xor edx,edx
@length:
{@C2} {0**} cmp edx,[esp+_MAXRANGE]
{1**} jae @maximum_repeat
{2} movzx ecx,byte ptr [esi+edx+01h]
{0} cmp cl,[edi+edx+01h]
{@D1} {1} lea edx,[edx+01h]
{2} jz @length
{0} movzx ecx,byte ptr [esi+00h]
{1} mov ch,[esi+ebp]
{2**} cmp edx,ebp
{0**} jbe @repeat
{@E0} {1-} mov ebp,edx
{2} mov ch,[esi+edx]
{0} mov [esp+_MOVEDIST],edi
{2} jmp @repeat
{ x6 } test ebx,00000000h
{@F0} { x4 } xor ebp,ebp; xor esi,esi
@maximum_repeat:
{@F4} {0} mov [esp+_MOVEDIST],edi
{1} mov ebp,00000028
{2-} xor eax,eax
{0-} xor ebx,ebx
{@00} {1} mov edi,[esp+_ENCODED]
{2**} cmp edx,00000258
{0**} jz @indexed
{1} movzx ecx,byte ptr [esi+00h]
{2-} mov ebp,edx
@pre_encode:
{@11} {0} mov edi,[esp+_ENCODED]
{1-} xor ebx,ebx
{2*} sub ebp,03h
{0*} jb @encode_alpha
{@20} {1-} movzx eax,bl
{2} lea edx,[ebp+03h]
{ } jz @indexed
@encode_length:
{---} bsr ecx,ebp
{0*} sub ecx,02h
{1*} jle @indexed
{@30} {2-} mov ebx,ebp
{0} shr ebp,cl
{1-} mov eax,ebp
{2} lea ebp,[ebp+ecx*04h+00h]
{0} shl eax,cl
{1} xor ebx,eax
{2-} mov eax,ecx
@indexed:
{@40} {0} mov ecx,dword ptr [ZFIXED_ENCODE+257*04h+ebp*0
{1} mov ebp,[esp+_ZIPPED]
{2} add al,cl
{0} shl ebx,cl
{1} shr ecx,10h
{@52} {2} or ebx,ecx
{0-} mov ecx,edi
{1} and ecx,07h
{2} shr edi,03h
{0} shl ebx,cl
{1} or bl,[edi+ebp]
{@61} {2} add ecx,eax
{0} mov eax,[esp+_MOVEDIST]
@writelength:
{0} mov [edi+ebp],bl
{1} add edi,01h
{2} shr ebx,08h
{0*} sub ecx,08h
{@72} {1*} jge @writelength
@encode_distance:
{ } { x3 } mov ebp,00000000h
{ } sub eax,esi
{ } xor eax,-1
{@80} { } lea edi,[edi*08h+ecx*08h+00]
{ } jz @distindexed
{---} bsr ecx,eax
{0*} sub ecx,01h
{1*} js @distindexed
{2-} mov ebx,eax
{@90} {0} shr eax,cl
{1-} mov ebp,eax
{2} lea eax,[ecx*02h+eax]
{0} shl ebp,cl
{1} xor ebx,ebp
{2-} mov ebp,ecx
{0} shl ebx,05h
@distindexed:
{@A0} {0} or ebx,dword ptr [REVERSE2_5+eax*04h]
{1-} mov ecx,edi
{0} shr edi,03h
{2} mov eax,[esp+_ZIPPED]
{@B0} {1} and ecx,07h
{2} shl ebx,cl
{0} or bl,[edi+eax]
{1} lea ecx,[ecx+ebp+05h]
{2} mov ebp,[esp+_HASH]
@writedistance:
{@C0} {0} mov [edi+eax],bl
{1} add edi,01h
{2} shr ebx,08h
{0*} sub ecx,08h
{1*} jge @writedistance
{ } add edx,esi
{@D0} { } lea edi,[edi*08h+ecx]
{ -} mov eax,ebp
{ } jmp @administration
{ x9 } xor eax,eax; xor ebp,ebp; mov edx,00000000h
{@00} { x4 } xor edx,edx; xor ecx,ecx
@encode_alpha:
{@04} {0} mov ebp,[esp+_ZIPPED]
{1-} movzx edx,cl
{2-} mov ecx,edi
{0} shr edi,03h
{@10} {1} mov edx,dword ptr [ZFIXED_ENCODE+edx*04h]
{2} and ecx,07h
{0} movzx eax,dx
{1} shr edx,10h
{@20} {2} shl edx,cl
{0} add ecx,eax
{1} mov eax,[esp+_HASH]
{2} or dl,[edi+ebp]
@writechar:
{0} mov [edi+ebp],dl
{1} add edi,01h
{@31} {2} shr edx,08h
{0*} sub ecx,08h
{1*} jge @writechar
{ } lea edx,[esi+01h]
{ } lea edi,[edi*08h+ecx+00h]
@administration:
{@20} {0} mov ecx,[esp+_LAST+eax*04h]
{1} mov [esp+_LAST+eax*04h],esi
{2} shl eax,__BITS
{0} and eax,__LOOKUP-1
{1-} mov ebp,esi
{2} xor al,[esi+03h]
{0} add esi,01h
{1} and ebp,(__WINDOW-1)
{2} mov [esp+_PREV+ebp*04h],ecx
{0**} cmp esi,edx
{1**} jnz @administration
@nextloop:
{0} mov [esp+_HASH],eax
{@70} {1} mov ebp,[esp+_LEN]
{2} sub ebx,esi
{0} mov eax,[esp+_LAST+eax*04h]
{1-} xor edx,edx
{2} movzx ecx,byte ptr [esi+00h]
{0*} sub ebp,esi
{1*} jz @finalize
{2**} cmp ebp,00000258
{@90} {0**} jae @compression
{ } mov [esp+_MAXRANGE],ebp
{ } jmp @compression
{ x1 } nop
{@80} { x1 } nop
@special:

[ Szerkesztve ]

Egy program sosincs befejezve, csak abbahagyva van.

@FIX_character:
{@A2} {0} mov [edi],al
{1-} mov ecx,edx
{2} add edi,01h
@@FIX_symbol:
{@A9} {0} mov eax,(($1 shl ZFIX_aMAXBITS)-1)
{1} shl ebp,cl
{@B0} {2} xor ecx,(03h shl 03h)
{0} and ax,bx
{1} or edx,(03h shl 03h)
{2} shr ecx,03h
{0} or ebx,ebp
{1} add esi,ecx
@@FIX_code:
{@C0} {2} mov ecx,dword ptr [ZFIXED_RELOC+eax*08h+_SIZE]
{0} mov ebp,[esi]
{1} mov eax,dword ptr [ZFIXED_RELOC+eax*08h+_CODE]
{@D0} {2} shr ebx,cl
{0*} sub edx,ecx
{1*} jnc @FIX_character
@FIX_length:
{2} sar ecx,10h
{0} and al,bl
{1} sub dl,cl
{2} shr ebx,cl
{@FF} {0-} movzx ecx,al
{@02} {1} sar eax,10h
{2} jz @NXSECTION
{0} sub eax,ecx
{1-} movzx ecx,bl
@FIX_distance:
{@10} {2} sub edx,ZFIX_dBITS
{0} mov [esp+_MOVELEN],eax
{1} sub edi,eax
{2} mov eax,dword ptr [ZFIXED_DISTx8+ecx*04h]
{@20} {0-} movzx ecx,dl
{1} shr ebx,ZFIX_dBITS
@FIX_load:
{2} or edx,(03h shl 03h)
{0} shl ebp,cl
{1} xor ecx,(03h shl 03h)
{2} shr ecx,03h
{@31} {0} or ebx,ebp
{1} mov ebp,[esp+_MOVELEN]
{2} movzx edx,dl
{0} add esi,ecx
{1-} mov ecx,eax
{2} sar eax,10h
{@41} {0} jns @FIX_movechar
{1} jc @FIX_moveword
{2} mov ebp,00000001h
@FIX_movedword:
{0} sub dl,cl
{1} shl ebp,cl
{2} add eax,edi
{@50} {0} add ebp,0FFFFFFFFh
{1} and ebp,ebx
{2} shr ebx,cl
{0} mov ecx,[esp+_MOVELEN]
{1} sub eax,ebp
@FIX_move4byte:
{@60} {0} mov ebp,[ecx+eax+00h]
{1} mov [edi+ecx+00h],ebp
{2} mov ebp,[ecx+eax+04h]
{0} mov [edi+ecx+04h],ebp
{1*} add ecx,08h
{@71} {2*} js @FIX_move4byte
{0-} mov ecx,edx
{1} mov ebp,[esi]
{2} jmp @@FIX_symbol
{ x4 } lea eax,[edx+edx+01h]
@FIX_movechar:
{@60} {0} movzx eax,byte ptr [ebp+edi-01h]
{0} imul ecx,eax
{1-} mov eax,ebx
@FIX_move1byte:
{0} mov [edi+ebp+00h],ecx
{@70} {1} mov [edi+ebp+04h],ecx
{2*} add ebp,08h
{0*} js @FIX_move1byte
{1} and eax,(($1 shl ZFIX_aMAXBITS)-1)
{2} jmp @@FIX_code
@FIX_moveword:
{@80} {0} add eax,edi
@FIX_move2byte:
{@82} {0} movzx ecx,word ptr [eax+ebp+00h]
{1} mov [edi+ebp+00h],cx
{2} movzx ecx,word ptr [eax+ebp+02h]
{@8F} {0} mov [edi+ebp+02h],cx
{@94} {1*} add ebp,04h
{2*} js @FIX_move2byte
{0-} mov eax,ebx
{1} and eax,(($1 shl ZFIX_aMAXBITS)-1)
{@A0} {2} jmp @@FIX_code

Örömmel jelentem, hogy lassabb nem lett

.............................

{ } movsx ebx,byte ptr [edx]
{ } xor eax,eax
{ } mov esi,ebp
{ } mov [edi+__N],ebp
{ } and esi,-8
{ } mov ecx,ebp
@init:
{ } mov [edi+esi*08h+(00h*08h)+__K],eax
{ } mov [edi+esi*08h+(04h*08h)+__K],eax
{ } add esi,08h
{ } jnz @init
@argument
{ } cmp ebx.00h
{ } lea eax,[ebp+ebx*04h]
{ } movsx ebx,byte ptr [edx+01h]
{ } lea edx,[edx+01h]
{ } mov [edi+eax*08h+__K],ebp
{ } cmovs eax,esi
{ } mov [edi+ecx*08h+__F],eax
{ } add ecx,04h
{ } jnz @argument
{ } mov [edi+ebp*08h-(04h*08h)+__K],esi
{ } lea edx,[ebp-04h]
{ } mov ebx,edi
{ } jmp @next0row
@ROWS:
{ } mov [edi+__LEFT1+edx*08h+__W],esi
@next0row:
{ } mov eax,[edi+edx*08h+(04h*08h)+__S]
{ } add edx,04h
{ } jz @@COLUMNS
{ } mov [edi+edx*08h+B],eax
{ } xor esi,esi
{ } mov [edi+edx*08h+_R],eax
{ } sub ebx,ebp
{ **} test eax,eax
{ **} jnz @@ROWS
{ } lea ecx,[ebp+04h]
{ } mov esi,[ebx+ebp]
{ } or esi,[edi+ebp*08h+__K]
{ } and ecx,-8
@findrowmin:
{ } mov eax,[ebx+ecx]
{ } or eax,[edi+ecx*08h+__K]
{ } add ecx,08h
{ } cmp eax,ebp
{ } cmovb ebp,eax
{ } mov eax,[ebx+ecx-04h]
{ } or eax,[edi+ecx*08h-(04h*08h)+__K]
{ } cmp eax,esi
{ } cmovb esi,eax
{ **} cmp ecx,00h
{ **} jnz @findrowmin
{ } cmp ebp,esi
{ } cmovb esi,ebp
{ } mov ebp,[edi+__N]
{ } neg esi
{ } jle @@ROWS
@@XXX:
{ } mov esi,[esp+_A]
{ } mov ecx,[esp+_I]
{ } mov dword ptr [esi+A.OPTIMUM],?
{ } mov ebx,[esi+TRESULT.NEXT]
{ } jmp ecx
@free0col:
{ } add dword ptr [edi+__0COUNTER],-1
{ } mov [edi+__CCOLMIN],esi
{ } mov ecx,0FFFFFFFFh
{ } mov [edi+ebp*08h-(04h*08h)+__K],edx
@0col:
{ } mov [edi+__LEFT1+edx*08h+__COLMOD],esi
@@COLUMNS:
{ -} mov ebx,ebp
@next0col:
{ } mov [edi+__LEFT1+edx*08h+__C],ecx
{ } mov ecx,edi+edx*08h-(04h*08h)+__K]
{ } lea eax,[edx-04h]
{ } sub eax,ebp
{ } js @@INIT0COL
{ } sub edx,04h
{ } xor ecx,-1
{ } jns @next0col
@findcolmin:
{ } mov esi,[eax+edi]
{ } add esi,[edi+__LEFT1+ebx*08h+__U]
{ } or esi,[edi+ebx*08h+__S]
{ } jz @test0row
{ } sub eax,ebp
{ } cmp esi,ecx
{ } cmovb ecx,esi
{ } add ebx,04h
{ } jnz @findcolmin
{ } mov eax,edx
{ } lea ebx,[ebp-04h]
{ } mov esi,ecx
{ } cmp ecx,00h
{ } js @@XXX
@seek0col:
{ } mov ecx,[edi+__LEFT1+ebx*08h+(04h*08h)+__W]
{ } sub eax,ebp
{ } add ebx,04h
{ } jz @free0col
{ } add ecx,[eax+edi]
{ **} cmp ecx,esi
{ **} jnz @seek0col
@test0row:
{ } mov ecx,[edi+ebx*08h+B]
{ **} test ecx,ecx
{ **} js @seek0col
{ } mov [edi+ebx*08h+B],edx
{ } mov [edi+edx*08h+__K],ebx
{ } jmp @0col
@@INIT0COL:
{ } lea eax,[edi+ecx]
{ } mov [edi+__L],ecx
{ } neg ebp
{ } sal ecx,10h
{ } jnz @init2col
{ -} xor esi,esi
{ } jmp @@FINISHED
@@5TH_STEP:
{ -} mov edx,esi
{ } movsx esi,si
{ } sar eax,10h
@5TH_STEP:
{ } movsx ecx,byte ptr [edi+__LEFT1+ebx*08h+__SIGN+__C]
{ } and ecx,edx
{ } add [edi+__LEFT1+ebx*08h+__COLMOD],ecx
{ } movsx ecx,byte ptr [edi+ebx*08h+__SIGN+_R]
{ } and ecx,edx
{ } add [edi+__LEFT1+ebx*08h+__W],ecx
{ } add ebx,04h
{ } jnz @5TH_STEP
{ } mov edx,es:[edi+esi*08h+B]
{ } db $8B,$8C,$3B,__L,?,?,?
{ **} test edx,edx
{ **} jz @@4TH_STEP
{ } add dword ptr [edi+__PN],-1
{ } mov [edi+esi*08h+_R],eax
{ } mov [edi+__LEFT1+edx*08h+__C],esi
{ } cmp edx,ecx
{ } cmovb ecx,edx
{ } sub ebx,ebp
{ } mov [edi+__L],ecx
{ } jmp @@9ND_STEP
@fast6forward:
{ } mov esi,[edi+__LEFT1+ebx*08h+(04h*08h)+__W]
{ } add ebx,04h
{ } jz @pass8col
{ } sal ecx,10h
{ } jmp @loop
@pass8col:
{ } mov eax,[edi+__N]
{ } sub ebx,ebp
{ } mov [edi+__LEFT1+ecx*08h+__C],eax
@next20col:
{ } add ecx,04h
{ } jz @@5TH_STEP { clears ECX register
{ **} cmp [edi+__LEFT1+ecx*08h+__C],eax
{0**} jbe @next20col
@@8ND_STEP:
{ } mov esi,[edi+__LEFT1+ecx*08h+__COLMOD]
{ } lea eax,[edi+ecx]
{ } mov [edi+__CCOL],esi
{ } imul ecx,00010000h
@init2col:
{ } add eax,ebp
{ } mov esi,[edi+ebx*08h+__W]
@loop:
{ } sub esi,[edi+__COLMIN]
{ } add esi,[eax]
{ } lea eax,[eax+ebp]
{ } jo @over6flow
{ } or esi,[edi+ebx*08h+_R]
{ } jz @@11D_STEP
{ } cmp esi,edx
{ } cmovb edx,esi
{ } cmovb cx,bx
@over6flow:
{ } mov esi,[edi+__LEFT1+ebx*08h+(04h*08h)+__W]
{ } add ebx,04h
{ } jnz @loop
{ -} mov eax,ecx
{ } sar ecx,10h
{ } cmovc esi,eax
{ } mov [edi+__MC],esi
{ } jmp @pass8col
@@11D_STEP:
{ -} mov esi,ecx
{ } sar ecx,10h
{ } cmovnc esi,[edi+__M]
{ } mov [edi+__MC],esi
{ } mov esi,[edi+ebx*08h+B]
{ **} test esi,esi
{ **} jz @4TH_STEP
{ } mov [edi+ebx*08h+_R],ecx
{ } mov [edi+__LEFT1+esi*08h+__C],-1
{ **} cmp word ptr [edi+__MC],bx
{ **} jz @re2start
{ **} cmp esi,ecx
{ **} jae @fast6forward
{ } mov ecx,esi
{ } xor ebx,ebx
{ } mov eax,[edi+__L]
{ } sub ebx,ebp
{ } cmp esi,eax
{ } cmovb eax,esi
{ } mov [edi+__L],eax
{ } jmp @@7ND_STEP
@re2start:
{ } mov ecx,[edi+__L]
{ } xor ebx,ebx
{ } add dword ptr [edi+__PN],-1
{ } mov edx,esi
{ } cmp esi,ecx
{ } cmovb ecx,esi
{ } sub ebx,ebp
{ } mov [edi+__L],ecx
{ } jmp @@6ND_STEP
@@4TH_STEP:
{ } mov ecx,eax
{ } mov ebx,esi
@4TH_STEP:
{ } mov [edi+ebx*08h+BB],ecx
{ } mov edx,[edi+ecx*08h+__K]
{ } mov [edi+ecx*08h+__K],ebx
{ } mov ebx,edx
{ } mov ecx,[edi+edx*08h+_R]
{ } sub edx,ebp
{ } jnc @4TH_STEP
{ } xor esi,esi
{ } mov ebx,edx
{ } sub dword ptr [edi+__0COUNTER],-1
{ } jz @@FINISHED
@@1ST_STEP:
{ } mov eax,[edi+esi*08h-(04h*08h)+__K]
{ } xor eax,-1
{ } mov [edi+__LEFT1+esi*08h-(04h*08h)+__C],eax
{ } lea esi,[esi-04h]
{ } mov eax,[edi+esi*08h+__S]
{ } cmovs ecx,esi
{ } mov [edi+esi*08h+_R],eax
{ **} cmp edx,esi
{ **} jnz @@1ST_STEP
{ } nop
{ } mov [edi+__L],ecx
{ } jmp @@5ND_STEP

@@FINISHED:
{ } mov eax,edi
{ } mov ecx,[esp+_KIMENET]
{ } mov ebp,edx
@@results:
{ } mov ebx,[edi+edx*08h+__B]
{ } sub eax,ebp
{ } add esi,[eax+ebx]
{ } sub ebx,ebp
{ } shr ebx,02h
{ } mov [ecx],bl
{ } add ecx,01h
{ } add edx,04h
{ } jnz @@results
(CODE)

[ Szerkesztve ]

Skeleton of code adjusted to Zen(1) and Zen+ (i. e. placeholder codes omitted).

Runs constantly at 3.4 IPC (of maximum 4.0 due to the 4 available ALU-s) for 50x50 matrices, this means 85% utilization.

Since more than 90% percent of instructions need ALU, so important theorem is the way of instruction distribution among the ALUs. This is true for all other microarchitectures as well.

{ } movsx ebx,byte ptr [eax+E.FIELD0+00h]
{ } mov esi,ebp
{ } xor edx,edx
{ } and esi,-8
{ } mov [edi+__A],ebp
{ } mov ecx,ebp
@init:
{ } mov [edi+esi*08h+(00h*08h)+__B],edx
{ } mov [edi+esi*08h+(04h*08h)+__B],edx
{ } sub esi,-8
{ } jnz @init
@@a:
{ } cmp ebx,ebp
{ } lea esi,[ebp+ebx*04h]
{ } movsx ebx,byte ptr [eax+E.FIELD0+01h]
{ } lea eax,[eax+01h]
{ } mov [edi+esi*08h+__B],ebp
{ } cmova esi,edx
{ } mov [edi+ecx*08h+__C],esi
{ } add ecx,04h
{ } jnz @@a
{ } mov eax,[edi+ebp*08h+__C]
{ } mov ebx,ebp
{ } mov edx,edi
{ } jmp @b
@@ROWS:
{ } mov eax,[edi+ebx*08h+(04h*08h)+__C]
{ } add ebx,04h
{ } jz @@COLS
@next0b:
{ } mov [edi+ebx*08h+__D],eax
{ } sub edx,ebp
{ } mov [edi+ebx*08h+R],eax
{ } add eax,ebp
{ } jc @@ROWS
{ } lea ecx,[ebp+04h]
{ } mov esi,[edx+ebp]
{ } or esi,[edi+ebp*08h+__B]
{ } and ecx,-8
{ } mov ebp,[edi+ecx*08h+__B]
@findr:
{ } or ebp,[edx+ecx+00h]
{ } cmp ebp,eax
{ } cmovb eax,ebp
{ } mov ebp,[edx+ecx+04h]
{ } or ebp,[edi+ecx*08h+(04h*08h)+__B]
{ } cmp ebp,esi
{ } cmovb esi,ebp
{ } mov ebp,[edi+ecx*08h+(08h*08h)+__B]
{ } add ecx,08h
{ } jnz @findr
{ } cmp eax,esi
{ } mov ebp,[edi+__A]
{ } cmovb esi,eax
{ } neg esi
{ } mov [edi+__L+ebx*08h+__F],esi
{ } jle @ROWS
@@EXIT:
{ } mov esi,[esp+_X]
{ } mov [esi+E.O],7FFFFFFFh
{ } jmp @outside
@free0col:
{ } add [edi+__0],ebp
{ } mov [edi+__Y],esi
{ } mov ecx,0FFFFFFFFh
@@COLS:
{ } mov [edi+ebp*08h-(04h*08h)+__B],ebx
@mark:
{ } mov [edi+__L+ebx*08h+__CC],esi
{ } mov esi,[edi+__L+ebp*08h+__F]
{ } mov edx,ebp
@nextc:
{ } lea eax,[ebx-04h]
{ } mov [edi+__L+ebx*08h+__M],ecx
{ } mov ecx,[edi+ebx*08h-(04h*08h)+__B]
{ } mov ebx,eax
{ } sub eax,ebp
{ } jc @@init0
{ } xor ecx,-1
{ } jns @nextc
@findc:
{ } add esi,[eax+edi]
{ } or esi,[edi+edx*08h+__D]
{ } lea edx,[edx+04h]
{ } jz @testr
{ } sub eax,ebp
{ } cmp esi,ecx
{ } cmovb ecx,esi
{ } mov esi,[edi+__L+edx*08h+__F]
{ **} cmp edx,00h
{ **} jnz @findc
{ } mov eax,ebx
{ } mov edx,ebp
{ } mov esi,ecx
{ **} cmp ecx,00h
{ **} js @@EXIT
@seek0:
{ } mov ecx,[edi+__L+edx*08h+__F]
{ } sub eax,ebp
{ } add edx,04h
{ } jg @free0col
{ } add ecx,[eax+edi]
{ **} cmp ecx,esi
{ **} jnz @seek0
@testr:
{ } lea ecx,[edx-04h]
{ **} test [edi+edx*08h-(04h*08h)+__C],ebx
{ **} js @seek0col
{ } mov [edi+ebx*08h+__B],ecx
{ } mov [edi+edx*08h-(04h*08h)+__C],ebx
{ } xor ecx,ecx
{ } jmp @mark
@@init0:
{ } mov [edi+__I],ecx
{ } mov eax,ecx
{ } sal ecx,10h
{ } jnz @scan
{ } mov eax,edi
{ } mov esi,[esp+_X]
{ } jmp outside
@@1ST_STEP:
{ } movsx esi,ax
{ } mov esi,[edi+esi*08h+__C]
{ } neg edx
@1ST_STEP:
{ } movsx ecx,byte ptr [edi+__L+ebx*08h+__S+__M]
{ } and ecx,edx
{ } sub [edi+__L+ebx*08h+__CC],ecx
{ } movsx ecx,byte ptr [edi+ebx*08h+__S+R]
{ } and ecx,edx
{ } sub [edi+__L+ebx*08h+__F],ecx
{ } add ebx,04h
{ } jnz @1ST_STEP
{ } mov ecx,[edi+__I]
{ } movsx ebx,ax
{ } sar eax,10h
{ **} test esi,esi
{ **} jz @@2ND_STEP
{ } add dword ptr [edi+__A],-1
{ } mov [edi+ebx*08h+R],eax
{ } mov [edi+__L+esi*08h+__M],ebx
{ } cmp esi,ecx
{ } cmovb ecx,esi
{ } mov ebx,ebp
{ } mov [edi+__I],ecx
{ } jmp @@6TH_STEP
@pass:
{ } mov eax,ecx
{ } sar ecx,10h
{ } cmovnc eax,[edi+__W]
{ } mov [edi+__W],eax
{ } lea ebx,[ebp+00h]
{ } mov [edi+__L+ecx*08h+__M],esi
@nx:
{ } mov esi,[edi+__L+ecx*08h+__M +(04h*08h)]
{ } add ecx,04h
{ } jz @@1ST_STEP
{ **} cmp esi,[edi+__A]
{ **} jbe @nx
@@6TH_STEP:
{ } mov esi,[edi+__L+ecx*08h+__CC]
{ } lea ebx,[ebp-04h]
{ } { x1 } nop
{ } mov eax,ecx
{ } mov [edi+__Y],esi
@ffd:
{ } sal ecx,10h
{ } mov esi,[edi+__L+ebx*08h+(04h*08h)+__F]
@z:
{ **} cmp ebx,-4
{ **} jz @pass
@scan:
{ } add ebx,04h
{ } sub eax,ebp
{ } sub esi,[edi+__Y]
{ } add esi,[edi+eax]
{ } or esi,[edi+ebx*08h+R]
{ } jz @@5TH_STEP
{ } cmp esi,edx
{ } cmovb cx,bx
{ } cmovb edx,esi
{ } mov esi,[edi+__L+ebx*08h+(04h*08h)+__F]
{ **} cmp ebx,-4
{ **} jz @pass
{ } add ebx,04h
{ } sub eax,ebp
{ } sub esi,[edi+__Y]
{ } add esi,[edi+eax]
{ } or esi,[edi+ebx*08h+R]
{ } jz @@5TH_STEP
{ } cmp esi,edx
{ } cmovb cx,bx
{ } cmovb edx,esi
{ } mov esi,[edi+__L+ebx*08h+(04h*08h)+__F]
{ } db $66,$66,$66; nop
{ } jmp @zZ
@@5TH_STEP:
{ } mov esi,ecx
{ } sar ecx,10h
{ } cmovnc esi,[edi+__W]
{ } mov [edi+__W],esi
{ } mov esi,[edi+ebx*08h+__C]
{ **} test esi,esi
{ **} jz @2ND_STEP
{ } mov [edi+ebx*08h+R],ecx
{ } mov [edi+__L+esi*08h+__M],0FFFFFFFFh
{ **} cmp word ptr [edi+__W],bx
{ **} jz @re
{ **} cmp esi,ecx
{ **} jae @ffd
{ } mov ecx,esi
{ } mov eax,[edi+__I]
{ } cmp esi,eax
{ } cmovb eax,esi
{ } mov [edi+__I],eax
{ } jmp @@6TH_STEP
@re:
{ } mov ecx,[edi+__I]
{ } add dword ptr [edi+__A],-1
{ } mov edx,esi
{ } cmp esi,ecx
{ } cmovb ecx,esi
{ } mov [edi+__I],ecx
{ } jmp @@6TH_STEP
@@2ND_STEP:
{ } mov ecx,eax
@2ND_STEP:
{ } mov [edi+ebx*08h+__C],ecx
{ } mov edx,[edi+ecx*08h+__B]
{ } mov [edi+ecx*08h+__B],ebx
{ } mov ecx,[edi+edx*08h+R]
{ } mov ebx,edx
{ } add edx,ebp
{ } jc @2ND_STEP
{ } mov ecx,esi
{ } sub [edi+__0],ebp
{ } jz @@outside
@@9ST_STEP:
{ } mov eax,[edi+esi*08h-(04h*08h)+__B]
{ } xor eax,-1
{ } mov [edi+__L+esi*08h-(04h*08h)+__M],eax
{ } lea esi,[esi-04h]
{ } cmovs ecx,esi
{ } mov ebx,[edi+esi*08h+__D]
{ } mov eax,[edi+esi*08h-(04h*08h)+__B]
{ } mov [edi+esi*08h+R],ebx
{ **} cmp ebp,esi
{ **} jz @i9
{ } xor eax,-1
{ } mov [edi+__L+esi*08h-(04h*08h)+__M],eax
{ } lea esi,[esi-04h]
{ } cmovs ecx,esi
{ } mov eax,[edi+esi*08h+__D]
{ } mov [edi+esi*08h+R],eax
{ **} cmp ebp,esi
{ **} jnz @@9ST_STEP
@i9:
{ } mov [edi+__I],ecx
{- } jmp @@6TH_STEP

[ Szerkesztve ]