Instruksjonssettarkitektur (ISA)

ISA er grensesnittet mellom maskinvare og programvare. Den definerer:

Registerfilens størrelse (ARM: 16 registre á 32 bits, $R0$–$R15$)
Instruksjonsformat og instruksjonssett
Adresseringsmoduser
Minnemodell

Hente–dekode–eksekvere (fetch–decode–execute)

Alle prosessorer følger den grunnleggende instruksjonssyklusen:

Fetch (IF): Les instruksjon fra minne på adressen i Program Counter (PC). Inkrementer PC.
Decode (ID): Tolk instruksjonsbitene: opcode, registeradresser, umiddelbar verdi. Les operander fra registerfil.
Execute (EX): ALU utfører operasjonen (beregning, adresse, sammenlikning).
Memory (MEM): Tilgang til dataminne (load/store).
Write-back (WB): Skriv resultat tilbake til registerfil.

Enkeltyklusprosessor

En enkeltyklusprosessor gjennomfører hele instruksjonssyklusen i én klokkesyklus. Klokkperioden må være lang nok for den tregeste instruksjonen (typisk load). Fordelene er enkelhet; ulempen er at raskere instruksjoner bruker unødvendig lang tid.

Flersyklusprosessor

En flersyklusprosessor deler gjennomføringen over flere kortere klokkesykluser. Enkle instruksjoner (f.eks. AND) bruker færre sykluser enn komplekse (f.eks. LW). Register for mellomliggende verdier (IR, A, B, ALUout, MDR) lagrer tilstand mellom stegene. Kontrollenheten er en FSM.

Kontrollenhet: hardwired vs. mikroprogrammert

En hardwired kontrollenhet er implementert direkte i kombinatorisk/sekvensiell logikk – rask men vanskelig å modifisere. En mikroprogrammert kontrollenhet lagrer kontrollsignaler i ROM (mikroprogram) – fleksibel, lettere å designe, men tregere.

Eksempel: Datasti for ADD-instruksjon

En minimal datapath for ADD-instruksjonen (R-type): (1) PC → InstruksjonsMinne → IR (fetch). (2) IR deles i felter: opcode, $R_n$ (src1), $R_m$ (src2), $R_d$ (dst). (3) Registerfil leser $R_n$ og $R_m$. (4) ALU utfører ADD. (5) Resultat skrives til $R_d$ i registerfil. (6) PC = PC + 4. Kontrollenheten setter MUX-valgbiter og ALU-kontrollen basert på opcode.

Eksempel: Klokkesykler for single-cycle, multi-cycle og pipeline

En fast oppgave er å telle klokkesykler/kjøretid for de tre mikroarkitekturene fra læreboka. Gitt et program på $N$ instruksjoner (anta f.eks. $N=6$):

Single-cycle: CPI $=1$, så $6$ sykler. (Men lengst klokkeperiode.)
Multi-cycle med fast CPI $=4$: $6 \times 4 = 24$ sykler.
5-stegs pipeline med hazard-enhet: $N + (k-1) + \text{staller}$. Uten staller: $6 + 4 = 10$ sykler. Hver nødvendig load-use-stall legger til én syklus.

Ytelses-sammenligning med ulik klokkefrekvens: regn $T = (\text{sykler}) \times t_{clk}$. Eks.: single-cycle $@1\,\text{GHz}$ ($t_{clk}=1\,\text{ns}$) bruker $6\,\text{ns}$; pipeline $@2\,\text{GHz}$ ($t_{clk}=0{,}5\,\text{ns}$) bruker $10 \times 0{,}5 = 5\,\text{ns}$. Generelt: pipeline er typisk raskere enn multi-cycle, og forholdet single-vs-pipeline avhenger av program og klokke.

Studieguide: Prosessorarkitektur