Un semplice microprocessore - istruzioni, ciclo singolo e cicli multipli

Dopo il datapath (Un semplice microprocessore - datapath, ALU e register fileUn calcolatore semplificato ma completo ha datapath, unità di controllo e memoria. Il datapath contiene un register file ($2^m$ registri da $n$ bit, due porte di lettura A e B e una di scrittura), un MUX B (registro o costante), una unità funzionale = ALU + shifter e un MUX D (risultato o dato dalla memoria); segnala V, C, N, Z. La ALU unisce un circuito aritmetico (sommatore con logica di ingresso per $B$: $0$, $B$, $\overline B$, tutti 1, più $C_{in}$) e uno logico (AND, OR, XOR, NOT) tramite un MUX. Le 15 microoperazioni si scelgono con un codice FS a 4 bit; la control word del datapath è di 16 bit (DA, AA, BA, MB, FS, MD, RW).Un semplice microprocessore - datapath, ALU e register file →) si completa il calcolatore con la unità di controllo e la memoria. Il quadro generale delle architetture è in Instruction Set ArchitectureChe cosa definisce un insieme di istruzioni; elementi di un'istruzione; tipi di operandi e di operazioni; macchine a 0, 1, 2 e 3 indirizzi con lo stesso calcolo svolto in ciascuna; architetture load/store.Instruction Set Architecture →, Formato delle istruzioni e modalità di indirizzamentoModalità di indirizzamento (immediato, diretto, indiretto, a registro, indiretto a registro, con spiazzamento, relativo al PC, indicizzato e scalato, a pila) con indirizzo effettivo ed esempi; formati fissi e variabili; i formati R, I e J di MIPS e il formato a 32 bit di ARM con il calcolo dei campi.Formato delle istruzioni e modalità di indirizzamento →, Ciclo fetch-executeRegistri PC, IR, MAR e MBR; ciclo dell'istruzione diviso in fetch ed execute; i quattro tipi di operazioni; diagramma degli stati del ciclo con calcolo degli indirizzi degli operandi e controllo delle interruzioni; esempio su una macchina ad accumulatore.Ciclo fetch-execute →, Unità di controlloCompiti dell'unità di controllo e micro-operazioni; segnali di controllo del datapath con tabella per le classi di istruzioni; controllo cablato (combinatorio o a stati finiti) e controllo microprogrammato (memoria di controllo, microistruzioni orizzontali e verticali); confronto.Unità di controllo →.

Il calcolatore e il Program Counter

Il computer prende in ingresso una sequenza di istruzioni contenute in una memoria (RAM o ROM). Ogni istruzione comprende l'operazione da effettuare, gli operandi, la destinazione e, in alcuni casi, la prossima istruzione. Il Program Counter (PC) contiene l'indirizzo della prossima istruzione, che può essere ottenuto in due modi: con un contatore ($+1$, istruzione successiva) oppure con un caricamento parallelo (parallel load) per cambiare il flusso (salti).

Eseguire un'istruzione significa attivare la sequenza appropriata di microoperazioni: nel datapath e come trasferimenti da e verso la memoria. La unità di controllo:

1. preleva (fetch) un'istruzione dalla memoria;
2. la decodifica;
3. la esegue con una sequenza di una o più microistruzioni.

Definizione (istruzione, instruction set e ISA). Un'istruzione è un insieme di bit che specifica completamente un'operazione in modo sintetico; l'instruction set è l'insieme di tutte le istruzioni; l'ISA ne è il catalogo con la descrizione completa. Si vedono due strutture di controllo: ciclo singolo e cicli multipli.

Esempio. Con un opcode di $7$ bit l'instruction set può avere fino a $2^7=128$ istruzioni, ciascuna di $16$ bit.

Instruction set architecture

Tre componenti: elementi di memoria, formato delle istruzioni, specifiche delle istruzioni.

Elementi di memoria visibili all'utente: la memoria istruzioni e la memoria dati (nell'esempio $2^{15}\times16$ bit ciascuna; potrebbero essere fisicamente la stessa memoria), il register file ($8\times16$, operandi delle operazioni logico-aritmetiche), il program counter. A seconda della microarchitettura ci possono essere altri elementi usati internamente e non visibili.

Formato delle istruzioni

Definizione (formato delle istruzioni a 16 bit). I bit sono divisi in campi. L'opcode specifica l'operazione; gli operandi (registri o memoria) sono indicati in modo esplicito (bit dedicati) o implicito (inclusi nell'opcode). Tre formati, a 16 bit:

formato	bit 15–9	bit 8–6	bit 5–3	bit 2–0
Registro	opcode (7)	DR (registro destinazione)	SA (sorgente A)	SB (sorgente B)
Immediato	opcode (7)	DR	SA	OP (operando immediato)
Salto (jump/branch)	opcode (7)	AD sinistra	SA	AD destra

Esempio. Nel formato registro $7+3+3+3=16$ bit; con $DR=R_3$, $SA=R_1$ e $SB=R_2$ i tre campi valgono $011$, $001$ e $010$.

Gli 8 registri si indicano con 3 bit. Nel formato immediato l'operando ha solo 3 bit: i 13 restanti sono riempiti con zeri (zero fill, zf). Il formato di salto serve ad alterare il flusso:

• branch (ramo): condizionato dal contenuto di un registro (per esempio $R[SA]=0$); è PC-relativo: $PC\leftarrow PC+\text{offset}$ con offset AD di $3+3=6$ bit esteso in segno (se, sign extension) per poter saltare avanti e indietro (complemento a 2). Intervallo limitato di indirizzi (vicini al PC);
• jump (salto): intervallo più ampio, il contenuto di un registro è la destinazione.

Set di istruzioni

(RD, RA, RB = registri; OP = operando; AD = indirizzo; mnemonico = rappresentazione simbolica dell'opcode, tradotta in binario dall'assembler; bit di stato aggiornati: $N,Z$.)

Per tutte le istruzioni (salvo salti presi) vale anche $PC\leftarrow PC+1$, per preparare il ciclo successivo. È un'architettura load/store: LD e ST sono le uniche istruzioni con accesso alla memoria dati; tutte le altre operano sui registri.

Osservazione sui codici. I quattro bit meno significativi dell'opcode (bit 12–9 dell'istruzione) coincidono con il codice $FS$ della unità funzionale (Un semplice microprocessore - datapath, ALU e register fileUn calcolatore semplificato ma completo ha datapath, unità di controllo e memoria. Il datapath contiene un register file ($2^m$ registri da $n$ bit, due porte di lettura A e B e una di scrittura), un MUX B (registro o costante), una unità funzionale = ALU + shifter e un MUX D (risultato o dato dalla memoria); segnala V, C, N, Z. La ALU unisce un circuito aritmetico (sommatore con logica di ingresso per $B$: $0$, $B$, $\overline B$, tutti 1, più $C_{in}$) e uno logico (AND, OR, XOR, NOT) tramite un MUX. Le 15 microoperazioni si scelgono con un codice FS a 4 bit; la control word del datapath è di 16 bit (DA, AA, BA, MB, FS, MD, RW).Un semplice microprocessore - datapath, ALU e register file →): ADD $=0000010\to FS=0010$ ($A+B$), SUB $=0000101\to FS=0101$ ($A+\overline B+1$), AND $\to1000$, LDI $\to1100$ ($F=B$ con $B$ = costante), ADI $\to0010$. I tre bit alti (15, 14, 13) distinguono il tipo: $000$ operazioni su registri, $001$ LD, $010$ ST, $100$ operazioni con costante, $110$ salti condizionati, $111$ salto incondizionato.

Esempio di rappresentazione in memoria

L'offset di BRZ è $101100_2$ che in complemento a 2 a 6 bit vale $-20$: se $R_6=0$ il programma torna a $55-20=35$. Se $R_4=70$ e $R_5=80$, l'istruzione in 35 scrive $80$ all'indirizzo $70$ (dove prima c'era $192$).

Computer a ciclo singolo

Il computer a ciclo singolo carica ed esegue ogni istruzione in un solo ciclo di clock. Blocchi: PC, memoria istruzioni (non viene scritta), decoder delle istruzioni, register file, MUX B, unità funzionale, memoria dati (scritta con $MW$), MUX D, un blocco di controllo del PC e un'unità di estensione (extend) che aggiunge i bit a sinistra dell'offset. Nella parte di controllo l'unica memoria è il PC, aggiornato a ogni ciclo:

• normalmente $PC\leftarrow PC+1$;
• jump: $PC\leftarrow$ valore del bus A;
• branch: $PC\leftarrow PC+$ offset esteso in segno (se la condizione è vera).

Decoder delle istruzioni. È una rete combinatoria che dai bit dell'istruzione produce i segnali di controllo del datapath. Alcuni bit passano diretti: $DA$ = bit 8–6 (campo DR), $AA$ = bit 5–3 (SA), $BA$ = bit 2–0 (SB), $FS$ = bit 12–9. Gli altri segnali ($MB,MD,RW,MW,PL,JB,BC$) dipendono dai bit 15, 14, 13 e 9. Tabella di verità (X = indifferente):

Significato: $MB$ (0 registro, 1 costante), $MD$ (0 risultato, 1 dato dalla memoria), $RW$ (scrive il register file), $MW$ (scrive la memoria dati), PL (load PC: il PC non incrementa ma si carica), JB (jump: il PC prende il bus A, altrimenti PC + offset), BC (condizione: 0 zero, 1 negativo). La control word a ciclo singolo è di 20 bit: $DA\,(3)\ AA\,(3)\ BA\,(3)\ MB\ FS\,(4)\ MD\ RW\ MW\ PL\ JB\ BC$.

Come esegue un'istruzione (sempre nello stesso ciclo): il PC indirizza la memoria istruzioni; l'istruzione è decodificata; si leggono i registri $SA$ e $SB$; la unità funzionale calcola; il risultato (o il dato letto dalla memoria) torna al register file (scritto sul fronte di clock); il PC è aggiornato. Esempi:

• ADD (tipo registro): $MB=0$, $MD=0$, $RW=1$, $FS=0010$;
• LD RD,RA: l'indirizzo è il bus A ($R[SA]$), $MD=1$, $RW=1$;
• ST RA,RB: indirizzo = bus A ($R[SA]$), dato = bus B ($R[SB]$), $MW=1$, $RW=0$.

Formula (periodo di clock del ciclo singolo). Il periodo di clock deve essere almeno la somma dei ritardi di tutti i blocchi lungo il cammino critico, perché in un ciclo il segnale attraversa tutti in sequenza. Esempio con ritardi tipici:

blocco	PC	memoria istruzioni	register file (lettura)	MUX B	unità funzionale o memoria dati	MUX D	register file (scrittura)
ritardo (ns)	0,2	4	0,6	0,2	4	0,2	0,6

Somma $=9{,}8$ ns $\Rightarrow$ $f_{max}\approx102$ MHz. Anche l'istruzione più semplice (un ADD) impiega l'intero periodo, dimensionato sulla più lenta (LD). Inoltre servono memorie separate per istruzioni e dati (nello stesso ciclo si accede a entrambe), cosa costosa: le due limitazioni si superano con il computer a cicli multipli, e le prestazioni con la pipeline (Pipeline, hazard e architetture RISC e CISCLa pipeline divide l'esecuzione in stadi separati da registri (IF, DOF, EX, WB) che lavorano in parallelo su istruzioni diverse: la latenza di una istruzione non cambia, il throughput aumenta di un fattore minore del numero di stadi (ritardo dei FF, stadio più lento). Con $k$ stadi e $N$ istruzioni servono $k+N-1$ cicli (riempimento e svuotamento). Gli hazard bloccano la pipeline: di dato (operando non ancora scritto: rimedi NOP, stall, forwarding) e di controllo (salti: bolle, branch prediction). RISC: istruzioni semplici, load/store, formato unico, 32 registri con R0$=0$; CISC: istruzioni complesse, più modi di indirizzamento, formato variabile, controllo microprogrammato.Pipeline, hazard e architetture RISC e CISC →).

Esempio. Con ritardo totale $0{,}2+4+0{,}6+0{,}2+4+0{,}2+0{,}6=9{,}8$ ns si ha $f_{max}=1/9{,}8\ \mathrm{ns}\approx102$ MHz.

Computer a cicli multipli

Le istruzioni sono eseguite in un numero variabile di cicli di clock, quindi possono essere più complesse. Servono modifiche a:

• memoria: si può usare una sola memoria per istruzioni e dati. Spesso per una singola istruzione servono più accessi (l'istruzione stessa e un dato), impossibili in un ciclo;
• unità di controllo: l'istruzione va mantenuta per più cicli, quindi si aggiunge l'instruction register (IR) con segnale di load; il decoder combinatorio è sostituito da una macchina sequenziale: un registro dello stato di controllo, logica di controllo e uno stato futuro: (stato, opcode, bit di stato) $\Rightarrow$ control word;
• datapath: registri duplicati per contenere risultati intermedi, ottenuti in un ciclo e necessari in un ciclo successivo della stessa istruzione. Sono interni e non visibili al programmatore ($R_8$–$R_{15}$); i campi $DX$, $AX$, $BX$ (4 bit) scelgono un registro utente (DR/SA/SB) oppure interno, a seconda del bit più significativo.

Control word a cicli multipli (28 bit): $NS$ (4, stato futuro) $PS$ (2) $IL$ $DX$ (4) $AX$ (4) $BX$ (4) $MB$ $FS$ (4) $MD$ $RW$ $MM$ $MW$. $PS$ (program sequence) determina il PC: $00$ mantiene, $01$ incrementa, $10$ salto condizionato, $11$ jump; $IL$ (instruction load) carica l'IR; $MM$ è il MUX che sceglie l'indirizzo della memoria (PC per il fetch, bus A per i dati).

Macchina a stati. Le istruzioni più semplici richiedono il numero minimo di cicli, due, perché accedono sia all'istruzione sia ai dati: instruction fetch (INF), in cui $IR\leftarrow M[PC]$, e instruction execution (EX0), che esegue l'operazione, aggiorna il PC e riporta a INF. Esempi: ADD: INF, poi EX0 con $R[DR]\leftarrow R[SA]+R[SB]$ e $PC\leftarrow PC+1$.

Istruzioni più lunghe (3 o più cicli): per esempio un load con registro indiretto $R[DR]\leftarrow M[M[R[SA]]]$ ha 3 cicli: INF; EX0: $R_8\leftarrow M[R[SA]]$ (uso del registro interno $R_8$); EX1: $R[DR]\leftarrow M[R_8]$ e $PC\leftarrow PC+1$. Gli shift multipli (a destra e a sinistra di più posizioni, definite da OP) richiedono un ciclo di stati EX0–EX4 che usa $R_8$ come registro di lavoro e $R_9$ come contatore che si decrementa finché non vale zero (il segnale di stato $Z$ ne rileva l'azzeramento): ogni iterazione sposta di un bit, alla fine $R[DR]\leftarrow R_8$.

Vantaggi: l'orologio può essere più veloce (determinato dal blocco più lento in ogni ciclo, non dall'intera catena) e si può usare una memoria sola; svantaggio: ogni istruzione impiega almeno due cicli. Per riportare a un'istruzione per ciclo con clock veloce si usa la pipeline.

Errori comuni

• Dire che l'indirizzo di memoria di LD/ST è un campo dell'istruzione: è il contenuto del registro $SA$ (bus A).
• Dimenticare l'incremento del PC nelle istruzioni che non saltano.
• Credere che in un ciclo singolo un'istruzione semplice impieghi meno tempo: il periodo è lo stesso per tutte.
• Confondere registri interni (non visibili) e registri utente.
• Leggere l'offset di BRZ come numero senza segno: è in complemento a 2 ($44\to-20$).