Rozšíření instrukční sady SSE2 v programech psaných v assembleru (dokončení)

Obsah

1. Rozšíření instrukční sady SSE2 (dokončení)

2. Přečtení příznaku záporné hodnoty pro všechny bajty ve 128bitovém vektoru

3. První demonstrační příklad – výsledky instrukce PMOVMSKB

4. Extrakce a proložení prvků o šířce 64bitů ze 128bitových vektorů

5. Druhý demonstrační příklad – výsledky instrukce UNPCKHPD

6. Třetí demonstrační příklad – výsledky instrukce UNPCKLPD

7. Extrakce a proložení jednotlivých bajtů ze 128bitových vektorů

8. Čtvrtý demonstrační příklad – výsledky instrukce PUNPCKHBW

9. Pátý demonstrační příklad – výsledky instrukce PUNPCKLBW

10. Komplikovanější proložení prvků vektorů instrukcí PSHUFD

11. Šestý demonstrační příklad – výsledky instrukce PSHUFD pro různé konstanty

12. Okomentované výsledky šestého příkladu

13. Praktické použití instrukcí popsaných v předchozích kapitolách

14. Přičtení konstanty ke všem bajtům ve 128bitovém vektoru

15. Rozšíření předchozího příkladu na dvojici 128bitových vektorů

16. Skalární součin osmibitových hodnot uložených ve dvojici 128bitových vektorů

17. Přepis do assembleru

18. Závěr

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Rozšíření instrukční sady SSE2 (dokončení)

Na předchozí dvojici článků o rozšíření instrukční sady SSE2 [1] [2] dnes navážeme. Popíšeme si některé zbývající instrukce, které je možné v SSE2 nalézt. Ty již většinou neslouží k provádění „klasických“ vektorových operací typu „součet odpovídajících si prvků dvou vektorů“ nebo „porovnání odpovídajících si prvků dvou vektorů“; jedná se naopak o operace pro prokládání prvků, extrakci či naopak spojování prvků vektorů atd. Možnosti instrukční sady SSE2 jsou sice v tomto ohledu poněkud neefektivní (vyřešeno až v AVX-512), ovšem tyto instrukce jsou často používány, zejména pro operace typu scan nebo reduce (součet všech prvků vektorů, nalezení maximálního prvku, provedení skalárního součinu atd.).

2. Přečtení příznaku záporné hodnoty pro všechny bajty ve 128bitovém vektoru

První instrukce, kterou se dnes budeme zabývat, vlastně nepatří ani do jedné z kategorií zmíněných v úvodním odstavci. Tato instrukce se jmenuje PMOVMSKB a akceptuje dva operandy – 128bitový vektor XMM a standardní pracovní registr CPU (například EAX atd.). PMOVMSKB z každého bajtu 128bitového vektoru získá informaci o znaménku a tu uloží na příslušné místo do pracovního registru. Vzhledem k tomu, že do 128bitového vektoru je možné uložit šestnáct bajtů, budou informace o znaménku (1=záporná hodnota, 0=kladná hodnota) uloženy v nejnižších šestnácti bitech zvoleného pracovního registru.

Některé instrukce v sadě SSE2 (ale nikoli všechny) existují ve více variantách, které se od sebe liší typem prvků vektorů (bajt, slovo, dvouslovo, čtyřslovo). Instrukce PMOVMSKB ovšem žádnou další variantu nemá a ani to vlastně není zapotřebí. Pokud se totiž zpracovává například vektor s prvky typu slovo, postačuje z výsledku přečíst sudé příznaky znaménka a ty liché ignorovat. Totéž platí i pro další typy prvků (a to včetně hodnot float a double).

3. První demonstrační příklad – výsledky instrukce PMOVMSKB

V dnešním prvním demonstračním příkladu jsou ukázány výsledky vypočtené instrukcí PMOVMSKB popsané v předchozí kapitole. Vektor bajtů, u nichž se bude zjišťovat jejich znaménko, obsahuje hodnoty 0×00, 0×10 až 0×f0, tj. polovina hodnot je kladná a polovina záporná (resp. je lze interpretovat jako záporné hodnoty). Výsledkem bude šestnáct příznakových bitů, které jsou uloženy do registru EAX, jehož obsah je následně vypsán na standardní výstup:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message

align 16
sse_val_1 db 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
  
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm0, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        pmovmskb eax, xmm0           ; ziskani priznaku znamenka pro vsechny bajty ve vektoru
 
        print_hex eax, 13            ; tisk registru eax, v jehoz spodnich 16 bitech jsou priznaky
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Podívejme se na vypsané hodnoty:

F0E0D0C0 B0A09080 70605040 30201000
0000FF00

Ty lze interpretovat takto:

bajt:    F0 E0 D0 C0 B0 A0 90 80 70 60 50 40 30 20 10 00
znaménko: 1  1  1  1  1  1  1  1  0  0  0  0  0  0  0  0

Z výsledků je patrné, že příznak zápornosti je skutečně nastaven korektně.

4. Extrakce a proložení prvků o šířce 64bitů ze 128bitových vektorů

Další dvě instrukce, které si dnes popíšeme a taktéž otestujeme, se jmenují UNPCKHPD a UNPCKLPD. Pravidelní čtenáři tohoto seriálu již pravděpodobně rozpoznávají způsob rozklíčování jmen těchto instrukcí: UNPCK znamená unpack, H znamená high values (tedy horní prvky vektorů), L pochopitelně znamená low, P znamená packed (vektorová operace, nikoli skalární) a konečně D je označení datového typu prvků, tedy v tomto případě double. Ze jména instrukcí lze tedy odvodit, že jsou určeny pro přečtení horního nebo dolního prvku typu double z vektoru, který obsahuje dvě takové hodnoty. A vzhledem k tomu, že se jedná o vektorovou operaci, je přečtení horního/dolního prvku provedeno na dvojici vstupních vektorů, přičemž výsledkem bude nová 128bitová hodnota.

5. Druhý demonstrační příklad – výsledky instrukce UNPCKHPD

V dnešním druhém demonstračním příkladu si ukážeme, jakým způsobem se prokládají 64bitové prvky dvou vektorů do jediného 128bitového vektoru. Přitom je použita instrukce UNPCKHPD a vektory budou mít obsah:

vektor1:  0x1111111111111111  0x2222222222222222
vektor2:  0x3333333333333333  0x4444444444444444

Zdrojový kód tohoto demonstračního příkladu vypadá následovně:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 16
sse_val_1 dq 0x1111111111111111, 0x2222222222222222
sse_val_2 dq 0x3333333333333333, 0x4444444444444444
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm0, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2           ; adresa druheho vektoru
        movdqu xmm1, [ebx]           ; nacteni puvodniho vektoru do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM0
 
        unpckhpd xmm0, xmm1          ; ziskani hornich polovin z obou vektoru
 
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Podívejme se nyní na výsledky, které získáme po spuštění příkladu. Popis jednotlivých řádků byl dodán ručně (zbytečně by komplikoval zdrojový kód):

vektor 1: 2222222222222222 1111111111111111
vektor 2: 4444444444444444 3333333333333333
výsledek: 4444444444444444 2222222222222222
význam:   vektor2          vektor1
          (vyšší prvek)    (vyšší prvek)

6. Třetí demonstrační příklad – výsledky instrukce UNPCKLPD

Třetí příklad, který si dnes ukážeme, je prakticky totožný s příkladem předchozím, ovšem namísto instrukce UNPCKHPD je zde použita instrukce UNPCKLPD. Záměna znaku H za L značí, že do výsledného vektoru budou uloženy nižší (low) prvky typu double a nikoli vyšší (high) prvky. To si snadno ověříme:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 16
sse_val_1 dq 0x1111111111111111, 0x2222222222222222
sse_val_2 dq 0x3333333333333333, 0x4444444444444444
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm0, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2           ; adresa druheho vektoru
        movdqu xmm1, [ebx]           ; nacteni puvodniho vektoru do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM0
 
        unpcklpd xmm0, xmm1          ; ziskani dolnich polovin z obou vektoru
 
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Opět se podívejme na výsledky:

vektor 1: 22222222 22222222 11111111 11111111
vektor 2: 44444444 44444444 33333333 33333333
výsledek: 33333333 33333333 11111111 11111111
význam:   vektor2          vektor1
          (nižší prvek)    (nižší prvek)

7. Extrakce a proložení jednotlivých bajtů ze 128bitových vektorů

V předchozím textu jsme se věnovali popisu a testování instrukcí nazvaných UNPCKHPD a UNPCKLPD, které pracují s vektory obsahující dvojice hodnot typu double. Instrukční sada SSE2 sice není plně ortogonální, ale obsahuje podobné instrukce pracující s vektory s odlišným typem a tím pádem i počtem prvků (vlastně kromě typu float – tyto instrukce totiž byly obsaženy již v původní sadě SSE). Pro extrakci a proložení prvků, které jsou typu bajt (a je jich tedy ve vektorech uloženo vždy šestnáct) slouží instrukce nazvané PUNPCKHBW a PUNPCKLBW.

To může vypadat zvláštně, protože bychom čekali, že jméno bude stejné, jako v případě UNPCKHPD/UNPCKLPD, pouze se bude lišit poslední znak (B-byte namísto D-double). Není tomu tak z historických důvodů, protože instrukce PUNPCKHBW/PUNPCKLBW původně pochází z instrukční sady MMX a pro účely SSE2 byly rozšířeny registry, s nimiž se pracuje, na dvojnásobnou šířku (svět architektury x86 je ostatně plný podobných překvapení a historických důvodů).

8. Čtvrtý demonstrační příklad – výsledky instrukce PUNPCKHBW

Vyzkoušejme si nejdříve chování instrukce PUNPCKHBW. Její název dokážeme do značné míry rozklíčovat – extrakce horních bajtů z dvojice vektorů a uložení těchto bajtů do vektoru cílového. Přičemž je otázkou, co považovat za horní bajty (napoví poslední znak W nebo spíš zmate čtenáře?). To ovšem jasně ukážou výsledky:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message

align 16
sse_val_1 db 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, 0x81, 0x91, 0xa1, 0xb1, 0xc1, 0xd1, 0xe1, 0xf1
sse_val_2 db 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, 0x82, 0x92, 0xa2, 0xb2, 0xc2, 0xd2, 0xe2, 0xf2
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm0, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2           ; adresa druheho vektoru
        movdqu xmm1, [ebx]           ; nacteni puvodniho vektoru do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM0
 
        punpckhbw xmm0, xmm1         ; provedeni operace prolozeni hodnot z obou vektoru po bajtech
 
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Výsledky vypsané tímto příkladem jsou přeformátovány a doplněny o komentáře:

vektor 1: F1 E1 D1 C1 B1 A1 91 81 71 61 51 41 31 21 11 01
vektor 2: F2 E2 D2 C2 B2 A2 92 82 72 62 52 42 32 22 12 02
výsledek: F2 F1 E2 E1 D2 D1 C2 C1 B2 B1 A2 A1 92 91 82 81

Do výsledného vektoru byly uloženy jen vyšší poloviny z obou vstupních vektorů (tedy high) a navíc byly proloženy. Tj. nejnižší bajt výsledného vektoru obsahuje devátý bajt z vektoru prvního, dále devátý bajt z vektoru druhého atd.

9. Pátý demonstrační příklad – výsledky instrukce PUNPCKLBW

Vzhledem k tomu, že jsme si právě ukázali výsledky činnosti instrukce PUNPCKHBW, je zřejmé, že si ukážeme i výsledky instrukce pojmenované PUNPCKLBW. Opět platí, že záměna znaku H za znak L naznačuje, že se do výsledného vektoru budou ukládat nižší prvky obou vstupních vektorů. To si snadno ověříme:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 16
sse_val_1 db 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, 0x81, 0x91, 0xa1, 0xb1, 0xc1, 0xd1, 0xe1, 0xf1
sse_val_2 db 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, 0x82, 0x92, 0xa2, 0xb2, 0xc2, 0xd2, 0xe2, 0xf2
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm0, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2           ; adresa druheho vektoru
        movdqu xmm1, [ebx]           ; nacteni puvodniho vektoru do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM0
 
        punpcklbw xmm0, xmm1         ; provedeni operace prolozeni hodnot z obou vektoru po bajtech
 
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Podívejme se na okomentované výsledky získané tímto příkladem:

vektor 1: F1 E1 D1 C1 B1 A1 91 81 71 61 51 41 31 21 11 01
vektor 2: F2 E2 D2 C2 B2 A2 92 82 72 62 52 42 32 22 12 02
výsledek: 72 71 62 61 52 51 42 41 32 31 22 21 12 11 02 01

Z výsledného vektoru je patrné, že se skutečně proložily jen spodní prvky obou vstupních vektorů – z každého vektoru se přečetlo osm nižších prvků a ty byly proloženy do výsledku.

10. Komplikovanější proložení prvků vektorů instrukcí PSHUFD

Jednou z nejkomplikovanějších instrukcí v sadě SSE2 je instrukce pojmenovaná PSHUFD, což je zkratka značící shuffle packed doublewords (mimochodem: znak D má někdy význam doubleword a jindy double precision float, protože konzistence je přece v IT tak důležitá). Tato instrukce pracuje pouze s jedním zdrojovým vektorem a vybírá z něho prvky na základě bitového pole, které je druhým operandem této instrukce. V tomto bitovém poli je uloženo osm bitů rozdělených do čtyř skupin. Z toho vyplývá, že každá skupina má dva bity a tedy obsahuje hodnoty 0–3.

Prvky vstupního vektoru si můžeme označit takto: X=[x3, x2, x1, x0]. A hodnoty v osmibitové konstantě rozdělené do čtyř skupin si můžeme označit: s3, s2, s1 a s0 (každá hodnota je v rozsahu 0–3). Výsledný vektor bude obsahovat tyto hodnoty:

[X[s3], X[s2], X[s1], X[s0]]

Tedy například pokud bude s3=0, s2=3, s1=1, s0=1, dostaneme:

[X[0], X[3], X[1], X[1]] = [x0, x3, x1, x1]

Vidíme, že tato instrukce dokáže zdvojit/ztrojit prvky, zpřeházet je, otočit jejich pořadí atd. Jediným omezením je, že ono bitové pole s hodnotami s3, s2, s1 a s0 je v instrukčním slovu uloženo formou konstanty (a nejde tedy jednoduše modifikovat).

11. Šestý demonstrační příklad – výsledky instrukce PSHUFD pro různé konstanty

V pořadí již šestém demonstračním příkladu si ukážeme výsledky získané instrukcí PSHUFD v případě, že druhým operandem této instrukce je konstanta od 0 do 15. Musí se skutečně jednat o konstantu, takže nebylo možné použít počítanou programovou smyčku (kód je v současnosti uložen v neměnitelných sekcích, takže ho nelze snadno modifikovat za běhu). Vstupem je vždy stejný vektor s obsahem:

0x11111111, 0x22222222, 0x33333333, 0x44444444

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 16
sse_val_1 dd 0x11111111, 0x22222222, 0x33333333, 0x44444444
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm0, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 0         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 1         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 2         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 3         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 4         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 5         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 6         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 7         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 8         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 9         ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 10        ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 11        ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 12        ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 13        ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 14        ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        pshufd xmm1, xmm0, 15        ; prolozeni obsahu dvou vektoru
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

12. Okomentované výsledky šestého příkladu

Podívejme se nyní na výsledky vypsané dnešním šestým demonstračním příkladem, které byly navíc okomentovány:

původní vektor:          44444444 33333333 22222222 11111111
 
s3=0, s2=0, s1=0, s0=0:  11111111 11111111 11111111 11111111  nejvyšší tři prvky = nultý prvek původního vektoru
s3=0, s2=0, s1=0, s0=1:  11111111 11111111 11111111 22222222  nejnižší prvek = vybíraný různě podle indexu 0-3
s3=0, s2=0, s1=0, s0=2:  11111111 11111111 11111111 33333333
s3=0, s2=0, s1=0, s0=3:  11111111 11111111 11111111 44444444
 
s3=0, s2=0, s1=1, s0=0:  11111111 11111111 22222222 11111111  nejvyšší dva prvky = nultý prvek původního vektoru
s3=0, s2=0, s1=1, s0=1:  11111111 11111111 22222222 22222222  druhý nejnižší prvek = první prvek původního vektoru
s3=0, s2=0, s1=1, s0=2:  11111111 11111111 22222222 33333333  nejnižší prvek = vybíraný různě podle indexu 0-3
s3=0, s2=0, s1=1, s0=3:  11111111 11111111 22222222 44444444
 
s3=0, s2=0, s1=2, s0=0:  11111111 11111111 33333333 11111111  nejvyšší dva prvky = nultý prvek původního vektoru
s3=0, s2=0, s1=2, s0=1:  11111111 11111111 33333333 22222222  druhý nejnižší prvek = druhý prvek původního vektoru
s3=0, s2=0, s1=2, s0=2:  11111111 11111111 33333333 33333333  nejnižší prvek = vybíraný různě podle indexu 0-3
s3=0, s2=0, s1=2, s0=3:  11111111 11111111 33333333 44444444
 
s3=0, s2=0, s1=3, s0=0:  11111111 11111111 44444444 11111111  nejvyšší dva prvky = nultý prvek původního vektoru
s3=0, s2=0, s1=3, s0=1:  11111111 11111111 44444444 22222222  druhý nejnižší prvek = nejvyšší prvek původního vektoru
s3=0, s2=0, s1=3, s0=2:  11111111 11111111 44444444 33333333  nejnižší prvek = vybíraný různě podle indexu 0-3
s3=0, s2=0, s1=3, s0=3:  11111111 11111111 44444444 44444444

13. Praktické použití instrukcí popsaných v předchozích kapitolách

Instrukce, s nimiž jsme se dnes seznámili, slouží pro různé manipulace a kombinace prvků vektorů. Mohlo by se zdát, že tyto instrukce jsou používány spíše výjimečně, ovšem v SSE2 nemáme k dispozici instrukce, které by dokázaly provést broadcasting. To je označení používané například v knihovně Numpy, kde značí operaci mezi skalární hodnotou a vektorem – operace je provedena postupně se všemi prvky vektoru, které jsou nějakým způsobem zkombinovány se skalární hodnotou. A taktéž v instrukční sadě SSE2 nenalezneme instrukce typu scan či reduce, tedy postupnou aplikaci nějaké operace na všechny prvky vektoru (příkladem je součet všech prvků vektoru nebo asi známější skalární součin). Právě v těchto oblastech si musíme vystačit s instrukcemi, které jsme si až doposud popsali – což nemusí být vždy triviální.

14. Přičtení konstanty ke všem bajtům ve 128bitovém vektoru

Výběr instrukcí, které jsme si popsali v předchozích kapitolách, není náhodný, protože tři z nich, konkrétně PUNPCKHBW, PUNPCKLBW a PSHUFD jsou použity v dalším příkladu, který provede přičtení konstanty ke všem bajtům 128bitového vektoru. Samotné přičtení je pochopitelně realizováno „vektorově“ instrukcí PADDB, ovšem nejdříve musíme nějakým způsobem ze skalární konstanty zkonstruovat vektor obsahující tu samou opakující se hodnotu:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 16
sse_val_1 db 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa vektoru
        movdqu xmm1, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        mov esi, 1                   ; konstanta, kterou budeme pricitat
        movd xmm0, esi               ; nacteni konstanty do druheho vektoru
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        punpcklbw xmm0, xmm0         ; prolozeni hodnot, zdrojem je jediny registr
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        punpcklwd xmm0, xmm0         ; prolozeni hodnot, zdrojem je jediny registr
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        pshufd xmm0, xmm0, 0         ; rozkopirovani spodnich osmi bajtu do celeho vektoru
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        paddb xmm0, xmm1             ; vektorovy soucet
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Prováděná operace je zřejmá z vypsaných vstupních dat, mezivýsledků a výsledků:

vstupní vektor:           0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00
přičítaná konstanta:      00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01
první proložení hodnot:   00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 01
druhé proložení hodnot:   00 00 00 00 00 00 00 00 00 00 00 00 01 01 01 01
rozkopírování dvojslova:  01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
výsledek:                 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01

15. Rozšíření předchozího příkladu na dvojici 128bitových vektorů

V předchozím příkladu bylo nutné použít trojici vektorových instrukcí PUNPCKHBW, PUNPCKLBW a PSHUFD jen pro to, aby se ze skalární konstanty stal vektor totožných prvků. To se může zdát jako poměrně mnoho práce s relativně malým užitkem. Výhodou ovšem je, že ve chvíli, kdy již máme připraven vektor s totožnými prvky, je možné ho využít pro přičtení konstant k delším polím. Například rozšíření přičtení konstanty ze šestnácti prvků na 32 prvků spočívá v přidání pouze jediné vektorové instrukce PADD, takže se „přípravná práce“ lépe amortizuje:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 16
sse_val_1 db 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
sse_val_2 db 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm1, [ebx]           ; nacteni puvodniho vektoru do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        mov ebx, sse_val_2           ; adresa druheho vektoru
        movdqu xmm2, [ebx]           ; nacteni puvodniho vektoru do registru XMM0
        print_sse_reg_as_hex xmm2    ; tisk hodnoty registru XMM2
 
        mov esi, 1                   ; konstanta, kterou budeme pricitat
        movd xmm0, esi               ; nacteni konstanty do druheho vektoru
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        punpcklbw xmm0, xmm0         ; prolozeni hodnot, zdrojem je jediny registr
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        punpcklwd xmm0, xmm0         ; prolozeni hodnot, zdrojem je jediny registr
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        pshufd xmm0, xmm0, 0         ; rozkopirovani spodnich osmi bajtu do celeho vektoru
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        paddb xmm1, xmm0             ; vektorovy soucet
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM0
 
        paddb xmm2, xmm0             ; vektorovy soucet
        print_sse_reg_as_hex xmm2    ; tisk hodnoty registru XMM0
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Opět si ukážeme okomentované výsledky:

první vstupní vektor:        0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00
druhý vstupní vektor:        1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10
přičítaná konstanta:         00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01
první proložení hodnot:      00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 01
druhé proložení hodnot:      00 00 00 00 00 00 00 00 00 00 00 00 01 01 01 01
rozkopírování dvojslova:     01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
přičtení k prvnímu vektoru:  10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01
přičtení ke druhému vektoru: 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11

16. Skalární součin osmibitových hodnot uložených ve dvojici 128bitových vektorů

Na závěr si vyzkoušíme, jakým způsobem by se mohl realizovat algoritmus skalárního součinu osmibitových hodnot uložených ve dvojici 128bitových vektorů (tedy každý vektor má v tomto případě šestnáct prvků). Nejedná se o náhodně vybraný algoritmus, protože výpočet skalárního součinu nalezneme v AI, velkých jazykových modelech, algoritmech počítačové grafiky, zpracování signálu atd.

V jazyku C by mohl být tento výpočet realizován takto:

unsigned char dot_product_16bytes(unsigned char *a, unsigned char *b) {
    #define SIZE 16
    int i;
    unsigned char result = 0;
    for (i=0; i<SIZE; i++) {
        result += a[i] * b[i];
    }
    return result;
}

17. Přepis do assembleru

Zadání problému bylo napsáno takovým způsobem, aby nebylo možné jednoduše nahradit operaci násobení za jedinou instrukci. Je tomu tak z toho důvodu, že neexistuje vektorová instrukce pro vynásobení vektorů bajtů. Proto je řešení relativně složité a k výsledku vede celá řada kroků, včetně logických operací a bitových posunů (tedy vlastně celá SSE2). Tyto operace jsou popsány v komentářích, ovšem ještě lepší je porovnání těchto komentářů s mezivýsledky, což si ukážeme pod zdrojovým kódem:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 16
sse_val_1 db 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
sse_val_2 db 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1           ; adresa prvniho vektoru
        movdqu xmm2, [ebx]           ; nacteni puvodniho vektoru do registru XMM2
        print_sse_reg_as_hex xmm2    ; tisk hodnoty registru XMM2
 
        mov ebx, sse_val_2           ; adresa druheho vektoru
        movdqu xmm1, [ebx]           ; nacteni puvodniho vektoru do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        movdqa    xmm3, xmm2         ; kopie prvniho vektoru
        movdqa    xmm0, xmm1         ; kopie druheho vektor
        punpcklbw xmm3, xmm2         ; provedeni operace prolozeni hodnot z obou vektoru po bajtech
        punpcklbw xmm0, xmm1
        punpckhbw xmm2, xmm2         ; dtto
        punpckhbw xmm1, xmm1
 
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
        print_sse_reg_as_hex xmm2    ; tisk hodnoty registru XMM2
        print_sse_reg_as_hex xmm3    ; tisk hodnoty registru XMM3
 
        pmullw  xmm0, xmm3           ; součiny odpovídajících si prvku
        pmullw  xmm1, xmm2
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        mov     eax, 0x00ff00ff      ; 32bitová maska sudých bajtů
        movd    xmm2, eax
        print_sse_reg_as_hex xmm2    ; tisk hodnoty registru XMM2
        pshufd  xmm2, xmm2, 0        ; rozkopírování masky do všech dvouslov vektoru
        print_sse_reg_as_hex xmm2    ; tisk hodnoty registru XMM2
 
        pand    xmm0, xmm2           ; vymaskování sudých bajtů
        pand    xmm1, xmm2           ; vymaskování sudých bajtů
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        packuswb xmm0, xmm1          ; proložení prvků vektorů
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        movdqa  xmm1, xmm0
        psrldq  xmm1, 8              ; bitový posun doleva
        paddb   xmm0, xmm1
        pxor    xmm1, xmm1           ; toto je taktéž proložení
        psadbw  xmm0, xmm1           ; součet
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        movd    eax, xmm0            ; výsledná hodnota do registru EAX
        print_hex eax, "*"
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

100F0E0D 0C0B0A09 08070605 04030201  ; první vstupní vektor
01020304 05060708 090A0B0C 0D0E0F10  ; druhý vstupní vektor
 
09090A0A 0B0B0C0C 0D0D0E0E 0F0F1010  ; registr XMM0 po proložení prvků vstupních vektorů
01010202 03030404 05050606 07070808  ; registr XMM1 po proložení prvků vstupních vektorů
10100F0F 0E0E0D0D 0C0C0B0B 0A0A0909  ; registr XMM2 po proložení prvků vstupních vektorů
08080707 06060505 04040303 02020101  ; registr XMM3 po proložení prvků vstupních vektorů
 
90488C46 8442783C 6834542A 3C1E2010  ; 16bitové součiny odpovídajících si prvků XMM0 a XMM3
20103C1E 542A6834 783C8442 8C469048  ; 16bitové součiny odpovídajících si prvků XMM1 a XMM2
 
00000000 00000000 00000000 00FF00FF  ; 32bitová maska sudých bajtů
00FF00FF 00FF00FF 00FF00FF 00FF00FF  ; rozkopírování masky do všech dvouslov vektoru
 
00480046 0042003C 0034002A 001E0010  ; vymaskování sudých bajtů výsledků součinů
0010001E 002A0034 003C0042 00460048  ; vymaskování sudých bajtů výsledků součinů
 
101E2A34 3C424648 4846423C 342A1E10  ; proložení prvků
00000000 00000198 00000000 00000330  ; součet slov se saturací
00000330*                            ; výsledná hodnota vypsaná v hexadecimálním tvaru

Ověřme si výsledek ručním výpočtem:

1*16 + 2*15 + 3*14 + 4*13 + 5*12 + 6*11 + 7*10 + 8*9 + 9*8 + 10*7 + 11*6 + 12*5 + 13*4 + 14*3 + 15*2 + 16*1 = 816

A skutečně: 0×330 = 816 decimálně.

18. Závěr

Instrukční sada SSE2 nepochybně znamenala dosti velký pokrok v oblasti vektorových (SIMD) instrukcí pro platformu x86. S jejím využitím bylo (a je) možné zpracovávat vektory s různými typy prvků, na rozdíl od SSE zaměřené pouze na typ float. Taktéž je důležité, že SSE2 již není v případě 64bitové platformy x86–64 volitelným rozšířením, ale naopak povinnou součástí instrukční sady (navíc s dvojnásobným počtem pracovních registrů). To znamená, že na 64bitových systémech není nutné dodávat kód s rozhodnutím, zda SSE2 použít či nikoli. Ovšem SSE2 mělo i několik nedostatků. Ty se týkaly mj. malých (nebo spíš neohrabaných) možností extrakce dat z vektorů a jejich prokládání. Taktéž by se hodilo využívat vektory delší než 128 bitů – to plyne z toho, že počet tranzistorů na CPU neustále rostl a bylo je tak možné využívat nějakým rozumným způsobem.

Řešením (i když částečným a dočasným) se stalo rozšíření instrukční sady nazvané „Advanced Vector Extension“ neboli zkráceně pouze AVX. Oproti již popsaným rozšířením MMX či SSE a SSE2 se jedná o výrazné vylepšení podpory SIMD operací, které se mj. projevilo prodloužením vektorů a zcela novými instrukcemi, takže slovo „advanced“ je zde do jisté míry namístě. Původní technologie AVX byla představena v roce 2008, přičemž první mikroprocesory vybavené tímto rozšířením začaly být ve větších sériích prodávány v roce 2011 (na jejich adaptaci jsme tedy měli zhruba patnáct let). Jedná se tedy o (z pohledu vývojáře) relativně dobře zavedenou technologii, která je v samotném hardware dnes již široce podporována a lze ji bez větších problémů začít využívat. A právě touto technologií se budeme zabývat v navazujícím článku.

19. Repositář s demonstračními příklady

Demonstrační příklady napsané v assembleru, které jsou určené pro překlad s využitím assembleru NASM, byly uloženy do Git repositáře, který je dostupný na adrese https://github.com/tisnik/8bit-fame. Jednotlivé demonstrační příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý (dnes již poměrně rozsáhlý) repositář:

20. Odkazy na Internetu

1. The Intel 8088 Architecture and Instruction Set
   https://people.ece.ubc.ca/~ed­c/464/lectures/lec4.pdf
2. x86 Opcode Structure and Instruction Overview
   https://pnx.tf/files/x86_op­code_structure_and_instruc­tion_overview.pdf
3. x86 instruction listings (Wikipedia)
   https://en.wikipedia.org/wi­ki/X86_instruction_listin­gs
4. x86 assembly language (Wikipedia)
   https://en.wikipedia.org/wi­ki/X86_assembly_language
5. Intel Assembler (Cheat sheet)
   http://www.jegerlehner.ch/in­tel/IntelCodeTable.pdf
6. 25 Microchips That Shook the World
   https://spectrum.ieee.org/tech-history/silicon-revolution/25-microchips-that-shook-the-world
7. Chip Hall of Fame: MOS Technology 6502 Microprocessor
   https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-mos-technology-6502-microprocessor
8. Chip Hall of Fame: Intel 8088 Microprocessor
   https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-intel-8088-microprocessor
9. Jak se zrodil procesor?
   https://www.root.cz/clanky/jak-se-zrodil-procesor/
10. Apple II History Home
    http://apple2history.org/
11. The 8086/8088 Primer
    https://www.stevemorse.or­g/8086/index.html
12. flat assembler: Assembly language resources
    https://flatassembler.net/
13. FASM na Wikipedii
    https://en.wikipedia.org/wiki/FASM
14. Fresh IDE FASM inside
    https://fresh.flatassembler.net/
15. MS-DOS Version 4.0 Programmer's Reference
    https://www.pcjs.org/docu­ments/books/mspl13/msdos/dos­ref40/
16. DOS API (Wikipedia)
    https://en.wikipedia.org/wiki/DOS_API
17. Bit banging
    https://en.wikipedia.org/wi­ki/Bit_banging
18. IBM Basic assembly language and successors (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Basic_assembly_lan­guage_and_successors
19. X86 Assembly/Bootloaders
    https://en.wikibooks.org/wi­ki/X86_Assembly/Bootloaders
20. Počátky grafiky na PC: grafické karty CGA a Hercules
    https://www.root.cz/clanky/pocatky-grafiky-na-pc-graficke-karty-cga-a-hercules/
21. Co mají společného Commodore PET/4000, BBC Micro, Amstrad CPC i grafické karty MDA, CGA a Hercules?
    https://www.root.cz/clanky/co-maji-spolecneho-commodore-pet-4000-bbc-micro-amstrad-cpc-i-graficke-karty-mda-cga-a-hercules/
22. Karta EGA: první použitelná barevná grafika na PC
    https://www.root.cz/clanky/karta-ega-prvni-pouzitelna-barevna-grafika-na-pc/
23. RGB Classic Games
    https://www.classicdosgames.com/
24. Turbo Assembler (Wikipedia)
    https://en.wikipedia.org/wi­ki/Turbo_Assembler
25. Microsoft Macro Assembler
    https://en.wikipedia.org/wi­ki/Microsoft_Macro_Assembler
26. IBM Personal Computer (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Personal_Computer
27. Intel 8251
    https://en.wikipedia.org/wi­ki/Intel_8251
28. Intel 8253
    https://en.wikipedia.org/wi­ki/Intel_8253
29. Intel 8255
    https://en.wikipedia.org/wi­ki/Intel_8255
30. Intel 8257
    https://en.wikipedia.org/wi­ki/Intel_8257
31. Intel 8259
    https://en.wikipedia.org/wi­ki/Intel_8259
32. Support/peripheral/other chips – 6800 family
    http://www.cpu-world.com/Support/6800.html
33. Motorola 6845
    http://en.wikipedia.org/wi­ki/Motorola_6845
34. The 6845 Cathode Ray Tube Controller (CRTC)
    http://www.tinyvga.com/6845
35. CRTC operation
    http://www.6502.org/users/an­dre/hwinfo/crtc/crtc.html
36. The 6845 Cathode Ray Tube Controller (CRTC)
    http://www.tinyvga.com/6845
37. Motorola 6845 and bitwise graphics
    https://retrocomputing.stac­kexchange.com/questions/10996/mo­torola-6845-and-bitwise-graphics
38. IBM Monochrome Display Adapter
    http://en.wikipedia.org/wi­ki/Monochrome_Display_Adap­ter
39. Color Graphics Adapter
    http://en.wikipedia.org/wi­ki/Color_Graphics_Adapter
40. Color Graphics Adapter and the Brown color in IBM 5153 Color Display
    https://www.aceinnova.com/en/e­lectronics/cga-and-the-brown-color-in-ibm-5153-color-display/
41. The Modern Retrocomputer: An Arduino Driven 6845 CRT Controller
    https://hackaday.com/2017/05/14/the-modern-retrocomputer-an-arduino-driven-6845-crt-controller/
42. flat assembler: Assembly language resources
    https://flatassembler.net/
43. FASM na Wikipedii
    https://en.wikipedia.org/wiki/FASM
44. Fresh IDE FASM inside
    https://fresh.flatassembler.net/
45. MS-DOS Version 4.0 Programmer's Reference
    https://www.pcjs.org/docu­ments/books/mspl13/msdos/dos­ref40/
46. DOS API (Wikipedia)
    https://en.wikipedia.org/wiki/DOS_API
47. IBM Basic assembly language and successors (Wikipedia)
    https://en.wikipedia.org/wi­ki/IBM_Basic_assembly_lan­guage_and_successors
48. X86 Assembly/Arithmetic
    https://en.wikibooks.org/wi­ki/X86_Assembly/Arithmetic
49. Art of Assembly – Arithmetic Instructions
    http://oopweb.com/Assembly/Do­cuments/ArtOfAssembly/Volu­me/Chapter₆/CH06–2.html
50. ASM Flags
    http://www.cavestory.org/gu­ides/csasm/guide/asm_flag­s.html
51. Status Register
    https://en.wikipedia.org/wi­ki/Status_register
52. Linux assemblers: A comparison of GAS and NASM
    http://www.ibm.com/develo­perworks/library/l-gas-nasm/index.html
53. Programovani v assembleru na OS Linux
    http://www.cs.vsb.cz/gryga­rek/asm/asmlinux.html
54. Is it worthwhile to learn x86 assembly language today?
    https://www.quora.com/Is-it-worthwhile-to-learn-x86-assembly-language-today?share=1
55. Why Learn Assembly Language?
    http://www.codeproject.com/Ar­ticles/89460/Why-Learn-Assembly-Language
56. Is Assembly still relevant?
    http://programmers.stackex­change.com/questions/95836/is-assembly-still-relevant
57. Why Learning Assembly Language Is Still a Good Idea
    http://www.onlamp.com/pub/a/on­lamp/2004/05/06/writegreat­code.html
58. Assembly language today
    http://beust.com/weblog/2004/06/23/as­sembly-language-today/
59. Assembler: Význam assembleru dnes
    http://www.builder.cz/rubri­ky/assembler/vyznam-assembleru-dnes-155960cz
60. Programming from the Ground Up Book – Summary
    http://savannah.nongnu.or­g/projects/pgubook/
61. DOSBox
    https://www.dosbox.com/
62. The C Programming Language
    https://en.wikipedia.org/wi­ki/The_C_Programming_Langu­age
63. Hercules Graphics Card (HCG)
    https://en.wikipedia.org/wi­ki/Hercules_Graphics_Card
64. Complete 8086 instruction set
    https://content.ctcd.edu/cou­rses/cosc2325/m22/docs/emu8086in­s.pdf
65. Complete 8086 instruction set
    https://yassinebridi.github.io/asm-docs/8086_instruction_set.html
66. 8088 MPH by Hornet + CRTC + DESiRE (final version)
    https://www.youtube.com/wat­ch?v=hNRO7lno_DM
67. Area 5150 by CRTC & Hornet (Party Version) / IBM PC+CGA Demo, Hardware Capture
    https://www.youtube.com/wat­ch?v=fWDxdoRTZPc
68. 80×86 Integer Instruction Set Timings (8088 – Pentium)
    http://aturing.umcs.maine­.edu/~meadow/courses/cos335/80×86-Integer-Instruction-Set-Clocks.pdf
69. Colour Graphics Adapter: Notes
    https://www.seasip.info/Vin­tagePC/cga.html
70. Restoring A Vintage CGA Card With Homebrew HASL
    https://hackaday.com/2024/06/12/res­toring-a-vintage-cga-card-with-homebrew-hasl/
71. Demoing An 8088
    https://hackaday.com/2015/04/10/de­moing-an-8088/
72. Video Memory Layouts
    http://www.techhelpmanual.com/89-video_memory_layouts.html
73. Screen Attributes
    http://www.techhelpmanual.com/87-screen_attributes.html
74. IBM PC Family – BIOS Video Modes
    https://www.minuszerodegre­es.net/video/bios_video_mo­des.htm
75. EGA Functions
    https://cosmodoc.org/topics/ega-functions/#the-hierarchy-of-the-ega
76. Why the EGA can only use 16 of its 64 colours in 200-line modes
    https://www.reenigne.org/blog/why-the-ega-can-only-use-16-of-its-64-colours-in-200-line-modes/
77. How 16 colors saved PC gaming – the story of EGA graphics
    https://www.custompc.com/retro-tech/ega-graphics
78. List of 16-bit computer color palettes
    https://en.wikipedia.org/wi­ki/List_of₁₆-bit_computer_color_palettes
79. Why were those colors chosen to be the default palette for 256-color VGA?
    https://retrocomputing.stac­kexchange.com/questions/27994/why-were-those-colors-chosen-to-be-the-default-palette-for-256-color-vga
80. VGA Color Palettes
    https://www.fountainware.com/EX­PL/vga_color_palettes.htm
81. Hardware Level VGA and SVGA Video Programming Information Page
    http://www.osdever.net/Fre­eVGA/vga/vga.htm
82. Hardware Level VGA and SVGA Video Programming Information Page – sequencer
    http://www.osdever.net/Fre­eVGA/vga/seqreg.htm
83. VGA Basics
    http://www.brackeen.com/vga/ba­sics.html
84. Introduction to VGA Mode ‚X‘
    https://web.archive.org/web/20160414072210/htt­p://fly.srk.fer.hr/GDM/ar­ticles/vgamodex/vgamx1.html
85. VGA Mode-X
    https://web.archive.org/web/20070123192523/htt­p://www.gamedev.net/referen­ce/articles/article356.asp
86. Mode-X: 256-Color VGA Magic
    https://downloads.gamedev­.net/pdf/gpbb/gpbb47.pdf
87. Instruction Format in 8086 Microprocessor
    https://www.includehelp.com/embedded-system/instruction-format-in-8086-microprocessor.aspx
88. How to use „AND,“ „OR,“ and „XOR“ modes for VGA Drawing
    https://retrocomputing.stac­kexchange.com/questions/21936/how-to-use-and-or-and-xor-modes-for-vga-drawing
89. VGA Hardware
    https://wiki.osdev.org/VGA_Hardware
90. Programmer's Guide to Yamaha YMF 262/OPL3 FM Music Synthesizer
    https://moddingwiki.shika­di.net/wiki/OPL_chip
91. Does anybody understand how OPL2 percussion mode works?
    https://forum.vcfed.org/in­dex.php?threads/does-anybody-understand-how-opl2-percussion-mode-works.60925/
92. Yamaha YMF262 OPL3 music – MoonDriver for OPL3 DEMO [Oscilloscope View]
    https://www.youtube.com/watch?v=a7I-QmrkAak
93. Yamaha OPL vs OPL2 vs OPL3 comparison
    https://www.youtube.com/wat­ch?v=5knetge5Gs0
94. OPL3 Music Crockett's Theme
    https://www.youtube.com/wat­ch?v=HXS008pkgSQ
95. Bad Apple (Adlib Tracker – OPL3)
    https://www.youtube.com/wat­ch?v=2lEPH6Y3Luo
96. FM Synthesis Chips, Codecs and DACs
    https://www.dosdays.co.uk/to­pics/fm_synthesizers.php
97. The Zen Challenge – YMF262 OPL3 Original (For an upcoming game)
    https://www.youtube.com/wat­ch?v=6JlFIFz1CFY
98. [adlib tracker II techno music – opl3] orbit around alpha andromedae I
    https://www.youtube.com/wat­ch?v=YqxJCu_WFuA
99. [adlib tracker 2 music – opl3 techno] hybridisation process on procyon-ii
    https://www.youtube.com/wat­ch?v=daSV5mN0sJ4
100. Hyper Duel – Black Rain (YMF262 OPL3 Cover)
     https://www.youtube.com/wat­ch?v=pu_mzRRq8Ho
101. IBM 5155–5160 Technical Reference
     https://www.minuszerodegre­es.net/manuals/IBM/IBM_5155_5160_Techni­cal_Reference_6280089_MAR86­.pdf
102. a ymf262/opl3+pc speaker thing i made
     https://www.youtube.com/watch?v=E-Mx0lEmnZ0
103. [OPL3] Like a Thunder
     https://www.youtube.com/wat­ch?v=MHf06AGr8SU
104. (PC SPEAKER) bad apple
     https://www.youtube.com/wat­ch?v=LezmKIIHyUg
105. Powering devices from PC parallel port
     http://www.epanorama.net/cir­cuits/lptpower.html
106. Magic Mushroom (demo pro PC s DOSem)
     http://www.crossfire-designs.de/download/articles/sou­ndcards//mushroom.rar
107. Píseň Magic Mushroom – originál
     http://www.crossfire-designs.de/download/articles/sou­ndcards/speaker_mushroom_con­verted.mp3
108. Píseň Magic Mushroom – hráno na PC Speakeru
     http://www.crossfire-designs.de/download/articles/sou­ndcards/speaker_mushroom_spe­aker.mp3
109. Pulse Width Modulation (PWM) Simulation Example
     http://decibel.ni.com/content/docs/DOC-4599
110. Resistor/Pulse Width Modulation DAC
     http://www.k9spud.com/trax­mod/pwmdac.php
111. Class D Amplifier
     http://en.wikipedia.org/wi­ki/Electronic_amplifier#Clas­s_D
112. Covox Speech Thing / Disney Sound Source (1986)
     http://www.crossfire-designs.de/index.php?lang=en&what=ar­ticles&name=showarticle.htm&ar­ticle=soundcards/&page=5
113. Covox Digital-Analog Converter (Rusky, obsahuje schémata)
     http://phantom.sannata.ru/kon­kurs/netskater002.shtml
114. PC-GPE on the Web
     http://bespin.org/~qz/pc-gpe/
115. Keyboard Synthesizer
     http://www.solarnavigator­.net/music/instruments/ke­yboards.htm
116. FMS – Fully Modular Synthesizer
     http://fmsynth.sourceforge.net/
117. Javasynth
     http://javasynth.sourceforge.net/
118. Software Sound Synthesis & Music Composition Packages
     http://www.linux-sound.org/swss.html
119. Mx44.1 Download Page (software synthesizer for linux)
     http://hem.passagen.se/ja_linux/
120. Software synthesizer
     http://en.wikipedia.org/wi­ki/Software_synthesizer
121. Frequency modulation synthesis
     http://en.wikipedia.org/wi­ki/Frequency_modulation_syn­thesis
122. Yamaha DX7
     http://en.wikipedia.org/wi­ki/Yamaha_DX7
123. Wave of the Future
     http://www.wired.com/wired/ar­chive/2.03/waveguides_pr.html
124. Analog synthesizer
     http://en.wikipedia.org/wi­ki/Analog_synthesizer
125. Minimoog
     http://en.wikipedia.org/wiki/Minimoog
126. Moog synthesizer
     http://en.wikipedia.org/wi­ki/Moog_synthesizer
127. Tutorial for Frequency Modulation Synthesis
     http://www.sfu.ca/~truax/fmtut.html
128. An Introduction To FM
     http://ccrma.stanford.edu/sof­tware/snd/snd/fm.html
129. John Chowning
     http://en.wikipedia.org/wi­ki/John_Chowning
130. I'm Impressed, Adlib Music is AMAZING!
     https://www.youtube.com/wat­ch?v=PJNjQYp1ras
131. Milinda- Diode Milliampere ( OPL3 )
     https://www.youtube.com/wat­ch?v=oNhazT5HG0E
132. Dune 2 – Roland MT-32 Soundtrack
     https://www.youtube.com/wat­ch?v=kQADZeB-z8M
133. Interrupts
     https://wiki.osdev.org/In­terrupts#Types_of_Interrup­ts
134. Assembly8086SoundBlasterDma­SingleCycleMode
     https://github.com/leonardo-ono/Assembly8086SoundBlas­terDmaSingleCycleMode/blob/mas­ter/sbsc.asm
135. Interrupts in 8086 microprocessor
     https://www.geeksforgeeks­.org/interrupts-in-8086-microprocessor/
136. Interrupt Structure of 8086
     https://www.eeeguide.com/interrupt-structure-of-8086/
137. A20 line
     https://en.wikipedia.org/wi­ki/A20_line
138. Extended memory
     https://en.wikipedia.org/wi­ki/Extended_memory#eXtended_Me­mory_Specification_(XMS)
139. Expanded memory
     https://en.wikipedia.org/wi­ki/Expanded_memory
140. Protected mode
     https://en.wikipedia.org/wi­ki/Protected_mode
141. Virtual 8086 mode
     https://en.wikipedia.org/wi­ki/Virtual_8086_mode
142. Unreal mode
     https://en.wikipedia.org/wi­ki/Unreal_mode
143. DOS memory management
     https://en.wikipedia.org/wi­ki/DOS_memory_management
144. Upper memory area
     https://en.wikipedia.org/wi­ki/Upper_memory_area
145. Removing the Mystery from SEGMENT : OFFSET Addressing
     https://thestarman.pcminis­try.com/asm/debug/Segments­.html
146. Segment descriptor
     https://en.wikipedia.org/wi­ki/Segment_descriptor
147. When using a 32-bit register to address memory in the real mode, contents of the register must never exceed 0000FFFFH. Why?
     https://stackoverflow.com/qu­estions/45094696/when-using-a-32-bit-register-to-address-memory-in-the-real-mode-contents-of-the
148. A Brief History of Unreal Mode
     https://www.os2museum.com/wp/a-brief-history-of-unreal-mode/
149. Segment Limits
     https://wiki.osdev.org/Segment_Limits
150. How do 32 bit addresses in real mode work?
     https://forum.osdev.org/vi­ewtopic.php?t=30642
151. The LOADALL Instruction by Robert Collins
     https://www.rcollins.org/ar­ticles/loadall/tspec_a3_doc­.html
152. How do you put a 286 in Protected Mode?
     https://retrocomputing.stac­kexchange.com/questions/7683/how-do-you-put-a-286-in-protected-mode
153. Control register
     https://en.wikipedia.org/wi­ki/Control_register
154. CPU Registers x86
     https://wiki.osdev.org/CPU_Re­gisters_x86
155. x86 Assembly/Protected Mode
     https://en.wikibooks.org/wi­ki/X86_Assembly/Protected_Mo­de
156. MSW: Machine Status Word
     https://web.itu.edu.tr/kes­gin/mul06/intel/intel_msw­.html
157. 80×87 Floating Point Opcodes
     http://www.techhelpmanual.com/876–80×87_floating_point_opcodes.html
158. Page Translation
     https://pdos.csail.mit.edu/6­.828/2005/readings/i386/s05_02­.htm
159. 80386 Paging and Segmenation
     https://stackoverflow.com/qu­estions/38229741/80386-paging-and-segmenation
160. 80386 Memory Management
     https://tldp.org/LDP/khg/Hy­perNews/get/memory/80386mm­.html
161. DOSEMU
     http://www.dosemu.org/
162. Intel 80386, a revolutionary CPU
     https://www.xtof.info/intel80386.html
163. PAI Unit 3 Paging in 80386 Microporcessor
     https://www.slideshare.net/Kan­chanPatil34/pai-unit-3-paging-in-80386-microporcessor
164. 64 Terabytes of virtual memory for 32-bit x86 using segmentation: how?
     https://stackoverflow.com/qu­estions/5444984/64-terabytes-of-virtual-memory-for-32-bit-x86-using-segmentation-how
165. Pi in the Pentium: reverse-engineering the constants in its floating-point unit
     http://www.righto.com/2025/01/pentium-floating-point-ROM.html
166. Simply FPU
     http://www.website.masmfo­rum.com/tutorials/fptute/
167. Art of Assembly language programming: The 80×87 Floating Point Coprocessors
     https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–3.html
168. Art of Assembly language programming: The FPU Instruction Set
     https://courses.engr.illi­nois.edu/ece390/books/arto­fasm/CH14/CH14–4.html
169. INTEL 80387 PROGRAMMER'S REFERENCE MANUAL
     http://www.ragestorm.net/dow­nloads/387intel.txt
170. x86 Instruction Set Reference: FLD
     http://x86.renejeschke.de/html/fi­le_module_x86_id₁₀₀.html
171. x86 Instruction Set Reference: FLD1/FLDL2T/FLDL2E/FLDPI/­FLDLG2/FLDLN2/FLDZ
     http://x86.renejeschke.de/html/fi­le_module_x86_id₁₀₁.html
172. X86 Assembly/Arithmetic
     https://en.wikibooks.org/wi­ki/X86_Assembly/Arithmetic
173. 8087 Numeric Data Processor
     https://www.eeeguide.com/8087-numeric-data-processor/
174. Data Types and Instruction Set of 8087 co-processor
     https://www.eeeguide.com/data-types-and-instruction-set-of-8087-co-processor/
175. 8087 instruction set and examples
     https://studylib.net/doc/5625221/8087-instruction-set-and-examples
176. GCC documentation: Extensions to the C Language Family
     https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html#C-Extensions
177. GCC documentation: Using Vector Instructions through Built-in Functions
     https://gcc.gnu.org/online­docs/gcc/Vector-Extensions.html
178. SSE (Streaming SIMD Extentions)
     http://www.songho.ca/misc/sse/sse­.html
179. Timothy A. Chagnon: SSE and SSE2
     http://www.cs.drexel.edu/~tc365/mpi-wht/sse.pdf
180. Intel corporation: Extending the Worldr's Most Popular Processor Architecture
     http://download.intel.com/techno­logy/architecture/new-instructions-paper.pdf
181. SIMD architectures:
     http://arstechnica.com/ol­d/content/2000/03/simd.ar­s/
182. Tour of the Black Holes of Computing!: Floating Point
     http://www.cs.hmc.edu/~ge­off/classes/hmc.cs105…/sli­des/class02_floats.ppt
183. 3Dnow! Technology Manual
     AMD Inc., 2000
184. Intel MMX^TM Technology Overview
     Intel corporation, 1996
185. MultiMedia eXtensions
     http://softpixel.com/~cwrig­ht/programming/simd/mmx.phpi
186. AMD K5 („K5“ / „5k86“)
     http://www.pcguide.com/ref/cpu/fam/g5K5-c.html
187. Sixth Generation Processors
     http://www.pcguide.com/ref/cpu/fam/g6­.htm
188. Great Microprocessors of the Past and Present
     http://www.cpushack.com/CPU/cpu1.html
189. Very long instruction word (Wikipedia)
     http://en.wikipedia.org/wi­ki/Very_long_instruction_word
190. CPU design (Wikipedia)
     http://en.wikipedia.org/wi­ki/CPU_design
191. Bulldozer (microarchitecture)
     https://en.wikipedia.org/wi­ki/Bulldozer_(microarchitec­ture)
192. MMX (instruction set)
     https://en.wikipedia.org/wi­ki/MMX_(instruction_set)
193. Extended MMX
     https://en.wikipedia.org/wi­ki/Extended_MMX
194. Saturation arithmetic
     https://en.wikipedia.org/wi­ki/Saturation_arithmetic
195. CMPPS — Compare Packed Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/cmpps
196. ADDPS — Add Packed Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/addps
197. SUBPS — Subtract Packed Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/subps
198. SQRTPS — Square Root of Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/sqrtps
199. RSQRTPS — Compute Reciprocals of Square Roots of Packed Single Precision Floating-PointValues
     https://www.felixcloutier­.com/x86/rsqrtps
200. UNPCKHPS — Unpack and Interleave High Packed Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/unpckhps
201. UNPCKLPS — Unpack and Interleave Low Packed Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/unpcklps
202. SHUFPS — Packed Interleave Shuffle of Quadruplets of Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/shufps
203. CVTSI2SS — Convert Doubleword Integer to Scalar Single Precision Floating-Point Value
     https://www.felixcloutier­.com/x86/cvtsi2ss
204. CVTSS2SI — Convert Scalar Single Precision Floating-Point Value to Doubleword Integer
     https://www.felixcloutier­.com/x86/cvtss2si
205. CVTTSS2SI — Convert With Truncation Scalar Single Precision Floating-Point Value to Integer
     https://www.felixcloutier­.com/x86/cvttss2si
206. CVTPI2PS — Convert Packed Dword Integers to Packed Single Precision Floating-Point Values
     https://www.felixcloutier­.com/x86/cvtpi2ps
207. CVTPS2PI — Convert Packed Single Precision Floating-Point Values to Packed Dword Integers
     https://www.felixcloutier­.com/x86/cvtps2pi
208. CVTTPS2PI — Convert With Truncation Packed Single Precision Floating-Point Values to PackedDword Integers
     https://www.felixcloutier­.com/x86/cvttps2pi
209. Streaming SIMD Extensions 2 (SSE2)
     https://softpixel.com/~cwrig­ht/programming/simd/sse2.php
210. Redundant SSE instructions
     https://www.pagetable.com/?p=19