---

1. Due numeri identici a 16 bit con ripple-carry (giugno 2024, luglio 2025)

Il tempo necessario per sommare (tutte le uscite della somma al valore finale) due numeri a $16$ bit identici con un sommatore ripple-carry vale: a. $t_{carry}+t_{sum}$; b. $15\,t_{carry}+t_{sum}$; c. $16\,t_{carry}+t_{sum}$.

Risposta: a (chiave: "si presti attenzione al fatto che i due bit devono essere identici"). Se $A_i=B_i$ in ogni posizione, ogni stadio è generate ($1,1$) o delete ($0,0$): il riporto in uscita dipende solo dagli ingressi locali e non attende il riporto precedente. Quindi ogni riporto è pronto dopo $t_{carry}$ e la somma dopo $t_{carry}+t_{sum}$ (il caso peggiore $15\,t_c+t_s$ si ha solo con tutti gli stadi in propagate).

2. Somma di due numeri a 16 bit con ripple-carry (giugno 2025)

Sommatore a $16$ bit ripple-carry. Tempo per calcolare la somma di (LSB a destra) $A=1010101010101000$, $B=1100100010101100$: a. $4t_{PC}+t_{PS}$; b. $5t_{PC}+t_{PS}$; c. $6t_{PC}+t_{PS}$.

Analisi. Posizioni $0\ldots15$ (da destra): $(A_i,B_i)=(0,0)$ D, $(0,0)$ D, $(0,1)$ P, $(1,1)$ G, $(0,0)$ D, $(1,1)$ G, $(0,0)$ D, $(1,1)$ G, $(0,0)$ D, $(1,0)$ P, $(0,0)$ D, $(1,1)$ G, $(0,0)$ D, $(0,1)$ P, $(0,1)$ P, $(1,1)$ G. Con il modello del corso (la catena riparte da $t_c$ in ogni stadio G o D; i P la prolungano): le catene più lunghe sono "D in posizione $12$, P in $13$, P in $14$", cioè il riporto che entra nel bit $15$ è pronto dopo $3\,t_{PC}$, e la somma dopo $3\,t_{PC}+t_{PS}$ (verificato con Python). Nessuna delle opzioni (4, 5, 6) coincide con $3$. Il valore $4\,t_{PC}+t_{PS}$ (opzione a) si ottiene se la catena parte dal generate in posizione $11$ e non si azzera al delete in posizione $12$: il riporto "$1$" generato nel bit $11$ attraverserebbe i bit $12,13,14$ ($4$ stadi). Questo conteggio, però, contraddice la risposta al quesito dei numeri identici (se un delete non azzerasse la catena, due numeri nulli identici richiederebbero $15\,t_c$). Poiché mancano la chiave e il testo originale delle opzioni, la risposta attesa è con tutta probabilità (a), ma il valore del modello del corso è $3\,t_{PC}+t_{PS}$.

3. Sommatori carry-bypass (settembre 2024, giugno 2025, settembre 2026)

Nei sommatori carry-bypass il tempo di ritardo per il calcolo della somma finale è determinato principalmente dai tempi di: a. somma; b. riporto; c. set-up.

Risposta: b. $t_{add}=t_{setup}+(2M-1)\,t_{carry}+(N/M-1)\,t_{mux}+t_{sum}$: set-up e somma compaiono una sola volta, il riporto $2M-1$ volte (più i multiplexer di bypass). Numeri ($T$ unitario, $N=32$): ripple $33T$, carry-bypass con $M=4$ (ottimo $M=\sqrt{32/2}=4$): $1+7+7+1=16T$.

4. Linear carry-select a 20 bit (luglio 2026)

Sommatore a $20$ bit di tipo linear carry-select ($4$ blocchi da $5$ bit); tempo per calcolare la somma (LSB a sinistra) $A=11111\ 11111\ 11111\ 11111$, $B=10010\ 00000\ 00000\ 00001$ [con $t_{mux}<t_c$]: a. $t_{su}+2t_c+4t_{mux}+t_s$; b. $t_{su}+5t_c+4t_{mux}+t_s$; c. $t_{su}+5t_c+3t_{mux}+t_s$.

Risposta ricavata: c. Il primo blocco (ripple): bit $0$ $(1,1)$ G, $1$ $(1,0)$ P, $2$ $(1,0)$ P, $3$ $(1,1)$ G, $4$ $(1,0)$ P: il riporto uscente è pronto dopo $2\,t_c$ (il generate del bit $3$ e il propagate del bit $4$). Nei blocchi $2$, $3$ e $4$ i riporti sono calcolati in parallelo per entrambe le ipotesi ($c_{in}=0,1$): i blocchi $2$ e $3$ hanno $A=11111$, $B=00000$ (tutti propagate): la catena di $5$ stadi richiede $5\,t_c$ (più dei $2\,t_c$ del blocco $1$). I multiplexer scelgono poi il riporto vero: il riporto del blocco $2$ dopo $5t_c+t_{mux}$, quello del blocco $3$ dopo un altro $t_{mux}$, e la selezione delle somme del blocco $4$ dopo un terzo $t_{mux}$: tre multiplexer (il primo blocco non ne ha). Con $t_{mux}<t_c$ la catena dei multiplexer non supera i $5\,t_c$ del calcolo parallelo. Totale: $t_{su}+5t_c+3t_{mux}+t_s$. La formula generale ($t_{su}+M\,t_c+(N/M)\,t_{mux}+t_s$, con $N/M=4$) conta $4$ multiplexer: è un limite superiore (opzione b), che l'esame usa verosimilmente come distrattore, insieme all'opzione (a) che considera solo la catena del primo blocco.

5. Square-root carry-select (confronto numerico)

Blocchi di $M,M+1,\ldots$: con $T$ unitario e $N=32$, $M=3$: blocchi da $3,4,5,6,7,8$ ($=33$ bit), $K=6$ multiplexer: $t=1+3+6+1=11T$, contro $14T$ del linear select e $33T$ del ripple ($\propto\sqrt N$ contro $\propto N$).

Verifica numerica

Python: modello a catena del riporto sulle due coppie di operandi (identici: $1\,t_c$; giugno 2025: $3\,t_c$ con "G o D azzera", $4\,t_c$ con "solo G azzera"); conteggio dei multiplexer per il carry-select; tabella dei ritardi di bypass/select/square-root per $N=16,32,64$.

Errori comuni

• Usare il caso peggiore $(N-1)t_c+t_s$ per operandi che non lo realizzano.
• Dimenticare che un delete (come un generate) azzera la catena.
• Contare in un carry-select $N/M$ multiplexer quando il primo blocco non ne ha.
• Dire che il ritardo di un carry-bypass sia dominato dalla somma.

Esercizio 17 - quesiti rapidi sui sommatori con dati numerici (temi d'esame 2025-2026)

• Operandi identici a 16 bit: ogni stadio è G o D (azzera la catena): $t_c+t_s$ (a).
• Giugno 2025 (ripple, $A=1010101010101000$, $B=1100100010101100$): D(12), P(13), P(14): $3t_{PC}+t_{PS}$ nel modello del corso; opzioni $4/5/6$: probabilmente (a) $4t_{PC}+t_{PS}$ se il delete non azzera (incoerente con il primo quesito).
• Carry-bypass: $t=t_{setup}+(2M-1)t_c+(N/M-1)t_{mux}+t_s$: dominato dal riporto (b); $N=32$: $33T\to16T$ ($M=4$).
• Linear carry-select $20$ bit: primo blocco $2t_c$, blocchi $2$-$4$ in parallelo $5t_c$, $3$ mux in cascata: $t_{su}+5t_c+3t_{mux}+t_s$ (c); formula generale con $4$ mux (b) = limite superiore.
• Square-root select: $N=32$, $M=3$: $11T$ ($14T$ linear, $33T$ ripple).
• Errori: caso peggiore sempre; D non azzera; $N/M$ mux nel primo blocco; bypass dominato da sum.