# Reduced instruction set computer

**Reduced instruction set computer** (**RISC**) er en type mikroprosessor som i motsetning til CISC-prosessorer kan utføre relativt få instruksjoner. Til gjengjeld tar hver instruksjon kort tid å utføre.

Komplekse beregninger krever gjerne at flere instruksjoner kjøres etter hverandre på en RISC-prosessor, mens en CISC-prosessor kunne gjort en tilsvarende beregning i ett trinn.

Eksempler på RISC-prosessorfamilier er ARM, AVR, PowerPC og SPARC.

## Egenskaper

Da de tre første RISC-prosessorene ble lansert fra 1980 til 1983, var de konstruert etter andre prinsipper enn datidens CISC-prosessorer.

Senere CISC-arkitekturer adopterte deler av RISC-filosofien, ikke minst bruken av *pipelining*. Innenfor x86-arkitekturen er NexGen Nx586, AMD K5, Pentium Pro, og også senere prosessorer, i realiteten RISC-prosessorer som emulerer CISC instruksjoner. Slike hybrider er noen ganger også blitt omtalt som «CRISC».

Av praktiske årsaker er det derfor enklest å forklare RISC-filosofien ved å sammenligne den med rene CISC-arkitekturer.

### Flytt kompleksiteten fra maskinvaren til kompilatorene

Forkortelsen **RISC** betyr «en datamaskin med et redusert instruksjons-sett» *(Reduced Instruction Set Computing)*. Ironisk nok ble denne datamaskin-arkitekturen oppkalt etter noe som slett ikke var dens primære kjennetegn. Færre instruksjoner var bare en konsekvens av RISC-filosofien.

Grensen mellom maskinvare og programvare er flytende, og mange oppgaver som utføres av fysiske gjenstander kan også utføres av programvare. Et modem kan f.eks. både være en fysisk gjenstand og et dataprogram.

|  |  |  |
| --- | --- | --- |
|  Enklere programvare | CISC | Kompleks maskinvare |
| Kompleks programvare | RISC |  Enklere maskinvare |

I de første høynivåspråkene var det mye arbeid forbundet med å lage en kompilator som sørget for å oversette disse til assembler og igjen til maskinkode. IBM benyttet f.eks. 18 år på å utvikle høynivåspråket Fortran. Istedenfor å tilpasse høynivåspråkene etter datamaskinene, valgte derfor industrien å tilpasse datamaskinene etter høynivåspråkene.

Datamaskiner ble stadig mer komplekse (deriblant ved å tilføye stadig flere instruksjoner) for å forenkle realiseringen av høynivåspråk. Det var *denne utvidelsen av antall instruksjoner* som skapte benevnelsene CISC og RISC.

### Færre instruksjoner

| År | Arkitektur | Antall instruksjoner | Mikroprogrammet | Instruksjones lengde |
| --- | --- | --- | --- | --- |
| 1973 | IBM 370/168 | 208 | 54 byte | 2–6 byte |
| 1978 | VAX 11/780 | 303 | 61 byte | 2–57 byte |
| 1978 | Xerox Dorado | 270 | 17 byte | 1–3 byte |
| 1980 | IBM 801 | 120 | 0 byte | 4 byte |
| 1981 | Berkeley RISC I | 31 | 0 byte | 4 byte |
| 1983 | Stanford MIPS | 55 | 0 byte | 4 byte |

De tre øverste datamaskinene i tabellen over er CISC-arkitekturer, mens de tre nederste er RISC-prosessorene. Tabellen viser hvordan RISC-prosessorene har færre instruksjoner.

### Intet mikroprogram

Et kjennetegn ved RISC-arkitekturen er fraværet av «mikroprogrammet». Et mikroprogram er en kommandotolk som oversetter mikroprosessorens programmer (mikrokode) til kjørbar kode under kjøring. Dette er nødvendigvis tregere enn å utføre et program direkte, som på forhånd er oversatt til kjørbar kode.

Det første «mikroprogrammet» så dagens lys den 7. april 1964, da IBM lanserte stormaskinen IBM System/360. Denne arkitekturen introduserte et komplekst sett med instruksjoner, som etterhvert fikk navnet «maskinkode». Tolken var lagret i datamaskinens ROM (leseminne) og kunne ikke modifiseres.

I løpet av noen få år formelig eksploderte mikrokoden i kompleksitet. Endog minidatamaskiner som benyttet mikroprosessoren VAX, hadde mer enn 200 instruksjoner og 10-15 forskjellige adresseringsmodi som ble oversatt under kjøring.

Utviklingen ble påskyndet av høynivåspråk, som gjorde det enklere å skrive programmer enn i tradisjonell assembler. Høynivåspråk innførte bl.a. en syntaks med ord som **if**, **while** og **case**. Slike ord manglet direkte paralleller i assembler, og ble oversatt av kompilatorer til komplekse sammensetninger av assembler-syntaks som JUMP, ADD og MOVE. For å forenkle skrivingen av kompilatorer, ble mikrokoden utvidet med stadig nye instruksjoner.

Stadig flere oppgaver ble påført kommandotolken: Nye adresseringsmodi for å håndtere tabeller, komplekse datastrukturer og håndteringen av prosedyre-kall, deriblant overføring av parametre, lagring av registrenes innhold og endringer av stakkens innhold, ble utført av tolken. Etterhvert var tolkens kompleksitet blitt en flaskehals for mikroprosessorenes ytelse.

Gjennombruddet som gjorde RISC-prosessorer mulige, var fremveksten av *optimaliserte kompilatorer*. Istedenfor å oversette mikrokode under kjøring ved hjelp av en kommandotolk, ble den oversatt direkte av kompilatorene. Ved å eliminere behovet for den mellomliggende tolken, kunne også ytelsen kraftig forbedres.

### Kun to adresseringsmodi: «Hent» og «lagre»

RISC-arkitekturer kommuniserer svært enkelt med datamaskinens hovedminne. Det benyttes bare to metoder – «hent» og «lagre», for å flytte data mellom mikroprosessoren og hovedminnet.

I mikroprosessoren SPARC ble dette implementert med følgende assembler-instruksjoner:

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|

| Instruksjon | Forklaring |
| --- | --- |
| LDSB | Hent byte (8 bit) med fortegn |
| LDSH | Hent halvt ord (16 bit) med fortegn |
| LDUB | Hent byte (8 bit) uten fortegn |
| LDUH | Hent halvt ord (16 bit) uten fortegn |
| LD | Hent ord (32 bit) |
| LDD | Hent dobbelt ord (64 bit) |

 |   |

| Instruksjon | Forklaring |
| --- | --- |
| STB | Lagre byte (8 bit) |
| STH | Lagre halvt ord (16 bit) |
| ST | Lagre ord (32 bit) |
| STD | Lagre dobbelt ord (64 bit) |

 |

I motsetning til dette hadde CISC-prosessorer – eksempelvis Intel 80386, Motorola 68000 og National Semiconductor 32000, svært komplekse metoder til å flytte data fra og til minnet. CISC-prosessorenes adresseringsmodi innbefattet direkte adressering, register-adressering, direkteoperand-adressering, indeksert adressering og indirekte adressering. I tillegg til indirekte adressering, hadde f.eks. Intel 80386 også indirekte registeradressering med avvik, indirekte adressering med base- og indeksregister, og indirekte adressering med base-, indeksregister og konstant.

Alle disse adresseringsmodiene var også blitt skapt for å gjøre det enklere å lage kompilatorer.

### Én instruksjon per klokkepuls

I CISC-prosesser utføres ulike instruksjoner med ulike antall klokkepulser. En filosofi bak RISC er å utføre én instruksjon per klokkepuls, slik at f.eks. måle-enheten MIPS er identisk med prosessorens klokkehastighet i MHz.

### Pipelining

For å oppnå målsetningen om én utført instruksjon per klokkepuls, må flere instruksjoner bearbeides samtidig. I en fire-trinns *pipe* blir én instruksjon hentet fra hurtigminnet, mens en annen blir dekodet, en tredje utført, mens resultatet av en fjerde skrevet til minnet:

| Syklus | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Instruksjon 1 | HENT | DEKOD | UTFØR | SKRIV |  |
| Instruksjon 2 |  | HENT | DEKOD | UTFØR | SKRIV |  |
| Instruksjon 3 |  | HENT | DEKOD | UTFØR | SKRIV |  |
| Instruksjon 4 |  | HENT | DEKOD | UTFØR | SKRIV |

Denne idéen ble etterhvert også tatt i bruk av CISC-prosessorer, og er derfor ikke lenger noe kjennetegn på RISC. I tillegg er det idag vanlig med *pipelines* der mer enn fire instruksjoner bearbeides samtidig. I denne sammenheng omtales prinsippet i sammenheng med RISC-filosofien.

### Instruksjoner med fastsatt størrelse

For å gjennomføre *pipelining* er det nødvendig at hver instruksjon har samme størrelse i bytes. Intel 80386 utførte f.eks. også *pipelining*, men i et begrenset omfang, fordi instruksjoner kunne variere i størrelse fra mellom 1 og 17 bytes.

### Generelle registre

I CISC-arkitekturer er mikroprosessorens interne registrene reserverte til spesielle formål. RISC innførte prinsippet om generelle interne registre, for å redusere trafikken mellom mikroprosessoren og hovedminnet til et minimum.

## De første RISC-prosessorne

Den første moderne RISC-maskinen var minidatamaskinen IBM 801. Den ble bygd i 1975, men ingen offentlig informasjon om dens eksistens ble tilgjengelig før i 1982.

IBM 810 ble etterfulgt av RISC-prosessoren ROMP, som dannet basis for IBM 6150 RT frem til mai 1991. Da ble den erstattet av PowerPC.

Arbeidet med en annen RISC-prosessor startet i 1980 hos en gruppe ved Berkeley, University of California, under navnet RISC I, som etter kort tid ble etterfulgt av RISC II. RISC I og RISC II var inspirasjonskilden til SPARC.

I 1981 utviklet og fabrikkerte John Hennessy ved Stanford University en tredje RISC-arkitektur, som han kalte MIPS. Brikken førte senere til dannelsen av MIPS Computer Systems, og mikroprosessorfamilien MIPS.

## Referanser