Università degli Studi dell’Insubria Dipartimento di Scienze Teoriche e Applicate
Architettura degli elaboratori
Registri e Memoria
Marco Tarini
Dipartimento di Scienze Teoriche e Applicate marco.tarini@uninsubria.it
Register File
Spesso occorre utilizzare un certo numero di registri paralleli tutti aventi le stesse dimensioni e le stesse funzioni
Sono organizzati in una struttura a vettore, chiamata Register File
(in italiano, a volte: «Banco» dei Registri)
(nota linguistica: «File» nel senso di «filiera», «fila»:
il File System non centra nulla)
Un Register File =
un insieme di M registi da N bit
e, i circuiti di controllo: per accedervi in lettura e scrittura
I registri di una macchina, contenuti nel Register File,
sono tipicamente l’input e l’output dei conti eseguiti dalla ALU
In molte architetture, sono l’unica cosa su cui la ALU può lavorare!
Esempio: i registri della CPU Schema concettuale
Qui: un registro viene sovrascritto con la somma di altri due (calcolata dalla ALU)
Memoria
Architettura degli elaboratori - 3 -
A B
Register File
A + B
A L U
Register File come blocco logico:
funzionamento
2
kregistri da n bits
n
n n
k
o
0o
1i
0dato da memorizzare
Reg[ o1] Reg[ o0]
clock
Esempio: un Register File a 2 uscite e 1 entrata (altre combinazioni sono possibili)
k
k
Register file come blocco logico:
funzionamento
Un Register File a 2 uscite e 1 entrata, per m = 2k a n bit contiene: m = 2kregistri da n bit ciascuno
numerati da 0 a 2k – 1 in output, restituisce il valore attuale di due dei registri:
specificati dagli indici o0 e o1 (presi in ingresso)
in input, prende anche la parola (di n bit) che verrà memorizzata nel registro di indice i0
(appena il clock manda ) e il clock, per la sincronizzazione (come al solito)
Memoria
Architettura degli elaboratori - 6 -
2
kregistri da n bits
n
n n
k k k
o
0o
1i
0dato da memorizzare
Reg[ o1] Reg[ o0]
clock
Register File
Uso di un Register File esempio
Reg[9] Reg[12] + Reg[4]
n
n n
k k k
A L U 4
12
SUM
9
clock
Reg[12]
Reg[4]
Reg[12] + Reg[4]
o
0o
1i
0Uso di un Register File esempio
Reg[9] Reg[12] + Reg[4]
Memoria
Architettura degli elaboratori - 8 -
n
n n
k k k
A L U
Re g 4
Re g 12 Re g 9
4 12
SUM
9
clock
Reg[12]
Reg[4]
Reg[4] + reg[12]
Programmabilità
Il circuito di questo esempio sta eseguendo comandi del tipo:
«somma i registri R4 e R12 e metti il risultato in R9» ! cioè « R9 = R4 + R12 »
in un Linguaggio Macchina, questo comando può apparire come:
in un Linguaggio Assembler, questo comando può apparire come 0 0 1 0 0 1 0 0 1 0 0 1 0 0 0 1 1 0 0
codice per l’operazione
«SUM»
(da mandare alla ALU come OP)
«9», indice del registro di destinazione
(da mandare al Register File
come i0)
«4», indice del primo operando (da mandare al Register File
come o0)
«12», indice del secondo
operando (da mandare al Register File
come o0)
ADD R9, R4, R12
Torniamo un secondo ad una visione complessiva dei livelli di astrazione
In un linguaggio ad alto livello (es. C o Java) scriveremo:
Il compilatore potrebbe (per es) decidere che le variabili con gli identificatori «tot_animali», «n_mucche», «n_pecore»
vadano memorizzati nei registri n. 10, 11, e 12 rispettivamente, e tradurre il comando di assegnamento come:
che in un linguaggio macchina binario diventa (per es):
Memoria
Architettura degli elaboratori - 10 -
int tot_animali, n_mucche, n_pecore;
… /* altro codice */
tot_animali = n_mucche + n_pecore;
ADD R10, R11, R12
0 0 1 0 0 1 0 1 0 0 1 0 1 1 0 1 1 0 0
Register File (con 32 registri a 64 bit) : possibile implementazione
CK
64 64
R0 U
I
L
R1 U I
L
…
64
R2 U I
L
64
R3 U I
L
…
…
64
R30 U
I
L
64
R31 U
I
L
D E C
32 31 30
64
64 64
M U X M U X
29 28 2
o
0o
1i
0 55 5
Register File e ALU:
note sul ciclo di clock
Fino a che il ciclo di clock non finisce (con un fronte in discesa):
il Register File manda gli operandi in uscita;
la ALU trova questi operandi nei propri ingresso;
la ALU manda il risultato computato nella propria uscita;
il Register File trova il risultato nel proprio ingresso.
Quando avviene il fronte in discesa, il Register File memorizza il risultato nel registro indicato
(nota: agli altri mandiamo L=0 e non si modificano) Alcune conseguenze importanti:
è possibile eseguire comandi del tipo R5 R5 + R9 infatti R5 viene sovrascritto solo alla fine del ciclo di clock.
Fino ad allora la ALU vede il vecchio R5 immutato come operando.
Il ciclo di clock deve essere sufficientemente lungo da permettere al segnale di propagarsi dall’output del Register File al suo input, (compreso il computo della ALU)
Questo mette un limite alla frequenza di clock!
Memoria
Architettura degli elaboratori - 12 -
Register File: note sull’uso
Ogni registro può contenere valori di qualsiasi tipo:
naturali in binario, virgola mobile, complemento a due, caratteri…
purché usino (al massimo) il numero di bit a disposizione nel reg.
Spetterà a chi definisce il programma in binario (cioè, tipicamente, al compilatore)
usare i dati memorizzati nei registri in modo coerente con il loro tipo Ricorda: per la ALU
«somma fra interi» e «somma fra numeri in virgola mobile»
sono due operazione distinte!
Con due codici diversi.
Sono due istruzioni diverse in Assembler e in Linguaggio Macchina.
(anche se hanno la stessa sintassi per es in C o Java) Se in R5 memorizzo un numero in virgola mobile, e poi lo uso come operando in una somma fra interi,
il risultato non avrà molto senso
Register File: note sulle dimensioni
Per mregistri a nbit, ci vogliono:
k= log2m bit di input per ciascun indice due MUX a mingressi
m branching del dato in input (e un DEC da ka m bit) mregistri paralleli, con comando di caricamento (L) (quindi ben m xn Flip-Flop )
3k bit nelle istruzioni in linguaggio macchina binario necessari solo per specificare i tre indici dei registri Dimensioni tipiche:
n è la dimensione della «parola» (un word) dell’architettura.
Macchine «a 32 bit»: n = 32 Macchine «a 64 bit»: n = 64
m in quasi tutte le architetture reali è piccolo (es da 8 a 64) valore più popolare: m = 32 (k = 5)
m piccolo = Istruzioni Corte + Register File piccolo e veloce
Memoria
Architettura degli elaboratori - 14 -
un prezzo molto caro, soprattutto per m
Memorie più grandi?
Se i nostri programmi richiedessero, per lavorare, solo una manciata di variabili in memoria, la lezione sulle memorie finirebbe qui.
Il tipico programma richiede invece migliaia, milioni, miliardi, o oltre, di parole (word) di dati.
(fra l’altro, le nostre architetture sono di Von Neumann: anche i programmi alloggiano in memoria. I programmi però non sono quasi mai il grosso dell’occupazione di memoria. I dati lo sono.) Il semplice Register File come lo abbiamo visto non si presta neanche lontanamente a dimensioni di questo tipo.
(cioè: è un archiettura non scalabile, non scala facilmente a dimensioni molto maggiori di quelle viste)
Serviranno molti compromessi, e alcune tecnologie non ancora viste, per dotarci di memorie molto più capienti (come vedremo)
Il Register File rimane comunque la memoria più veloce:
un comodo ed efficientissimo «banco di lavoro» della ALU.
Meglio riservare il suo uso ai dati che utilizziamo più spesso!