Obsah
1. Superskalární RISCová jádra SH-4 a SH-4A použitá v mikroprocesorech i mikrořadičích
2. Základní pipeline použité v architektuře SH-4
3. Pipeline určené pro operace s plovoucí řádovou čárkou
4. Paralelní vykonávání instrukcí
6. Instrukce pro SH-2A, které nejsou podporovány v jádru SH-4
8. Pipeline použité v architektuře SH-4A
10. Instrukce matematického koprocesoru určené pro urychlení grafických operací
11. Obsah následující části seriálu
1. Superskalární RISCová jádra SH-4 a SH-4A použitá v mikroprocesorech i mikrořadičích
V předchozích částech tohoto seriálu jsme se seznámili s RISCovými jádry nazvanými SH-1, SH-2 a SH-2A. Ve všech případech se jedná o 32bitová RISCová jádra, která se od většiny ostatních mikroprocesorů s architekturou RISC odlišují především tím, že instrukční slova mají šířku šestnáct bitů, zatímco u klasických RISCových architektur nalezneme slova o šířce 32 bitů. Tento rozdíl je pravděpodobně nejvíce markantní v oblasti mikrořadičů, takže není divu, že čipy SH (SuperH) nalezneme právě v této aplikační oblasti (na tomto místě je však nutné upozornit na fakt, že u SH-2(A) nalezneme několik instrukcí uložených do dvou slov, ovšem stále se jedná o několik výjimek a nikoli o pravidlo, jak je tomu například na typických architekturách CISC x86 a 68k). Od jader SH-1 a SH-2 jsou odvozeny další dvě řady: SH-3 (tato jádra se dnes již příliš nepoužívají) a SH-4. A právě popisem jader SH-4 a jejich vylepšené varianty SH-4A se budeme zabývat v dnešním článku, kterým celé téma čipů SuperH dokončíme.
Původní varianta jádra SH-4 je použita například v následujících mikroprocesorech:
| Čip | Max frekvence | Pinů | Napájení |
|---|---|---|---|
| SH7750R | 240 MHz | 208–292 | 3–3,6V |
| SH7750S | 200 MHz | 208–264 | 3–3,6V |
| SH7751 | 167 MHz | 256 | 3–3,6V |
| SH7751R | 240 MHz | 256–292 | 3–3,6V |
| SH7760 | 200 MHz | 256 | 3–3,6V |
Poznámka: poměrně nízká hodinová frekvence nemusí být limitujícím faktorem, protože tyto čipy nejsou v žádném případě určeny pro použití v desktopech ani v klasických serverech (což můžeme chápat i tak, že v těchto oblastech nejsou či nebyly konkurenceschopné :-). Spíše je zajímavé sledovat údaj o spotřebě, který dosahuje hodnoty až 1,2 W (při vyšším napájecím napětí).
V některých mikrořadičích nalezneme jádra SH-4A, která mají odlišnou konstrukci pipeline i upravenou sadu instrukcí. Jedná se především o řadu SH7450 s těmito variantami čipů:
| Čip | Max frekvence | Pinů | Napájení | RAM | Flash ROM |
|---|---|---|---|---|---|
| SH7450, SH7451 | 240 MHz | 292 | 3–5,5 V | 536 kB | 1536–2048 kB |
| SH7455, SH7456 | 160 MHz | 176 | 3–5,5 V | 280 kB | 1024 kB |
| SH7457, SH7459 | 240 MHz | 176 | 3–5,5 V | 280–536 kB | 1024–1536 kB |
2. Základní pipeline použité v architektuře SH-4
V marketingových materiálech společnosti Renesas se můžeme dočíst, že jádra SH-4 dokážou díky použití pipeline a superskalární architektury dokončit v každém hodinovém taktu dvě instrukce (přičemž se bez dalších podrobnějších informací dodává „včetně FPU operací“). Ve skutečnosti je ovšem tato výpočetní rychlost pouze teoretická, protože v SH-4 nalezneme hned několik pravidel, která se týkají jak překryvu instrukcí v pipeline, tak i v omezené kombinaci instrukcí, které je možné spustit paralelně. Prakticky se dostáváme k hodnotám okolo 1,5 instrukce/takt. S některými omezeními se seznámíme v následujícím textu.
Čipy postavené na jádru SH-4 používají tři typy pipeline. První typ je využit u operací typu load and store, u všech operací pracujících s celočíselnou aritmeticko-logickou jednotkou, u skoků i u instrukcí pracujících s příznakovým bitem T. Zvláštní konfigurace pipeline nalezneme u matematického koprocesoru, kde je nutné vyhradit větší počet řezů na samotné provedení požadované operace (u ALU operací je to jen jeden takt), na druhou stranu se však u těchto operací neprovádí zápis zpět do operační paměti, takže se vynechává fáze/modul WB (Write Back).
Nejprve se však věnujme konfiguraci pipeline prvního typu. Tato pipeline má pět řezů, což je typické i pro mnoho dalších konkurenčních RISCových procesorů. Jaké konkrétní činnosti se v každém řezu provedou závisí na typu instrukce, takže se nyní na jednotlivé možnosti podívejme podrobněji.
Operace typu load and store (včetně FPUL, MOV, FMOV, LDS) jsou provedeny v asi nejklasičtějším režimu pipeline, protože se v něm používají fáze Instruction Fetch, Instruction Decode, Execute, Memory Access a Write Back:
+----+----+----+----+----+ | IF | ID | EX | MA | WB | +----+----+----+----+----+
Většina operací s ALU (ADD, CMP, DT, NEG, …) + skoky nepotřebuje provést zpětný zápis výsledku do operační paměti:
+----+----+----+----+----+ | IF | ID | EX | NA | WB | +----+----+----+----+----+
Přesuny dat s využitím adresování přes GBR (Global Base Register) používají odlišný třetí řez, což se projeví v možností překryvu instrukcí:
+----+----+----+----+----+ | IF | ID | SX | NA | WB | +----+----+----+----+----+
Load a store operace s využitím registru GBR:
+----+----+----+----+----+ | IF | ID | SX | MA | WB | +----+----+----+----+----+
Význam zkratek použitých ve schématech pipeline:
| IF | Instruction Fetch |
| ID | Instruction Decode (+ čtení z registrů) |
| EX | Execute, provedení ALU operace atd. |
| NA | Non-memory Data Access (nebo jen přenos dat do další fáze) |
| MA | Memory Access, přístup do operační paměti |
| WB | Write Back, opět přístup do registrů |
U naprosté většiny instrukcí se mohou jednotlivé (samozřejmě navzájem odlišné, tj. minimálně o takt posunuté) fáze pipeline překrývat, pokud samozřejmě nedochází ke konfliktům při přístupu k pracovním registrům a/nebo při přístupu do operační paměti. Vzhledem k tomu, že samotný CPU je propojen s cache paměťmi s použitím oddělených sběrnic pro data a instrukce (a i cache je rozdělena na instrukční cache a datovou cache), je minimalizován konflikt mezi fází IF a MA, ovšem jiným konfliktům to samozřejmě nezabrání (zde se může negativně projevit relativně malý počet pracovních registrů v porovnání s některými dalšími RISCovými procesory, jejichž banky registrů bývají dvojnásobné).
3. Pipeline určené pro operace s plovoucí řádovou čárkou
Pipeline používaná u operací s plovoucí řádovou čárkou má poněkud odlišnou strukturu, protože se zde nemusí použít zpětný zápis výsledku operace do operační paměti. U „jednoduchých“ operací se setkáme s pětiřezovou pipeline, v níž symboly F1 a F2 reprezentují různé na sebe navazující fáze výpočtu a FS je zpětný zápis výsledku do vybraného pracovního registru:
+----+----+----+----+----+ | IF | ID | F1 | F2 | FS | +----+----+----+----+----+
Některé FPU instrukce mají nepatrně prodlouženou dobu výpočtu, takže celá pipeline má šest řezů:
+----+----+----+----+----+----+ | IF | ID | F0 | F1 | F2 | FS | +----+----+----+----+----+----+
Specialitou jsou pak dvě instrukce nazvané FDIV a FSQRT, o nichž již z předchozího článku víme, že jejich doba trvání je 10 a 9 cyklů pro typ single a 23 a 22 cyklů pro typ double – zde je tedy pipeline značně „natažena“ a provádí se mnohem větší množství fází Fn. Navíc se prodlužuje i doba operací s čísly s dvojnásobnou přesností, a to z toho důvodu, že přenosy dat se provádí po 32bitových sběrnicích (výjimkou je jen přenos mezi FPU a datovou cache s šířkou 64 bitů, což odpovídá typu double).
4. Paralelní vykonávání instrukcí
Jak jsme si již řekli v úvodních kapitolách, mají jádra SH-4 superskalární architekturu, což zde konkrétně znamená, že v ideálním případě je možné spustit vykonávání dvou instrukcí současně, což dále (společně s překryvem různých fází v pipeline) vede či může vést k urychlení běhu programu. Protože zdaleka ne všechny bloky na čipu jsou skutečně zdvojeny (někdy to ani není možné – například v případě paměti atd.), je zavedeno několik omezení pro paralelní běh instrukcí. Všechny instrukce jsou rozděleny do šesti skupin, přičemž je stanoveno, za jakých okolností je možné instrukce párovat (spouštět skutečně paralelně). Například platí, že lze párovat jakoukoli ALU instrukci s instrukcí podmíněného skoku, instrukcí přenosu dat (load/store) či s instrukcí matematického koprocesoru. Naproti tomu není možné párovat dvě ALU instrukce, dvě instrukce matematického koprocesoru atd. Jen instrukce z první skupiny mohou tvořit pár, jinak je vždy nutné párovat instrukce ze dvou odlišných skupin. Speciální skupinu pak tvoří několik instrukcí, které se nepárují nikdy (mohou však samozřejmě být postupně spouštěny v jediné pipeline).
Poznámka: jádra SH-4 mají v oblasti paralelního spouštění instrukcí větší množství teoretických omezení, než například původní čipy Pentium se dvěma pipeline nazvanými U a V. To však souvisí například s tím, že v poměrně minimalisticky pojatém SH-4 je použita pouze jedna plnohodnotná ALU s barrel shifterem, která je doplněna samostatným blokem pro porovnání dvou operandů (Pentium mělo dvě ALU, i když ta druhá neměla barrel shifter). Totéž porovnání lze samozřejmě provést i v ALU, což znamená, že párování operací CMP/xx+ADD (například) je možné provést prakticky za všech okolností, dokonce lze i párovat operace CMP/xx+CMP/xx (což však nemá praktický význam). Nemožnost párování dvou ALU operací nemusí být kritická ve chvíli, kdy se navíc provádí přenosy dat popř. příprava dat v pracovních registrech, protože ALU operaci+load/store či ALU operaci+MOV provést paralelně lze.
5. Instrukční sada jader SH-4
Počet instrukcí použitých v RISCových jádrech řady SuperH postupně narůstal, takže se původní sada 56 RISCových instrukcí v jádru SH-1 rozrostla až na trojnásobek v jádrech s podporou DSP operací (SH-2 DSP a SH-3 DSP). V následující tabulce jsou vypsány počty instrukcí u základních řad procesorových jader SuperH:
| Jádro | Počet instrukcí |
|---|---|
| SH-1 | 56 |
| SH-2 | 62 |
| SH-3 | 68 |
| SH-4 | 91 |
| SH-2A | 97 |
| SH-2 DSP | 154 |
| SH-3 DSP | 160 |
Důležité upozornění: instrukční sady se ve skutečnosti zcela nepřekrývají, což se týká především porovnání SH-2A a SH-4, i když obě tato jádra ideově vychází z jádra SH-2.
V následujících tabulkách jsou vypsány všechny instrukce podporované jádry SH-4. Tučně jsou zvýrazněny ty instrukce, které byly nově přidány (v porovnání s řadou SH-2).
Přenosy dat:
| Instrukce | Popis |
|---|---|
| MOV | přesun dat do registru popř. uložení do operační paměti (mnoho adresovacích režimů) |
| MOVA | výpočet disp × 4 + PC → R0 (užitečné při načítání 32bitových konstant) |
| LDC | přenos dat mezi pracovním registrem Rs a speciálním registrem SR, GBR či VBR |
| LDS | přenos dat mezi pracovním registrem Rs a speciálním registrem PR, MACH či MACL |
| STC | přenos dat mezi speciálním registrem SR, GBR či VBR a pracovním registrem Rs |
| STS | přenos dat mezi speciálním registrem PR, MACH či MACL a pracovním registrem Rd |
| SWAP | prohození dvou nejnižších bajtů či dvou 16bitových slov (lze použít dva registry) |
| XTRCT | prostředních 32 bitů z registrového páru Rs:Rd se uloží do Rd |
| EXTS | znaménkové rozšíření bajtu či 16bitového slova na 32bitové slovo |
| EXTU | bezznaménkové rozšíření bajtu či 16bitového slova na 32bitové slovo (horních 24/16 bitů se vynuluje) |
Aritmetické instrukce:
| Zkratka | Popis |
|---|---|
| ADD | součet registr+registr či registr+konstanta |
| ADDC | součet registr+registr+T, přenos (carry) se uloží do T |
| ADDV | součet registr+registr, přetečení (overflow) se uloží do T |
| SUB | rozdíl registr-registr či registr-konstanta |
| SUBC | rozdíl registr-registr-T, výpůjčka (borrow) se uloží do T |
| SUBV | rozdíl registr-registr, podtečení (underflow) se uloží do T |
| NEG | rozdíl 0-registr |
| NEGC | rozdíl 0-registr-T, výpůjčka (borrow) se uloží do T |
| MUL | násobení 16bitových či 32bitových operandů s 32bitovým výsledkem |
| MULS | násobení 16bitových operandů s 32bitovým výsledkem (signed) |
| MULU | násobení 16bitových operandů s 32bitovým výsledkem (unsigned) |
| MAC | (Rn)*(Rm)+MAC → MAC, Rn++, Rm++ (posun v poli) |
| DMULS | násobení 32bitových operandů s 64bitovým výsledkem (signed) |
| DMULU | násobení 32bitových operandů s 64bitovým výsledkem (unsigned) |
| DIV1 | jeden krok dělení Rs/Rd |
| DIV0S | příprava na dělení dvou čísel se znaménkem (nastavení bitů M, Q a T) |
| DIV0U | příprava na dělení dvou čísel bez znaménka (nastavení bitů M, Q a T) |
Logické instrukce:
| Zkratka | Popis |
|---|---|
| AND | provedení operace Rs & Rd či Rs & konstanta |
| OR | provedení operace Rs | Rd či Rs | konstanta |
| XOR | provedení operace Rs ⊕ Rd či Rs ⊕ konstanta |
| NOT | negace bitů zdrojového registru Rs |
Bitové posuny a rotace:
| Zkratka | Popis |
|---|---|
| ROTL | rotace registru doleva, do T se uloží původní nejvyšší bit |
| ROTR | rotace registru doprava, do T se uloží původní nejnižší bit |
| ROTCL | rotace registru doleva přes bit T (33 bitů) |
| ROTCR | rotace registru doprava přes bit T (33 bitů) |
| SHAL | aritmetický posun doleva (nasouvá se nula, nejvyšší bit se kopíruje do T) |
| SHAR | aritmetický posun doprava (nejvyšší bit se klonuje, nejnižší se přesouvá do T) |
| SHLL | bitový posun doleva, T se nemění |
| SHLLn | bitový posun doleva o 2, 8 či 16 bitů, T se nemění |
| SHLR | bitový posun doprava, T se nemění |
| SHLRn | bitový posun doprava o 2, 8 či 16 bitů, T se nemění |
| SHAD | pokud Rn≥0 posun doleva o Rm, pokud Rn<0 aritmetický posun doprava |
| SHLD | pokud Rn≥0 posun doleva o Rm, pokud Rn<0 bitový posun doprava |
Porovnání či další operace nastavující bit T:
| Zkratka | Popis |
|---|---|
| CMP/EQ | nastavení 1→T za podmínky Rs=Rd |
| CMP/HS | nastavení 1→T za podmínky Rs≥Rd (unsigned) |
| CMP/GE | nastavení 1→T za podmínky Rs≥Rd (signed) |
| CMP/HI | nastavení 1→T za podmínky Rs>Rd (unsigned) |
| CMP/GT | nastavení 1→T za podmínky Rs>Rd (signed) |
| CMP/PZ | nastavení 1→T za podmínky Rs≥0 |
| CMP/PL | nastavení 1→T za podmínky Rs>0 |
| CMP/STR | nastavení 1→T za podmínky Rs=Rd (jen spodní bajt) |
| TAS | nastavení 1→T za podmínky (Rs)=0 (buňka v paměti) |
| TST | nastavení 1→T za podmínky Rs & Rd == 0 |
| DT | snížení obsahu registru o 1 a nastavení 1→T pokud Rs==0 |
Operace s bity T a S:
| Zkratka | Popis |
|---|---|
| MOVT | uložení bitu T do registru Rn |
| CLRT | vynulování bitu 0→T |
| SETT | nastavení bitu 1→T |
| CLRS | uložení 0 do bitu S |
| SETS | nastavení bitu 1→S |
Poznámka: bit S je používán instrukcemi typu multiply and accumulate.
Podmíněné a nepodmíněné skoky, vstup a návrat z podprogramu:
| Zkratka | Popis |
|---|---|
| JMP | skok na adresu Rs |
| BRA | skok na adresu PC+displacement*2 |
| BRAF | skok na adresu PC+Rs |
| JSR | uložení PC do registru PR, skok na adresu Rs |
| RTS | skok na adresu v PR |
| BSR | uložení PC do registru PR, skok na adresu PC+displacement*2 |
| BSRF | uložení PC do registru PR, skok na adresu PC+Rs |
| BF | skok na adresu PC+disp pokud platí T==0 |
| BT | skok na adresu PC+disp pokud platí T==0 |
| BF/S | totéž jako BF, ale bez branch delay slotu |
| BT/S | totéž jako BF, ale bez branch delay slotu |
Další instrukce:
| Zkratka | Popis |
|---|---|
| NOP | neprovede žádnou operaci |
| CLRMAC | vynulování registrů MACH a MACL (například před aplikací číslicového filtru) |
| RTE | návrat z přerušení atd. (obnovení SR a PC ze zásobníku) |
| SLEEP | přepnutí do stavu sleep (pouze u mikrořadičů SH-2) |
| TRAPA | příprava zásobníkového rámce, skok na adresu VBR+konstanta |
| LDTLB | registry PTEH a PTEL se uloží do TLB (translation lookaside buffer) |
| MOVCA.L R0,@Rn | uložení registru R0 do paměti, ovšem bez načtení bloku z paměti, když není v cache |
| OCBI @Rn | invalidace bloku v cache (vynuluje bit V) |
| OCBP @Rn | zápis+invalidace bloku v cache |
| OCBWB @Rn | vynucení zápisu bloku z cache do paměti |
| PREFI @Rn | načtení bloku (32 bajtů) do instrukční cache |
6. Instrukce pro SH-2A, které nejsou podporovány v jádru SH-4
V páté kapitole jsme si řekli, že instrukční sada SH-4 se přesně nepřekrývá s již popsanou instrukční sadou SH-2A. Konkrétně to znamená, že na SH-4 nenajdeme následující instrukce, které se týkají práce s bankami registrů (ty jsou řešeny odlišným způsobem) a především pak operací Booleovského procesoru (bitové operace):
| Zkratka | Popis |
|---|---|
| MOVI20 | přenos konstanty o šířce 20 bitů do registru Rn |
| MOVI20S | dtto, ale konstanta je posunuta o osm bitů doleva |
| MOVML.L Rm,@-R15 | zápis registrů R0..Rm do paměti adresované R15 |
| MOVML.L @R15+,Rn | přečtení registrů R0..Rn z paměti adresované R15 |
| MOVMU.L Rm,@-R15 | zápis PR a registrů Rn..R14 do paměti adresované R15 |
| MOVMU.L @R15+,Rn | přečtení registrů PR a Rn..R14 z paměti adresované R15 |
| RESBANK | přepnutí banky registrů a tím pádem přepsání všech 19 výše zmíněných registrů |
| STBANK | uložení registru R0 do vybrané banky registrů |
| LDBANK | načtení registru R0 z vybrané banky registrů |
| BCLR | vynulování i-tého bitu registru Rn |
| BSET | nastavení i-tého bitu registru Rn (na 1) |
| BLD | přenos i-tého bitu registru Rn do příznakového bitu T |
| BST | přenos příznakového bitu T do i-tého bitu registru Rn |
| BCLR.B | uložení 0 na i-tý bit na adrese (disp + Rn)) |
| BSET.B | uložení 1 na i-tý bit na adrese (disp + Rn)) |
| BLD.B | načtení i-tého bitu z adresy (disp + Rn) a uložení do T |
| BLDNOT.B | negace předchozího výpočtu |
| BST.B | uložení T do i-tého bitu na adrese (disp + Rn) |
| BAND.B | (i-tý bit z adresy (disp + Rn)) ∧ T → T |
| BANDNOT.B | negace předchozího výpočtu |
| BOR.B | (i-tý bit z adresy (disp + Rn)) | T → T |
| BORNOT.B | negace předchozího výpočtu |
| BXOR.B | (i-tý bit z adresy (disp + Rn)) ⊕ T → T |
| CLIPS.B Rn | když Rn > 127, zapiš do Rn 127 a nastav CS totéž pro podmínku Rn < –128 |
| CLIPS.W Rn | když Rn > 32767, zapiš do Rn 127 a nastav CS totéž pro podmínku Rn < –32768 |
| CLIPU.B Rn | když Rn > 255, zapiš do Rn 255 a nastav CS |
| CLIPU.W Rn | když Rn > 65535, zapiš do Rn 65535 a nastav CS |
| MULR | operace Rn × R0 → Rn |
| DIVU | operace Rn ÷ R0 → Rn (hodnoty bez znaménka) |
| DIVS | operace Rn ÷ R0 → Rn (hodnoty se znaménkem) |
| MOVRT | přenos negovaného bitu T do vybraného registru Rn |
| NOTT | negace stavového bitu; T=~T |
| JSR/N | skok do subrutiny (ovšem bez branch delay slotu) |
| RTS/N | návrat ze subrutiny (opět bez branch delay slotu) |
| RTV/N | uložení vybraného registru do R0 a návrat ze subrutiny (opět bez branch delay slotu) |
7. Jádra SH-4A
Architektura SH-4A by se sice podle svého jména měla podobat architektuře SH-4, ve skutečnosti se ovšem vnitřní uspořádání procesoru v některých ohledech odlišuje. Poznáme to například při pohledu na pipeline, která již nemá pouhých pět řezů, ale řezů osm. To na jednu stranu sice znamená, že doba trvání jedné instrukce je delší (pokud počítáme strojové cykly a nikoli nutně reálný čas), na stranu druhou je však možné současně vykonávat větší množství instrukcí; navíc jsou jednotlivé řezy provedeny za kratší dobu (jsou jednodušší). Pravděpodobně důležitější je však vylepšení superskalární architektury a zavedení forwardingu do pipeline (tím se zmenší počet případných konfliktů).
8. Pipeline použité v architektuře SH-4A
Základní pipeline procesoru s jádry SH-4A vypadá následovně:
+----+----+----+----+----+----+----+----+ | I1 | I2 | I3 | ID | E1 | E2 | E3 | WB | +----+----+----+----+----+----+----+----+
První dvě fáze I1 a I2 provádí načtení instrukce, ve fázích I3 a ID dochází k dekódování instrukce a ke čtení vybraného registru/registrů (například do latche ALU). Pro instrukce typu load a store se ve fázi E1 vypočte adresa a ve fázích E2+E3 se přistupuje k operační paměti (čtení či zápis). Pokud se však jedná o ALU operace, provádí se ve fázích E2+E3 výpočty a fáze E1 je rezervována pro případný forwarding (to je na těchto jádrech užitečná novinka!).
9. Pipeline pro FPU operace
Pipeline určená pro FPU operace má minimálně devět řezů:
+----+----+----+----+----+----+----+----+----+ | I1 | I2 | I3 | ID | FS1| FS2| FS3| FS4| FS | +----+----+----+----+----+----+----+----+----+
Rozdílem oproti předchozí konfiguraci pipeline je, že čtení pracovních registrů se provádí až ve fázi FS1 (nikoli ID), současně je možné v téže fázi provést forwarding. Fáze FS2-FS4 slouží pro vlastní výpočet.
Složitější instrukce (kromě FDIV či FSQRT) mají pipeline ještě delší:
+----+----+----+----+----+----+----+----+----+----+----+ | I1 | I2 | I3 | ID | FS1| FS2| FS3| FS4| FS5| FS6| FS | +----+----+----+----+----+----+----+----+----+----+----+
Opět platí, že několik instrukcí, zejména pak FDIV a FSQRT, trvají ještě delší dobu
10. Instrukce matematického koprocesoru určené pro urychlení grafických operací
Matematický koprocesor kromě základních instrukcí podporuje i čtyři (SH-4) či dokonce sedm (SH-4A) nových instrukcí, které jsou určeny pro urychlení některých grafických operací. Jedná se o následující instrukce:
| Zkratka | Jádro | Popis |
|---|---|---|
| FIPR | SH-4 | výpočet skalárního součinu popř. součtu čtverců prvků vektorů |
| FTRV | SH-4 | příprava pro maticové násobení či vynásobení matice vektorem (čtyřprvkovým) |
| FSRRA | SH-4A | výpočet hodnoty 1/sqrt(FR) |
| FSCA | SH-4A | FRn=sin(FPUL), FRn+1=cos(FPUL) |
| FRCHG | SH-4 | negace bitu FPSCR.FR |
| FSCHG | SH-4 | negace bitu FPSCR.SZ |
| FPCHG | SH-4A | negace bitu FPSCR.PR |
Užitečná je především první operace FIPR, protože ji lze použít jak na výpočet délky vektoru (oba vstupní vektory jsou shodné), tak i pro operace s polygony atd. Pro první účel, pokud je tedy skutečně nutné vypočítat délku vektoru, se může použít kombinace instrukcí FIPR+FSRRA. Zajímavá instrukce FSCA se používá například při výpočtu rotací, konkrétně při vyplňování transformační matice rotace. Operace FTRV sice neprovádí přímo maticové násobení, ale připravuje (extrahuje) prvky z matice 4×4 do vektoru.
Poslední čtyři instrukce lze použít pro rychlé přepínání režimu koprocesoru, protože bit FPSCR.FR přepíná banku registrů, bit FPSCR.ZF určuje, zda se budou přenášet hodnoty single či double a konečně bit FPSCR.PR přepíná režim výpočtů (single/double).
Pro maticové operace byla sada pracovních registrů rozšířena o nových šestnáct registrů pojmenovaných XF0 až XF15, které tvoří matici XMTRX o velikosti 4×4 prvky. Bitem FPSRC.FR je možné přepnutí mezi původními pracovními registry a „maticovými registry“, o „projekci“ čtyř prvků z matice se postará již zmíněná operace FTRV.
11. Obsah následující části seriálu
V navazujícím článku se budeme zabývat popisem dalších čipů, které byly v minulosti navrženy a vyráběny společností Hitachi, ovšem dnes je prakticky celý tento segment vlastněn firmou Renesas Technology. Bude se jednat o čipy patřící do rodiny nazvané H8, která zahrnuje osmibitové, šestnáctibitové a dokonce i 32bitové mikrořadiče. Tyto čipy se však – i přes poněkud podobný název s řadou SuperH – v mnoha podstatných věcech odlišují. Týká se to jak jejich vnitřního uspořádání (pipeline, velikost sady pracovních registrů, podpora či naopak nepodpora superkalárního zpracování, podpora pro branch delay sloty apod.), tak i instrukční sady, která je u řady H8 v některých ohledech inspirována ortogonálními (tedy de facto neRISCovými) instrukčními sadami počítačů DEC PDP-11.
Poznámka: teoreticky by bylo možné pokračovat popisem architektury SH-5, což je/byl (další) poměrně neúspěšný pokus o vytvoření 64bitového RISCového procesoru, ovšem tato architektura není podporována v reálných čipech ani v překladačích.
12. Odkazy na Internetu
- Renesas SH Instruction Set Summary
http://shared-ptr.com/sh_insns.html - SH-4 RISC Processor by HITACHI
http://www.cs.umd.edu/~meesh/cmsc411/website/projects/risc/risc.htm - SH-4 RISC Processor
http://www.cs.umd.edu/~meesh/cmsc411/website/projects/risc/sh-4.htm - Superscalar processor (Wikipedia)
https://en.wikipedia.org/wiki/Superscalar_processor - Category:Parallel computing (Wikipedia)
https://en.wikipedia.org/wiki/Category:Parallel_computing - SH7750R
https://www.renesas.com/en-us/document/hw-manual?hwLayerShowFlg=true&prdLayerId=1060&layerName=SH7750R&coronrService=document-prd-search&hwDocUrl=%2Fen-us%2Fdoc%2Fproducts%2Fmpumcu%2F001%2Fr01uh0456ej0702_sh7750.pdf&hashKey=fb85df425a5b14b0b3c982f71d0ac1c7 - SH7201 Group User's Manual: Hardware
https://www.renesas.com/en-us/document/hw-manual?hwLayerShowFlg=true&prdLayerId=2038&layerName=SH7201&coronrService=document-prd-search&hwDocUrl=%2Fen-us%2Fdoc%2Fproducts%2Fmpumcu%2Fdoc%2Fsuperh%2Fr01uh0026ej_sh7201_hm.pdf&hashKey=4d1ed116961466babf99bc7cf1d2cdec - SH7203 Group User's Manual: Hardware
https://www.renesas.com/en-us/document/hw-manual?hwLayerShowFlg=true&prdLayerId=2126&layerName=SH7203&coronrService=document-prd-search&hwDocUrl=%2Fen-us%2Fdoc%2Fproducts%2Fmpumcu%2F001%2Fr01uh0458ej0400_sh7203.pdf&hashKey=68baf3ad6c52e9e2616e44024589e8cf - SuperH RISC engine Family Features
https://www.renesas.com/en-us/products/microcontrollers-microprocessors/superh/superh-features.html - Orthogonal instruction set
https://en.wikipedia.org/wiki/Orthogonal_instruction_set - Konkurence procesorů s mikroprogramovým řadičem – RISC
http://www.root.cz/clanky/konkurence-procesoru-s-mikroprogramovym-radicem-architektura-risc/ - Mikroprocesory s architekturou RISC I
http://www.root.cz/clanky/mikroprocesory-s-architekturou-risc-i/ - Procesory RISC v pracovních stanicích a serverech
http://www.root.cz/clanky/procesory-s-architekturou-risc-v-pracovnich-stanicich-a-serverech/ - Procesory RISC v pracovních stanicích a serverech – architektura SPARC V8 a
http://www.root.cz/clanky/procesory-risc-v-pracovnich-stanicich-a-serverech-architektura-sparc-v8-a-v9/ - Procesory RISC v pracovních stanicích a serverech – architektura PA-RISC
http://www.root.cz/clanky/procesory-risc-v-pracovnich-stanicich-a-serverech-architektura-pa-risc/ - Rozšíření instrukční sady procesorových jader s otevřenou architekturou RISC-V
http://www.root.cz/clanky/rozsireni-instrukcni-sady-procesorovych-jader-s-otevrenou-architekturou-risc-v/ - Sega documentation
http://koti.kapsi.fi/~antime/sega/docs.html - 1995 Programming on the Sega Saturn
http://cowboyprogramming.com/2010/06/03/1995-programming-on-the-sega-saturn/ - Sega Myths-Saturn was the most difficult console to program for of 5th Gen
http://forums.sega.com/showthread.php?313485-Sega-Myths-Saturn-was-the-most-difficult-console-to-program-for-of-5th-Gen - SuperH RISC engine Family
http://www.renesas.com/products/mpumcu/superh/index.jsp - Sega Saturn
http://en.wikipedia.org/wiki/Sega_saturn - Fourth-Generation Consoles
http://gaming.wikia.com/wiki/Fourth-Generation_Consoles - Fifth-Generation Consoles
http://gaming.wikia.com/wiki/Fifth-Generation_Consoles - History of video game consoles (fifth generation)
http://en.wikipedia.org/wiki/History_of_video_game_consoles_(fifth_generation) - Sega Mega Drive
http://sega.jp/archive/segahard/md/ - Sega Archives
http://sega.jp/archive/segahard/ - Sega Genesis
http://www.dmoz.org/Games/Video_Games/Console_Platforms/Sega/Genesis/ - The Sega Mega Drive/Genesis
http://www.captainwilliams.co.uk/sega/megadrive/megadrive.php - Sega Master System Museum
http://alexkidd.com/ - Jadeite's Sega Master System Museum
http://rp_gamer.tripod.com/SMS/1.html - Sega Master System (Wikipedia)
http://en.wikipedia.org/wiki/Sega_Master_System - Sega Card (Wikipedia)
http://en.wikipedia.org/wiki/Sega_Card - Sega Master System VDP documentation
http://www.smspower.org/uploads/Development/msvdp-20021112.txt?sid=28c370e1fcac51d5774319979bf96f4c - The16bit Era Of Console Video Games
http://tvtropes.org/pmwiki/pmwiki.php/Main/The16bitEraOfConsoleVideoGames - The Console Wars
http://www.cracked.com/funny-2590-the-console-wars/ - Console Wars
http://tvtropes.org/pmwiki/pmwiki.php/Main/ConsoleWars - Era of the „Bit Wars“
http://www.gtplanet.net/forum/threads/era-of-the-bit-wars.119796/ - Rez Wars: How the Bit Wars never really ended
http://www.ign.com/blogs/beastmastertoad/2013/01/31/rez-wars-how-the-bit-wars-never-really-ended - Which system ended the „Bit Wars“?
http://atariage.com/forums/topic/199163-which-system-ended-the-bit-wars/ - Status Register
https://en.wikipedia.org/wiki/Status_register - Introduction to ARM Thumb
http://www.embedded.com/electronics-blogs/beginner-s-corner/4024632/Introduction-to-ARM-thumb - Code Size – a comprehensive comparison of microMIPS32 and Thumb code size using many Megabytes of customer code
https://community.arm.com/groups/processors/blog/2014/04/28/code-size-a-comprehensive-comparison-of-micromips32-and-thumb-code-size-using-many-megabytes-of-customer-code - MIPS MCUs Outrun ARM
http://www.linleygroup.com/newsletters/newsletter_detail.php?num=5117 - Carry bits, The Architect's Trap
http://yarchive.net/comp/carry_bit.html - Microprocessor Design/ALU Flags
https://en.wikibooks.org/wiki/Microprocessor_Design/ALU_Flags - Flags register in an out-of-order processor
http://cs.stackexchange.com/questions/42095/flags-register-in-an-out-of-order-processor - Berkeley RISC
http://en.wikipedia.org/wiki/Berkeley_RISC - Great moments in microprocessor history
http://www.ibm.com/developerworks/library/pa-microhist.html - RISC vs. CISC
http://www-cs-faculty.stanford.edu/~eroberts/courses/soco/projects/2000–01/risc/risccisc/ - RISC and CISC definitions:
http://www.cpushack.com/CPU/cpuAppendA.html - The Evolution of RISC
http://www.ibm.com/developerworks/library/pa-microhist.html#sidebar1 - The VFP architecture
http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0056d/Bcfibfha.html - NEON
http://www.arm.com/products/processors/technologies/neon.php - ARM Floating Point Accelerator (ARM FPA)
http://vswww.kaist.ac.kr/ver4.0/index.php/research/past-research/arm-fpa.html
