Redigerer SPARCV7 mikroprosessor (avsnitt)

==Arkitektur==
===RISC===
{{utdypende|Reduced instruction set computer}}
Denne artikkelen handler om en mikroprosessor av typen [[RISC]] (''Reduced instruction set computer''). RISC ble lansert som følge av en iboende og voksende begrensning i tidligere mikroprosessorer av typen [[CISC]] (''Complex instruction set computer''). CISC-arkitekturene ble gradvis stadig mer komplekse, inntil kompleksiteten ble en hindring for deres ytelse. Filosofien bak RISC var å flytte denne kompleksiteten fra [[maskinvare]]n til [[programvare]]n. En rekke oppgaver som var påført mikroprosessorene under kjøring, ble nå overlatt til [[kompilator]]ene å utføre.
[[Fil:Berkeley glade afternoon.jpg|thumb|280px|Bakgrunnsarbeidet for SPARC ble lagt ved [[University of California, Berkeley]].{{byline|Foto: UpstateNYer|16. januar 2009}}]]
De tre første RISC-arkitekturene kom noenlunde samtidig:

* [[IBM 801]] fra [[IBM]] (1980)
* [[Berkeley RISC]] (1981) ved [[University of California, Berkeley]]
* [[MIPS (RISC-arkitektur)|MIPS]] (1981) ved [[Stanford University]], [[California]]

Videreutviklingen av IBM 801 førte til nye mikroprosessorer og familier i form av [[ROMP]] i 1981, [[IBM POWER]] i 1990 og  [[PowerPC]] i 1991. SPARC er en videreutvikling av Berkeley RISC, og mikroprosessorene RISC I og RISC II. MIPS førte til etableringen av selskapet [[MIPS Computer Systems]], som lanserte sin egen familie med mikroprosessorer.

En nyvinning ved Berkeley RISC var såkalte ''«registervinduer»''. En stor flaskehals for ytelsen i CISC mikroprosessorer, var knyttet til dataoverføringene mellom mikroprosessoren og hovedminnet under prosedyrekall. Registervinduene opphevet effektivt de fleste av slike dataoverføringer. SPARC «arvet» registervinduene fra Berkeley RISC, men realiserte dem på en litt anderledes måte.

===SPARC===
{{utdypende|SPARC}}
SPARC er først og fremst navnet på en [[instruksjonssett|datamaskinarkitektur]], som omfatter en familie med mange ulike mikroprosessorer.<ref name="Sun1988_1-1"/> Navnet blir tidvis også brukt om de første mikroprosessorene i denne familien. Disse er beskrevet lenger ned i denne artikkelen.

SPARC er en forkortelse for '''''S'''calable '''P'''rocessor '''ARC'''hitecture'' &ndash; «skalerbar [[instruksjonssett|mikroprosessorarkitektur]]».<ref name="SPARC2003_XIII"/> «Skalerbar» betyr at den er konstruert for [[symmetrisk flerprosessering]] i [[stormaskin]]er og [[superdatamaskin]]er.<ref name="SPARC2003_XIII"/> Datamaskiner med SPARC kan ''skaleres'' fra å inneholde èn enkelt mikroprosessor ([[SISD]]), til å bestå av to, fire eller flere mikroprosessorer som deler et felles [[RAM|dataminne]] ([[SIMD]]).<ref name="SPARC2003_XIII"/>

Arkitekturen beskrives av en manual. Tre versjoner av manualen er blitt brukt til produksjon av  mikroprosessorer:

* Versjon 7, mars 1986 (32-biter)<ref name="Sun1986"/>
* Versjon 8, desember 1990 (32-biter)<ref name="Sun1990"/>
* Versjon 9, 1992 (64-biter)<ref name="Sun1992"/>

Denne artikkelen beskriver versjon 7 av manualen, og mikroprosessorer som bygger på den.

===Flere separate enheter===
Versjon 7 av spesifikasjonen til SPARC ble publisert av [[Sun Microsystems]] i mars 1986.<ref name="Sun1986"/> Manualen beskriver en 32-biter [[RISC]] [[mikroprosessor]] med en enkelt kjerne.<ref name="Sun1988_1-1"/><ref name="Sun1988_2-1"/> Arkitekturen består av tre separate deler:<ref name="Sun1988_1-1"/><ref name="Sun1988_2-1"/>

* En [[aritmetisk logisk enhet]], kalt heltallsenhet (''Integer Unit'')
* En [[koprosessor]] for [[flyttall]] (''Floating Point Unit'')
* En valgfri koprosessor
[[Fil:HP-HP9000-PA-RISC-NS2-CPU 06.jpg|300px|thumb|Eksempel på en arkitektur med flere brikker. Hovedkort for arbeidstasjonen [[HP 9000]] med mikroprosessoren [[PA-RISC NS-2]], syv andre utførende enheter og to [[Weitek]] koprosessorer for flyttall.{{byline|Foto: Thomas Schanz|21. mai 2012}}]]
Benevnelsen «mikroprosessor» brukes kun om heltallsenheten. I tillegg kom to andre eksterne enheter:

* En [[minnehåndterer]]
* Et valgfritt [[hurtigminne]]

Spesifikasjonen la ingen føringer på størrelsen av hurtigminnet<ref name="Sun1988_1-1"/> eller implementasjonen av minnehåndtereren.<ref name="Sun1988_1-1"/> Det naturlige for en slik mikroprosessor vil være en 32-biter [[databuss]] og en 32-biter [[adressebuss]], som aksesserer en 32-biter [[virtuell hukommelse]] på 2<sup>32</sup> eller 4 [[gigabyte]].<ref name="Sun1988_2-1"/> Men heller ikke bredden på disse bussene er definert av spesifikasjonen.<ref name="Sun1988_1-1"/> Valg av bussenes bredde, hurtigminnets størrelse (eller hurtigminne overhodet) og utformingen av minnehåndtereren ble i praksis overlatt til maskinvarefabrikantene.{{#tag:ref|De to første [[arbeidsstasjon]]ene fra [[Sun Microsystems]] med SPARC, var modellene 4/260 og 4/280 i serien [[sun-4]]. De var begge uten hurtigminne, benyttet [[MB86900|Fujitsu SPARC MB86900]] og koprosessoren Weitek 1164 eller Weitek 1165 til flyttall. Fjerde generasjon SPARC fra Fujitsu, Fujitsu SPARC MB8603, hadde en integrert koprosessor for flyttall. Den ble benyttet på [[SPARCstation IPX]], som også var forsynt med 64 Kb hurtigminne.|group="lower-alpha"|name="sun4cache"}}

Oppdelingen i mange separate enheter var vanlig på denne tiden; transistorene var ennå ikke kommet ned i størrelser som tillot integrasjon i en enkelt brikke. Oppe til høyre ser vi utsnitt av et hovedkort for arbeidsstasjonen [[HP 9000]] med en enkelt 32-biter [[PA-RISC NS-2]] mikroprosessor. Det består av mikroprosessoren, syv separate tilleggsenheter, og to koprosessorer for flyttall i form av [[Weitek]] 2264 og Weitek 2265.

===Laste-lagre-arkitektur===
{{utdypende|Laste-lagre arkitektur}}
Mikroprosessoren kommuniserer med hovedminnet i datamaskinen på en enkel måte. Den benytter de to operasjonene ''Laste'' (''Load'') og ''Lagre'' (''Store''). Data overføres fra hovedminnet (Laste) eller til hovedminnet (Lagre).<ref name="Sun1988_2-3"/>

SPARC hadde fire adresseringsmodi: Summen av to prosessor-registere, indeksert modus, register indirekte og register absolutt. De to sistnevnte er varianter av indeksert modus.

Denne enkle minnehåndteringen er et særpreg ved alle RISC-arkitekturer, og skiller dem fra [[CISC]]-arkitekturer.<ref name="Colwell1985s_10"/>

===Ingen mikrokode===
{{Utdypende|Mikrokode}}
SPARC mangler mikrokode. Også dette er et generelt kjennetegn ved RISC.<ref name="Colwell1985s_10"/> En mikrokode er en [[kommandotolk]] som oversetter [[maskinkode]] til eksekverbar kode under kjøring. Dette er selvsagt tregere enn å utføre programmer direkte, som på forhånd er oversatt til eksekverbar kode. Et gjennombrudd som gjorde dette mulig, var fremveksten av ''optimaliserende kompilatorer''. I RISC-maskiner er oppgavene til mikrokoden overført til kompilatorene; man kan også si at kompleksiteten ved mange CISC-maskiner (se f.eks. forrige avsnitt om adresseringsmodi) er flyttet fra maskinvaren til kompilatorene.

===Fast størrelse på instruksjoner===
SPARC hadde en fast størrelse på instruksjonene, og de var alle 32-biter.<ref name="Sun1988_1-1"/><ref name="Sun1988_2-3"/>

Denne faste størrelsen er også en egenskap ved RISC generelt, som kontrast til CISC.<ref name="Colwell1985s_10"/>

===4-trinns pipelining===
{{utdypende|Instruksjonspipeline}}
SPARC benyttet en 4-trinns pipeline for instruksjoner som behandlet heltall, og arbeidet med fire instruksjoner samtidig. Mens èn instruksjon ble hentet fra minnet, ble en annen dekodet, en tredje utført, og resultatet av en fjerde skrevet til minnet:

{| class="wikitable"
|- style="background:#efefef;"
! Syklus
! 1
! 2
! 3
! 4
! 5
! 6
! 7
|-bgcolor=#FAFAD2
|Instruksjon 1
|HENT
|DEKOD
|UTFØR
|SKRIV
|colspan="3" bgcolor="DDEEFF" |
|-bgcolor=#FAFAD2
|Instruksjon 2
|bgcolor="DDEEFF" |
|HENT
|DEKOD
|UTFØR
|SKRIV
|colspan="2" bgcolor="DDEEFF" |
|-bgcolor=#FAFAD2
|Instruksjon 3
|colspan="2" bgcolor="DDEEFF" |
|HENT
|DEKOD
|UTFØR
|SKRIV
|bgcolor="DDEEFF" |
|-bgcolor=#FAFAD2
|Instruksjon 4
|colspan="3" bgcolor="DDEEFF" |
|HENT
|DEKOD
|UTFØR
|SKRIV
|}

===En instruksjon per klokkepuls===
Den faste størrelsen på instruksjonene er noe som gjør pipelining lettere. Og sluttresultatet er at SPARC alltid utfører en instruksjon per klokkesyklus.<ref name="Sun1988_1-1"/> En SPARC som kjører i 10 MHz vil derfor alltid ha en ytelse på 10 [[MIPS]].

Også dette er et særpreg ved RISC generelt, i kontrast til CISC.<ref name="Colwell1985s_10"/> På CISC mikroprosessorer tar instruksjoner et varierende antall klokkepulser å gjennomføre.

===Formatene på instruksjonene===
SPARC versjon 7 spesifiserte fem ulike formater på instruksjonene &ndash; tre hovedformater og to underformater.<ref name="Sun1988_4-1"/> Disse er avbildet under.

{| class="wikitable"
|- style="background:#efefef;"
! Format
! 2 bit
! 5 bit
! 6 bit
! 5 bit
! 1 bit
! 8 bit
! 5 bit
|-bgcolor=#DDEEFF
|1
|
|DEST
|OPCODE
|SRC 1
|0
|FP-OP
|SRC 2
|-bgcolor=#DDEEFF
|2
|
|DEST
|OPCODE
|SRC1
|1
|colspan="2" | IMMEDIATE CONSTANT
|}

I det første formatet overføres innholdet fra et register til et annet. I det andre formatet overføres en konstant i størrelsesorden -4096 til +4096 til et register. Bit 13 skiller mellom positive og negative tall.

{| class="wikitable"
|- style="background:#efefef;"
! Format
! 2 bit
! 1 bit
! 4 bit
! 3 bit
! 22 bit
|-bgcolor=#DDEEFF
|3
|
|A
|COND
|OP
|PC-RELATIVE DISPLACEMENT
|-bgcolor=#DDEEFF
|4
|
|colspan="2" | DEST
|OP
|IMMEDIATE CONSTANT
|-bgcolor=#DDEEFF
|5
|
|colspan="4" | PC-RELATIVE DISPLACEMENT
|}

Det tredje formatet er knyttet til betingede hopp ved subrutiner. Feltet COND spesifiserer typen ''branch'' (BLT, BLE eller BEQ). 22-bit feltet DISPLACEMENT gir den relative 32-biter adressen til målet, slik at betingede hopp kan bevege seg fremover og bakover i størresesordenen 8 Mb. A-bitet (ANNUL) er et triks som brukes til å eliminere noen ''delay slots'' ved betingede hopp. Hvis det er 1, blir en ''delay slot'' bare utført når betingelsen oppfylles. Hvis betingelsen ikke oppfylles sløyfes subrutinehoppet.

Det fjerde formatet gir den absolutte adressen til målet, uten ''delay slots'' og uten å oppgi typen ''branch''. Heller ikke det femte formatet oppgir typen ''branch'' eller angir ''delay slots'', men kun den relative 32-biter adressen til målet.

===Stort antall generelle registere===
SPARC versjon 7 speifiserer et stort antall generelle registere. Dette er ikke nødvendigvis en  egenskap ved RISC i motsetning til CISC,<ref name="Colwell1985s_11"/> men var implementert i Berkeley RISC I og Berkeley RISC II til bruk for registervinduer.<ref name="Colwell1985s_14"/> SPARC spesifiserer totalt 520 slike generelle registere.

===Registervinduer===
I CISC-prosessorer er en stor del av dataoverføringene mellom mikroprosessoren og hovedminnet knyttet til [[funksjon (programmering)|prosedyrekall]]: Parametrene  overføres, innholdet i registrene lagres, returadressen legges på [[stakk (datastruktur)|stakken]] og hentes tilbake igjen når prosedyren er avsluttet. Datamaskinens minne har tradisjonelt vært, og er fortsatt, mye tregere enn både mikroprosessorens interne registre og hurtigminne. Derfor er prosedyrekall en stor flaskehals for den totale ytelsen.

Arkitektene bak RISC-prosessorene Berkeley RISC I og RISC II benyttet en genial metode for å oppheve nesten alle slike dataoverføringer. De innførte «overlappende registervinduer»,<ref name="Colwell1985s_14-15"/> som også benyttes i SPARC.<ref name="Patterson_Sequin">David. A. Patterson, Carlo. H. Sequin: ''RISC I: A Reduced Instruction Set VLSI Computer'', Proc. 8th International Symposium on Computer Architecture, Association for Computing Machinery, side 443-457, [[1981]], 2. utgave, International Symposium on Computer Architecture archive, 25 years of the international symposia on Computer architecture, side 216&ndash;230, [[1998]], ISBN 1-58113-058-9</ref> RISC I og RISC II var inspirasjonskilden til SPARC, men SPARC benytter en noe avvikende implementasjon. 

RISC I hadde 78 registere; 18 var globale, mens 6 vinduer inneholdt 14 registere hver. RISC II hadde 138 registere; 10 var globale, mens 8 vinduer inneholdt 16 registere hver.

SPARC-spesifikasjonen opererer med 32 stk virtuelle 32-biter registre i hvert vindu, nummerert fra R0 til R31. Registrene er delt inn i fire grupper:

{| class="wikitable"
|- style="background:#efefef;"
! #
! 32 bit lange registre
|-bgcolor=#FAFAD2
|R0&ndash;R7
|Globale variabler
|-bgcolor=#FAFAD2
|R8&ndash;R15
|Inngående parametre
|-bgcolor=#FAFAD2
|R16&ndash;R23
|Lokale variable
|-bgcolor=#FAFAD2
|R24&ndash;R31
|Utgående parametre
|}

* R0&ndash;R7 er nedenfor nummererte fra G0 til G7. G0 er alltid null. Registrene G1&ndash;G7 er globale, og kan inneholde heltall, pekere til tabeller eller andre data-elementer. 

* R8&ndash;R15 er nedenfor nummererte fra I0 til I7, og inneholder de inngående parametrene til en kallende prosedyre. I tradisjonelle CISC-maskiner legges disse på stakken én etter én, like før prosedyrekall.

* R16&ndash;R23 er nedenfor nummererte fra L0 til L7. De er avsatt til åtte lokale variabler inne i den kalte prosedyren. Også her unngår man bruk av stakken.

* R24&ndash;R31 er nedenfor nummererte fra O0 til O7. De er avsatt til åtte utgående parametre fra prosedyren som er avsluttet. Også her unngår man stakken.

SPARC tillater flere sett («registervinduer») med 32 stk 32-bit registre. Dette er antallet registere som enhver prosedyre på et gitt tidspunkt «ser». 5-bit variabelen ''CWP'' ''(Current Window Pointer)'' peker på R8. 2<sup>5</sup>= 32, og gir opptil (32 x 16) + 8 globale registre, eller 520 registre.

Istedenfor å flytte data mellom registrene og hovedminnet, flyttes CWP innenfor registrene, og gir programmet den illusjon at det opererer med et annet register.
{|
|width="33"|&nbsp;
|valign="top"|
{| class="wikitable" cellpadding=2 cellspacing=2
|-bgcolor="#cccccc"
! # !! Register-innhold
|-bgcolor=#FFE8E8
| R0&ndash;R7 || Globale
|}
{| class="wikitable" cellpadding=2 cellspacing=2
|-bgcolor="#cccccc"
! # !! Register-innhold
|-bgcolor=#DDEEFF
| R8&ndash;<br/>R15 || Inn
|-bgcolor=#DDEEFF
| R16&ndash;R23 || Lokale
|-bgcolor=#DDEEFF
| R24&ndash;R31 || Ut [[Fil:Fairytale right red.png|15px]]
|-bgcolor=#FAFAD2
|(R32&ndash;R38) || 
|-bgcolor=#FAFAD2
|(R39&ndash;R45) || 
|-bgcolor=#FAFAD2
|(R46&ndash;R52) || 
|-bgcolor=#FAFAD2
|(R53&ndash;R59) || 
|}
|width="33"|&nbsp;
|valign="top"|
{| class="wikitable" cellpadding=2 cellspacing=2
|-bgcolor="#cccccc"
! # !! Register-innhold
|-bgcolor=#FFE8E8
| R0&ndash;R7 || Globale
|}
{| class="wikitable" cellpadding=2 cellspacing=2
|-bgcolor="#cccccc"
! # !! Register-innhold
|-bgcolor=#FAFAD2
|(R8&ndash;R15) || 
|-bgcolor=#FAFAD2
|(R16&ndash;R23) || 
|-bgcolor=#DDEEFF
| R8&ndash;<br/>R15 || [[Fil:Fairytale right red.png|15px]] Inn
|-bgcolor=#DDEEFF
| R16&ndash;R23 || Lokale
|-bgcolor=#DDEEFF
| R24&ndash;R31 || Ut [[Fil:Fairytale right red.png|15px]]
|-bgcolor=#FAFAD2
|(R46&ndash;R52) || 
|-bgcolor=#FAFAD2
|(R53&ndash;R59) || 
|}
|width="33"|&nbsp;
|valign="top"|
{| class="wikitable" cellpadding=2 cellspacing=2
|-bgcolor="#cccccc"
! # !! Register-innhold
|-bgcolor=#FFE8E8
| R0&ndash;R7 || Globale
|}
{| class="wikitable" cellpadding=2 cellspacing=2
|-bgcolor="#cccccc"
! # !! Register-innhold
|-bgcolor=#FAFAD2
|(R8&ndash;R15) || 
|-bgcolor=#FAFAD2
|(R16&ndash;R23) || 
|-bgcolor=#FAFAD2
|(R24&ndash;R31) || 
|-bgcolor=#FAFAD2
|(R32&ndash;R38) || 
|-bgcolor=#DDEEFF
| R8&ndash;<br/>R15 || [[Fil:Fairytale right red.png|15px]] Inn
|-bgcolor=#DDEEFF
| R16&ndash;R23 || Lokale
|-bgcolor=#DDEEFF
| R24&ndash;R31 || Ut [[Fil:Fairytale right red.png|15px]]
|}
|}
Ovenfor illustreres tre registervinduer for tre prosedyrer. I det første registervinduet (og prosedyren) ligger utgående variabler i R24&ndash;R31. Ved å flytte CWP nedover 16 registre i registervinduet til det andre registeret (og prosedyren), blir samme register omdefinert til å inneholde inngående variabler. Det samme gjentar seg i tredje registervindu (og prosedyre).

I SPARC blir CWP dekrementert ved prosedyrekall. Den kallende prosedyren legger parametrene i R8&ndash;R15, og disse blir R24&ndash;R31 i prosedyren som kalles opp. Ved prosedyrekall «glir» «vinduet» oppover istedenfor nedover.

===Instruksjonssettet===
{|
|valign="top"|

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| LDSB || Hent byte (8 bit) med fortegn
|- bgcolor=#DDEEFF
| LDSH || Hent halvt ord (16 bit) med fortegn
|- bgcolor=#DDEEFF
| LDUB || Hent byte (8 bit) uten fortegn
|- bgcolor=#DDEEFF
| LDUH || Hent halvt ord (16 bit) uten fortegn
|- bgcolor=#DDEEFF
| LD || Hent ord (32 bit)
|- bgcolor=#DDEEFF
| LDD || Hent dobbelt ord (64 bit)
|}

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| STB || Lagre byte (8 bit)
|- bgcolor=#DDEEFF
| STH || Lagre halvt ord (16 bit)
|- bgcolor=#DDEEFF
| ST || Lagre ord (32 bit)
|- bgcolor=#DDEEFF
| STD || Lagre dobbelt ord (64 bit)
|}

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| LDSTUB || Hent og lagre byte (8 bit) uten fortegn
|- bgcolor=#DDEEFF
| SWAP || Swap ord (32 bit) i minnet med innhold i register
|}

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| ADD || Adder
|- bgcolor=#DDEEFF
| ADDCC || Adder, sett icc
|- bgcolor=#DDEEFF
| ADDX || Adder med mente
|- bgcolor=#DDEEFF
| ADDXCC || Adder med mente, sett icc
|- bgcolor=#DDEEFF
| SUB || Subtraher
|- bgcolor=#DDEEFF
| SUBCC || Subtraher, sett icc
|- bgcolor=#DDEEFF
| SUBX || Subtraher med mente
|- bgcolor=#DDEEFF
| SUBXCC || Subtraher med mente, sett icc
|- bgcolor=#DDEEFF
| MULSCC || Multipliser, sett icc
|}

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| TADDCC || 
|- bgcolor=#DDEEFF
| TSUBCC || 
|- bgcolor=#DDEEFF
| TADDCCTV || 
|- bgcolor=#DDEEFF
| TSUBCCTV || 
|}
|width="50"|&nbsp;
|valign="top"|

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| AND || Boolsk AND
|- bgcolor=#DDEEFF
| ANDCC || Boolsk AND, sett icc
|- bgcolor=#DDEEFF
| ANDN || Boolsk NAND
|- bgcolor=#DDEEFF
| ANDNCC || Boolsk NAND, sett icc
|- bgcolor=#DDEEFF
| OR || Boolsk OR
|- bgcolor=#DDEEFF
| ORCC || Boolsk OR, sett icc
|- bgcolor=#DDEEFF
| ORN || Boolsk NOR
|- bgcolor=#DDEEFF
| ORNCC || Boolsk NOR, sett icc
|- bgcolor=#DDEEFF
| XOR || Boolsk XOR
|- bgcolor=#DDEEFF
| XORCC || Boolsk XOR, sett icc
|- bgcolor=#DDEEFF
| XNOR || Boolsk XNOR
|- bgcolor=#DDEEFF
| XNORCC || Boolsk XNOR, sett icc
|}

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| SLL || Logisk venstre-skift
|- bgcolor=#DDEEFF
| SRL || Logisk høyre-skift
|- bgcolor=#DDEEFF
| SRA || Aritmetisk høyre-skift
|}

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| Bxx || Betinget branch
|- bgcolor=#DDEEFF
| Txx || Betinget avbrudd
|- bgcolor=#DDEEFF
| CALL || Prosedyrekall
|- bgcolor=#DDEEFF
| JMPL || 
|- bgcolor=#DDEEFF
| SAVE || Flytt registervindu fremover
|- bgcolor=#DDEEFF
| RESTORE || Flytt registervindu bakover
|- bgcolor=#DDEEFF
| RETT || Returner fra avbrudd
|}

{| class="wikitable" cellpadding=2 cellspacing=2
|- bgcolor="#cccccc"
! Instruksjon !! Forklaring
|- bgcolor=#DDEEFF
| SETHI || Sett de øverste 22 bit
|- bgcolor=#DDEEFF
| UNIMP || Ikke implementert (avbrudd)
|- bgcolor=#DDEEFF
| RD || Les et register
|- bgcolor=#DDEEFF
| WR || Skriv til et register
|- bgcolor=#DDEEFF
| IFLUSH || Tøm instruksjons-cache
|}
|}

===Eksempel-algoritme: «Tårnene i Hanoi»===
{{utdypende|Tårnet i Hanoi}}
Det såkalte [[Tårnet i Hanoi|«Tårnet i Hanoi»]] er et yndet og populært eksempel på [[rekursjon]] innenfor programmering. Algoritmen nedenfor gir en rekursiv løsning på dette puslespillet, skrevet i [[assembler]]språket til SPARC. Den viser også bruken av registrene og registervinduer, som er forklart ovenfor.

  .proc 4                    ! start rutinen
  .globl _towers             ! definer "towers" som et globalt symbol
 _towers: save %sp,-112%sp   ! flytt register-vinduet og stakkpeker
 ! if n = 1 then;            ! I0 = n, l1 = i, l2 = j
   cmp %IO,1                 ! hvis n = 1
   bne ELSE                  ! ellers gå til ELSE
 ! writeln("move", i, 'to', j);
      sethi %HI(AI), %00     ! 0o = de øverste 22 bit av adressen A1
      call .writestr         ! skriv ut teksten "Flytt"
      or %00,%L0(AI),%00     ! 00 = adressen til A1
      call .writenum         ! skriv ut i til skjerm
      mov %Il,%00            ! 0o = i
      sethi %HI(A2),%00      ! 0o = de øverste 22 bit til adressen A2
      call .writenum         ! skriv ut teksten 'til'
      or %00,%L0(A2),%00     ! 0o = adressen til A2
      call .writenum         ! skriv ut j til skjerm
      mov %12,%00            ! I0 = j
      call .writecr          ! Linjeskift
      nop                    ! Ingen utførelse
      b DONE                 ! hopp til rutinen DONE
      mov 0,%00              ! Returner 0 (OK)
  ! k = 6 - i - j;           ! Beregn k i det lokale registeret L0
  ELSE: mov 6,%LO            ! Lokalt register L0 = 6
        sub %L0,%Il,%LO      ! Lokalt register L0 = 6 - i
        sub %L0,%I2,%LO      ! Lokalt register L0 = 6 - i - j
  ! towers(n – 1, i, k);
        sub %I0,1,%00        ! parameter 0: 0o = n - 1
        mov %Il,%01          ! parameter 1: 01 = i
        call _towers,3       ! towers(n – 1, i, k)
        mov %L0,%02          ! parameter 2: 02 = k
  ! towers(l, i, j);
        mov 1,%00            ! parameter 0: 0o = 1
        mov %Il,%01          ! parameter 1: 01 = i
        call _towers,3       ! towers (l, i, j)
        mov %I2,%02          ! parameter 2: 02 = j
  ! towers(n – l, k, j)
        sub %I0, l, %00      ! parameter 0: 0o = n - 1
        mov %L0,%01          ! parameter 1: 01 = k
        call _towers,3       ! towers(n – 1, k, j)
        mov%I2, %02          ! parameter 2: 02 = j
        mov 0,%00            ! returnerer 0 (OK)
  DONE: ret                  ! avslutter algoritmen
        restore %g0,%00,%00  ! nullstiller register-vinduet
        .seg "data"          ! bruker data-segmentet
  A1:   .ascii "Flytt \0"    ! allokerer en tekst
  A2:   .ascii "til \0"      ! allokerer en tekst

===SPARC versjon 7 versus andre arkitekturer===
I tabellen nedenfor er SPARC versjon 7 sammenlignet med andre datamaskinarkitekturer. Dette er gjort for å sette mikroprosessoren inn i et større perspektiv.

Til sammenligning har vi valgt ut mikroprosessoren [[R2000]], som ble lansert av [[MIPS Computer Systems]] i januar 1986. Dette var også en 32-bit RISC mikroprosessor, og den ble lansert noenlunde samtidig. Den var bygd opp etter versjon I av arkitekturen [[MIPS (RISC-arkitektur)|MIPS]] (MIPS I) fra [[Stanford University]], som ble nevnt innledningsvis.

CISC mikroprosessorene [[Intel 80386]] og [[Motorola 68030]] er også brukt som sammenligning på grunn av deres store utbredelse, og fordi de begge ble lansert nesten samtidig.

{| class="wikitable"
|- style="background:#efefef;"
! Element
! SPARC v7
! MIPS R2000
! Intel 80386
! Motorola 68030
|-bgcolor=#DDEEFF
|Arkitektur
|RISC
|RISC
|CISC
|CISC
|-bgcolor=#DDEEFF
|Biter
|32-biter
|32-biter
|32-biter
|32-biter
|-bgcolor=#DDEEFF
|Koprosessor<br/>for flyttall
|Ekstern<br/>(flere<br/>produsenter)
|Ekstern<ref name="Johansson1990_42"/><br/>(flere<br/>produsenter)
|Ekstern<br/>([[Intel 80387]])
|Ekstern<br/>([[Motorola 68881]] eller<br/>[[Motorola 68882]])
|-bgcolor=#DDEEFF
|Andre koprosessorer
|1
|2
|0
|1
|-bgcolor=#DDEEFF
|Minnehåndtereren
|Ekstern
|Intern
|Intern
|Intern
|-bgcolor=#DDEEFF
|Mikrokontroller<br/>for hurtigminne
|Ekstern
|Intern
|Intern
|Intern
|-bgcolor=#DDEEFF
|Hurtigminne
|Eksternt
|Eksternt
|Eksternt
|Internt
|-bgcolor=#DDEEFF
|Delt hurtigminne
|Nei
|Ja
|Nei
|256 byte for data<br/>256 byte for instruksjoner
|-bgcolor=#DDEEFF
|Databuss
|32-biter
|32-biter
|32-biter
|32-biter
|-bgcolor=#DDEEFF
|Adressbuss
|32-biter
|31-biter
|32-biter
|32-biter
|-bgcolor=#DDEEFF
|Adresseringsmodi
|4
|3
|8
|18
|-bgcolor=#DDEEFF
|Mikrokode
|Nei
|Nei
|Ja
|Ja
|-bgcolor=#DDEEFF
|Lengde på instruksjoner
|32-biter
|32-biter.<ref name="Johansson1990_42"/>
|8&ndash;68 biter
|16&ndash;104 biter
|-bgcolor=#DDEEFF
|Instruksjonsformater
|5
|3<ref name="Johansson1990_42"/>
|Mange
|Mange
|-bgcolor=#DDEEFF
|
|
|
|
|
|}

De tre adresseringmodi i MIPS R2000 var indeksert modus, register indirekte og register absolutt. Den manglet summen av to prosessor-registere, som var den fjerde i SPARC.

MIPS R2000 benyttet en 5-trinns pipe: 1) hent instruksjon, 2) dekod instruksjon, 3) utfør instruksjon, 4) lagre data i hovedminne/hurtigminne, 5) overfør resultat fra den aritmetisk logiske enheten til register.<ref name="Johansson1990_46"/>

===Andre derivater av Berkeley RISC===
SPARC er den direkte etterfølgeren av [[Berkeley RISC]] og de to mikroprosessorene RISC I og RISC II. Flere andre RISC-arkitekturer er også direkte derivater av Berkeley RISC, og de viktigste er nevnt nedenfor.

*Arkitekturen [[PA-RISC]] ble utviklet av [[Hewlett Packard]]. Selskapet produserte og solgte sine egne RISC-prosessorer basert på denne arkitekturen fra 1986 til 2008.
*Arkitekturen [[DEC Alpha]] ble utviklet av [[Digital Equipment Corporation]]. Den ble innledet med RISC-prosessoren [[Alpha 21064]] i 1992. [[Alpha 21364]] ble lansert i april 2001 og var den siste i denne familien.
*[[Motorola 88000]] var en familie med RISC-prosessorer som ble utviklet av [[Motorola]], og som ble benyttet som [[mikrokontroller]]e i [[innebygd system|innebygde systemer]]. I 1988 lanserte selskapet mikroprosessoren [[MC88100]]. Den ble i 1992 ble etterfulgt av [[MC88110]].
*[[Intel i960]] var en RISC-prosessor som ble lansert av [[Intel]] i 1985. Den ble etterhvert en av markedets mest populære mikrokontrollere i skrivere og harddisker, men hadde også andre bruksområder.
* [[Intel i860]] ble lansert av Intel i 1989. Det var en superskalær mikroprosessor og en hybrid mellom 32-biter og 64-biter. Intel hadde planer om å utbre denne i [[personlig datamaskin|personlige datamaskiner]], og [[operativsystem]]et [[Windows NT]] var opprinnelig tiltenkt denne. Den mislyktes imidlertid i å erobre markedet.
* [[AMD Am29000]] ble lansert av [[AMD]] i 1989, og innledet en ny familie med RISC mikroprosessorer. Den var en konkurrent til Intel i960, og på 1990-tallet dominerte disse to markedet for mikrokontrollere. Begge to ble til slutt faset ut til fordel for arkitekturen ARM.
* RISC-arkitekturen [[ARM (prosessorarkitektur)|ARM]] ble introdusert i 1985 og overtok etterhvert markedet for mikrokontrollere. Den benyttes idag i de fleste [[mobiltelefon]]er.