1 / 33

MMX assembly programozás

MMX assembly programozás. 6. előadás dr. Robu Judit szeminárium drd. Lukács Sándor. 2006. Bevezető. 1996-ban jelent meg az Intel Pentium MMX MMX = Multi Media eXtensions elsősorban gyorsabb audio és video adat-feldolgozást tett lehetővé → MP3, MPEG video

cili
Download Presentation

MMX assembly programozás

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. MMX assembly programozás 6 előadás dr. Robu Judit szeminárium drd. Lukács Sándor 2006

  2. Bevezető • 1996-ban jelent meg az Intel Pentium MMX • MMX = Multi Media eXtensions • elsősorban gyorsabb audio és video adat-feldolgozást tett lehetővé → MP3, MPEG video • más területeken is könnyen használható • pl. adattömörítés, képfeldolgozás • egész számokkal (integer) végez műveleteket • tipikusan x3 – x4-es sebesség növekedés érhető el BBTE, Alkalmazások és operációs rendszerek optimizálása

  3. MMX végrehajtási modell • SIMD modell – Single Instruction Multiple Data • a legtöbb mai PC és Workstation kategóriájú processzor ezt a modellt (is) támogatja BBTE, Alkalmazások és operációs rendszerek optimizálása

  4. SIMD 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) BBTE, Alkalmazások és operációs rendszerek optimizálása

  5. SIMD 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 BBTE, Alkalmazások és operációs rendszerek optimizálása

  6. MMX végrehajtási környezet • az általános regiszterekkel végezzük a memória címzését • egyes MMX utasítások esetén az általános regiszterek oprandusként is jelen vannak • az MMX regiszterek az x87-es regiszter területet használják • vagy MMX, vagy x87-es FPU BBTE, Alkalmazások és operációs rendszerek optimizálása

  7. MMX regiszterszett BBTE, Alkalmazások és operációs rendszerek optimizálása

  8. MMX adattípusok • három új, hardveresen támogatott adattípus • 64 bitre tömörített bájt egészek • 64 bitre tömörített szó egészek • 64 bitre tömörített duplaszó egészek • mindenik típus lehet előjeles és előjel nélküli • új utasítások az MMX regiszterekkel és memóriában lévő operandusokkal végzedő műveletek számára • a legtöbb utasításmmreg1,mmreg2/mem64 formájú BBTE, Alkalmazások és operációs rendszerek optimizálása

  9. Túlcsordulás vezérlés • túlcsordulásos (wraparound) • mint a processzor általános regisztereivel végzett aritmetikai műveletek esetén • előjeles korlátozás (signed saturation) • előjel nélküli korlátozás (unsigned saturation) • egy esetleges túlcsordulás NINCS jelezve sem kivétellel, sem EFLAGS-ben beállított bitekkel BBTE, Alkalmazások és operációs rendszerek optimizálása

  10. MMX utasítások – Bevezető • a legtöbb utasítás külön-külön jelen van mind a három adattípus és két-három túlcsordulás vezérlés számára • az útasítások nevében suffixekkel van jelölve a kiválasztott adattípus és túlcsordulás • –, S, US – túlcsordulás suffixek • B, W, D – adattípus suffixek • a legtöbb útasítás a P prefixel kezdődik BBTE, Alkalmazások és operációs rendszerek optimizálása

  11. MMX – Inicializálás, EMMS • amikor bármely MMX utasítást végrehajtjuk automatikusan inicializálódik az MMX állapot (átvált FPU x87-ről MMX-re) • x87-es FPU Tag 00-ra állítódik (VALID) • a TOS (Top Of Stack) mindig 000-ra vált • EMMS – törli az MMX adatállapotot • a x87-es FPU Tag 11-re állítódik (EMPTY) • mindig kötelezően meg kell hívni, mielőtt átváltanánk MMX-ről x87-es FPU-ra BBTE, Alkalmazások és operációs rendszerek optimizálása

  12. MMX – Adatátiveli utasítások • MOVD – skaláris 32 bites adatmozgatás • reg/m32, mmx0-31 • mmx0-31, reg/m32 ←a felső 32 bit lenullázódik • használható általános regiszterekkel • MOVQ – vektoriális 64 bites adatmozgatás • mmx/m64, mmx • mmx, mmx/m64 • NEM használható általános regiszterekkel BBTE, Alkalmazások és operációs rendszerek optimizálása

  13. MMX – Aritmetikai utasítások 1 • összeadás • PADDB, PADDW, PADDD • PADDSB, PADDSW • PADDUSB, PASSUSW • kívonás • PSUBB, PSUBW, PSUBD • PSUBSB, PSUBSW • PSUBUSB, PSUBUSW BBTE, Alkalmazások és operációs rendszerek optimizálása

  14. Z3[15-0] Z3[31-16] X3 Y3 Z3=X3*Y3 Z2=X2*Y2 Z2[15-0] Y2 Z2[31-16] X2 Z1[15-0] Z1[31-16] Z1=X1*Y1 Y1 X1 Z0[31-16] Y0 Z0=X0*Y0 X0 Z0[15-0] MMX – Aritmetikai utasítások 2 • szorzás – PMULLW, PMULHW • szorzás-összeadás – PMADDWD SRC DEST TEMP PMULLW - DEST PMULHW - DEST PMADDWD - DEST Z3 + Z2 Z1 + Z0 BBTE, Alkalmazások és operációs rendszerek optimizálása

  15. var StartTime, StopTime: Int64; function RDTSC: Int64; assembler; asm rdtsc // TIME STAMP COUNTER end; 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 TWordVector = array [0..N-1] of Word; var a1, b1, c1: TWordVector; a2, b2, c2: TWordVector; i: Integer; ... MMX példa – Vektor szorzás 1 BBTE, Alkalmazások és operációs rendszerek optimizálása

  16. function CpuMulVector(var a, b, c: TWordVector; 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, CPU-val történő szorzás ... for i := 0 to N-1 do begin a1[i] := Random(256); b1[i] := Random(256); a2[i] := a1[i]; b2[i] := b1[i]; end; cpu := CpuMulVector(a1, b1, c1, N); mmx := MmxMulVector(a2, b2, c2, N); writeln('cpu = ', cpu, ' ticks'); writeln('mmx = ', mmx, ' ticks'); writeln(' x = ', cpu/mmx:5:3); ... MMX példa – Vektor szorzás 2 BBTE, Alkalmazások és operációs rendszerek optimizálása

  17. function MmxMulVector(var a, b, c: TWordVector; 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: movq mm0, [edi] movq mm1, [esi] pmullw mm0, mm1 movq [edx], mm0 add edi, 8 add esi, 8 add edx, 8 sub ecx, 1 jnz @next sub eax, 1 jnz @next2 ... emms end; MMX példa – Vektor szorzás 3 BBTE, Alkalmazások és operációs rendszerek optimizálása

  18. MMX példa – Vektor szorzás 4 ...DEMO... BBTE, Alkalmazások és operációs rendszerek optimizálása

  19. MMX – Logikai utasítások • bitenként hajtódnak végre 64 biten • PAND – DEST ← DEST AND SRC • PANDN – DEST ← (NOT DEST) AND SRC • POR – DEST ← DEST OR SRC • PXOR – DEST ← DEST XOR SRC BBTE, Alkalmazások és operációs rendszerek optimizálása

  20. MMX – Összehasonlító utasítások 1 • egyenlőség vizsgálata • PCMPEQB, PCMPEQW, PCMPEQD • nagyobb-mint vizsgálata • PCMPGTPB, PCMPGTPW, PCMPGTPD • műveletdestmmx,mmx/m64 • bájtonkénti, szavankénti, dupla-szavankénti összehasonlítás • ha a cél regiszter > forrás operandus (illetve ha egyenlő) akkor a cél regiszter megfelelő bájtja / szava / dupla-szava 0xFF / 0xFFFF / 0xFFFFFFFF lessz, különben 0 • a műveletek előjeles összehasonlítást végeznek • NEM módosítják az EFLAGS jelzőbitjeit • a logikai utasításokkal együtt jól használhatók feltételes adatmozgatásokra BBTE, Alkalmazások és operációs rendszerek optimizálása

  21. pl. csak a 10-nél nagyobb bájtokat őrizzük meg, a többit nullázzuk egy 64 bites operandusból 0x0105090B0AFF4433 0x0A0A0A0A0A0A0A0A 0x0000000B00004433 __int64 a, b, limit; a = 0x0105090B0AFF4433; limit = 0x0A0A0A0A0A0A0A0A; b = 0xFFFFFFFFFFFFFFFF; __asm { movq mm0, a movq mm1, mm0 pcmpgtb mm1, limit pand mm0, mm1 movq b, mm0 emms } printf("0x%016I64X\n", a); printf("0x%016I64X\n", limit); printf("0x%016I64X\n", b); MMX – Összehasonlító utasítások 2 BBTE, Alkalmazások és operációs rendszerek optimizálása

  22. D2 C2 B2 A2 MMX – Betömörítő utasítások • PACKSSWB – 2 x 4 x 16 bit → 1 x 8 x 8 bit • PACKSSDW – 2 x 2 x 32 bit → 1 x 4 x 16 bit • túlcsordulás esetén maximális / minimális előjeles értékek kerülnek a célregiszterbe (pl. 0x7FFF) • PACKUSWB – 2 x 4 x 16 bit → 1 x 8 x 8 bit • mint a PACKSSWB, csak előjel nélküli tömörítés SRC D1 C1 DEST B1 A1 DEST PACKSSDW DEST,SRC BBTE, Alkalmazások és operációs rendszerek optimizálása

  23. MMX – Kitömörítő utasítások 1 • rangosabb fél kitömörítése • PUNPCKHBW – 2 x 4 x 8 bit → 1 x 8 x 8 bit • PUNPCKHWD – 2 x 2 x 16 bit → 1 x 4 x 16 bit • PUNPCKHDQ – 2 x 1 x 32 bit → 1 x 2 x 32 bit • kevésbé rangos fél kitömörítése • PUNPCKLBW, PUNPCKLWD, PUNPCKLDQ • a kitömörítés során a cél regiszterbe felváltva kerül egy-egy elem a két forrásoperandusból BBTE, Alkalmazások és operációs rendszerek optimizálása

  24. D1 D1 D2 D2 C1 C2 B2 C1 B1 A1 C2 A2 MMX – Kitömörítő utasítások 2 • PUNPCKLWD – 2 x 2 x 16 bit → 1 x 4 x 16 bit • PUNPCKHWD – 2 x 2 x 16 bit → 1 x 4 x 16 bit PUNPCKLWDDEST,SRC DEST B1 B2 A1 A2 SRC DEST DEST PUNPCKHWDDEST,SRC BBTE, Alkalmazások és operációs rendszerek optimizálása

  25. MMX – Shift utasítások • logikai eltolás balra • PSLLW, PSLLD, PSLLQ mmx,imm8 • logikai eltolás jobbra • PSRLW, PSRLD, PSRLQ mmx,imm8 • aritmetikai eltolás jobbra • PSRAW, PSRAD mmx,imm8 • előjeles kiegészítés !!! BBTE, Alkalmazások és operációs rendszerek optimizálása

  26. SSE utasítás-szett bővítések MMX-es egész műveletek számára 1 • MASKMOVQmmx1,mmx2 – feltételes másolás a memóriába • DS:[EDI]← mmx1 azon bájtjai, amelyek esetén az mmx2-ben lévő megfelelő bájt legrangosabb bit 1 • PAVGB, PAVGW mmx1,mmx2 – átlagszámítás előjel nélkül • mmx1 ← (mmx1 + mmx2 + 1) >> 1bájtonként / szavanként • PEXTRW r32,mmx,imm8 – szó kimásolása általános regiszterbe • PINSRW mmx,r32,imm8 – szó bemásolása általános regiszterből • PMAXSW, PMINSW – maximum / minimum előjelesen, szavanként • PMAXUB, PMINUB – maximum / minimum előjel nélkül, bájtonként • PMOVMSKB r32,mmx – előjelbitmaszk készítése • minden bájt legrangosabb bitjét egymás után r32-nak a legkevésbé rangos bájtába helyezi el BBTE, Alkalmazások és operációs rendszerek optimizálása

  27. SSE utasítás-szett bővítések MMX-es egész műveletek számára 2 • PMULHUW – mint PMULHW, csak előjel nélküli szorzás • PSHUFW xmm1,xmm2/m64,imm8 – szavankénti keverés • imm8 két-két bitje határozza meg, hogy melyik szó kerül az xmm1 megfelelő poziciójára xmm2/m64-ből • pl. pshufw mm0,mm1,0x1B ← tükörkép (00.01.10.11) • PREFETCHNTA, PREFETCHT0, PREFETCHT1, PREFETCHT2, MOVNTQ, SFENCE • PSADBW BBTE, Alkalmazások és operációs rendszerek optimizálása

  28. MMX példa – Képek fényessége 1 • RGB, 32 bit / pixel BITMAP képek • az adatok felosztása ideális tömörített bájtok feldolgozására • fényerő módosítása • + r,g,b → fényesebb kép • – r,g,b → sötétebb kép BBTE, Alkalmazások és operációs rendszerek optimizálása

  29. type TRGB32Vector = array[0..0] of packed record b,g,r,null:Byte; end; PRGB32Vector = ^TRGB32Vector; function IncBright(Image): Int64; var i, j: Integer; line: PRGB32Vector; begin ... Start; for j := 0 to Height-1 do begin line := Bitmap.ScanLine[j]; for i := 0 to Width-1 do ... begin if line[i].r < 250 then line[i].r := line[i].r + 5 else line[i].r := 255; if line[i].g < 250 then line[i].g := line[i].g + 5 else line[i].g := 255; if line[i].b < 250 then line[i].b := line[i].b + 5 else line[i].b := 255; end; end; Result := Stop; ... end; MMX példa – Képek fényessége 2 BBTE, Alkalmazások és operációs rendszerek optimizálása

  30. asm mov edx, line mov eax, 0 mov ecx, width movq mm0, delta @next: movq mm1, [edx + 4*eax] paddusb mm1, mm0 movq [edx + 4*eax], mm1 inc eax loop @next end; asm mov eax, line mov ecx, width shr ecx, 2 movq mm0, delta // 0x00050505 @next: movq mm1, [eax] movq mm2, [eax + 4] movq mm3, [eax + 8] movq mm4, [eax + 12] paddusb mm1, mm0 paddusb mm2, mm0 paddusb mm3, mm0 paddusb mm4, mm0 movq [eax], mm1 movq [eax + 4], mm2 movq [eax + 8], mm3 movq [eax + 12], mm4 add eax, 16 loop @next end; MMX példa – Képek fényessége 3, hibás BBTE, Alkalmazások és operációs rendszerek optimizálása

  31. asm mov edx, line mov eax, 0 mov ecx, width shr ecx, 1 movq mm0, delta @next: movq mm1, [edx + 8*eax] paddusb mm1, mm0 movq [edx + 8*eax], mm1 inc eax loop @next end; delta=$0005050500050505; asm mov eax, line mov ecx, width shr ecx, 3 movq mm0, delta @next: movq mm1, [eax] movq mm2, [eax + 8] movq mm3, [eax + 16] movq mm4, [eax + 24] paddusb mm1, mm0 paddusb mm2, mm0 paddusb mm3, mm0 paddusb mm4, mm0 movq [eax], mm1 movq [eax + 8], mm2 movq [eax + 16], mm3 movq [eax + 24], mm4 add eax, 32 loop @next end; MMX példa – Képek fényessége 3 BBTE, Alkalmazások és operációs rendszerek optimizálása

  32. MMX példa – Képek fényessége 4 ...DEMO... BBTE, Alkalmazások és operációs rendszerek optimizálása

  33. Köszönöm a figyelmet! BBTE, Alkalmazások és operációs rendszerek optimizálása

More Related