Od instrukční sady SSE k sadě SSE2

Obsah

1. Od instrukční sady SSE k sadě SSE2

2. Nové datové typy podporované instrukční sadou SSE2

3. Nové instrukce přidané v rámci rozšíření instrukční sady SSE2

4. Seznam všech aritmetických instrukcí SSE2

5. Logické instrukce – rozšíření možností zavedených v rámci MMX

6. Instrukce pro konverzi dat

7. Instrukce pro porovnání skalárních hodnot nebo vektorů

8. Instrukce pro načítání či ukládání skalárů a vektorů

9. Prokládání dat, shuffling atd.

10. Řízení cache

11. Praktická část

12. Detekce podpory instrukcí SSE2

13. Součty vektorů s různými počty a typy prvků

14. Součet dvojice vektorů 16×8 bitů

15. Součet dvojice vektorů 8×16 bitů

16. Součet bezznaménkových bajtů se saturací

17. Součet bajtů se znaménkem se saturací

18. Obsah navazujícího článku

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

20. Odkazy na Internetu

1. Od instrukční sady SSE k sadě SSE2

Poměrně záhy po uvedení instrukční sady SSE se mnozí vývojáři začali vcelku logicky ptát, z jakého důvodu se vlastně většina nově přidaných instrukcí omezuje pouze na práci s numerickými hodnotami s jednoduchou přesností (single), když je mnoho aplikací založených na celočíselných datech (osmibitových bajtech, šestnáctibitových slovech, 32bitových slovech atd.), které by tak mohly využívat všech možností nabízených novými 128bitovými registry technologie SSE. Vývojáři pracující především na vývoji algoritmů z oblasti numerické matematiky by naopak uvítali práci s numerickými hodnotami s dvojitou přesností (double) uloženými v 64 bitech (tj. v případě 128bitových registrů by bylo možné do těchto registrů ukládat dvojice čísel s dvojitou přesností – i to by mohlo představovat poměrně významné zvýšení výpočetního výkonu).

Odpovědí na oba v podstatě protichůdné požadavky byla instrukční sada pojmenovaná jednoduše SSE2, která pochází z roku 2001 (je dobré si uvědomit, že SIMD jsou s námi na platformě x86 již dlouho). Tato instrukční sada byla zpočátku použita v mikroprocesorech Intel Pentium 4 a Intel Xeon, později se však rozšířila i na mikroprocesory firmy AMD (Athlon64, Opteron), což umožnilo její širokou adaptaci.

Technologie SSE2 vývojářům přinesla nové instrukce a samozřejmě i podstatné změny v interní struktuře vektorové výpočetní jednotky, ovšem počet registrů ani jejich bitová šířka se (alespoň prozatím) nijak nezměnila. Programátoři používající, ať již přímo či nepřímo, rozšíření instrukční sady SSE2, mohli do osmice 128bitových registrů pojmenovaných XMM0 až XMM7 ukládat celkem šest různých typů vektorů, resp. přesněji řečeno pracovat s vektory, jejichž prvky jsou šesti různých typů (formátů). Základ zůstal nezměněn – jednalo se o čtyřprvkové vektory obsahující čísla reprezentovaná ve formátu plovoucí řádové čárky, přičemž každé číslo bylo uloženo v 32 bitech (4×32=128 bitů), což odpovídá typu single/float definovanému v normě IEEE 754.

2. Nové datové typy podporované instrukční sadou SSE2

Kromě výše uvedeného typu vektoru 4×single byly v rámci SSE2 ještě zavedeny dvouprvkové vektory obsahující taktéž hodnoty reprezentované ve formátu plovoucí řádové čárky, ovšem tentokrát se jednalo o čísla uložená v 64 bitech (2×64=128) odpovídající dvojité přesnosti (double) z normy IEEE 754 (a to včetně volby zaokrouhlovacích režimů atd.).

Zbývají nám ovšem ještě čtyři další podporované datové typy. V těchto případech se jedná o vektory s celočíselnými prvky: šestnáctiprvkové vektory s osmibitovými hodnotami (zpracování obrazů), osmiprvkové vektory s šestnáctibitovými hodnotami (zpracování zvukových vzorků), čtyřprvkové vektory s 32bitovými hodnotami a konečně dvouprvkové vektory s 64bitovými celočíselnými hodnotami.

Obrázek 1: Nové typy vektorů, s kterými je nově možné nativně pracovat na mikroprocesorech podporujících technologii SSE2.

Instrukce SSE2 je možné využít i v některých oblastech numerické matematiky, i když je na tomto místě nutné říct, že přímo v SSE2 nejsou podporována čísla s rozšířenou přesností (extended), takže v některých případech může dojít při výpočtech v jednotce SSE2 (a nikoli FPU) ke kumulaci chyb ve výsledku. Nicméně kombinace instrukcí určených pro matematický koprocesor s instrukcemi určenými pro funkční jednotku SSE2 byla možná a v mnoha případech dokonce nutná, protože matematický koprocesor kromě základních aritmetických operací podporuje například i výpočet goniometrických funkcí, logaritmů atd.

3. Nové instrukce přidané v rámci rozšíření instrukční sady SSE2

Zatímco se v rozšiřující instrukční sadě SSE popsané v předchozích třech článcích nachází „pouze“ 70 nových instrukcí, byli tvůrci instrukční sady SSE2 mnohem velkorysejší, protože navrhli a posléze i implementovali hned 144 nových instrukcí, což mimochodem přibližně odpovídá počtu všech základních instrukcí procesorů x86 (pokud samozřejmě nepočítáme všechny povolené adresní režimy a další instrukce, které byly na tuto architekturu postupně „nabaleny“). Tento velký počet nových instrukcí souvisí jak s jíž zmíněnou podporou šesti nových datových typů popsaných v předchozí kapitole (včetně více než dvaceti zcela nových konverzních funkcí), tak i s novými režimy přístupu k prvkům uloženým ve vektorech a se zcela novými operacemi, které byly navrženy pro podporu algoritmů pro 3D grafiku a taktéž pro práci s videem.

Všechny instrukce, které byly přidány v rozšiřující instrukční sadě SSE2, je možné rozdělit do několika kategorií:

1. Aritmetické operace prováděné s celými čísly (včetně součtu a rozdílu se saturací)
2. Aritmetické operace prováděné s čísly s plovoucí řádovou čárkou (single, double)
3. Logické operace (některé jsou prováděny pro všech 128 bitů)
4. Bitové posuny prvků o různé bitové šířce
5. Porovnávací (komparační, relační) operace
6. Konverzní funkce
7. Konverze prvků uložených ve vektorech (zvýšení či snížení bitové šířky, shuffling apod.)
8. Načítání a ukládání dat do operační paměti
9. Řízení vyrovnávací paměti (cache)

O těchto instrukcích se zmíníme v navazující kapitole.

Obrázek 2: Ukázka urychlení operace součtu 1024 číselných prvků reprezentovaných ve formátu s plovoucí řádovou čárkou. Celkem byly použity čtyři algoritmy pro součet:
1 – využití instrukcí FPU
2 – využití instrukcí FPU s rozbalením smyčky
3 – využití vektorových operací SSE/SSE2
4 – využití vektorových operací SSE/SSE2 s rozbalením smyčky

4. Seznam všech aritmetických instrukcí SSE2

Podobně jako u již dříve popsaných rozšiřujících instrukčních sad MMX, 3DNow! a SSE se SIMD instrukcemi, tvoří i u instrukční sady SSE2 nejpodstatnější část nové instrukce určené pro provádění aritmetických operací nad vektory prvků různých datových typů. Všechny nové operace implementované v rámci SSE2 jsou vypsány v následující tabulce. Ve třetím sloupci je naznačeno, jaké vektory jsou danou operací zpracovávány, přičemž první číslo znamená počet prvků vektoru, za nímž následuje bitová šířka jednotlivých prvků:

Obrázek 3: Ukázka urychlení operace výpočtu skalárního součinu pro 1024 trojrozměrných vektorů. Prvky vektorů jsou opět reprezentovány ve formátu s plovoucí řádovou čárkou. Celkem byly použity čtyři algoritmy pro součet:
1 – využití instrukcí FPU
2 – využití instrukcí FPU s rozbalením smyčky
3 – využití vektorových operací SSE/SSE2
4 – využití vektorových operací SSE/SSE2 s rozbalením smyčky
Důvod, proč ze došlo k většímu urychlení při použití SSE/SSE2 je jednoduchý: s jednou načtenými daty (vektory) se provádělo větší množství operací, takže se zde v menší míře projevila latence operačních pamětí a další externí vlivy. Sice je možné najít i algoritmy, u nichž je dosaženo ještě většího urychlení výpočtů, ale v praxi je zhruba trojnásobné urychlení (podobně jako na tomto grafu) považováno za poměrně velký úspěch.

5. Logické instrukce – rozšíření možností zavedených v rámci MMX

V instrukční sadě SSE2 můžeme kromě aritmetických instrukcí najít i nové logické instrukce a taktéž instrukce určené pro provádění logických či aritmetických posunů. Ve skutečnosti se vlastně jedná o pouhé rozšíření stávajících instrukcí MMX takovým způsobem, aby bylo možné pracovat s novými 128bitovými vektory, popř. s daty uloženými v operační paměti v bloku šestnácti bajtů (16×8=128 bitů). Nejprve si popišme instrukce pro aritmetické a logické posuny. Ty dokážou pracovat s celočíselnými hodnotami o velikosti 16, 32, 64 či 128 bitů, tj. každá část vektoru se posouvá zvlášť (je tedy například velký rozdíl mezi posunem jednoho 128bitového čísla a dvojice 64bitových čísel). Při logických posunech se do nového bitu nasouvá vždy logická nula (nikoli příznak carry), u aritmetických posunů se opakuje hodnota původního nejvyššího bitu, tj. instrukce pracují přesně tak, jak to programátoři očekávají:

Následuje seznam instrukcí určených pro provádění logických operací nad vektory různé délky. V některých případech (PAND, POR, PXOR) se jedná o „pouhé“ rozšíření původních MMX instrukcí takovým způsobem, aby tyto instrukce mohly pracovat se 128bitovými vektory. Dokonce i operační kódy instrukcí zůstávají stejné, ovšem v případě SSE2 je před vlastním instrukčním kódem uveden prefix 0×66, takže jsou instrukce o jeden bajt delší (to ostatně platí i pro aritmetické operace popsané o několik odstavců výše):

6. Instrukce pro konverzi dat

Při implementaci mnoha typů algoritmů, především pak při zpracování obrazových a zvukových datových toků, se mnohdy programátoři dostanou do situace, kdy potřebují zkonvertovat data do jiného formátu, než v jakém byla původně uložena. Pro tyto účely jsou v instrukční sadě SSE2 k dispozici dvě desítky konverzních instrukcí začínajících prefixem CVT, vypsaných v tabulce pod tímto odstavcem. Opět platí, že konverze jsou prováděny paralelně:

Obrázek 28: Univerzální konverzní funkce PSHUF byla v instrukční sadě SSE2 rozšířena tak, aby dokázala pracovat i se 128bitovými registry (existuje několik variant této instrukce, další varianty byly zavedeny až v SSE3 atd).

7. Instrukce pro porovnání skalárních hodnot nebo vektorů

Dalších několik instrukcí dokáže porovnat vektory různých typů a buď nastavit prvky výsledného vektoru či přímo ovlivnit příznakový registru EFLAGS (což je poměrně užitečná novinka). Jedná se o následující instrukce:

Většina assemblerů rozpoznává následující znaky, kterými lze nahradit otazníky v názvu instrukce. Tyto znaky specifikují způsob porovnání a v instrukční slovu jsou uloženy ve zvláštním bajtu (jedná se vlastně o třetí operand těchto instrukcí):

8. Instrukce pro načítání či ukládání skalárů a vektorů

Další část instrukcí slouží pro načtení či naopak pro uložení skalárních hodnot z/do registrů XMM. Některé z těchto instrukcí jsme již viděli ve variantě pro SSE, další jsou nově zavedené právě pro SSE2:

Nově jsou přidány instrukce pro přenosy bez použití cache, což může být velmi užitečná optimalizace (samozřejmě v závislosti na řešeném problému). A poslední dvě instrukce pracují s takzvanými maskami. Těmito instrukcemi se budeme zabývat v samostatné kapitole.

9. Prokládání dat, shuffling atd.

Nejzajímavější změny, které byly v instrukční sadě SSE2 provedeny, se týkají instrukcí pro prokládání dat ve vektorových registrech, pro přesuny prvků (shuffling) v rámci registrů atd. Těchto instrukcí je nyní celá řada a doplňují tak původní trojici instrukcí UNPCKHPS, UNPCKLPS a SHUFPS, které jsme si popsali minule. Tyto instrukce sice mohou být poněkud složitější na pochopení (a příslušný vzor nerozpoznají ani mnohé překladače), ale jsou velmi užitečné:

10. Řízení cache

Posledních několik instrukcí slouží pro řízení cache; takže je například možné vyprázdnění cache před prováděním složitějších výpočtů na stejným (větším) polem atd.:

11. Praktická část

Podobně jako v předchozích článcích se i dnes vydáme do temných zákoutí assembleru. Ukážeme si několik příkladů využití vybraných instrukcí ze sady SSE2. Ovšem ty složitější (a nutno dodat, že i zajímavější) instrukce budou ukázány příště, kdy téma SSE2 dokončíme. Všechny dále uvedené demonstrační příklady jsou napsány pro Netwide Assembler (NASM) a jsou přeložitelné a spustitelné v Linuxu.

12. Detekce podpory instrukcí SSE2

Začneme již klasickým příkladem – využitím instrukce CPUID pro zjištění, zda mikroprocesor vůbec podporuje instrukce SSE2. Většina mikroprocesorů x86, resp. x86–64 vyrobená v posledních dvaceti letech by měla plně podporovat většinu již popsaných SIMD rozšíření, tedy MMX, SSE i SSE2 (ovšem nikoli 3DNow!, což však nevadí). Povšimněte si, že podpora SSE2 je vyjádřena příznakovým bitem, jehož index je o jedničku vyšší, než index příznaku podpory SSE:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
mmx_supported:
         db 10, "MMX supported"
         mmx_supported_length equ $ - mmx_supported
 
sse_supported:
         db 10, "SSE supported"
         sse_supported_length equ $ - sse_supported
 
sse2_supported:
         db 10, "SSE2 supported"
         sse2_supported_length equ $ - sse2_supported
 
;-----------------------------------------------------------------------------
section .bss
 
id_string: resb 8
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        ; ziskani indexu nejvyssi volatelne funkce CPUID
        xor eax, eax                 ; nulta kategorie
        cpuid
        mov     edx, eax             ; hodnota, ktera se ma vytisknout
        mov     ebx, hex_message     ; buffer, ktery se zaplni hexa cislicemi
        call    hex2string           ; zavolani prislusne subrutiny
        print_string   hex_message, hex_message_length    ; tisk hexadecimalni hodnoty
 
        ; test podpory SSE
        mov eax, 1                   ; prvni kategorie
        cpuid
        mov     ebx, hex_message     ; buffer, ktery se zaplni hexa cislicemi
        call    hex2string           ; zavolani prislusne subrutiny
        print_string   hex_message, hex_message_length    ; tisk hexadecimalni hodnoty
 
        ; vypis CPU ID
        xor eax, eax                 ; nulta kategorie
        cpuid
        mov [id_string], ebx         ; prvni ctyri znaky ID
        mov [id_string+4], edx       ; dalsi ctyri znaky ID
        mov [id_string+8], ecx       ; posledni ctyri znaky ID
        print_string id_string, 12   ; tisk 12 znaku CPU ID
 
        mov eax, 1                   ; prvni kategorie
        cpuid                        ; naplneni EDX a ECX
        bt edx, 23                   ; test bitu cislo 23: podpora MMX
        jnc mmx_not_supported
        print_string  mmx_supported, mmx_supported_length
 
mmx_not_supported:
 
        mov eax, 1                   ; prvni kategorie
        cpuid                        ; naplneni EDX a ECX
        bt edx, 25                   ; test bitu cislo 25: podpora SSE
        jnc sse_not_supported
        print_string  sse_supported, sse_supported_length
 
sse_not_supported:
 
        mov eax, 1                   ; prvni kategorie
        cpuid                        ; naplneni EDX a ECX
        bt edx, 26                   ; test bitu cislo 25: podpora SSE2
        jnc sse2_not_supported
        print_string  sse2_supported, sse2_supported_length
 
sse2_not_supported:
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Výsledky mohou vypadat například takto:

00000020 BFEBFBFF GenuineIntel
MMX supported
SSE supported
SSE2 supported

13. Součty vektorů s různými počty a typy prvků

V rámci instrukční sady SSE2 se rozšířily možnosti instrukcí provádějících vektorové součty. Situace je vlastně velmi jednoduchá – tyto instrukce existovaly již v sadě MMX, kde pracovaly s 64bitovými vektory. V SSE2 došlo k rozšíření těchto instrukcí takovým způsobem, že bylo možné použít i registry XMM s dvojnásobnou šířkou a tím pádem i s vektory, které obsahují dvojnásobný počet prvků. Čistě teoreticky tak lze dosáhnout dvojnásobného výpočetního výkonu u těchto operací (v praxi to samozřejmě bude méně):

Zajímavé bude zjistit, jak se vlastně liší kódování stejných instrukcí ze sady MMX a SSE2. To, o kterou instrukci se jedná, se zjistí z jejich parametrů:

section .text
        paddb mm0, mm1
        paddb xmm0, xmm1
 
        paddsb mm0, mm1
        paddsb xmm0, xmm1
 
        paddusb mm0, mm1
        paddusb xmm0, xmm1
 
        paddw mm0, mm1
        paddw xmm0, xmm1
 
        paddsw mm0, mm1
        paddsw xmm0, xmm1
 
        paddusw mm0, mm1
        paddusw xmm0, xmm1
 
        paddd mm0, mm1
        paddd xmm0, xmm1
 
        paddq mm0, mm1
        paddq xmm0, xmm1

Z výsledků je patrné, že nové SSE2 instrukce pouze přidávají prefixový bajt 0×66, zbytek instrukčního slova je shodný:

     1                                  [bits 32]
     2
     3                                  ;-----------------------------------------------------------------------------
     4                                  section .text
     5 00000000 0FFCC1                          paddb mm0, mm1
     6 00000003 660FFCC1                        paddb xmm0, xmm1
     7
     8 00000007 0FECC1                          paddsb mm0, mm1
     9 0000000A 660FECC1                        paddsb xmm0, xmm1
    10
    11 0000000E 0FDCC1                          paddusb mm0, mm1
    12 00000011 660FDCC1                        paddusb xmm0, xmm1
    13
    14 00000015 0FFDC1                          paddw mm0, mm1
    15 00000018 660FFDC1                        paddw xmm0, xmm1
    16
    17 0000001C 0FEDC1                          paddsw mm0, mm1
    18 0000001F 660FEDC1                        paddsw xmm0, xmm1
    19
    20 00000023 0FDDC1                          paddusw mm0, mm1
    21 00000026 660FDDC1                        paddusw xmm0, xmm1
    22
    23 0000002A 0FFEC1                          paddd mm0, mm1
    24 0000002D 660FFEC1                        paddd xmm0, xmm1
    25
    26 00000031 0FD4C1                          paddq mm0, mm1
    27 00000034 660FD4C1                        paddq xmm0, xmm1
    28

14. Součet dvojice vektorů 16×8 bitů

V dnešním druhém demonstračním příkladu je ukázán součet dvou šestnácti prvkových vektorů s hodnotami typu byte. Nejprve načteme dvojici vektorů do SSE registrů XMM0 a XMM1. Následně provedeme součet obou vektorů instrukcí PADDB, která provádí součet bajt po bajtu (tedy paralelně se sečte šestnáct hodnot prvního vektoru se šestnácti hodnotami vektoru druhého). V případě, že výsledek přesáhne hodnotu 255, dojde k přetečení:

[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
sse_val_2 db 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1
        movaps xmm0, [ebx]           ; nacteni prvni hodnoty do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2
        movaps xmm1, [ebx]           ; nacteni druhe hodnoty do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        paddb xmm0, xmm1             ; soucet vektoru po bajtech
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Výsledky ukazují, že dochází k přetečení k rámci jednotlivých bajtů, ovšem nikoli k přenosu hodnoty do vyšších bajtů:

vektor1:  F0 E0 D0 C0 B0 A0 90 80 70 60 50 40 30 20 10 00
vektor2:  80 80 80 80 80 80 80 80 80 80 80 80 80 80 80 80
          -----------------------------------------------
výsledek: 70 60 50 40 30 20 10 00 F0 E0 D0 C0 B0 A0 90 80

15. Součet dvojice vektorů 8×16 bitů

Podobným způsobem, ovšem s využitím instrukce PADDW namísto PADDB, můžeme provést součet osmi šestnáctibitových prvků vektorů. Samotný zdrojový kód příkladu se změní jen nepatrně (náhrada jediné instrukce), ovšem výsledky budou zcela odlišné:

[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
sse_val_2 db 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1
        movaps xmm0, [ebx]           ; nacteni prvni hodnoty do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2
        movaps xmm1, [ebx]           ; nacteni druhe hodnoty do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        paddw xmm0, xmm1             ; soucet vektoru po slovech
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Ze zobrazených výsledků je patrné, že nyní dochází k přenosu do vyšších bajtů, ale vždy jen v hranici 16bitových slov:

vektor1:  F0E0 D0C0 B0A0 9080 7060 5040 3020 1000
vektor2:  8080 8080 8080 8080 8080 8080 8080 8080
          ---------------------------------------
výsledek: 7160 5140 3120 1100 F0E0 D0C0 B0A0 9080
přenosy:   ^    ^    ^    ^

16. Součet bezznaménkových bajtů se saturací

V multimediálních a DSP aplikacích je velmi užitečná i možnost sčítat a odčítat hodnoty se saturací namísto přetečení. Tuto operaci si můžeme ukázat na součtu bezznaménkových bajtů (resp. přesněji řečeno vektorů se šestnácti osmibitovými prvky), přičemž použijeme instrukci PADDUSB. Tato instrukce provádí součet se saturací, přičemž se sčítané hodnoty považují za osmibitové hodnoty bez znaménka (unsigned). Výsledky tedy nepřetečou přes hodnotu 0×FF (což si 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 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0
sse_val_2 db 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1
        movaps xmm0, [ebx]           ; nacteni prvni hodnoty do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2
        movaps xmm1, [ebx]           ; nacteni druhe hodnoty do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        paddusb xmm0, xmm1           ; soucet vektoru po bajtech se saturaci
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Z výsledků je skutečně patrné, že součty, které přesahují hodnotu 255, jsou saturovány právě na této hodnotě (0×ff):

vektor1:  F0 E0 D0 C0 B0 A0 90 80 70 60 50 40 30 20 10 00
vektor2:  80 80 80 80 80 80 80 80 80 80 80 80 80 80 80 80
          -----------------------------------------------
výsledek: FF FF FF FF FF FF FF FF F0 E0 D0 C0 B0 A0 90 80

17. Součet bajtů se znaménkem se saturací

V některých případech, například při zpracování audio vzorků, se nepracuje s hodnotami bez znaménka (unsigned), ale naopak s hodnotami se znaménkem (signed). V případě bajtů budou takové hodnoty saturovány v rozsahu –128 až 127, což si ověříme na tomto příkladu:

[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
sse_val_2 db 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
 
;-----------------------------------------------------------------------------
section .bss
sse_tmp resb 16
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, sse_val_1
        movaps xmm0, [ebx]           ; nacteni prvni hodnoty do registru XMM0
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
 
        mov ebx, sse_val_2
        movaps xmm1, [ebx]           ; nacteni druhe hodnoty do registru XMM1
        print_sse_reg_as_hex xmm1    ; tisk hodnoty registru XMM1
 
        paddsb xmm0, xmm1            ; soucet vektoru po bajtech se saturaci
        print_sse_reg_as_hex xmm0    ; tisk hodnoty registru XMM0
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Výsledky v případě, že sčítáme hodnoty s konstantami 0×80 (tedy nejmenší reprezentovatelnou hodnotou v oboru bajtů se znaménkem):

vektor1:  F0 E0 D0 C0 B0 A0 90 80 70 60 50 40 30 20 10 00
vektor2:  80 80 80 80 80 80 80 80 80 80 80 80 80 80 80 80
          -----------------------------------------------
výsledek: 80 80 80 80 80 80 80 80 F0 E0 D0 C0 B0 A0 90 80

Saturace na nejvyšší možné kladné hodnotě 127 (0×7F) vypadá takto:

vektor1:  F0 E0 D0 C0 B0 A0 90 80 70 60 50 40 30 20 10 00
vektor2:  7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F 7F
          -----------------------------------------------
výsledek: 6F 5F 4F 3F 2F 1F 0F FF 7F 7F 7F 7F 7F 7F 7F 7F

18. Obsah navazujícího článku

V dalším článku se zaměříme na komplikovanější instrukce, které byly zavedeny v sadě SSE2. Ukážeme si také praktičtěji zaměřené příklady, například rychlý výpočet skalárního součinu, což nemusí být tak triviální úloha, jak by se mohlo na první pohled zdát (na druhou stranu se tento výpočet používá velmi často, jako jedna z variant zjištění podobnosti dvou vektorů v mnoha „AI“ algoritmech).

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