Obsah
1. Instrukční sada procesorových jader s otevřenou architekturou RISC-V
2. Dvě kritická rozhodnutí při návrhu ISA: bitová šířka ALU a počet pracovních registrů
3. Operační kódy instrukcí u procesorových jader RISC-V
4. Základní instrukční sada RV32I
5. Seznam instrukcí z instrukční sady RV32I
6. Čtyři způsoby kódování instrukcí RV32I
7. Aritmetické instrukce s registry (tříadresový kód)
8. Aritmetické instrukce s konstantou
9. Instrukce typu LOAD a STORE
10. Instrukce nepodmíněného skoku (JUMP)
11. Instrukce rozvětvení (BRANCH)
1. Instrukční sada procesorových jader s otevřenou architekturou RISC-V
V článku s nadpisem Otevřené RISCové architektury OpenRISC a RISC-V, který na Rootu vyšel minulý týden, jsme se seznámili se základními vlastnostmi otevřených RISCových architektur OpenRISC a zejména pak RISC-V. Připomeňme si, že tyto dvě architektury sice mají společného ideového předka, jímž jsou původní 32bitová jádra MIPS, ovšem konkrétní implementace OpenRISC a RISC-V jsou od sebe dosti odlišné. Dnes se budeme zabývat popisem instrukční sady RV32I, což je základní instrukční sada 32bitových jader RISC-V, která však může být v případě potřeby rozšířena o další oficiální či neoficiální sady instrukcí v závislosti na tom, v jakém systému se budou jádra RISC-V používat. Například pro takzvaná „minion cores“ bude tato instrukční sada plně dostačovat, při použití jádra RISC-V v desktopovém mikroprocesoru bude nutné doplnit jednotku s násobičkou a děličkou i matematickým koprocesorem, v serverech s čipy s mnoha jádry se pak uplatní rozšíření o atomické operace atd. atd.
Připomeňme si, které základní a rozšiřující instrukční sady v současnosti pro jádra RISC-V existují či které jsou teprve ve stadiu návrhu:
| Označení | Význam |
|---|---|
| Oficiální sady instrukcí | |
| I | aritmetické instrukce (32/64 bit), load/store, skoky, rozvětvení, speciální operace |
| M | rozšíření o instrukce pro násobení a dělení |
| A | atomické operace typu read-modify-write (využitelné zejména pro multicore) |
| F | operace s hodnotami typu float/single (jednoduchá přesnost) |
| D | operace s hodnotami typu double (dvojitá přesnost) |
| Další rozšíření | |
| Q | operace s hodnotami typu quad (čtyřnásobná přesnost) |
| L | decimální aritmetika |
| C | komprimované instrukce (viz též navazující kapitoly) |
| B | bitové operace |
| T | podpora pro transakční paměť |
| P | SIMD operace |
Pod označení „I“ ve skutečnosti spadají dvě sady: jedna instrukční sada pro zpracování 32bitových operandů (RV32I) a druhá instrukční sada pro 64bitové operandy (RV64I).
Poznámka: „minion core“ je termín používaný společností LowRisc pro (poněkud zjednodušeně řečeno) pojmenování jádra s architekturou RISC-V připojeného přímo na GPIO, tedy na skupinu vstupně-výstupních pinů. Toto jádro, či v případě potřeby větší množství jader, se chová jako samostatně fungující koprocesor, který má přístup ke společné sběrnici i k hlavnímu procesoru/procesorům. To v důsledku znamená, že se vlastně jedná o „inteligentní“ vstupně-výstupní zařízení, které může softwarově implementovat chování různých sběrnic a rozhraní, například U(S)ART, SPI, I2C, Ethernet, USB atd. atd., samozřejmě včetně možnosti návrhu zcela nových sběrnic (předpokládá se, že RISCové procesorové jádro bude dostatečně levné na to, aby se nevyplatilo použít specializovaný modul). Teoreticky se zde otevírá cesta k masivně paralelním a přitom levným strojům, popřípadě ke kompletně „otevřenému“ hardwaru (zejména segment síťových karet mi přijde býti dosti kritický), to však ukáže budoucnost.
2. Dvě kritická rozhodnutí při návrhu ISA: bitová šířka ALU a počet pracovních registrů
Při návrhu architektury mikroprocesorových jader RISC-V museli tvůrci provést minimálně dvě kritická rozhodnutí: bylo nutné stanovit implicitní bitovou šířku operandů (a tím pádem i počet bitů operandů vstupujících do aritmeticko-logické jednotky, šířku datových sběrnic i pracovních registrů) a taktéž celkový počet pracovních registrů. Bitová šířka operandů ovlivňuje složitost, cenu a spotřebu čipu. Navíc je nutné si uvědomit, že zdaleka neplatí, že čím větší je šířka operandů, tím lépe, protože se mnoho operací stále provádí nad „pouhými“ bajty či šestnáctibitovými operandy.
Celkový počet pracovních registrů přímo ovlivňuje strukturu instrukční sady, protože je nutné rozhodnout, kolik registrů bude v instrukci zakódováno (typicky jeden, dva či tři registry) a kolik bitů bude nutné obětovat pro uložení indexu každého registru v instrukčním slově. Tvůrci RISC-V uvažovali o možnosti použití šestnácti registrů a 16bitových operačních kódů instrukcí, to by však pro tříadresový kód bylo stále málo; proto se rozhodli použít 32 pracovních registrů a 32bitové operační kódy, stejně jako v klasických „ortodoxních“ RISCových architekturách. Vyhnuli se ovšem zbytečně složitým řešením s registrovými okny apod.
Podívejme se nyní na tabulku, v níž jsou stručně (bez podrobnějších vysvětlení různých specialit) vypsány počty a bitové šířky pracovních registrů u některých oblíbených (i neoblíbených) a používaných mikroprocesorů a mikroprocesorových jader. Z této tabulky je zřejmé, že klasické CISCové procesory měly k dispozici menší počet registrů; navíc tyto registry nebyly zcela univerzální, což platí jak pro procesory řady i386, tak i pro Motorolu 68000 (rozdělení na datové a adresové registry). Naproti tomu většina klasických RISCových procesorů, tj. MIPS a SPARC, se drží oblíbeného schématu 31×32bitů, protože jeden z registrů obsahuje konstantní nulu. Původní 32bitové čipy ARM (A32) stojí klasicky na pomezí mezi těmito dvěma extrémy, což se změnilo s příchodem A64 (AArch 64):
| Řada | Architektura | Registry |
|---|---|---|
| Motorola 68000 | CISC | 8×32bit + 7×32bit |
| IA-32 (i386) | CISC | 8×32bit |
| x86_64 | CISC | 16×64bit |
| IA-64 | EPIC | 128×64bit |
| Atmel AVR | RISC | 32×8bit |
| MIPS (32) | RISC | 31×32bit + zero |
| SPARC | RISC | 31×32bit + zero |
| ARM (A32) | RISC | 15×32bit |
| ARM (A64) | RISC | 31×64bit + zero |
| RISC-V | RISC | 31×32bit + zero |
3. Operační kódy instrukcí u procesorových jader RISC-V
Způsob kódování instrukcí v jádrech RISC-V je navržen takovým způsobem, aby byla instrukční sada rozšiřitelná a aby se v budoucnu mohlo začít pracovat na obdobě sady Thumb známé z řady ARM. Thumb používá jen šestnáctibitové instrukce s omezeným repertoárem operací a pracovních registrů, což ovšem zvyšuje hustotu strojového kódu. V RISC-V se pro základní rozlišení mezi šestnáctibitovými instrukcemi a instrukcemi větší šířky používají nejnižší dva bity instrukčního slova, které pro 16bitové instrukce obsahují dvojici jedniček a pro instrukce 32bitové (či větší) pak jednu z kombinací 00, 01, 10. Dekodér tedy může velmi snadno určit, jakým způsobem má instrukci zpracovat (RISC-V je little endian, což je zde poměrně důležité):
15 0 +----------------+ |xxxxxxxxxxxxxxaa| aa != 11 +----------------+
Ve skutečnosti však jdou možnosti RISC-V ještě dále, neboť z dalších bitů operačního kódu instrukce lze zjistit, zda má instrukce šířku 32bitů či zda je dokonce ještě širší. Používá se následující způsob kódování, který teoreticky umožňuje tvořit instrukce o šířce až 320bitů, což by pravděpodobně vedlo k monstróznímu čipu s architekturou VLIW (i když: těžko říct, možnosti překladačů jsou dnes dosti značné v porovnání s dobou, kdy VLIW začínalo). Nás bude samozřejmě zajímat především kódování 32bitových operačních kódů, které vypadá následovně:
31 16 15 0 +----------------+----------------+ |xxxxxxxxxxxxxxxx|xxxxxxxxxxxbbb11| bb != 111 +----------------+----------------+
Pro (prozatím) teoretické instrukce o šířce 48 bitů, které dnes neexistují, se používá tento formát:
47 32 31 16 15 0 +----------------+----------------+----------------+ |xxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxx|xxxxxxxxxx011111| +----------------+----------------+----------------+
A konečně pro instrukce s operačním kódem dlouhým 64 bitů by se použil následující formát:
63 48 47 32 31 16 15 0 +----------------+----------------+----------------+----------------+ |xxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxx|xxxxxxxxx0111111| +----------------+----------------+----------------+----------------+
Poznámka: šířka operačních kódů instrukcí žádným způsobem neurčuje šířku operandů. To, že základní instrukční sada RISC-V používá instrukce o šířce 32 bitů a operandy o šířce taktéž 32 bitů, je z tohoto pohledu vlastně „náhoda“. Ostatně vzpomeňme například na již zmíněnou architekturu A32 (ARM) s instrukční sadou Thumb (32bitové operandy, 16bitové instrukce) či A64 (AArch64) s 64bitovými operandy a 32bitovými instrukcemi.
4. Základní instrukční sada RV32I
V základní instrukční sadě jsou definovány všechny instrukce, které jsou zapotřebí pro implementaci plnohodnotného čistě RISCového jádra. Některé instrukce, které by vážený čtenář možná v této sadě hledal, nejsou v RV32I ve skutečnosti obsaženy. Především chybí instrukce pro celočíselné násobení a dělení. Tyto ne čistě RISCové instrukce jsou definovány v rozšířené sadě „M“, a to z toho důvodu, že například pro implementaci minion core by byla implementace násobičky a děličky zbytečným luxusem, ať již z hlediska ceny, tak i spotřeby. Dále zde nenajdeme žádné instrukce pro atomický přístup k paměti; opět se jedná o oblast, pro niž vzniklo rozšíření „A“. A konečně zde nehledejme ani instrukce matematického koprocesoru.
Když nyní víme, co RV32I neobsahuje, popišme si implementované instrukce. Seznam je relativně krátký, což například znalce architektury MIPS pravděpodobně nepřekvapí:
- Aritmetické a logické instrukce s dvojicí zdrojových registrů a registrem cílovým (tříadresový kód)
- Aritmetické a logické instrukce s jedním zdrojovým registrem, konstantou a registrem cílovým
- Nepodmíněné skoky (s případným uložením návratové adresy do registru)
- Podmíněné skoky (rozvětvení)
- Instrukce typu LOAD a STORE (práce s daty uloženými v paměti)
- Systémové operace
- Načtení aktuálního obsahu čítačů a časovačů (ty mají šířku 64 bitů a jsou tedy „nekonečné“)
5. Seznam instrukcí z instrukční sady RV32I
Všechny instrukce, které jsou definovány v základní instrukční sadě RV32I, jsou vypsány v tabulce pod tímto odstavcem. Instrukce jsou rozděleny podle své funkce, i když ve skutečnosti by si LUI a AUIPC zasloužily vlastní podkategorii:
| ALU instrukce | Skoky | LOAD/STORE | Čítače | Ostatní | |||
|---|---|---|---|---|---|---|---|
| 3 registry | konstanta | bez podmínky | s podmínkou | LOAD | STORE | ||
| ADD | ADDI | JAL | BEQ | LW | SW | RDCYCLE | FENCE |
| SUB | JALR | BNE | LH | SH | RDCYCLEH | FENCE.I | |
| AND | ANDI | BLT | LHU | RDTIME | SCALL | ||
| OR | ORI | BLTU | LB | SB | RDTIMEH | SBREAK | |
| XOR | XORI | BGE | LBU | RDINSTRET | |||
| SLL | SLLI | BGEU | LUI | RDINSTRETH | |||
| SRL | SRLI | AUIPC | |||||
| SRA | SRAI | ||||||
| SLT | SLTI | ||||||
| SLTU | SLTIU | ||||||
Ano, skutečně se jedná o pouhých 47 instrukcí!
6. Čtyři způsoby kódování instrukcí RV32I
Instrukce v základní sadě RV32I mají všechny konstantní šířku 32 bitů, přičemž instrukční slovo je rozděleno do několika bitových polí s různou velikostí, což je naznačeno na následujícím obrázku:
31 25 24 20 19 15 14 11 7 6 0 +-------+-----+-----+---+-----+-------+ | 7b | 5b | 5b |3b | 5b |xxbbb11| bb!=111 +-------+-----+-----+---+-----+-------+
Podle způsobu využití jednotlivých bitových polí se instrukce dělí do čtyř základních typů:
- Typ „R“ pro tříadresový kód (specifikace třech registrů v instrukci)
- Typ „I“ pro instrukci se dvěma registry a 12bitovou konstantou (tato konstanta je použita jako druhý vstupní operand)
- Typ „S“ používaný pouze instrukcemi typu STORE (uložení obsahu registru do paměti) a BRANCH
- Typ „U“ pro instrukce s jediným registrem a 20bitovou konstantou
Podívejme se nyní na způsob využití jednotlivých bitových polí v instrukcích všech čtyř typů:
Typ „R“
Jedná se vlastně o nejjednodušší formát, v němž se tři pětibitová pole používají pro uložení indexů dvou zdrojových registrů a jednoho registru cílového. Jedním z registrů samozřejmě může být i x0 obsahující konstantní nulu (tím lze „zadarmo“ vytvořit pseudoinstrukci MOV apod.):
31 25 24 20 19 15 14 11 7 6 0 +-------+-----+-----+---+-----+-------+ | func7 | rs2 | rs1 |fn3| rd | opcode| +-------+-----+-----+---+-----+-------+
Typ „I“
Mnoho (nejenom) aritmetických instrukcí používá namísto jednoho zdrojového registru konstantu. To je zajištěno instrukcemi typu „I“. Povšimněte si, že dvanáctibitová konstanta je umístěna v horních dvanácti bitech instrukčního slova, což není náhoda, protože konstanta je chápána jako číslo se znaménkem (signed), takže se díky umístění znaménka v 31 bitu (nejvyšším, MSB) zjednoduší návrh ALU:
31 20 19 15 14 11 7 6 0 +-------------+-----+---+-----+-------+ |konstanta 12b| rs1 |fn3| rd | opcode| +-------------+-----+---+-----+-------+
Typ „S“
U těchto instrukcí se specifikují dva zdrojové registry, žádný cílový registr a konstanta je rozdělena na dvě části. Toto rozdělení má svůj význam, protože se při návrhu instrukční sady dbalo na to, aby se indexy pracovních registrů v instrukčním slovu vždy nacházely na stejné pozici, což může zjednodušit a zrychlit instrukční dekodér:
31 25 24 20 19 15 14 11 7 6 0 +-------+-----+-----+---+-----+-------+ |kons.7b| rs2 | rs1 |fn3|k.5b | opcode| +-------+-----+-----+---+-----+-------+
Typ „U“
Instrukce s jediným cílovým registrem a 20bitovou konstantou je použita pouze u třech instrukcí: LUI, AUIPC a JAL. U těchto instrukcí se vyžaduje využití co nejdelší konstanty, k čemuž se ostatně dostaneme v navazujících kapitolách:
31 11 7 6 0 +-----------------------+-----+-------+ | konstanta 20 bitů | rd | opcode| +-----------------------+-----+-------+
7. Aritmetické instrukce s registry (tříadresový kód)
Existuje celkem deset aritmetických a logických instrukcí s tříadresovým kódem, tj. se dvěma zdrojovými registry a jediným registrem cílovým. Používá se zde kódování typu „R“:
| # | Instrukce | Význam |
|---|---|---|
| 1 | ADD | součet |
| 2 | SUB | rozdíl |
| 3 | AND | logický součin bit po bitu |
| 4 | OR | logický součet bit po bitu |
| 5 | XOR | nonekvivalence |
| 6 | SLL | bitový posun doleva |
| 7 | SRL | bitový posun doprava |
| 8 | SRA | aritmetický posun doprava (zachovává se znaménko) |
| 9 | SLT | porovnání registrů na operaci < (se znaménkem), výsledek je 0 nebo 1 |
| 10 | SLTU | porovnání registrů na operaci < (bez znaménka), výsledek je 0 nebo 1 |
Jednoduchá otázka pro čtenáře: v instrukční sadě neexistuje prázdná instrukce NOP se speciálním kódem, pouze existuje doporučení pro její implementaci jinou instrukcí. Jak by se dala instrukce NOP implementovat pomocí některé z výše popsaných instrukcí? (možností je více)
8. Aritmetické instrukce s konstantou
Aritmetických instrukcí s konstantou (rozšířenou z dvanácti bitů na 32 bitů se znaménkem) existuje pouze devět a nikoli deset. Je tomu tak z toho důvodu, že hypotetická operace SUBI je (až na jednu hodnotu) shodná s operací ADDI, pouze konstanta bude mít jiné znaménko:
| # | Instrukce | Význam |
|---|---|---|
| 1 | ADDI | součet |
| 2 | ANDI | logický součin bit po bitu |
| 3 | ORI | logický součet bit po bitu |
| 4 | XORI | nonekvivalence |
| 5 | SLLI | bitový posun doleva (zde má konstanta jen pět bitů, více netřeba) |
| 6 | SRLI | bitový posun doprava (dtto) |
| 7 | SRAI | aritmetický posun doprava (zachovává se znaménko) |
| 8 | SLTI | porovnání registru s konstantou na operaci < (se znaménkem), výsledek je 0 nebo 1 |
| 9 | SLTIU | porovnání registrů s konstantou na operaci < (bez znaménka), výsledek je 0 nebo 1 |
Povšimněte si, že naprostá většina operací s konstantou považuje tuto 12bitovou konstantu za hodnotu se znaménkem, což mj. umožňuje implementovat například negaci všech bitů v registru. Otázka pro čtenáře: kterou instrukcí by se dala bitová negace (NOT) implementovat?
9. Instrukce typu LOAD a STORE
Architektura RISC-V obsahuje instrukce typu LOAD a STORE, které mohou pracovat na úrovni bajtů, šestnáctibitových slov i 32bitových slov. Pro instrukce typu LOAD platí, že se adresa nachází v libovolném zdrojovém registru, k němuž je přičten offset, který je součástí instrukčního slova, hodnota je uložena do cílového registru. Totéž platí pro operaci typu STORE, zakódování je v tomto případě odlišné, protože se zde nenachází cílový registr:
| # | Instrukce | Význam |
|---|---|---|
| 1 | LB | načtení bajtu, znaménkové rozšíření do 32 bitů |
| 2 | LBU | načtení bajtu, vynulování horních 24 bitů cílového registru |
| 3 | LH | načtení 16bitového slova, znaménkové rozšíření do 32 bitů |
| 4 | LHU | načtení 16bitového slova, vynulování horních 16 bitů cílového registru |
| 4 | LW | načtení 32bitového slova |
| 5 | LUI | načtení 20bitové konstanty do horních 20 bitů |
| 6 | SB | uložení bajtu (spodních osmi bitů registru) |
| 7 | SH | uložení 16bitového slova (spodních šestnácti bitů registru) |
| 8 | SW | uložení 32bitového slova |
| 9 | AUIPC | spočítá 32bitový offset z 20bitové konstanty + PC a uloží do registru |
Třetí otázka: instrukce LUI dokáže naplnit horních 20 bitů registru konstantou, která je přímo součástí instrukčního slova. Jak se doplní spodních dvanáct bitů? Opět: máme k dispozici více možností.
10. Instrukce nepodmíněného skoku (JUMP)
Nepodmíněné skoky jsou implementovány dvojicí instrukcí JAL a JALR. Obě instrukce ukládají návratovou adresu skoku do specifikovaného cílového registru, ovšem výpočet cíle skoku se liší. V prvním případě se k registru PC přičte 20bitová konstanta (se znaménkem), ve druhém případě je přičtena pouze 12bitová konstanta, ovšem k libovolnému registru. Povšimněte si, že se vlastně „zadarmo“ dá vytvářet PIC (Position Independent Code):
| # | Instrukce | Význam |
|---|---|---|
| 1 | JAL | skok na adresu vypočtenou z registru a offsetu (20 bitů) |
| 2 | JALR | skok na adresu uloženou ve zdrojovém registru |
Poslední úkol pro čtenáře: jak je to s instrukcemi J či JUMP? Lze je nějak implementovat? A co skok na absolutní adresu?
11. Instrukce rozvětvení (BRANCH)
U instrukcí pro rozvětvení s podmínkou se vždy porovnají dva registry a na základě výsledků porovnání se skok buď provede nebo neprovede. Relativní adresa skoku (offset) je uložen přímo v instrukčním slovu. Existuje celkem šest podmínek, přičemž zbývající podmínky se implementují jednoduše: prohodí se první a druhý zdrojový registr:
| # | Instrukce | Význam |
|---|---|---|
| 1 | BEQ | porovnání dvou registrů a skok při splnění podmínky „rovno“ |
| 2 | BNE | porovnání dvou registrů a skok při splnění podmínky „nerovno“ |
| 3 | BLT | porovnání dvou registrů a skok při splnění podmínky „menší než“ |
| 4 | BGE | porovnání dvou registrů a skok při splnění podmínky „větší nebo rovno“ |
| 5 | BLTU | porovnání dvou registrů a skok při splnění podmínky „menší než“ |
| 6 | BGEU | porovnání dvou registrů a skok při splnění podmínky „větší nebo rovno“ |
Na tomto místě si připomeňme poznámku uvedenou minule: zatímco u MIPS existovaly jen dvě instrukce pro podmíněné skoky (beq, bne) doplněné o instrukce slt a slti), je u architektury RISC-V sada podmíněných skoků doplněna na beq, bne, blt a bge, přičemž další kombinace (bgt apod.) vzniknou jednoduše prohozením obsahu prvního a druhého registru. Opět nesmíme zapomenout na registr x0 s konstantní nulou, který umožňuje realizovat skoky typu bz a bnz.
12. Odkazy na Internetu
- 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
ČLÁNKY DO MAILU
