Obsah
1. Instrukční sady procesorových jader s otevřenou architekturou RISC-V (dokončení)
2. Dokončení popisu rozšíření instrukční sady „F“
3. Instrukce určené pro modifikaci znaménka výsledku
4. Rozdíl mezi konverzí FP hodnoty na celé číslo a kopií bitového vzorku
5. Rozšíření instrukční sady „D“ – podpora pro hodnoty s dvojitou přesností
6. Rozšíření instrukční sady „Q“ – podpora pro hodnoty se čtyřnásobnou přesností
7. Rozšíření instrukční sady „A“ – podpora pro atomické operace
8. AMO: Atomic Memory Operation
9. 64bitová instrukční sada RV64I
10. Neoficiální rozšíření instrukční sady „C“ – komprimované instrukce
1. Instrukční sady procesorových jader s otevřenou architekturou RISC-V (dokončení)
V předchozích dvou částech [1][2] seriálu o otevřené architektuře RISCových procesorových jader RISC-V jsme se seznámili jak se základní 32bitovou instrukční sadou pojmenovanou jednoduše RV32I (RISC-V 32bit Instructions), tak i s jejím rozšířením označeným písmenem „M“, které obsahuje nové instrukce určené pro provedení operací násobení a dělení. Teoreticky tedy tyto instrukce vyžadují hardwarovou násobičku a děličku, i když ve skutečnosti se může jednat i o implementaci založenou na ne-RISCovém mikroprogramovém řadiči. Taktéž jsme se ve stručnosti zmínili o rozšíření označeném písmenem „F“, tj. vlastně o matematickém koprocesoru určeném pro zpracování numerických hodnot s jednoduchou přesností (single/float). Termín „koprocesor“ zde používám z toho důvodu, že používá vlastní instrukční sadu i vlastní sadu registrů, i když fyzicky se velmi pravděpodobně bude jednat o totožný čip, na němž bude implementováno i RISCové jádro (a L1 cache).
Z předchozích dvou článků taktéž víme, že kromě rozšíření instrukční sady „M“ a „F“ jsou specifikována i další rozšíření, která mohou (ale nemusí) být na čipech RISC-V podporována. Jedná se především o rozšíření „D“, v němž jsou definovány instrukce provádějící operace s numerickými hodnotami s dvojnásobnou přesností (double), dále pak o rozšíření „Q“ pro operace s numerickými hodnotami s přesností čtyřnásobnou (quadruple) a taktéž o rozšíření „A“ s atomickými instrukcemi (resp. přesněji řečeno s instrukcemi, s jejichž využitím lze některé atomické operace provést, což je velmi důležitá vlastnost v případě použití většího množství paralelně běžících procesorových jader). Zapomenout nesmíme ani na sadu pojmenovanou RV64I s instrukcemi s 64bitovými operandy (64bitovými pracovními registry) a taktéž na prozatím neoficiální sadu „C“ s komprimovanými instrukcemi, které se vzdáleně podobají sadě Thumb známé z mikroprocesorů s architekturou ARM. Právě touto problematikou se budeme zabývat v dnešním článku.
2. Dokončení popisu rozšíření instrukční sady „F“
Před popisem dalších rozšíření instrukčních sad nejprve dokončeme popis rozšířené instrukční sady označené písmenem „F“, jemuž jsme se věnovali minule. Připomeňme si, že se jedná o instrukce určené pro provádění operací s numerickými hodnotami s plovoucí řádovou čárkou s jednoduchou přesností (single/float). Jak tyto operace, tak i formát čísel je specifikován ve známé normě IEEE 754, která se v roce 2008 dočkala své úpravy a zpřesnění. Právě této upravené normě odpovídají i instrukce v rozšíření „F“. Vzhledem k tomu, že se počítá s existencí matematického koprocesoru pracujícího v ideálním případě paralelně s hlavním CPU, využívá se i oddělená sada pracovních registrů, které jsou pojmenovány f0 až f31. Každý z těchto registrů má šířku 32 bitů, což přesně odpovídá požadavkům datových typů single/float. Navíc se u většiny operací používá i stavový a řídicí registr nazvaný fcrs. K dispozici jsou pseudoinstrukce FRCSR a FSCSR sloužící pro přenos obsahu stavového a řídicího registru do libovolného pracovního registru celočíselné části mikroprocesoru (R=Read, S=Store).
Minule jsme si již popsali i většinu instrukcí podporovaných tímto matematickým koprocesorem. Zejména se jednalo o následující instrukce (vynechávám jen některé instrukce určené pro přenos dat, které popsané níže):
# | Instrukce | Význam |
---|---|---|
1 | FLW | načtení FP hodnoty z paměti (adresa rs+offset) |
2 | FSW | uložení FP hodnoty do paměti (adresa rs+offset) |
3 | FADD.S | součet dvou FP hodnot (tříadresový kód) |
4 | FSUB.S | rozdíl dvou FP hodnot |
5 | FMUL.S | součin dvou FP hodnot |
6 | FDIV.S | podíl dvou FP hodnot |
7 | FMIN.S | vrací menší z obou FP hodnot |
8 | FMAX.S | vrací větší z obou FP hodnot |
9 | FSQRT.S | druhá odmocnina (použity jsou jen dva registry) |
10 | FMADD.S | rs1×rs2+rs3 (multiply-add, čtyřadresový kód!) |
11 | FMSUB.S | rs1×rs2-rs3 |
12 | FNMADD.S | -(rs1×rs2+rs3) |
13 | FNMSUB.S | -(rs1×rs2-rs3) |
14 | FLT.S | porovnání dvou FP hodnot, zápis 0 či 1 do integer registru |
15 | FLE.S | porovnání dvou FP hodnot, zápis 0 či 1 do integer registru |
16 | FEQ.S | porovnání dvou FP hodnot, zápis 0 či 1 do integer registru |
17 | FCLASS | zjistí „třídu“ FP hodnoty a nastaví deset bitů podle následující tabulky |
3. Instrukce určené pro modifikaci znaménka výsledku
Mezi další instrukce provádějících operace s hodnotami s plovoucí řádovou čárkou, které jsme si doposud nepopsali, patří především operace sloužící pro manipulaci se znaménkem výsledku. Tyto operace lze použít k mnoha účelům, typicky pro implementaci výpočtu absolutní hodnoty, negaci výsledku, popř. jen pro pouhý přesun dat atd. Všechny tři dále popsané instrukce mají ve svém slovu místo pro určení indexů dvou zdrojových registrů src1, src2 a jednoho registru cílového dest:
# | Instrukce | Význam |
---|---|---|
1 | FSGNJ.S | kopie z registru src1 do dest, ovšem kromě znaménka; to je přečteno ze src2 |
2 | FSGNJN.S | kopie z registru src1 do dest, ovšem kromě znaménka; to je přečteno ze src2 a znegováno |
3 | FSGNJX.S | kopie z registru src1 do dest, ovšem kromě znaménka; to je získáno ze src1 i src2 s využitím operace XOR |
Některé kombinace zdrojových registrů a cílového registru vedou k provedení operace, která má vlastní pseudoinstrukci (jen alias využívaný v assembleru):
Instrukce | Pseudoinstrukce | Význam |
---|---|---|
FSGNJ.S rx, ry, ry | FMV.S rx, ry | přesun dat (oba zdrojové registry jsou totožné) |
FSGNJN.S rx, ry, ry | FNEG.S rx, ry | přesun dat s negací |
FSGNJX.S rx, ry, ry | FABS,S rx, ry | výpočet absolutní hodnoty (XOR stejné hodnoty se vždy rovná nule) |
4. Rozdíl mezi konverzí FP hodnoty na celé číslo a kopií bitového vzorku
Vraťme se ještě na chvíli k instrukcím, které slouží pro přesuny dat mezi registry hlavního mikroprocesoru (tj. mezi celočíselnými registry) a mezi registry procesoru matematického. V případě hlavního mikroprocesoru má programátor k dispozici celkem 31 registrů pojmenovaných x1 až x31 doplněných o „konstantní nulu“ reprezentovanou registrem x0. Matematický koprocesor má registry pojmenované f0 až f31. Existují celkem dva typy instrukcí zajišťujících přesuny dat. Prvním typem jsou konverzní instrukce FCVT doplněné o typ konvertovaných dat (W – 32bitové slovo se znaménkem, WU – 32bitové slovo bez znaménka, S – single) a samozřejmě i o směr konverze. Druhým typem jsou instrukce provádějící bitové kopie dat bez jakékoli konverze. Tyto instrukce (jsou dvě) se jmenují FMV:
# | Instrukce | Význam |
---|---|---|
1 | FCVT.W.S | převod FP na integer |
2 | FCVT.S.W | převod integer na FP |
3 | FCVT.WU.S | převod FP na unsigned integer |
4 | FCVT.S.WU | převod unsigned integer na FP |
5 | FMV.X.S | pouze přesun mezi integer registrem a FP registrem (nikoli konverze) |
6 | FMV.S.X | pouze přesun mezi FP registrem a integer registrem (nikoli konverze) |
Konverzní instrukce zhruba odpovídají konverzím dat v jazyku C:
float f = fooBarBaz(...); int i = (int) f;
Bitové kopie se dají provést například s využitím unií (i když to přesně neodpovídá specifikaci):
union { int i; float f; } converter; converter.f = 3.1415f; int x = converter.i;
5. Rozšíření instrukční sady „D“ – podpora pro hodnoty s dvojitou přesností
Další rozšíření základní instrukční sady nese označení „D“, takže asi nebude velkým překvapením, že tato rozšiřující instrukční sada slouží pro provádění operací s numerickými hodnotami s dvojitou přesností (typ double), což jsou opět operace specifikované v normě IEEE 754. Pokud mikroprocesor s architekturou RISC-V podporuje tuto instrukční sadu, budou použity registry pojmenované f0 až f31, což jsou stejně pojmenované registry, jaké již známe z rozšíření „F“. Je zde ovšem jeden podstatný rozdíl – nyní budou mít registry šířku 64 bitů a nikoli pouze 32 bitů. I instrukční sady „F“ a „D“ jsou si v mnoha ohledech podobné, i když zde narazíme na některé pochopitelné rozdíly. Především došlo k přidání dvou nových instrukcí sloužících pro načtení resp. pro uložení numerické hodnoty do paměti:
# | Instrukce | Význam |
---|---|---|
1 | FLD | načtení FP hodnoty z paměti (adresa rs+offset) |
2 | FSD | uložení FP hodnoty do paměti (adresa rs+offset) |
Je zřejmé, že tyto instrukce jsou obdobou původních 32bitových instrukcí FLW a FSW.
Základní aritmetické operace jsou prakticky stejné, pouze mají odlišný postfix:
# | Instrukce | Význam |
---|---|---|
1 | FADD.D | součet dvou FP hodnot (tříadresový kód) |
2 | FSUB.D | rozdíl dvou FP hodnot |
3 | FMUL.D | součin dvou FP hodnot |
4 | FDIV.D | podíl dvou FP hodnot |
5 | FMIN.D | vrací menší z obou FP hodnot |
6 | FMAX.D | vrací větší z obou FP hodnot |
7 | FSQRT.D | druhá odmocnina (použity jsou jen dva registry) |
Dále jsou definovány konverzní operace mezi hodnotami s jednoduchou přesností a přesností dvojitou:
# | Instrukce | Význam |
---|---|---|
1 | FCVT.S.D | double na single (provádí se zaokrouhlení) |
2 | FCVT.D.S | single na double (hodnota se nezmění) |
Zapomenout nesmíme ani na konverzi mezi hodnotami typu integer a double, ovšem některé konverze lze provádět pouze na 64bitových procesorech s instrukční sadou RV64I (už jen z toho důvodu, že na 32bitových procesorech nejsou k dispozici dostatečně široké pracovní registry):
# | Instrukce | Význam |
---|---|---|
1 | FCVT.W.D | double → 32bit signed integer |
2 | FCVT.L.D | double → 64bit signed integer |
3 | FCVT.WU.D | double → 32bit unsigned integer |
4 | FCVT.LU.D | double → 64bit unsigned integer |
5 | FCVT.D.W | 32bit signed integer → double |
6 | FCVT.D.L | 64bit signed integer → double |
7 | FCVT.D.WU | 32bit unsigned integer → double |
8 | FCVT.D.LU | 64bit unsigned integer → double |
I instrukce pro práci se znaménky mají svoji 64bitovou obdobu:
# | Instrukce | Význam |
---|---|---|
1 | FSGNJ.D | kopie z registru src1 do dest, ovšem kromě znaménka; to je přečteno ze src2 |
2 | FSGNJN.D | kopie z registru src1 do dest, ovšem kromě znaménka; to je přečteno ze src2 a znegováno |
3 | FSGNJX.D | kopie z registru src1 do dest, ovšem kromě znaménka; to je získáno ze src1 i src2 s využitím operace XOR |
Stejně jako přesuny bitové kopie mezi celočíselným registrem a FP registrem (opět platí pouze pro 64bitovou instrukční sadu):
# | Instrukce | Význam |
---|---|---|
1 | FMV.X.D | pouze přesun mezi integer registrem a FP registrem (nikoli konverze) |
1 | FMV.D.X | pouze přesun mezi FP registrem a integer registrem (nikoli konverze) |
6. Rozšíření instrukční sady „Q“ – podpora pro hodnoty se čtyřnásobnou přesností
Dalším rozšířením instrukčních sad je rozšíření označené písmenem „Q“. To přidává možnost práce s numerickými hodnotami s plovoucí řádovou čárkou se čtyřnásobnou přesností. Formát uložení těchto hodnot je specifikován v již několikrát zmíněné normě IEEE 754–2008. Ostatně podívejme se na následující tabulku, v níž jsou vypsány vybrané formáty numerických hodnot, které jsou v této normě specifikovány (vynechávám takzvané „decimální“ formáty) a jak se tyto formáty mapují na rozšířené instrukční sady mikroprocesorů RISC-V:
Oficiální jméno | Známo též jako | Znaménko | Exponent | Mantisa | Celkem | Decimálních číslic | RISV-5 |
---|---|---|---|---|---|---|---|
binary16 | half | 1 | 5b | 10b | 16b | cca 3,3 | není |
binary32 | single/float | 1 | 8b | 23b | 32b | cca 7,2 | „F“ |
binary64 | double | 1 | 11b | 52b | 64b | cca 15,9 | „D“ |
binary128 | quadruple | 1 | 15b | 112b | 128b | cca 34,0 | „Q“ |
Jak je z této tabulky patrné, tak – alespoň prozatím – není podporován první formát, což je trošku škoda, protože při zpracování signálů i v počítačové grafice tento formát nalezl své uplatnění.
Rozšíření „Q“ lze implementovat jen na 64bitových mikroprocesorech s instrukční sadou RV64I, které navíc podporují jak rozšíření „F“, tak i rozšíření „D“. Opět došlo ke zvětšení šířky FP registrů, a to na 128 bitů. Většina původních FP instrukcí zůstala zachována, pouze se změnil jejich postfix určující typ zpracovávaných numerických hodnot. Jediné instrukce, které byly odstraněny, jsou instrukce pro bitovou kopii dat mezi celočíselným registrem a FP registrem (což je vlastně pochopitelné), což znamená nutnost načítání a ukládání operandů přímo do operační paměti. V instrukční sadě „Q“ tedy neexistují tyto dvě instrukce: FMV.X.Q a FMV.Q.X.
Nové instrukce pro načítání a ukládání operandů do operační paměti:
# | Instrukce | Význam |
---|---|---|
1 | FLQ | načtení FP hodnoty z paměti (adresa rs+offset) |
2 | FSQ | uložení FP hodnoty do paměti (adresa rs+offset) |
Základní aritmetické operace jsou (opět) prakticky stejné, pouze mají odlišný postfix:
# | Instrukce | Význam |
---|---|---|
1 | FADD.Q | součet dvou FP hodnot (tříadresový kód) |
2 | FSUB.Q | rozdíl dvou FP hodnot |
3 | FMUL.Q | součin dvou FP hodnot |
4 | FDIV.Q | podíl dvou FP hodnot |
5 | FMIN.Q | vrací menší z obou FP hodnot |
6 | FMAX.Q | vrací větší z obou FP hodnot |
7 | FSQRT.Q | druhá odmocnina (použity jsou jen dva registry) |
Konverze mezi typy single, float a quadruple:
# | Instrukce | Význam |
---|---|---|
1 | FCVT.S.Q | quadruple → single |
2 | FCVT.Q.S | single → quadruple |
3 | FCVT.D.Q | quadruple → double |
4 | FCVT.Q.D | double → quadruple |
Operace se znaménkem:
# | Instrukce | Význam |
---|---|---|
1 | FSGNJ.Q | kopie z registru src1 do dest, ovšem kromě znaménka; to je přečteno ze src2 |
2 | FSGNJN.Q | kopie z registru src1 do dest, ovšem kromě znaménka; to je přečteno ze src2 a znegováno |
3 | FSGNJX.Q | kopie z registru src1 do dest, ovšem kromě znaménka; to je získáno ze src1 i src2 s využitím operace XOR |
7. Rozšíření instrukční sady „A“ – podpora pro atomické operace
Pro čipy s větším počtem jader či pro potřeby multiprocesorových systémů je určeno rozšíření instrukční sady „A“ s podporou atomických operací. Účelem instrukcí z rozšíření „A“ je zajištění kooperace mezi vlákny, a to ideálně bez nutnosti použití mutexů či signálů pro zamčení celé sběrnice (lock). Některé z dále popsaných instrukcí mají svou obdobu v instrukčních sadách MIPS, PowerPC, Alpha či ARM. Mezi dvě základní instrukce patří instrukce typu Load-Reserved (korektněji load and reserve) a Store-Conditional. Instrukce typu Load-Reserved slouží pro načtení slova z operační paměti z adresy uložené ve zdrojovém registru, uložení načtených dat do cílového registru a současně i „rezervace“ tohoto místa v paměti pro aktivní vlákno. Naproti tomu instrukce Store-Conditional provede zápis do paměti na určenou adresu, pokud je slovo (adresa) rezervováno (+ zrušení rezervace). Podle výsledku této operace se do cílového registru zapíše hodnota 0 či 1, kterou lze snadno otestovat například pomocí instrukce BEQ.
Důležité je, že Store-Conditional správně rozpozná zápis do dané lokace jiným vláknem, takže zde nenastane ABA problém, kdy cizí vlákno zapíše jinou hodnotu, kterou následně přepíše na hodnotu původní (může se jednat například o dvojí negaci). Naproti tomu „alternativní “operace typu CAS/compare-and-swap tento stav rozpoznat nedokáže.
U obou zmíněných operací se ještě nastavují dva řídicí bity pojmenované „aq“ a „rl“. Nastavení bitu „aq“ na hodnotu 1 zajistí, že žádné další operace s pamětí probíhající v aktivním vláknu nebudou viditelné před „aq“ operací (či naopak: efekt „aq“ operace bude viditelný před všemi následujícími operacemi s pamětí). Bit „aq“ tedy ovlivňuje chování budoucích operací. Naproti tomu nastavení bitu „rl“ zajistí, že všechny předchozí operace budou viditelné před „rl“ operací, ovlivňuje se tedy chování minulých operací. Samozřejmě lze nastavit i oba bity („aq“==1, „rl“==1), takové operace jsou sekvenčně konzistentní.
Poznámka: při kooperaci mezi více CPU nás skutečně zajímá jen obsah operační paměti (viditelný dalšími CPU), nikoli stav pracovních registrů.
8. AMO: Atomic Memory Operation
V instrukční sadě „A“ nalezneme i několik instrukcí označovaných zkratkou AMO neboli Atomic Memory Operation. Jedná se o operace typu read-modify-write, tj. o operace, které načtou hodnotu z paměti, nějak ji modifikují a následně ji znovu uloží do paměti. Všechny AMO instrukce používají tříadresový kód, což konkrétně znamená, že se v instrukčním slově nachází indexy tří registrů rs1, rs2 a rd. Každá AMO operace se skládá ze tří částí:
- Načtení slova z adresy uložené v registru rs1.
- Uložení této hodnoty do registru rd.
- Aplikace zvolené operace s načtenou hodnotou a hodnotou z registru rs2.
- Uložení výsledku zpět do paměti na adresu uložené v registru rs1.
Mezi podporované operace patří:
# | Operace |
---|---|
1 | SWAP |
2 | ADD |
3 | AND |
4 | OR |
5 | XOR |
6 | MAX |
7 | MIN |
Některé kombinace registrů jsou podporovány i v pseudoinstrukcích (aliasech):
AMOADD pro load (s využitím registru x0) AMOSWAP pro store (výsledek se uloží do registru x0)
9. 64bitová instrukční sada RV64I
Kromě základní 32bitové instrukční sady RV32I je specifikována i 64bitová instrukční sada RV64I. Instrukce specifikované v této sadě pracují se 64bitovými operandy, i když šířka operačních kódů instrukcí zůstává nastavena na 32. V rámci RV64I je definováno patnáct nových instrukcí resp. úprav již existujících instrukcí:
# | Instrukce |
---|---|
1 | LWU rd,rs1,imm |
2 | LD rd,rs1,imm |
3 | SD rs1,rs2,imm |
4 | SLLI rd,rs1,shamt |
5 | SRLI rd,rs1,shamt |
6 | SRAI rd,rs1,shamt |
7 | ADDIW rd,rs1,imm |
8 | SLLIW rd,rs1,shamt |
9 | SRLIW rd,rs1,shamt |
10 | SRAIW rd,rs1,shamt |
11 | ADDW rd,rs1,rs2 |
12 | SUBW rd,rs1,rs2 |
13 | SLLW rd,rs1,rs2 |
14 | SRLW rd,rs1,rs2 |
15 | SRAW rd,rs1,rs2 |
Většina instrukcí z výše uvedené tabulky má suffix W značící, že tyto instrukce pracují s 32bitovými hodnotami (ignoruje se horních 32bitů pracovních registrů a výsledek je 32bitová hodnota se znaménkem), zatímco všechny původní instrukce pracují s hodnotami 64bitovými.
Pojďme si jednotlivé instrukce z horní tabulky popsat podrobněji.
Instrukce typu Load a Store:
Instrukce | Význam |
---|---|
LWU rd,rs1,imm | načtení slova a jeho rozšíření na 64 bitů nulami (rozdíl oproti LW) |
(LW rd,rs1,imm) | načtení slova a jeho znaménkové rozšíření na 64 bitů (rozdíl oproti LWU) |
LD rd,rs1,imm | načtení 64bitového slova z paměti |
SD rs1,rs2,imm | zápis 64bitového slova do paměti |
64bitové posuny a rotace:
Instrukce | Význam |
---|---|
SLLI rd,rs1,shamt | počet bitů posunu je uložen v 6 bitech (původně dostačovalo v pěti) |
SRLI rd,rs1,shamt | počet bitů posunu je uložen v 6 bitech (původně dostačovalo v pěti) |
SRAI rd,rs1,shamt | počet bitů posunu je uložen v 6 bitech (původně dostačovalo v pěti) |
32bitové posuny a rotace:
Instrukce | Význam |
---|---|
SLLW rd,rs1,rs2 | posun v rámci spodních 32bitů |
SRLW rd,rs1,rs2 | posun v rámci spodních 32bitů |
SRAW rd,rs1,rs2 | posun v rámci spodních 32bitů |
SLLIW rd,rs1,shamt | posun v rámci spodních 32bitů |
SRLIW rd,rs1,shamt | posun v rámci spodních 32bitů |
SRAIW rd,rs1,shamt | posun v rámci spodních 32bitů |
Aritmetické operace s operandy uloženými v registrech:
Instrukce | Význam |
---|---|
ADDW rd,rs1,rs2 | výpočet pouze v dolních 32 bitech bez přetečení |
SUBW rd,rs1,rs2 | výpočet pouze v dolních 32 bitech bez přetečení |
Aritmetické operace s konstantou:
Instrukce | Význam |
---|---|
ADDIW rd,rs1,imm | přičtení 12bitové konstanty ke zdrojovému registru, 32bitový výsledek se uloží do registru cílového se znaménkovým rozšířením |
Tuto instrukci (ADDIW) je možné použít ke konverzi 32bit →, když se přičte 0.
10. Neoficiální rozšíření instrukční sady „C“ – komprimované instrukce
„Leveraging 25 years of hindsight, RISC-V was designed to support compressed instructions from the start, leaving enough opcode space for RVC and many other extensions“
Tvůrci formátu instrukcí pro mikroprocesory RISC-V nezapomněli ani na to, že se tato procesorová jádra budou s velkou pravděpodobností používat mj. i v embedded systémech, kde se z různých důvodů (pomalá paměť Flash, relativně malá kapacita instrukční cache apod.) preferuje mít možnost vytvářet kód s větší hustotou, a to i za cenu menší výkonnosti celého čipu. Pro tyto účely byla navržena prozatím neoficiální instrukční sada „C“ nazývaná též RVC (RISC-V Compressed) s instrukcemi o šířce 16 bitů a nikoli 32 bitů. Tato instrukční sada byla vytvořena s tím, že se bude jednat o doplněk ke stávajícím instrukčním sadám, nebude tedy nutné provádět přepínání mezi různými režimy činnosti (na rozdíl od Thumb atd.).
Designéři se tak poučili z některých problémů, které doprovázely konkurenty, a to jak ARM (nutnost explicitního přepínání mezi A32 a Thumb, opuštění této kombinace v AArch64) tak i x86_64 (komplikace mikroprocesoru s instrukční sadou s instrukcemi proměnné délky). Podle soudobých měření se zdá, že instrukční sada „C“ může přinést zmenšení strojového kódu o přibližně 25 až 30%, což dále vede ke snížení výpadků instrukční cache o 20 až 25% (zde je ovšem nutné podotknout, že do značné míry záleží na podpoře v překladačích a JIT, tato podpora stále není dokonalá, takže lze předpokládat další zlepšení). Podrobnějším popisem této zajímavé technologie se budeme zabývat příště.
11. Odkazy na Internetu
- An Introduction to Lock-Free Programming
http://preshing.com/20120612/an-introduction-to-lock-free-programming/ - Sequential consistency
https://en.wikipedia.org/wiki/Sequential_consistency - Understanding Atomic Operations
https://jfdube.wordpress.com/2011/11/30/understanding-atomic-operations/ - Load-link/store-conditional
https://en.wikipedia.org/wiki/Load-link/store-conditional - The RISC-V Compressed Instruction Set Manual
http://riscv.org/spec/riscv-compressed-spec-v1.7.pdf - 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 - AMD Am29000
https://en.wikipedia.org/wiki/AMD_Am29000 - Status register
https://en.wikipedia.org/wiki/Status_register - AMD Am29000 microprocessor family
http://www.cpu-world.com/CPUs/29000/ - AMD 29k (Streamlined Instruction Processor) ID Guide
http://www.cpushack.com/Am29k.html - AMD Am29000 (Wikipedia)
http://en.wikipedia.org/wiki/AMD_Am29000 - AMD K5 („K5“ / „5k86“)
http://www.pcguide.com/ref/cpu/fam/g5K5-c.html - Comparing four 32-bit soft processor cores
http://www.eetimes.com/author.asp?section_id=14&doc_id=1286116 - RISC-V Instruction Set
http://riscv.org/download.html#spec_compressed_isa - RISC-V Spike (ISA Simulator)
http://riscv.org/download.html#isa-sim - RISC-V (Wikipedia)
https://en.wikipedia.org/wiki/RISC-V - David Patterson (Wikipedia)
https://en.wikipedia.org/wiki/David_Patterson_(computer_scientist) - OpenRISC (oficiální stránky projektu)
http://openrisc.io/ - OpenRISC architecture
http://openrisc.io/architecture.html - Emulátor OpenRISC CPU v JavaScriptu
http://s-macke.github.io/jor1k/demos/main.html - OpenRISC (Wikipedia)
https://en.wikipedia.org/wiki/OpenRISC - OpenRISC – instrukce
http://sourceware.org/cgen/gen-doc/openrisc-insn.html - OpenRISC – slajdy z přednášky o projektu
https://iis.ee.ethz.ch/~gmichi/asocd/lecturenotes/Lecture6.pdf - Maska mikroprocesoru RISC 1
http://www.cs.berkeley.edu/~pattrsn/Arch/RISC1.jpg - Maska mikroprocesoru RISC 2
http://www.cs.berkeley.edu/~pattrsn/Arch/RISC2.jpg - C.E. Sequin and D.A.Patterson: Design and Implementation of RISC I
http://www.eecs.berkeley.edu/Pubs/TechRpts/1982/CSD-82–106.pdf - Berkeley RISC
http://en.wikipedia.org/wiki/Berkeley_RISC - Great moments in microprocessor history
http://www.ibm.com/developerworks/library/pa-microhist.html - Microprogram-Based Processors
http://research.microsoft.com/en-us/um/people/gbell/Computer_Structures_Principles_and_Examples/csp0167.htm - Great Microprocessors of the Past and Present
http://www.cpushack.com/CPU/cpu1.html - A Brief History of Microprogramming
http://www.cs.clemson.edu/~mark/uprog.html - What is RISC?
http://www-cs-faculty.stanford.edu/~eroberts/courses/soco/projects/2000–01/risc/whatis/ - 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 - FPGA
https://cs.wikipedia.org/wiki/Programovateln%C3%A9_hradlov%C3%A9_pole - The Evolution of RISC
http://www.ibm.com/developerworks/library/pa-microhist.html#sidebar1 - SPARC Processor Family Photo
http://thenetworkisthecomputer.com/site/?p=243 - SPARC: Decades of Continuous Technical Innovation
http://blogs.oracle.com/ontherecord/entry/sparc_decades_of_continuous_technical - The SPARC processors
http://www.top500.org/2007_overview_recent_supercomputers/sparc_processors - Reduced instruction set computing (Wikipedia)
http://en.wikipedia.org/wiki/Reduced_instruction_set_computer - MIPS architecture (Wikipedia)
http://en.wikipedia.org/wiki/MIPS_architecture - Very long instruction word (Wikipedia)
http://en.wikipedia.org/wiki/Very_long_instruction_word - Classic RISC pipeline (Wikipedia)
http://en.wikipedia.org/wiki/Classic_RISC_pipeline - R2000 Microprocessor (Wikipedia)
http://en.wikipedia.org/wiki/R2000_(microprocessor) - R3000 Microprocessor (Wikipedia)
http://en.wikipedia.org/wiki/R3000 - R4400 Microprocessor (Wikipedia)
http://en.wikipedia.org/wiki/R4400 - R8000 Microprocessor (Wikipedia)
http://en.wikipedia.org/wiki/R8000 - R10000 Microprocessor (Wikipedia)
http://en.wikipedia.org/wiki/R10000 - SPARC (Wikipedia)
http://en.wikipedia.org/wiki/Sparc - CPU design (Wikipedia)
http://en.wikipedia.org/wiki/CPU_design - Control unit (Wikipedia)
http://en.wikipedia.org/wiki/Control_unit