sse assembly programozás

Alkalmazások és operációs rendszerek optimizálása

„Babeş-Bolyai” Tudományegyetem, Matematika-Informatika Kar

SSE assembly programozás

előadás

dr. Robu Juditszeminárium

drd. Lukács Sándor

7

2006

2006BBTE, Alkalmazások és operációs rendszerek optimizálása

2Referenciák

AMD x86-64 Architecture Programmer’s Manual, Volume 4: 128-bit Media Instructions Revision 3.03, August 2002 kiváló képek, ábrák

IA-32 Intel Architecture Software Developer’s Manual, Volume 2: Instruction Set Reference a 2000-es kiadásban voltak hibák, pl. PACKSSDW megtalálható benne a C/C++ compiler intrinsics-ek

rövid leírása


3SSE végrehajtási modell

SIMD modell – Single Instruction Multiple Dataa legtöbb mai PC és Workstation kategóriájú

processzor ezt a modellt (is) támogatja

SISDáltalános utasítások

SIMDtipikus multimédia utasítások

MISDgyakorlatban nem használt

MIMDkísérleti formában használt


4SIMD végrehajtás

a műveletek párhuzamosan végződnek el több operanduson implementáció szerint, vagy ugyanabban az óraciklusban mind a

négy (Intel Core 2), vagy kettessével (Intel NetBurst)


5SIMD technológiák x86-os platformokon

MMX – 1996, Intel Pentium MMX egész műveletek, az első x86-os SIMD szett

3DNow! – 1998, AMD K6-2 lebegőpontos műveletek 64 bites MMX regiszterken PREFETCH utasítás – adat-cache vonal explicit betöltése

SSE – 1999, Intel Pentium III lebegőpontos műveletek új, 128 bites XMM regisztereken kibővített utasításszett MMX egész műveletek számára

SSE2 – 2000, Intel Pentium 4 egész műveletek a 128 bites XMM regisztereken


6SSE végrehajtási környezet


7SSE regiszterszett

8 új, 128 bites regiszter32 bites üzemmódban

16 új, 128 bites regiszter64 bites üzemmódban

MXCSR, 32 bites kontrollés státuszregiszter STMXCSR m32 LDMXCSR m32 alapérték 0x00001F80

a regiszterek függetlenek a FPU/MMX regiszterektől

XMM0

XMM1

XMM7

XMM8

XMM15

…

…

MXCSR

min

dig

elér

het

ő64

bit

spec

ifiku

s


8SSE adattípusok 1

két új lebegőpontos adattípus 128 bites tömörített egyszeres pontosságú valós 128 bites tömörített, kétszeres pontosságú valós


9SSE adattípusok 2

az SSE 128 bitre bővítette az MMX tömörített egész adatípusait


10SSE egész ábrázolás


11SSE lebegőpontos ábrázolás


12SSE lebegőpontos értéktípusok

normalizált értékek a szignifikáns [1,2) intervalumon belüli érték a szám nagyságrendjét kizárólag az exponens határozza meg

denormalizált értékek (nagyon kis értékek) a szám nagyságrendje kisebb, mint az adattípus alsó határa

(pl. < 2-126 egyszeres pontosság esetén) a számot mégis ábrázoljuk, 0-ás egész résszel

nulla van pozitív és negatív nulla

végtelen van pozitív és negatív végtelen

nem-szám (not-a-number, NaN) értékek QNaN (Quiet NaN) – a processzor nem generál kivételt SNaN (Signalling NaN) – a processzor kivételt generál


13Túlcsordulás vezérlés

egész adatípusok esetén azonos az MMX-ben is jelenlévő három típussaltúlcsordulásoselőjeles korlátozás (signed saturation)előjel nélküli korlátozás (unsigned saturation)

lebegőpontos műveletek esetén nincs túlcsorduáls korlátozás – akárcsak FPU eseténvannak jelzőbittek és kivételek#19-es kivétel – SSE lebegőpontos kivétel


14SSE kontroll regiszter 1


15SSE kontroll regiszter 2

6 kivétel jelző bit IE, DE, ZE, OE, UE, PE 6 kivétel maszkbit IM, DM, ZM, OM, UM, PM

ha 0, engedélyezett a kivétel ha 1, a kivétel tiltott

négy lebegőpontos kerekítési módot támogat az SSE 00 – legközelebbi érékhez (round to nearest) 01 – lefele kerekítés (round down) 10 – felfele kerekítés (round up) 11 – nulla fele kerekítés (round toward zero)


16SSE utasítások – Bevezető 1

előtagok / prefixek CVT – konverizó CVTT – konverizó kerekítéssel (truncation) P – tömörített / vektor művelet PACK – tömörítés (2x szélességből 1x szélességbe) PUNPCK – kitömörítés és felváltva helyezés UNPACK – kitömörítés és felváltva helyezés

utótagok / suffixek, más jelölések B, W, D, Q, DQ – adatméret H – rangosabb fél (high) L – kevésbé rangos fél (low) vagy bal részoprandus (left)


17SSE utasítások – Bevezető 2

utótagok / suffixek, más jelölések PS – vektoriális egyszeres pontosságú lebegőpontos PD – vektoriális kétszeres pontosságú lebegőpontos SS – skaláris egyszeres pontosságú lebegőpontos, VAGY

SS – előjeles korlátozás (signed saturation) SD – skaláris kétszeres pontosságú lebegőpontos US – előjel nélküliu korlátozás (unsigned saturation) PI – tömörített egész SI – előjeles egész S – előjeles, korlátozás vagy shift U – előjel nélküli, unorderes, unaligned


18SSE/Int – Adatátviteli utasítások 1


19SSE/Int – Adatátviteli utasítások 2


20SSE/Float – Adatátviteli utasítások 1


21SSE/Float – Adatátviteli utasítások 2


22SSE – További adatátviteli utasítások

előjel bitmaszk generálásMASKMOVDQU, PMOVMSKBMOVMSKPS, MOVMSKPD

non-temporális / streaming tárolásnem tárolja az adatot a processzor cachejeibenMOVNTI, MOVNTQ, MOVNTDQMOVNTPS, MOVNTPD


23SSE/Int – Aritmetikai utasítások 1

összeadás PADDB, PADDW, PADDD, PADDQ PADDSB, PADDSW PADDUSB, PADDUSW

kivonás PSUBB, PSUBW, PSUBD, PSUBQ PSUBSB, PSUBSW PSUBUSB, PSUBUSW

szorzás, szorzás-összeadás PMULHW, PMULLW, PMULHUW PMULUDQ – DWORD szorzás és QWORD eredmények tárolása PMADDWD – WORD szorzás, majd DWORD eredmények összegzése PSADBW – BYTE abszolút különbségek WORD összege

átlag számítások PAVGB, PAVGW – előjel nélküli műveletek


24SSE/Int – Aritmetikai utasítások 2

PMULUDQ

PMADDWD


25SSE/Float – Aritmetikai utasítások 3

összeadás, kivonás ADDPS, ADDPD – vektoriális / tömörített összeadás ADDSS, ADDSD – skaláris összeadás, a rangosabb

regiszterrészek nem módosulnak SUBPS, SUBPD, SUBSS, SUBSD

szorzás, osztás MULPS, MULPD, MULSS, MULSD DIVPS, DIVPD, DIVSS, DIVSD

négyzetgyök és inverz (1/x) számítások SQRTPS, SQRTPD, SQRTSS, SQRTSD RSQRTPS, RSQRTSS RCPPS, RCPSS


26SSE/Float – Aritmetikai utasítások 4


27SSE példa – Vektor szorzás 1

var StartTime, StopTime: Int64;

function RDTSC: Int64; assembler;asm rdtsc // TIME STAMP COUNTERend;

procedure Start;begin StartTime := RDTSC;end;

function Stop: Int64;begin StopTime := RDTSC; Result := StopTime - StartTime;end;

const N = 100; // 100 szó elfér az L1 cache-ben K = 1000000; // többszörös végrehajtás, egyetlen // végrehajtás idejét nem igazaán // lehet pontosan lemérni

type TSingleVector = array[0..N-1] of

Single;

var a1, b1, c1: TSingleVector; a2, b2, c2: TSingleVector; i: Integer;

...



function FpuMulVector(var a, b, c: TSingleVector; N: Integer): Int64;

var i, j: Integer;begin Start; for j := 0 to K-1 do for i := 0 to N-1 do c[i] := a[i] * b[i]; Result := Stop;end;

klasszikus, FPU-val történő lebegőpontos szorzások

... for i := 0 to N-1 do begin a1[i] := Random; b1[i] := Random; a2[i] := a1[i]; b2[i] := b1[i]; end;

fpu := FpuMulVector(a1, b1, c1, N); sse := SseMulVector(a2, b2, c2, N);

writeln(‘fpu = ', fpu, ' ticks'); writeln(‘sse = ', sse, ' ticks'); writeln(' x = ', fpu/sse:5:3);...



function SseMulVector(var a, b, c: TSingleVector; N: Integer): Int64; assembler;

asm mov esi, a mov edi, b mov edx, c... mov eax, K@next2: pop edx pop edi pop esi push esi push edi push edx mov ecx, N shr ecx, 2

@next: movups xmm0, [edi]movups xmm0, [edi] movups xmm1, [esi]movups xmm1, [esi] mulps xmm0, xmm1mulps xmm0, xmm1 movups [edx], xmm0movups [edx], xmm0

add edi, 16 add esi, 16 add edx, 16

sub ecx, 1 jnz @next sub eax, 1 jnz @next2... // nem kell EMMS!end;



...DEMO...


31SSE példa – Sormátrix szorzása 1

iiiiiiii BBBB

TTTT

TTTT

TTTT

TTTT

AAAA 3210

3,32,31,30,3

3,22,21,20,2

3,12,11,10,1

3,02,01,00,0

3210

3

0,

kjk

ik

ij TAB

•oszlopmátrixok esetén más Bi,j formula van



type TQuad = array [0..3] of Single; TQuadVector = array [0..N-1] of TQuad; TMatrix = array [0..3] of TQuad;

...

for i := 0 to N-1 dobegin

b[i][0] := a[i][0]*t[0][0] + a[i][1]*t[1][0] + a[i][2]*t[2][0] + a[i][3]*t[3][0]; b[i][1] := a[i][0]*t[0][1] + a[i][1]*t[1][1] + a[i][2]*t[2][1] + a[i][3]*t[3][1]; b[i][2] := a[i][0]*t[0][2] + a[i][1]*t[1][2] + a[i][2]*t[2][2] + a[i][3]*t[3][2]; b[i][3] := a[i][0]*t[0][3] + a[i][1]*t[1][3] + a[i][2]*t[2][3] + a[i][3]*t[3][3];end;...

műveletelvégzési lehetőségek

oszloponként

soronként



function SseMulMat(var a, b: TQuadVector; N: Integer;var t: TMatrix): Int64; assembler;

asm mov esi, a mov edi, b mov edx, t mov ecx, N push esi push edi push ecx

movups xmm4, [edx]movups xmm4, [edx] movups xmm5, [edx+16]movups xmm5, [edx+16] movups xmm6, [edx+32]movups xmm6, [edx+32] movups xmm7, [edx+48]movups xmm7, [edx+48]...

... mov eax, K...@next2: pop ecx pop edi pop esi push esi push edi push ecx

@next: xorps xmm3, xmm3xorps xmm3, xmm3 movups xmm0, [esi]movups xmm0, [esi] movaps xmm2, xmm0movaps xmm2, xmm0...



T0,3 T0,2 T0,1 T0,0XMM4

T1,3 T1,2 T1,1 T1,0XMM5

T2,3 T2,2 T2,1 T2,0XMM6

T3,3 T3,2 T3,1 T3,0XMM7

0 0 0 0XMM3

A3 A2 A1 A0XMM0

A3 A2 A1 A0XMM2



... shufps xmm0, xmm0, $00shufps xmm0, xmm0, $00 mulps xmm0, xmm4mulps xmm0, xmm4 addps xmm3, xmm0addps xmm3, xmm0

movaps xmm1, xmm2movaps xmm1, xmm2 shufps xmm1, xmm1, $55shufps xmm1, xmm1, $55 mulps xmm1, xmm5mulps xmm1, xmm5 addps xmm3, xmm1addps xmm3, xmm1

movaps xmm0, xmm2movaps xmm0, xmm2 shufps xmm0, xmm0, $AAshufps xmm0, xmm0, $AA mulps xmm0, xmm6mulps xmm0, xmm6 addps xmm3, xmm0addps xmm3, xmm0...

... shufps xmm2, xmm2, $FFshufps xmm2, xmm2, $FF mulps xmm2, xmm7mulps xmm2, xmm7 addps xmm3, xmm2addps xmm3, xmm2

movups [edi], xmm3movups [edi], xmm3

add edi, 16 add esi, 16 loop @next sub eax, 1 jnz @next2 ...end;



A3 A2 A1 AA00XMM0

A0T0,3 A0T0,2 A0T0,1 A0T0,0XMM0

AA00 AA00 AA00 AA00XMM0

A0T0,3 A0T0,2 A0T0,1 A0T0,0XMM3

shufps xmm0,xmm0,$00 00.00.00.00

mulps xmm0,xmm4

addps xmm3,xmm0

T0,3 T0,2 T0,1 T0,0XMM4



A3 A2 AA11 A0XMM1

A1T1,3 A1T1,2 A1T1,1 A1T1,0XMM1


A1T1,3+A0T0,3 A1T1,2+A0T0,2 A1T1,1+A0T0,1 A1T1,0+A0T0,0XMM3

shufps xmm1,xmm1,$55 01.01.01.01

mulps xmm1,xmm5

addps xmm3,xmm1

T1,3 T1,2 T1,1 T1,0XMM5



AA33 A2 A1 A0XMM2

A3T3,3 A3T3,2 A3T3,1 A3T3,0XMM2


A3T3,3+... A3T3,2+... A3T3,1+... A3T3,0+...XMM3

shufps xmm2,xmm2,$FF 11.11.11.11

mulps xmm2,xmm7

addps xmm3,xmm2

T3,3 T3,2 T3,1 T3,0XMM7



...DEMO...


40SSE – Shift utasítások

bal-shiftPSLLW, PSLLD, PSLLQ, PSLLDQ

jobb-shiftPSRLW, PSRLD, PSRLQ, PSRLDQ

aritmetikai shiftPSRAW, PSRAD


41SSE – Logikai utasítások

egész értékek eseténPAND, PANDN, POR, PXOR

lebegőpontos értékek eseténANDPS, ANDPD, ANDNPS, ANDNPDORPS, ORPD, XORPS, XORPD

NINCS különbség az egész és lebegőpontos változatok végrehajtása között


42SSE/Int – Összehasonlító utasítások

összehasonlítás és maszk generálásaPCMPEQB, PCMPEQW, PCMPEQDPCMPGTB, PCMPGTW, PCMPGTD

minimum-maximum kiválasztásPMINUB, PMAXUBPMINSW, PMAXSW


43SSE/Float – Összehasonlító utasítások 1

összehasonlítás és maszk generálása CMPPS, CMPPD, CMPSS, CMPSD

skaláris összehasonlítás és EFLAGS jelzőbittek beállítása (ZF, PF, CF) COMISS, COMISD UCOMISS, UCOMISD

• csak SNaN-ok esetén generálnak kivételt, QNaN esetén nem minimum-maximum kiválasztása

MINPS, MAXPS, MINPD, MAXPD MINSS, MAXSS, MINSD, MAXSD


44SSE/Float – Összehasonlító utasítások 2

COMISD

CMPPD


45SSE példa – Összehasonlítás

r0 = a0>b0 ? a0:b0

r1 = a1>b1 ? a1:b1

r2 = a2>b2 ? a2:b2

r3 = a3>b3 ? a3:b3

r4 = a4>b4 ? a4:b4

r5 = a5>b5 ? a5:b5

r6 = a6>b6 ? a6:b6

r7 = a7>b7 ? a7:b7

MOVQ xmm3, xmm0

; a > b ? 0xffff : 0

PCMPGTW xmm3, xmm2

; a > b ? a : 0

PAND xmm0, xmm3

; a > b ? 0 : b

PANDN xmm3, xmm1

; r = a > b ? a: b

POR xmm0, xmm3


46

SSE/Int – Kitömörítő, betömörítő és adatátrendező utasítások 1

kitömörítés és felváltva elhelyezés PUNPCKHBW, PUNPCKLBW PUNPCKHWD, PUNPCKLWD PUNPCKHDQ, PUNPCKLDQ PUNPCKHQDQ, PUNPCKLQDQ

betömörítés és korlátozás PACKSSDW, PACKSSWB PACKUSWB

adatok keverése (shuffle) PSHUFHW, PSHUFLW, PSHUFD

adatok beszúrása / kimásolása PINSRW, PEXTRW


47

SSE/Int – Kitömörítő, betömörítő és adatátrendező utasítások 2

PINSRW

PSHUFD

PSHUFHW


48

SSE/Float – Kitömörítő és adatátrendező utasítások 1

kitömörítés és felváltva elhelyezésUNPCKHPS, UNPCKHPDUNPCKLPS, UNPCKLPD

adatok keveréseSHUFPS – 2-2 tetszőleges operandust helyez

el a két forrás regiszterből a cél regiszterbeSHUFPD – 1-1 tetszőleges operandust helyez

el a két forrás regiszterből a cél regiszterbe


49

SSE/Float – Kitömörítő és adatátrendező utasítások 2

UNPCKLPS

SHUFPS


50SSE példa – Kitömörítés-betömörítés 1

__m128 a, b, c, d;

a.m128_u64[1] = 0x7777666655554444;a.m128_u64[0] = 0x3333222211110000;

__asm{ pxor xmm0, xmm0 movdqu xmm2, a movdqu xmm3, xmm2

a 7777.6666.5555.4444.3333.2222.1111.0000

b 0000.7777.0000.6666.0000.5555.0000.4444 c 0000.3333.0000.2222.0000.1111.0000.0000

d 7777.6666.5555.4444.3333.2222.1111.0000

punpckhwd xmm3, xmm0

punpcklwd xmm2, xmm0

movdqu b, xmm3

movdqu c, xmm2

packssdw xmm2, xmm3

movdqu d, xmm2}


51SSE példa – Kitömörítés-betömörítés 2

...DEMO...


52SSE/Int – Konverziós utasítások

XMM egészből – lebegőpontosba CVTDQ2PS CVTDQ2PD

MMX egészből – lebegőpontosba CVTPI2PS CVTPI2PD

GPR egészből – lebegőpontosba CVTSI2SS CVTSI2SD


53SSE/Float – Konverziós utasítások 1

lebegőpontosból – lebegőpontosba CVTPS2PD CVTPD2PS CVTSS2SD CVTSD2SS

lebegőpontosból – XMM egészbe CVTPS2DQ CVTPD2DQ CVTTPS2DQ CVTTPD2DQ


54SSE/Float – Konverziós utasítások 2

lebegőpontosból – MMX egészbe CVTPS2PI CVTPD2PI CVTTPS2PI CVTTPD2PI

lebegőpontosból – GPR egészbe CVTSS2SI CVTSD2SI CVTTSS2SI CVTTSD2SI


55SSE példa – Hangerősség 1

a hangadatok (minták) 16 bites, előjeles egészek sztereo hang esetén egymás után váltakozva helyezkednek el a két

csatorna 16 bites mintái (együtt 32 bit egy BAL,JOBB páros) BALk,JOBBk,BALk+1,JOBBk+1,BALk+2,JOBBk+2,...

minta (sample) értékek 0 – hangtalan -32768, +32767 – maximális hangerő

hangosítás = a minták szorzása konstanssal x 2 – kétszeres hangerő x 0.5 – fél hangerő a végső érzékelt hangerő nem úgyanúgy módosul; az embeli fül számára

logaritmikus skálán kell módosítani a hangerőt (DB)

ebben a prezentációban a példát NEM fogom részletesen kielemezni az ASM szintű optimizációról szolló prezentáció keretében kerül sor rá



// get volume factor 0 – 1024fact := tckAmplify.Position; for i := start to stop dobegin // amplify left channel temp := Wave.Buffer[2*i]; temp := (temp*fact) div 512; if (temp < -32768) then Wave.Buffer[2*i] := -32768 else if (temp > +32767) then Wave.Buffer[2*i] := +32767 else Wave.Buffer[2*i] := temp;...

... // amplify right channel temp := Wave.Buffer[2*i+1]; temp := (temp*fact) div 512; if (temp < -32768) then Wave.Buffer[2*i+1] := -32768 else if (temp > +32767) then Wave.Buffer[2*i+1] := +32767 else Wave.Buffer[2*i+1] := temp;end;

x0 – x2 hangerő skála → 0 – 1024 0 – x0 hangerő 512 – x1 hangerő 1024 – x2 hangerő



asm // setup indexing mov edx, paddr mov eax, start // eax = i // setup zero XMM register pxor xmm0, xmm0 // setup factor XMM register movd xmm1, factor pshufd xmm1, xmm1, $00 // load source wave samples@again: // process 2x16 bit samples(L/R) movdqu xmm2, [edx + eax*4] movdqu xmm3, xmm2 // unpack samples to 32 bit punpcklwd xmm2, xmm0 punpckhwd xmm3, xmm0 ...

... // multiply samples by 0 – 1024 // (and add with zero) pmaddwd xmm2, xmm1 pmaddwd xmm3, xmm1 // divide samples by 512 psrad xmm2, 9 psrad xmm3, 9 // pack samples to 16 bit with // signed saturation packssdw xmm2, xmm3 // store destination samples movdqu [edx + eax*4], xmm2 // loop to next samples // 4 x (2x16) bit each step add eax, 4 cmp eax, stop jb @againend;



...DEMO...


59

Köszönöm a figyelmet!

sse assembly programozás

Documents