Blocchi logici di un microprocessore - ALU, bus e logica tri-state

Il corso collega i circuiti CMOS ai sistemi digitali completi. Questa nota raccoglie i blocchi che compongono un microprocessore elementare, di cui le note successive sviluppano le parti aritmetiche (Sommatori - full adder e ripple-carryLa somma di due bit con riporto in ingresso è realizzata dal full adder: S = A ⊕ B ⊕ C_in, C_out = AB + BC_in + AC_in. Con generate G = AB, propagate P = A ⊕ B (e delete D = Ā B̄) si scrive C_out = G + P·C_in e S = P ⊕ C_in: G e P non dipendono dal riporto in ingresso (fase di set-up), solo C_out ed S ne dipendono. Il sommatore ripple-carry collega N full adder in cascata: il riporto attraversa gli stadi uno dopo l'altro, nel caso peggiore t_add = (N−1) t_carry + t_sum (lineare in N). Il ritardo effettivo dipende dagli operandi: un generate o un delete azzera la catena, un propagate la prolunga; per operandi uguali bit a bit vale t_carry + t_sum.Sommatori - full adder e ripple-carry →, Traslatori, comparatori e moltiplicatoriOltre ai sommatori, la ALU contiene traslatori (shifter), comparatori e moltiplicatori. Lo shift a sinistra di k posizioni moltiplica per 2^k; lo shift a destra aritmetico (con replica del bit di segno) divide per 2^k nel complemento a due; il barrel shifter realizza qualsiasi traslazione fino a N − 1 posizioni con log₂N livelli di multiplexer 2→1. Il comparatore di uguaglianza è l'AND delle XNOR bit a bit; quello di grandezza confronta partendo dal bit più significativo (GT = g_{N−1} + e_{N−1}(g_{N−2} + e_{N−2}(…))) oppure usa la sottrazione e le flag. Il moltiplicatore a matrice (array) forma N² prodotti parziali con porte AND e li somma con N(N−1) full adder; il ritardo cresce come 2N t_carry; moltiplicatori ad albero (Wallace) e sequenziali (shift-and-add) sono alternative; le FPGA hanno blocchi DSP dedicati.Traslatori, comparatori e moltiplicatori →) e programmabili (FPGA - LUT, slice e risorse della famiglia 7Una FPGA è una matrice di blocchi logici configurabili (CLB) immersi in una griglia di interconnessioni programmabili, con risorse dedicate: block RAM, blocchi DSP, gestione del clock (MMCM, PLL), blocchi di I/O e transceiver. La memoria di configurazione è SRAM. L'elemento base è la LUT: una memoria SRAM con 2^k celle che realizza una qualsiasi funzione di k ingressi (i segnali di selezione del multiplexer sono gli ingressi della funzione). Nella famiglia 7 di Xilinx un CLB ha 2 slice; uno slice ha 4 LUT a 6 ingressi (ciascuna divisibile in due LUT a 5), multiplexer larghi F7/F8 (funzioni a 7-8 ingressi), una catena di riporto veloce, 4 flip-flop/latch più 4 flip-flop. Nei SLICEM la LUT può essere usata come RAM distribuita o registro a scorrimento (SRL32), nei SLICEL solo come logica.FPGA - LUT, slice e risorse della famiglia 7 →).

Architettura di un microprocessore semplice

• Unità di controllo: elabora le istruzioni macchina (le decodifica) e abilita gli altri blocchi, generando i segnali di controllo (selezione dell'operazione, scrittura nei registri, accesso alla memoria). È una macchina a stati finiti (Macchine a stati finiti in VHDLUna macchina a stati finiti (FSM) ha uno stato S(k) che evolve secondo la funzione di stato prossimo S(k+1) = F(S(k), X(k)) e produce uscite Y(k) = G(S(k), X(k)) (modello di Mealy: dipendono anche dall'ingresso, possono cambiare subito) oppure Y(k) = G(S(k)) (modello di Moore: dipendono solo dallo stato, cambiano solo ai fronti di clock). In VHDL si definisce un tipo enumerato per gli stati e si scrive in due processi: uno sequenziale (registro di stato con reset: state_reg <= state_next al fronte) e uno combinatorio (case sullo stato che assegna state_next, con un valore di default, e le uscite); lo stile a processo singolo registra anche le uscite. La progettazione parte dal diagramma degli stati, passa alla tabella di transizione e al codice.Macchine a stati finiti in VHDL →).
• ALU (arithmetic logic unit): elaborazione aritmetica e logica.
• Registri e memoria: la RAM è una matrice di celle da un byte (o parola) con decoder di riga e di colonna (Memorie a semiconduttore - struttura a matrice, decoder e ROMLe memorie a semiconduttore si classificano in lettura/scrittura (SRAM, DRAM: volatili) e sola lettura (ROM a maschera, PROM, EPROM, EEPROM, Flash: non volatili); l'accesso è casuale o non casuale (FIFO, registri a scorrimento, CAM). La struttura è a matrice di celle: una word line (WL) seleziona una riga attraverso il decoder di riga (N indirizzi → 2^N WL), una bit line (BL) porta il dato alla colonna scelta dal decoder/multiplexer di colonna e dal sense amplifier. La ROM a NOR ha per ogni bit line un p-MOS di carico e n-MOS dove il bit è 0 (con WL alta tirano la BL a massa): compatta e veloce; la ROM a NAND ha serie di n-MOS ed è molto più piccola ma più lenta. Ritardo di una WL: R del polisilicio × C dei gate (Elmore); di una BL: C dei drain con la R dei transistor o del carico.Memorie a semiconduttore - struttura a matrice, decoder e ROM →); i registri conservano gli operandi (Latch, registri e parametri temporaliUn circuito sequenziale ha uno stato memorizzato in due modi: retroazione positiva (due inverter in anello, bistabile, i latch statici) o immagazzinamento di carica (circuiti dinamici). Un latch è sensibile al livello del clock (trasparente quando il clock è attivo, memorizza quando non lo è), un registro (flip-flop) è sensibile al fronte e si realizza con due latch sulle fasi opposte (master-slave). Il latch SR a porte NOR/NAND non ammette la combinazione S = R = 1 perché passando da lì alla memoria lo stato finale è imprevedibile. Parametri temporali del registro: ritardo clock-uscita t_c-q, tempo di setup t_su (dato stabile prima del fronte), tempo di hold t_hold (dato stabile dopo il fronte). Periodo minimo: T_min = t_c-q + t_p,logic(max) + t_su; vincolo di hold: t_cd,reg + t_cd,logic > t_hold. La pipeline spezza la logica con registri per aumentare la frequenza (a spese della latenza).Latch, registri e parametri temporali →).
• Bus: linee condivise che trasportano dati e indirizzi tra i blocchi, unidirezionali o bidirezionali.

ALU

Una ALU esegue, secondo un codice di selezione $Sel$, un'operazione su due operandi $A$ e $B$ di $N$ bit e produce il risultato e alcune flag. Tipica struttura: un sommatore (Sommatori - full adder e ripple-carryLa somma di due bit con riporto in ingresso è realizzata dal full adder: S = A ⊕ B ⊕ C_in, C_out = AB + BC_in + AC_in. Con generate G = AB, propagate P = A ⊕ B (e delete D = Ā B̄) si scrive C_out = G + P·C_in e S = P ⊕ C_in: G e P non dipendono dal riporto in ingresso (fase di set-up), solo C_out ed S ne dipendono. Il sommatore ripple-carry collega N full adder in cascata: il riporto attraversa gli stadi uno dopo l'altro, nel caso peggiore t_add = (N−1) t_carry + t_sum (lineare in N). Il ritardo effettivo dipende dagli operandi: un generate o un delete azzera la catena, un propagate la prolunga; per operandi uguali bit a bit vale t_carry + t_sum.Sommatori - full adder e ripple-carry →), un'unità logica (AND, OR, XOR, NOT bit a bit, in parallelo) e un multiplexer che sceglie l'uscita. In VHDL (esempio di laboratorio, $N=2$): Sel="00" somma ($A+B$), "01" sottrazione ($A+\overline B+1$), "10" AND, "11" OR.

Sottrazione. In complemento a due $A-B=A+\overline B+1$ (Rappresentazione dei numeri e dell'informazioneUn'informazione digitale è una stringa di bit. Numeri senza segno: N bit rappresentano 0…2^N − 1; in esadecimale ogni cifra raggruppa 4 bit. Numeri con segno: complemento a due (range −2^(N−1)…2^(N−1) − 1; si nega invertendo i bit e sommando 1; il bit più significativo è il segno e l'estensione di segno lo replica). Il BCD codifica ogni cifra decimale con 4 bit (0…9) e si ottiene dal binario con l'algoritmo double dabble (shift a sinistra, e +3 a ogni gruppo maggiore di 4 prima dello shift). Il codice Gray cambia un solo bit tra valori consecutivi. I numeri frazionari si trattano in virgola fissa (4 bit di parte frazionaria = multipli di 1/16), i caratteri in ASCII, gli errori con un bit di parità.Rappresentazione dei numeri e dell'informazione →): si usano gli stessi sommatori, con una porta XOR su ogni ingresso $B_i$ comandata da un segnale "sottrai" (che inverte $B$ quando vale $1$) e lo stesso segnale come riporto in ingresso $C_{in}$.

Esempio ($N=4$). $A=0110$ ($6$), $B=0011$ ($3$): somma $1001$ ($9$); sottrazione: $\overline B=1100$, $0110+1100+1=1\,0011$, risultato $0011$ ($3$) con riporto $1$; AND: $0010$; OR: $0111$.

Flag:

• Z (zero): tutti i bit del risultato sono $0$;
• C (carry): riporto dell'ultimo stadio (per i numeri senza segno, indica overflow nella somma e assenza di prestito nella sottrazione);
• N (negativo): bit più significativo del risultato;
• V (overflow, numeri con segno): vale $1$ se gli operandi hanno lo stesso segno e il risultato il segno opposto: con $A=0110$ ($6$) e $B=0101$ ($5$) il risultato $1011$ ($-5$ in complemento a due, invece di $11$) segnala overflow. Equivale a $C_{N-1}\oplus C_N$ (riporto in ingresso e in uscita dell'ultimo stadio). Il percorso critico di una ALU è quello della somma: la velocità dipende dal sommatore usato (Sommatori veloci - carry-bypass, carry-select e square-rootIl ripple-carry ha ritardo lineare in N. Il carry-bypass divide i bit in blocchi da M: se tutti i propagate del blocco valgono 1 (BP = P0P1…P_{M−1} = 1) un multiplexer fa saltare il riporto dall'ingresso all'uscita del blocco. Ritardo: t = t_setup + M t_carry + (N/M − 1) t_mux + (M−1) t_carry + t_sum, ottimo per M = √(N t_mux/(2 t_carry)); è determinato principalmente dal tempo di riporto. Il carry-select calcola in ogni blocco le somme per riporto 0 e per riporto 1 e un mux sceglie quella giusta: t = t_setup + M t_carry + (N/M) t_mux + t_sum, M ottimo √(N t_mux/t_carry); lo square-root carry-select usa blocchi di dimensione crescente (M, M+1, M+2…) perché il riporto arriva ogni volta un mux dopo: N ≈ K²/2 e t = t_setup + M t_carry + √(2N) t_mux + t_sum, cioè ritardo ∝ √N.Sommatori veloci - carry-bypass, carry-select e square-root →).

Condivisione del bus

Su un bus più sorgenti (registri, memoria, ALU) possono trasmettere in momenti diversi sulla stessa linea. Se due uscite CMOS statiche pilotano la stessa linea con valori diversi, si crea un cammino diretto tra $V_{DD}$ e massa attraverso i due driver: conflitto (contention), che produce una tensione intermedia (non un livello logico valido) e corrente elevata (come in Esercizio 5 · NAND e NOR con soglia logica assegnata, ritardi, potenza e uscite in contrasto (tema d'esame luglio 2025), dove NAND e NOR hanno le uscite cortocircuitate). Servono quindi uscite che possano staccarsi dal bus.

Logica tri-state (three-state)

Si aggiunge un segnale di enable (en) che abilita la porta a imporre il valore logico di uscita; se non abilitata l'uscita è flottante (alta impedenza, $Z$). L'inverter tri-state ha, tra $V_{DD}$ e massa, in serie: un p-MOS comandato da $\overline{en}$, un p-MOS comandato da $A$, l'uscita, un n-MOS comandato da $A$ e un n-MOS comandato da $en$:

• $en=1$: i transistor di enable sono accesi e il circuito è un inverter ($V_{out}=\overline A$);
• $en=0$: entrambi i transistor di enable sono spenti e nessuno dei due rami può portare l'uscita a $V_{DD}$ o a massa: $Z$. Al massimo una sorgente alla volta deve avere $en=1$ (lo garantisce l'unità di controllo con un decoder). Il valore $Z$ compare anche in VHDL: 'Z' (VHDL - struttura, tipi di dato e processiVHDL è un linguaggio di descrizione dell'hardware: un listato non è una sequenza di istruzioni eseguite da un processore ma la descrizione di un circuito, che la sintesi traduce in uno schema (LUT, flip-flop, multiplexer). Ogni modulo ha una entity (interfaccia: port con modo in, out, inout e tipo; eventuali generic) e una architecture (parte dichiarativa: segnali, costanti, componenti; parte assertiva dopo begin: assegnazioni concorrenti e processi). Le istruzioni nell'architecture sono concorrenti: l'ordine in cui sono scritte non conta. Un process esegue le proprie istruzioni in modo sequenziale quando un segnale della lista di sensibilità cambia. Segnali (<=, aggiornati alla fine del delta cycle, definiti nella parte dichiarativa) e variabili (:=, immediate, solo dentro il processo) hanno semantica diversa. Tipi: bit, boolean, integer, std_logic (a 9 valori, tra cui 'Z', 'X', 'U'), std_logic_vector, unsigned e signed (numeric_std).VHDL - struttura, tipi di dato e processi →), e i buffer tri-state sono usati dalle FPGA per i bus bidirezionali di I/O.

Logica open-drain

Le porte che pilotano il bus hanno solo la PDN (un n-MOS verso massa, senza p-MOS): possono solo imporre uno 0. Una o più porte possono imporre $0$ sul bus senza conflitti (la corrente scorre verso massa attraverso più n-MOS in parallelo); se tutte lasciano il bus, serve un pull-up (resistenza o p-MOS di carico) che lo porta a $1$. Il bus è quindi l'AND cablato delle uscite (wired-AND): basta uno $0$ per avere $0$. Il prezzo è il consumo statico quando il bus è basso e il ritardo di salita del pull-up (Logica pseudo-nMOS e logiche a caricoNella logica pseudo-nMOS (a rapporto, ratioed) la PUN della CMOS complementare è sostituita da un solo p-MOS con gate a massa, sempre acceso, che fa da carico per la PDN a n-MOS. Così servono N+1 transistor invece di 2N e la capacità di ingresso è minore, ma l'uscita bassa non è 0: V_OL si ricava uguagliando la corrente dell'n-MOS (zona lineare) a quella del p-MOS (saturazione), ed esiste potenza statica quando l'uscita è bassa (P = V_DD·I). V_OH = V_DD. Per V_OL piccola serve Z_n ≫ Z_p; il ritardo di salita è lento (carica solo il p-MOS debole: t_pLH = 0,69 R_p C_L), quello di discesa è più veloce (t_pHL ≈ 0,69 R_n C_L). Lo stesso schema (carichi p-MOS a massa) si ritrova nelle ROM a NOR.Logica pseudo-nMOS e logiche a carico →).

Decoder e multiplexer come blocchi

• Un decoder $N\to2^N$ ha una sola uscita attiva (one-hot): serve per le WL, per abilitare un registro, per l'enable dei tri-state.
• Un multiplexer $2^N\to1$ seleziona un ingresso: nelle ALU per scegliere l'operazione, nei registri per scegliere tra caricamento e scorrimento (Registri dinamici, C2MOS, TSPC e registri a scorrimentoI registri dinamici memorizzano il bit come carica su un nodo capacitivo in alta impedenza: meno transistor e commutazioni più rapide dei registri statici, ma il dato si perde (serve un clock minimo) e il master-slave con gate di trasmissione è sensibile alla sovrapposizione dei clock (race). Il registro C2MOS (clocked CMOS) usa inverter con transistor di clock in serie: è insensibile alla sovrapposizione dei clock (0-0 e 1-1) se i fronti sono ripidi, perché durante la sovrapposizione ciascuno stadio può solo caricare o solo scaricare il nodo, mai propagare. Il TSPC usa una sola fase di clock (nessun clock invertito) e permette di inglobare logica nei latch. Un registro a scorrimento è una cascata di registri D: a ogni fronte il dato avanza di una posizione (conversione serie-parallelo, ritardi, FIFO); il collegamento diretto richiede t_c-q > t_hold.Registri dinamici, C2MOS, TSPC e registri a scorrimento →).

Errori comuni

• Collegare due uscite push-pull alla stessa linea senza tri-state: conflitto e corrente di cortocircuito.
• Confondere $Z$ con $0$: l'uscita in alta impedenza non è né $0$ né $1$.
• Scrivere la sottrazione come $A+\overline B$ senza il $+1$.
• Confondere le flag $C$ (senza segno) e $V$ (con segno).
• Dimenticare il pull-up nel bus open-drain.