Circuiti combinatori notevoli

Blocchi combinatori (vedi Reti combinatorie e mappe di KarnaughRete combinatoria (uscite funzione dei soli ingressi attuali); mintermini e maxtermini, forme canoniche SOP e POS; mappe di Karnaugh a 3 e 4 variabili con esempi svolti; condizioni di indifferenza; costo e ritardo di una rete a due livelli.Reti combinatorie e mappe di Karnaugh →) che si ritrovano in ogni processore: nel datapathMicroarchitettura come realizzazione dell'ISA; elementi del datapath (PC, memoria istruzioni e dati, banco dei registri, ALU, estensione del segno, multiplexer); percorso di un'istruzione aritmetica, di una load, di una store e di un salto; datapath a ciclo singolo e suo periodo di clock; datapath multiciclo.Datapath e microarchitettura →, nella ALURuolo dell'ALU, ingressi, uscite e flag; ALU a 1 bit con AND, OR e sommatore selezionati da un multiplexer; estensione a 32 bit, sottrazione, confronto set-less-than e rilevazione dello zero e dell'overflow; tabella dei segnali di controllo; unità di moltiplicazione e virgola mobile.Unità aritmetico-logica (ALU) →, nella decodifica degli indirizzi di memoria.

Multiplexer (MUX)

Sceglie uno tra $2^n$ ingressi dati in base a $n$ ingressi di selezione. MUX 2:1:

$$Y = \overline{S}\,I_0 + S\,I_1$$

MUX 4:1 con selezione $S_1S_0$: $Y = \overline{S_1}\,\overline{S_0} I_0 + \overline{S_1}S_0 I_1 + S_1\overline{S_0} I_2 + S_1 S_0 I_3$. Con un MUX a $2^n$ ingressi si realizza qualsiasi funzione di $n$ variabili, mettendo sugli ingressi dati i valori della tabella di verità. Un MUX a 32 bit sono 32 MUX in parallelo con la stessa selezione: nel datapath sceglie per esempio se il secondo operando dell'ALU è un registro o una costante.

Decodificatore e codificatore

• Decoder $n \to 2^n$: attiva una sola delle $2^n$ uscite, quella il cui numero è l'ingresso. Decoder 2→4: $D_0 = \overline{A_1}\,\overline{A_0}$, $D_1 = \overline{A_1}A_0$, $D_2 = A_1\overline{A_0}$, $D_3 = A_1A_0$. Usi: selezionare la cella di memoria o il chip dall'indirizzo, il registro di destinazione dal campo dell'istruzione.
• Encoder $2^n \to n$: l'inverso, dà il numero dell'unico ingresso attivo. L'encoder con priorità dà il numero dell'ingresso attivo più importante (usato per scegliere tra più richieste di interrupt).

Sommatori

Semisommatore (half adder): somma due bit.

$$S = A \oplus B \qquad C = AB$$

Sommatore completo (full adder): somma due bit e il riporto in ingresso.

$$S = A \oplus B \oplus C_{in} \qquad C_{out} = AB + C_{in}(A \oplus B) = AB + AC_{in} + BC_{in}$$

Sommatore a propagazione del riporto (ripple carry) a $n$ bit: $n$ full adder in cascata, il $C_{out}$ di ognuno è il $C_{in}$ del successivo. Il bit $i$ è corretto solo quando è arrivato il riporto dal bit $i-1$: il ritardo cresce linearmente con $n$ (circa $2n$ porte). Se una porta ritarda 20 ps, a 32 bit servono circa $64 \cdot 20 = 1280$ ps, cioè più di un ciclo di un clock a 1 GHz.

Anticipo del riporto (carry lookahead): si definiscono per ogni bit $g_i = A_iB_i$ (il bit genera un riporto) e $p_i = A_i + B_i$ (lo propaga), e si calcolano i riporti direttamente dagli ingressi:

$$c_1 = g_0 + p_0c_0, \quad c_2 = g_1 + p_1g_0 + p_1p_0c_0, \quad \dots$$

Più porte, ma ritardo che cresce circa come $\log n$.

Sommatore-sottrattore

Un solo sommatore fa anche la sottrazione in complemento a 2 (vedi Aritmetica binariaSomma e sottrazione in binario, overflow per senza segno (riporto) e per complemento a 2 (segni), flag del processore, moltiplicazione per somme e scorrimenti, algoritmo di Booth, divisione, shift logici e aritmetici.Aritmetica binaria →): ogni bit di $B$ passa per una XOR con il segnale $\text{SUB}$, che è anche il riporto iniziale.

• $\text{SUB} = 0$: $B \oplus 0 = B$, $c_0 = 0$ → $A + B$.
• $\text{SUB} = 1$: $B \oplus 1 = \overline{B}$, $c_0 = 1$ → $A + \overline{B} + 1 = A - B$.

Overflow (complemento a 2): $V = c_n \oplus c_{n-1}$, XOR tra il riporto che entra e quello che esce dal bit di segno.

Comparatore

Uguaglianza di due numeri di $n$ bit: $E = \overline{(A_0 \oplus B_0) + (A_1 \oplus B_1) + \dots}$, cioè NOR delle XOR bit a bit. Il confronto di ordine si fa di solito con una sottrazione guardando i flag N, Z, C, V.

Errori tipici

• Scrivere $S = A + B + C_{in}$ con il + dell'OR: la somma di un full adder è uno XOR a tre ingressi.
• Pensare che il ritardo di un sommatore ripple non dipenda dal numero di bit.