SPARCV7 mikroprosessor

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).
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.

Ingen mikrokode

SPARC mangler mikrokode. Også dette er et generelt kjennetegn ved RISC. 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.
Denne faste størrelsen er også en egenskap ved RISC generelt, som kontrast til CISC.

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. 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. På CISC mikroprosessorer tar instruksjoner et varierende antall klokkepulser å gjennomføre.

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, men var implementert i Berkeley RISC I og Berkeley RISC II til bruk for registervinduer. SPARC spesifiserer totalt 520 slike generelle registere.

Eksempel-algoritme: «Tårnene i Hanoi»

Det såkalte «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 assemblersprå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

Cypress SPARC CY7C601-40 og Cypress SPARC CY7C601-40GC

Disse prosessorene ble produsert med en 0.8 µ CMOS-prosess, og bestod av 1.8 millioner transistorer. Cypress SPARC CY7C601-40GC hadde 207 pinner for en PGA-socket, mens Cypress SPARC CY7C601-40 hadde 208 pinner for en QFP socket. Begge prosessorene kjørte i 40 MHz.
Desimaltallsenheten ble kalt Cypress CY7C602 (40 MHz), mens cache-kontrolleren hadde navnet Cypress CY7C605 (40 Mhz).