Rozšíření instrukční sady AVX a programy v assembleru

Obsah

1. Rozšíření instrukční sady AVX a programy v assembleru

2. Od SSE k AVX a posléze k AVX-512

3. Pracovní registry AVX a AVX-512

4. Datové typy podporované v instrukčních sadách AVX a AVX2

5. Tříadresový kód podporovaný instrukcemi ze sady AVX

6. Nový způsob kódování instrukcí

7. Instrukce AVX a assembler NASM

8. Detekce podpory instrukcí AVX

9. První demonstrační příklad: zjištění, zda mikroprocesor podporuje instrukce AVX

10. Instrukce pro přenosy dat mezi novými registry AVX

11. Pomocné makro pro tisk hodnoty YMM registru

12. Druhý demonstrační příklad: zobrazení hodnoty 256bitového vektoru

13. Operace součtu vektorů o délce 256 bitů s celočíselnými prvky

14. Třetí demonstrační příklad: instrukce VPADDB

15. Rozdíl mezi instrukcemi VPADDB, VPADDW, VPADDD a VPADDQ

16. Čtvrtý demonstrační příklad: ukázka výsledků získaných instrukcemi VPADDB, VPADDW, VPADDD a VPADDQ

17. Analýza získaných výsledků

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

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

20. Odkazy na Internetu

1. Rozšíření instrukční sady AVX a programy v assembleru

V dnešním článku si ukážeme základy práce s instrukcemi AVX v assembleru, konkrétně v NASMu (Netwide Assembler) běžícího v Linuxu. Samotná zkratka AVX znamená „Advanced Vector Extensions“ a oproti již popsaným rozšířením MMX, SSE a SSE2 se v případě AVX jedná o výrazné vylepšení podpory SIMD operací, které se mj. projevilo prodloužením vektorů a taktéž zcela novými instrukcemi, což znamená, že slovo „advanced“ je zde 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. 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. Podporu pro původní AVX nabízí například překladač GCC, assembler GAS i NASM, který v tomto seriálu používáme, atd. Pro většinou moderních překladačů jazyka C jsou navíc dostupná i různá rozšíření určená pro podporu vektorových operací (builtins, intrinsic).

Původní rozšíření AVX bylo v roce 2013 doplněno rozšířením nazvaným AVX2 a jen o několik měsíců později byla představena specifikace nazvaná AVX-512. V tomto případě se nejedná o jediné rozšíření instrukční sady, ale o specifikaci hned několika (dopočítal jsem devatenáct, ale uvádí se dvacet) rozšíření (extension), která mohou být (ale nemusí) všechna implementována. Většinou bude implementována jen určitá podmnožina AVX-512. AVX-512 je v mnoha ohledech stejně přelomové jako přechod na AVX, ovšem prozatím stále ho doprovází technické problémy – některé procesory se při vykonávání nových instrukcí AVX-512 zpomalují, a to mnohdy až na 60% svého limitu (to však již poněkud předbíháme). AVX-512 je v současnosti podporováno překladači GCC, ICC i Clang; tyto instrukce jsou podporovány i assemblery NASM (což nás zajímá primárně) a FASM.

Pro zajímavost se podívejme na postupné rozšiřování původní skalární architektury x86 o vektorové instrukce (nejsou uvedena všechna rozšíření AVX-512):

$ cat /proc/cpuinfo |head -n 27

Důležitý je v tomto případě obsah atributu flags:

processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 154
model name      : 12th Gen Intel(R) Core(TM) i7-1270P
stepping        : 3
microcode       : 0x436
cpu MHz         : 972.124
cache size      : 18432 KB
physical id     : 0
    siblings    : 16
core id         : 0
cpu cores       : 12
apicid          : 0
initial apicid  : 0
fpu             : yes
fpu_exception   : yes
cpuid level     : 32
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc art arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc cpuid aperfmperf tsc_known_freq pni pclmulqdq dtes64 monitor ds_cpl vmx smx est tm2 ssse3 sdbg fma cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand lahf_lm abm 3dnowprefetch cpuid_fault epb ssbd ibrs ibpb stibp ibrs_enhanced tpr_shadow flexpriority ept vpid ept_ad fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid rdseed adx smap clflushopt clwb intel_pt sha_ni xsaveopt xsavec xgetbv1 xsaves split_lock_detect user_shstk avx_vnni dtherm ida arat pln pts hwp hwp_notify hwp_act_window hwp_epp hwp_pkg_req hfi vnmi umip pku ospke waitpkg gfni vaes vpclmulqdq rdpid movdiri movdir64b fsrm md_clear serialize pconfig arch_lbr ibt flush_l1d arch_capabilities
vmx flags       : vnmi preemption_timer posted_intr invvpid ept_x_only ept_ad ept_1gb flexpriority apicv tsc_offset vtpr mtf vapic ept vpid unrestricted_guest vapic_reg vid ple shadow_vmcs ept_violation_ve ept_mode_based_exec tsc_scaling usr_wait_pause
bugs            : spectre_v1 spectre_v2 spec_store_bypass swapgs eibrs_pbrsb rfds bhi
bogomips        : 4992.00
clflush size    : 64
cache_alignment : 64
address sizes   : 46 bits physical, 48 bits virtual
power management:

2. Od SSE k AVX a posléze k AVX-512

Na technologii AVX se můžeme dívat jako na další krok, kterým se původně čistě skalární architektura x86 postupně rozšiřuje o nové vektorové operace (a nepřímo taktéž o nové vektorové registry, které doplňují původní sadu skalárních registrů). V souladu s Moorovým zákonem totiž mohou výrobci mikroprocesorů vytvářet na čipech nové (a delší, resp. možná přesněji řečeno širší) registry, zvětšovat počet aritmeticko-logických jednotek atd., což nepřímo přináší i nutnost změn (rozšíření) instrukční sady. A přesně tento postupný vývoj můžeme vidět i na platformě x86 a x86–64, která byla rozšířena o MMX, SSE (SSE, SSE2, SSE4.1 atd.), AVX (původní AVX i AVX2) a nyní o AVX-512 (samotné AVX10 si dovolím pro jednoduchost a jen pro tuto chvíli považovat za pouhou variantu AVX-512).

Kromě rozšíření instrukční sady se postupně zvětšoval i počet pracovních registrů a taktéž jejich šířka. Ostatně tyto změny jsou patrné i z následující tabulky:

3. Pracovní registry AVX a AVX-512

Z tabulky uvedené ve druhé kapitole je patrný dramatický skok v případě instrukční sady AVX-512, kdy se zdvojnásobil (resp. oproti 32bitové x86 dokonce zečtyřnásobil) počet vektorových registrů a současně se i zdvojnásobila jejich bitová šířka. Ve skutečnosti vznikly nové registry AVX se jmény YMMx i registry AVX-512 se jmény ZMMx rozšířením registrů SSE na 256 nebo 512 bitů a přidáním nových registrů. To například znamená, že operace s registrem XMM0 (SSE) ve skutečnosti může modifikovat spodních 128 bitů registru YMM0 i ZMM0. U instrukcí je pak definováno, zda budou horní prvky registrů vynulovány, nebo ponechány na původní hodnotě. Tento koncept není úplně nový a můžeme ho vidět i u základních pracovních registrů (AL → AX → EAX → RAX):

4. Datové typy podporované v instrukčních sadách AVX a AVX2

Při použití technologie AVX se používají vektory o šířce 256 bitů. Tyto vektory je možné rozdělit na celočíselné prvky popř. na prvky s hodnotami reprezentovanými s využitím systému plovoucí řádové čárky. V následující tabulce jsou všechny možné a podporované kombinace vypsány. Vzhledem k tomu, že jsou tyto datové typy relativně často používány i v překladačích jazyka C, uvádím pro úplnost i jejich názvy tak, jak jsou definovány v překladači GCC:

V assembleru se namísto toho používají pseudoinstrukce DB, DW, DD, DQ a DT, popř. pro neinicializované vektory pseudoinstrukce RESB, RESW, RESD, RESQ a REST.

To je vhodný doplněk ke (stále podporovaným) datovým typům pro SSE i pro SSE2:

5. Tříadresový kód podporovaný instrukcemi ze sady AVX

„Novým objevem“ (ve skutečnosti starým přibližně padesát let, ovšem zrovna u platformy x86 se jedná o novou vlastnost) je použití takzvaného tříadresového kódu (Three-Address Code, TAC) v AVX instrukcích. Co to znamená? V instrukčním slovu jsou zakódovány jak dva zdrojové operandy (registry popř. adresa), tak i jeden cílový operand. To znamená, že – na rozdíl od instrukcí SSE – není jeden ze zdrojových operandů (konkrétně registr) současně i operandem cílovým – není tedy přepsán výsledkem operace. To může pomoci překladači s alokací registrů, ovšem navíc se mnohdy ušetří operace kopie dat mezi dvojicí registrů (samozřejmě je stále možné v případě potřeby ten samý registr použít jak ve funkci zdrojového, tak i cílového operandu).

Podívejme se na rozdíly mezi dvouadresovým a tříadresovým kódem u instrukce součtu (a je jedno, jestli skalárního nebo vektorového). Ve dvouadresovém kódu je jeden ze zdrojových registrů i registrem cílovým:

   c:   0f 28 4d 10             movaps xmm1, XMMWORD PTR [rbp+0x10]
  10:   0f 28 45 30             movaps xmm0, XMMWORD PTR [rbp+0x30]
  14:   0f 58 c8                addps xmm1, xmm0

U tříadresového kódu tomu tak není (navíc je jedním ze zdrojů adresa a nikoli registr):

  1d:   c5 fc 28 44 24 e0       vmovaps ymm1, YMMWORD PTR [rsp-0x20]
  23:   c5 fc 58 44 24 c0       vaddps ymm0, ymm1, YMMWORD PTR [rsp-0x40]

6. Nový způsob kódování instrukcí

V souvislosti s AVX byl navržen nový (kolikátý už? na platformě x86 už asi osmý?) způsob kódování instrukcí nazvaný VEX. Díky tomuto rozšíření bylo umožněno jak zvýšení počtu instrukcí (navíc s prostorem pro další rozšiřování), tak i rozšíření vektorů ze 128 bitů na 256 bitů a v neposlední řadě je taktéž ve VEX implementován výše zmíněný tříadresový kód.

Instrukce mají proměnnou délku (a to až do délky jedenácti bajtů, nepočítaje v to možné prefixy), jejich kódování je velmi složité a navíc existují kolize v 32bitovém režimu. Obecně je možné říci, že způsob zakódování instrukcí vypadá následovně:

V bitovém poli ModR/M je zakódován způsob adresování operandů, které muselo být rozšířeno o SIB, v němž se specifikuje adresování přes index registr, bázový registr nebo vynásobení offsetu krátkou konstantou (2, 4, …). Navíc se na x86–64 zavádí prefix REX, který modifikuje význam bitového pole ModR/M tak, že lze použít nové pracovní registry (uff). Krátce: dnes již v naprosté většině případů nemá význam pokoušet se o dekódování instrukcí ručně; lepší je se spolehnout na debuggery, disassemblery nebo nástroj objdump (my se však k tomuto tématu ještě vrátíme).

7. Instrukce AVX a assembler NASM

Druhá část dnešního článku je – podobně jako u většiny ostatních článků z tohoto seriálu – věnována praktickému využití resp. přesněji řečeno otestování popsaných vlastností v praxi. Týkat se to bude i instrukcí AVX. Použijeme přitom assembler NASM, který AVX instrukce podporuje; viz též jejich seznam získaný z oficiální dokumentace NASMu. Všechny dále uvedené demonstrační příklady jsou přeložitelné na Linuxu (i na jeho 32bitové variantě). Příklady, které budou představeny dnes, ve skutečnosti ukazují jen velmi malou část nové funkcionality AVX. Složitější a přitom velmi užitečné instrukce typu gather/scatter, popř. instrukce umožňující kooperaci mezi SSE a AVX, budou popsány a pochopitelně i otestovány v navazujícím článku.

8. Detekce podpory instrukcí AVX

Současné typy mikroprocesorů s architekturou x86–64 již instrukce AVX podporují, ovšem ještě relativně nedávno byly prodávány čipy bez podpory tohoto rozšíření instrukční sady. Mj. i z tohoto důvodu je dobré vědět, jakým způsobem lze zjistit, jestli daný mikroprocesor AVX podporuje či nikoli. AVX je stále považována za jediné a ucelené rozšíření instrukční sady (na rozdíl od AVX-512), takže detekce jeho podpory nebo naopak nepodpory je snadná. K tomuto účelu použijeme instrukci CPUID, se kterou jsme se v tomto seriálu již několikrát setkali, a to při detekci rozšíření MMX, SSE a SSE2.

Konkrétně to znamená zavolat tuto instrukci s registrem EAX nastaveným na jedničku (první kategorie) s následným otestováním hodnoty bitu s indexem 28 registru ECX. Pozor: skutečně se testuje bit z registru ECX a nikoli EDX, jak jsme doposud prováděli. Výsledek lze interpretovat snadno: jedničkový bit je nastaven v případě, že instrukce AVX jsou podporovány; v opačném případě je nulový.

9. První demonstrační příklad: zjištění, zda mikroprocesor podporuje instrukce AVX

V dnešním prvním demonstračním příkladu je instrukcí CPUID zjištěno (v čase běhu), zda daný procesor podporuje instrukce AVX. Jedná se o rozšíření příkladů, které jsme si již ukázali, takže ve skutečnosti se bude detekovat i podpora MMX, SSE, SSE2. Na většině mikroprocesorů vyrobených v posledních cca deseti letech by se měla vypsat podpora pro všechna čtyři vektorová rozšíření (ale v případě později popsané AVX-512 to už není tak jisté):

[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
 
avx_supported:
         db 10, "AVX supported"
         avx_supported_length equ $ - avx_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 registru EDX: 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 registru EDX: podpora SSE2
        jnc sse2_not_supported
        print_string  sse2_supported, sse2_supported_length
sse2_not_supported:
 
        mov eax, 1                   ; prvni kategorie
        cpuid                        ; naplneni EDX a ECX
        bt ecx, 28                   ; test bitu cislo 28 registru ECX: podpora AVX
        jnc avx_not_supported
        print_string  avx_supported, avx_supported_length
avx_not_supported:
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Výsledek by mohl vypadat následovně (první řádek ovšem může být odlišný – záleží na konkrétním typu mikroprocesoru):

00000020 BFEBFBFF GenuineIntel
MMX supported
SSE supported
SSE2 supported
AVX supported

10. Instrukce pro přenosy dat mezi novými registry AVX

Mezi první typ instrukcí z instrukční sady AVX, které si musíme popsat, pochopitelně patří instrukce určené pro přenos hodnot mezi vektorovými registry YMMx navzájem, popř. mezi vektorovým registrem YMMx a operační pamětí. Již při popisu instrukční sady SSE jsme si řekli, že se ve skutečnosti nejedná o zcela triviální problematiku, protože při přesunech dat mezi operační pamětí a vektorovým registrem se rozlišuje čtení/zápis do paměti se zarovnáním adres a bez zarovnání (což do jisté míry souvisí se šířkou datového kanálu mezi mikroprocesorem a cache). „Zarovnaný“ přístup je (resp. byl) obecně rychlejší a pro tyto účely existují vlastní varianty přenosových instrukcí. Jména těchto instrukcí typicky začínají znaky VMOV (vector move), přičemž další znaky jména instrukce určují další vlastnosti operace, která je instrukcí prováděna:

V dalším textu si prozatím vystačíme s instrukcí VMOVDQU.

11. Pomocné makro pro tisk hodnoty YMM registru

V další trojici demonstračních příkladů a taktéž v příkladech, které budou uvedeny příště, budeme provádět tisk hodnot vektorových registrů YMMx. Víme již, že tyto registry mají šířku 256 bitů, což odpovídá třiceti dvěma bajtům. Hodnoty těchto bajtů budeme pro jednoduchost (a jednoznačnost) tisknout v hexadecimálním formátu. Pro zobrazení obsahu třiceti dvou bajtů je nutné vytisknout 64 hexadecimálních cifer, což je velké množství (v tištěných materiálech je to celá šířka řádku). Proto mezi skupiny těchto cifer budeme vkládat mezery, aby se jejich čtení zjednodušilo.

Vlastní tisk hodnoty registru YMMx je realizován v makru nazvaném print_avx_reg_as_hex, které očekává, že se mu předá jméno YMM registru, jehož obsah má být vytisknut. Vlastní funkce makra je poněkud těžkopádná: obsah registru se uloží do paměti (bufferu), ze kterého čteme jednotlivé čtveřice bajtů (32 bitů). Ty jsou tisknuty jiným makrem nazvaným print_hex:

; makro pro vypis obsahu AVX vektoru
%macro print_avx_reg_as_hex 1
        mov  ebx, avx_tmp           ; adresa bufferu
        vmovdqu [ebx], %1           ; ulozeni do pameti (32 bajtu)
        mov  eax, [ebx+28]          ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, ' '          ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
        mov  eax, [ebx+24]          ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, ' '          ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
        mov  eax, [ebx+20]          ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, ' '          ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
        mov  eax, [ebx+16]          ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, ' '          ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
        mov  eax, [ebx+12]          ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, ' '          ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
        mov  eax, [ebx+8]           ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, ' '          ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
        mov  eax, [ebx+4]           ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, ' '          ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
        mov  eax, [ebx]             ; nacteni casti AVX vektoru do celociselneho registru
        print_hex eax, 0x0a         ; zobrazeni obsahu tohoto registru v hexadecimalnim tvaru
%endmacro

12. Druhý demonstrační příklad: zobrazení hodnoty 256bitového vektoru

V dnešním druhém demonstračním příkladu si otestujeme funkci výše popsaného makra určeného pro tisk obsahu vybraného vektorového registru YMMx. Díky existenci dalších pomocných maker je zdrojový kód tohoto příkladu velmi krátký a doufejme, že i dobře pochopitelný. V textovém segmentu je uložena sekvence třiceti dvou bajtů, které jsou načteny do registru YMM0 a jeho obsah je následně vytištěn. Povšimněte si zejména toho, že způsob uložení jednotlivých bajtů v operační paměti (ať již se jedná o měnitelný nebo o neměnitelný segment) odpovídá little endian, tj. první uložený bajt bude mít ve vektorovém registru nejnižší index atd. Úplný 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 32
avx_val_1 db  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16
          db 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
 
;-----------------------------------------------------------------------------
section .bss
avx_tmp resb 32
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, avx_val_1           ; adresa prvniho vektoru
        vmovdqu ymm0, [ebx]          ; nacteni puvodniho vektoru do registru YMM0
        print_avx_reg_as_hex ymm0    ; tisk hodnoty registru YMM0
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Výsledek:

201F1E1D 1C1B1A19 18171615 14131211 100F0E0D 0C0B0A09 08070605 04030201

Popř. po rozdělení na jednotlivé bajty:

20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01

13. Operace součtu vektorů o délce 256 bitů s celočíselnými prvky

Dále si ukažme, jakým způsobem je možné provádět součty 256bitových vektorů (tedy vektorů o šířce třiceti dvou bajtů), v nichž jsou uloženy celočíselné prvky. Na výběr jsou čtyři typy těchto vektorů (minimálně v případě, že vynecháme celočíselný typ se šířkou 128 bitů, který se v praxi příliš nepoužívá):

14. Třetí demonstrační příklad: instrukce VPADDB

V dnešním třetím demonstračním příkladu je ukázán způsob použití instrukce VPADDB, tedy instrukce, která sčítá 256bitové vektory obsahující třicet dva jednobajtových prvků. První vektor obsahuje bajty s hodnotou od 1 do 32, druhý vektor obsahuje prvky se stejnou hodnotou 0×10=16 (pro účely jednoduššího tisku v hexadecimálním formátu):

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 32
avx_val_1 db  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16
          db 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
avx_val_2 times 32 db 0x10
 
;-----------------------------------------------------------------------------
section .bss
avx_tmp resb 32
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, avx_val_1           ; adresa prvniho vektoru
        vmovdqu ymm0, [ebx]          ; nacteni puvodniho vektoru do registru YMM0
        print_avx_reg_as_hex ymm0    ; tisk hodnoty registru YMM0
 
        mov ebx, avx_val_2           ; adresa druheho vektoru
        vmovdqu ymm1, [ebx]          ; nacteni puvodniho vektoru do registru YMM1
        print_avx_reg_as_hex ymm1    ; tisk hodnoty registru YMM1
 
        vpaddb ymm2, ymm0, ymm1      ; ymm2 = ymm0 + ymm1
        print_avx_reg_as_hex ymm2    ; tisk hodnoty registru YMM2
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

Výsledky ve formátu přímo zobrazeném příkladem po jeho překladu a spuštění:

201F1E1D 1C1B1A19 18171615 14131211 100F0E0D 0C0B0A09 08070605 04030201
10101010 10101010 10101010 10101010 10101010 10101010 10101010 10101010
302F2E2D 2C2B2A29 28272625 24232221 201F1E1D 1C1B1A19 18171615 14131211

Mnohem čitelnější je však vizuální rozdělení na jednotlivé bajty:

první vektor: 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01
druhý vektor: 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10
součet:       30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11

15. Rozdíl mezi instrukcemi VPADDB, VPADDW, VPADDD a VPADDQ

Ve třinácté kapitole jsme se zmínili o čtveřici instrukcí nazvaných VPADDB, VPADDW, VPADDD a VPADDQ. Všechny instrukce z této skupiny provádí součet 256bitových vektorů, ovšem liší se v tom, jak od sebe „izolují“ jednotlivé bajty nebo skupiny bajtů uložených v těchto vektorech. První z těchto instrukcí, tj. instrukce VPADDB, provádí součet po jednotlivých bajtech s tím, že pokud dojde k přenosu na hranici mezi jednotlivými bajty (tj. například mezi bitem 7 a 8), bude tento přenos ignorován. Výsledkem je přetečení obsahu jednotlivých bajtů, tj. za hodnotou 0×ff (255) následuje hodnota 0×00 (0) atd. Totéž platí i pro všech 31 následujících bajtů. Podobně se chovají i ostatní tři instrukce, jen s tím rozdílem, že VPADDW ignoruje přenos mezi bity 15 a 16 atd. (16×), instrukce VPADDD pracuje s 32bitovými dvojslovy (double word) a instrukce VPADDQ pracuje se 64bitovými čtyřslovy (quad word).

16. Čtvrtý demonstrační příklad: ukázka výsledků získaných instrukcemi VPADDB, VPADDW, VPADDD a VPADDQ

Ve čtvrtém a současně i dnešním posledním demonstračním příkladu jsou porovnány výsledky všech čtyř instrukcí součtu 256bitových vektorů s celočíselnými hodnotami. Povšimněte si, jak se díky tříadresovému kódu mohl zjednodušit zápis celého programu – mění se totiž vždy jen cílový registr, nikdy oba registry zdrojové:

[bits 32]
 
%include "linux_macros.asm"
 
;-----------------------------------------------------------------------------
section .data
 
hex_message:
         times 8 db '?'
         db ' '
         hex_message_length equ $ - hex_message
 
align 32
avx_val_1 db 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          db 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          db 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
          db 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
avx_val_2 db 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          db 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          db 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          db 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
;-----------------------------------------------------------------------------
section .bss
avx_tmp resb 32
 
 
;-----------------------------------------------------------------------------
section .text
        global _start                ; tento symbol ma byt dostupny i linkeru
 
_start:
        mov ebx, avx_val_1           ; adresa prvniho vektoru
        vmovdqu ymm0, [ebx]          ; nacteni puvodniho vektoru do registru YMM0
        print_avx_reg_as_hex ymm0    ; tisk hodnoty registru YMM0
 
        mov ebx, avx_val_2           ; adresa druheho vektoru
        vmovdqu ymm1, [ebx]          ; nacteni puvodniho vektoru do registru YMM1
        print_avx_reg_as_hex ymm1    ; tisk hodnoty registru YMM1
 
        vpaddb ymm2, ymm0, ymm1      ; ymm2 = ymm0 + ymm1 (po bajtech)
        print_avx_reg_as_hex ymm2    ; tisk hodnoty registru YMM2
 
        vpaddw ymm2, ymm0, ymm1      ; ymm2 = ymm0 + ymm1 (po slovech)
        print_avx_reg_as_hex ymm2    ; tisk hodnoty registru YMM2
 
        vpaddd ymm2, ymm0, ymm1      ; ymm2 = ymm0 + ymm1 (po dvojslovech)
        print_avx_reg_as_hex ymm2    ; tisk hodnoty registru YMM2
 
        vpaddq ymm2, ymm0, ymm1      ; ymm2 = ymm0 + ymm1 (po ctyrslovech)
        print_avx_reg_as_hex ymm2    ; tisk hodnoty registru YMM2
 
        exit                         ; ukonceni procesu
 
 
%include "hex2string.asm"

17. Analýza získaných výsledků

Po spuštění tohoto příkladu se zobrazí následující sekvence hexadecimálních hodnot:

FFFFFFFF FFFFFFFF 00000000 FFFFFFFF 00000000 0000FFFF 00000000 000000FF
00000000 00000001 00000000 00000001 00000000 00000001 00000000 00000001
FFFFFFFF FFFFFF00 00000000 FFFFFF00 00000000 0000FF00 00000000 00000000
FFFFFFFF FFFF0000 00000000 FFFF0000 00000000 00000000 00000000 00000100
FFFFFFFF 00000000 00000000 00000000 00000000 00010000 00000000 00000100
00000000 00000000 00000001 00000000 00000000 00010000 00000000 00000100

Jednotlivé řádky lze snadno dekódovat.

Součet po bajtech:

vstup1:  FF FF FF FF FF FF FF FF 00 00 00 00 FF FF FF FF 00 00 00 00 00 00 FF FF 00 00 00 00 00 00 00 FF
vstup2:  00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 01
         -----------------------------------------------------------------------------------------------
VPADDB:  FF FF FF FF FF FF FF 00 00 00 00 00 FF FF FF 00 00 00 00 00 00 00 FF 00 00 00 00 00 00 00 00 00
změny:                        ^^                      ^^                      ^^                      ^^

Součet po slovech:

vstup1:  FFFF FFFF FFFF FFFF 0000 0000 FFFF FFFF 0000 0000 0000 FFFF 0000 0000 0000 00FF
vstup2:  0000 0000 0000 0001 0000 0000 0000 0001 0000 0000 0000 0001 0000 0000 0000 0001
         -------------------------------------------------------------------------------
VPADDW:  FFFF FFFF FFFF 0000 0000 0000 FFFF 0000 0000 0000 0000 0000 0000 0000 0000 0100
změny:                  ^^^^                ^^^^                ^^^^                ^^^^

Součet po dvouslovech:

vstup1:  FFFFFFFF FFFFFFFF 00000000 FFFFFFFF 00000000 0000FFFF 00000000 000000FF
vstup2:  00000000 00000001 00000000 00000001 00000000 00000001 00000000 00000001
         -----------------------------------------------------------------------
VPADDD:  FFFFFFFF 00000000 00000000 00000000 00000000 00010000 00000000 00000100
změny:            ^^^^^^^^          ^^^^^^^^          ^^^^^^^^          ^^^^^^^^

Součet po čtyřslovech:

vstup1:  FFFFFFFFFFFFFFFF 00000000FFFFFFFF 000000000000FFFF 00000000000000FF
vstup2:  0000000000000001 0000000000000001 0000000000000001 0000000000000001
         -------------------------------------------------------------------
VPADDQ:  0000000000000000 0000000100000000 0000000000010000 0000000000000100
změny:   ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^

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

Mezi nejdůležitější nové instrukce AVX patří instrukce provádějící operace typu gather/scatter. A právě s konceptem, na kterých jsou tyto instrukce postaveny, se seznámíme 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
211. AVX2
     https://wiki.osdev.org/AVX2
212. x86/x64 SIMD Instruction List (SSE to AVX512)
     https://www.officedaytime­.com/simd512e/
213. NASM instruction list
     https://userpages.cs.umbc­.edu/chang/cs313/nasmdoc/html/nas­mdocb.html