Sei sulla pagina 1di 66

Elettronica dei

Sistemi Digitali LA
Universit di Bologna,
II Facolt di Ingegneria, Sede di Cesena
Aritmetica Computazionale
F.Campi, A. Romani
A.a. 2007-2008
Aritmetica Computazionale
Si studiano possibili architetture hardware per realizzare
operazioni matematiche su segnali composti da stringhe
di bit, in modo da soddisfare le specifiche fisiche che ci si
propone (Funzionalit, Timing, Power, Area):
RAPPRESENTAZIONI:
Unsigned (Codifica binaria di numeri positivi)
Twos complement (rappresentazione in complemento a due)
OPERAZIONI:
Addizione
Moltiplicazione
(Divisione, Radice Quadrata, etc) Non verranno trattate
Codifica Binaria:
N = { b
n
....... b
0
} dove b
i
rappresenta il numero b
i
* 2
i
Tipicamente n puo essere: 8 Bytes, 16 Half Word, 32 Word o piu.
Nel caso di architetture programmabili (Microprocessori, DSP) N e fissato,
mentre nel caso degli ASIC viene regolato a seconda della precisione voluta
in modo da ottimizzare le risorse utilizzate,
ES: 11 = { 1*8 + 0*4 + 1*2 + 1*1 } = 2
3 +
2
1
+ 2
0
= { 0 0 0 0 1 0 1 1 }
Complemento a 2: In modo da facilitare la esecuzione della sottrazione, I numeri
negativi sono espressi attraverso la seguente formula:
-n = () + 1
ES: -11 = -1 * {0 0 0 0 1 0 1 1} + 1 = { 11110100 } +1 = 11110101
Complemento a 2
La rappresentazione binaria a N bit in
complemento a 2 di un numero X definita in
questo modo:

< + =

=
0 X se X 2 X 2
0 X se X
X
N N
000000
111111
100000
0
1
2
2
N-1
-1
011111
-2
N-1
-1
Complemento a 2
Loperazione di complemento a 2 e realizzata attraverso una
negazione bit a bit (o inverto ogni bit oppure lo metto in XOR con 1)
( )
i i
i i
i i
1 N
0 i
1 N
0 i
1 N
0 i
i
i
i
i
i
1 N
0 i
i
i
N
i
1 N
0 i
i
N N
i
1 N
0 i
i
x ) x 1 (
0 ) x 1 ( 1 x se
1 ) x 1 ( 0 x se
1 X 1 2 x 1 1 2 x 2 1
2 x 1 ) 1 2 (
2 x 2 X 2 X
0 X sia 2 x X
=
)
`

= =
= =
+ = + = + =
= + =
= = =
> =

=
Moltiplicazione (potenze del 2)
Moltiplicazione per potenze del 2

=
+ =
> + = = = = + =
= = |

\
|
=
=
1
0
1
1
0
1
0
1
0
2 0 2
abili) rappresent sono non bit ultimi (gli
) 1 ( 1 1 , 0 [ k i j pongo
2 2 2 2
2 sia
k
j
j j
N
k j
k j
k i
N
i
i
k
N
i
i
i
k
i
N
i
i
x
N k N j N i k j i
x x X
x X
0
N-1
x
0
x
1
x
N-1
N-1
0
k-1 k
0 0 0
x
0
x
N-k-1
Divisione (potenze del 2)
Divisione per potenze del 2
j
1 k N
0 j
k j
k i
1 N
0 i
i
k
1 N
0 i
i
i
k
i
1 N
0 i
i
2 x
1 k n j 1 N i , 0 k j 0 i [ k i j pongo
2 x 2 2 x
2
X
2 x X sia
=
= = < = = =
= = |

\
|
=
=


=
+

=
0
N-1
x
0
x
1
x
N-1
N-1
0/1 0/1 x
N-1
x
k
x
k+1
Sign extension
0 con unsigned
x
N-1
con signed
Sommatori
OBIETTIVO: Analizzare delle architetture gate level che descrivano
loperazione di somma tra vettori di bit:
Problema: Scegliere il corretto TRADE-OFF (Compromesso) tra risorse fisiche
(Area e Consumo) e velocita di elaborazione
{a
n-1
a
0
}
{b
n-1
b
0
}
+
{s
n-1
s
0
}
Si vuole realizzare quindi la operazione seguente:
1 0 1 0 1 + Vogliamo scomporre la operazione
0 0 0 0 1 = su un singolo bit, sara poi sufficiente
_________ replicare N volte la stessa logica
1 0 1 1 1
Si puo scomporre dunque il calcolo in due funzioni logiche a bits, il calcolo della
somma (Sum) e del riporto (Carry Out): In generale, la operazione e descritta
dalle seguenti mappe di Karnaugh per S e Co.
Sommatori Ripple Carry
1
Half-Adder
0 1
1
1 0
0
1 0
\ B
A
1 0
1
0 0
0
1 0
\ B
A
SUM
Carry Out
Si ottiene quindi
S= A XOR B Co = A and B
Tale Circuito, definito HALF ADDER, somma soltanto 2 bit, mentre gli stadi
successivi dovranno sommare anche il CO dei precedenti stadi. Sara quindi
necessario un circuito a 3 ingressi.
Full-Adder
0 1 0 1
1
1 0 1 0
0
10 11 01 00 \ AB
Cin
SUM Carry Out
1 1 1 0
1
0 1 0 0
0
10 11 01 00 \ AB
Cin
Full Adder: Calcolo di Sum e Cout
c b a
b a c b a c
b a b a c b a b a c
c b a c b a c b a c b a Sum
=
= + =
= + + + =
= + + + =
) (
) ( * ) ( *
) * * ( * ) * * ( *
* * * * * * * *
) ( * ) ( *
)) ( * ) (( * ) ( * ) ( *
b a c b b b a b a a a c
b a b a c ab b a c ab b a c
= + + + =
= + + = + = +
Nota:
= + + = c * a c * b b * a Cout
c * ) b a ( b * a + =
Full Adder, schema logico
a
b
Sum
Cout
Cin
Sommatori Ripple-Carry
RIPPLE-CARRY = Propagazione del Carry
Vantaggi:
Struttura regolare
Svantaggi:
Il ritardo introdotto e proporzionale al numero di stadi, e quindi al
numero di bit degli operandi. (ogni bit di somma pu essere calcolato
solo quando disponibile anche il suo carry-in)
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
C
0
A
0
B
0
A
1
B
1
A
2
B
2
A
N-1
B
N-1
S
0
S
1
S
2
S
N-1
C
1
C
2
C
N
Prestazioni Sommatore Ripple-Carry
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
C
0
A
0
B
0
A
1
B
1
A
2
B
2
A
N-1
B
N-1
S
0
S
1
S
2
S
N-1
C
1
C
2
C
N
) N ( O t t ) 1 N ( t
SUM CARRY ADDER
= + =
Il cammino critico (cio il ritardo di propagazione del
caso peggiore) caratterizzato da questa espressione:
Il ritardo di propagazione cresce linearmente con N.
Anche il numero di sommatori (risorse) cresce
linearmente con N.
Sommatore Carry-Bypass
Sommatore Ripple-Carry: ritardo O(N)
[lento]
Idea: raggruppare i FA a gruppi di M
aggiungere una logica di bypass
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
C
0
A
0
B
0
A
1
B
1
A
2
B
2
A
M-1
B
M-1
S
0
S
1
S
2
S
M-1
C
1
C
2
C
M
FA
0
FA
1
FA
2
FA
M-1
C
out
0
1
SEL
Sommatore Carry Bypass
Avr dunque N/M gruppi da M full-adder
connessi come segue:
Come controllare i mux?
il mux di un blocco dovr attivarsi tutte le volte che il
riporto si propaga da C
i
a C
M
Il riporto si propaga in tutte le configurazioni di A e B tali che
cio quando C
M
dipende dal solo C
i
(e non dagli ingressi A, B)
C
0
B
0
A
0
B
1
A
1
B
2
A
2
B
M-1
A
M-1
B
M+1
A
M+1
B
M
A
M
B
2M-1
A
2M-1
S
0
S
1
S
2
S
M-1
S
M
S
M+1
S
2M-1
B
N-1
A
N-1
S
N-1
C
out
M i
C C
Condizione di propagazione
Per un F.A. la condizione di propagazione la
seguente:
(cio C
out
non dipende dagli ingressi A e B: cio ho propagazione
quando, se li fisso, allora C
out
segue il valore di C
in
)
Per il blocco di M f.a. avr propagazione da C
0
a
C
M
se: P
0
P
1
P
2
P
M-1
= 1
Carry Out Full Adder
1 1 1 0
1
0 1 0 0
0
10 11 01 00 \ AB
Cin
C C cui in volte le tutte 1 ) B , A ( P
i out
=
P=1
P=1 P=0 P=0
P = A xor B
Sommatore Carry Bypass
Quindi completiamo lo schema:
Qual il cammino critico?
da A
0
, B
0
a C
M
[se avessi propagazione C
0
C
M
allora il mux
selezionerebbe laltro cammino: + veloce, non caso peggiore]
attraverso tutti i mux
nellultimo gruppo attraverso i f.a. fino a S
N-1
C
0
B
0
A
0
B
1
A
1
B
2
A
2
B
M-1
A
M-1
B
M+1
A
M+1
B
M
A
M
B
2M-1
A
2M-1
S
0
S
1
S
2
S
M-1
S
M
S
M+1
S
2M-1
B
N-1
A
N-1
S
N-1
C
out
P
0
P
1
P
2
P
M-1
P
M
P
M+1
P
2M-1
P
N-2
P
N-1
( )
SUM MUX CARRY SEL
SUM CARRY MUX CARRY SEL ADDER
t t 1
M
N
t ) 1 M 2 ( t
t t 1 M t 1
M
N
t M t t
+
|

\
|
+ + =
= + +
|

\
|
+ + =
Sommatore Carry-Bypass
Lespressione del ritardo di propagazione sul
cammino critico, oltre che funzione di N, dipende
da M
SUM MUX CARRY SEL ADDER
t t 1
M
N
t ) 1 M 2 ( t t +
|

\
|
+ + =
ripple-carry adder
N
carry bypass adder
4
8
t
ADDER
Sommatore Carry-Bypass
Esiste un valore ottimale di M? Posso dunque
raggruppare i F.A. secondo un criterio ottimale?
Definiamo:
E andiamo a verificare quando:
(il minimo di t
*
adder
sar minimo anche di t
adder
)
|
|

\
|
+
+ + = = =
CARRY
SUM MUX CARRY SEL
CARRY
ADDER
*
ADDER
CARRY
MUX
t
) t t t t
a
M
N
M 2
t
t
) N , M ( t ,
t
t
a
0
M
t
*
ADDER
=

Sommatore Carry-Bypass
= = =

2 0 2 0
2 2
*
a
M
N
M
Na
M
t
ADDER
= =
= + =
=
CARRY
MUX
*
opt , ADDER
opt
t
t
N 2 2 aN 2 2
2
aN
aN
2
aN
2 ) N ( t
2
aN
M


SUM MUX CARRY CARRY MUX SEL opt , ADDER
t t t t t N 2 2 t t + + =
il ritardo del sommatore carry-bypass ottimo va come N
Carry-Select Adder
Idea: invece di attendere, per il calcolo dei riporti, larrivo del carry in
degli stadi precedenti effettuiamo i calcoli nei 2 casi possibili (Cin = 0,
Cin = 1)
Utilizziamo questa notazione, raggruppando i soliti M full-adder:
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
a b
Cin Cout
Sum
C
0
A
0
B
0
A
1
B
1
A
2
B
2
A
M-1
B
M-1
S
0
S
1
S
2
S
M-1
C
1
C
2
C
M
FA
0
FA
1
FA
2
FA
M-1
C
0 C
M
A
0..M-1
B
0..M-1
S
0..M-1
M
M
M
Carry-Select Adder
Possiamo definire questa struttura:
0
C
2M
(0)
A
M..2M-1
B
M..2M-1
S
M..2M-1
(0)
M
M
M
1
C
2M
(1)
A
M..2M-1
B
M..2M-1
S
M..2M-1
(1)
M M
M
0
1
0
1
S
M..2M-1
C
2M
0
C
2M
(0)
A
M..2M-1
B
M..2M-1
S
M..2M-1
(0)
M M
M
1
C
2M
(1)
A
M..2M-1
B
M..2M-1
S
M..2M-1
(1)
M M
M
0
1
0
1
S
M..2M-1
C
2M
C
N
(0)
C
N
(1)
0
1
C
N
S
N-M-2..N-1
(1)
0
1
S
N-M-2..N-1
S
N-M-2..N-1
(0)
C
0
C
M
A
0..M-1
B
0..M-1
S
0..M-1
M
M M
ATTENZIONE: Rispetto agli altri sommatori il numero di risorse aumenta!
mux 1 2 adder full 2 1 2
|

\
|
=
|

\
|
+
M
N
M N
M
N
M M
Carry-Select Adder
Effettuo il calcolo nei due casi possibili:
Cin = 0, Cin = 1 (uno dei 2 sar necessariamente quello giusto)
Ogni gruppo di F.A. inizia il calcolo da subito
Sulla base del riporto dello stadio precedente SELEZIONO un
risultato gi pronto (NON CALCOLO! perch i risultati sono gi
pronti)
Sommatore Carry-Select
Vediamo il ritardo di propagazione del
cammino critico:
sum , MUX MUX CARRY ADDER
t t 2
M
N
Mt t +
|

\
|
+ =
Sommatore Carry-Select
Il cammino critico ha
questo ritardo:
Definiamo:
Risulta:
Vediamo quale
valore di M ottimizza
il ritardo peggiore:
CARRY
MUX
CARRY
ADDER
*
ADDER
t
t
a ,
t
t
t = =
MUX CARRY sum , MUX MUX CARRY ADDER
t 1
M
N
Mt t t 2
M
N
Mt t
|

\
|
+ +
|

\
|
+ =
a 1
M
N
M t
*
ADDER
|

\
|
+ =
( )
( )
MUX CARRY MUX opt , ADDER
*
opt , ADDER
opt
2
*
ADDER
t 1 N 2 t t t
1 N 2 a t
aN M 0 a
M
N
1
M
t
=
=
= = =


Sommatore Carry-Select
E possibile ottimizzare i tempi di calcolo
utilizzando un semplice accorgimento:
In questo modo viene effettuato il calcolo di un bit
di somma in pi mentre avviene la propagazione
attraverso i mux degli stadi precedenti
4 4
4
5
5
6
6
Sommatori Carry-Lookahead
i i i i i i
i i i i
B A P C P S
C B A S
= =
=
se

) B A ( * C B * A C
1 i 1 i 1 i 1 i 1 i i
+ + =
1 i 1 i 1 i 1 i 1 i 1 i i
C * A C * B B * A C

+ + =
Si ricordi il calcolo per la determinazione del Carryout nel full-adder:
(il riporto in ingresso a una colonna dipende dalla colonna precedente)
Si puo scrivere come
Possiamo definire GENERATE e PROPAGATE:

+ = =
=
) B A ( B A P
B A G
i i i i i
i i i
Ci di calcolo del fini ai
Possiamo altres scrivere:
Risulta:
1 i 1 i 1 i i
C P G C

+ =
Sommatori Carry-Lookahead
0 0 1 2 3 0 1 2 3 1 2 3 2 3 3 4
0 0 1 2 0 1 2 1 2 2 3
0 0 1 0 1
1
2
0
0 0
1
C P P P P G P P P G P P G P G C
C P P P G P P G P G C
C P P G P G C
C P G C
+ + + + =
+ + + =
+ + =
+ =
Il calcolo dei diversi carry out presenti nel sommatore a 4 bit puo essere
quindi descritto secondo lalgoritmo seguente:
1 i 1 i 1 i i
C P G C

+ =
Sommatory Carry-Lookahead
Possiamo scrivere:
Lo schema sar di questo tipo:
...
C P P P P G P P P G P P G P G C
C P P P G P P G P G C
C P P G P G C
C P G C
0 0 1 2 3 0 1 2 3 1 2 3 2 3 3 4
0 0 1 2 0 1 2 1 2 2 3
0 0 1 0 1 1 2
0 0 0 1
+ + + + =
+ + + =
+ + =
+ =
Carry lookahead
A
0
B
0
S
0
P
0
G
0
C
0
A
1
B
1
S
1
P
1
G
1
C
1
A
2
B
2
S
2
P
2
G
2
C
2
A
N-1
B
N-1
S
N-1
P
N-1
G
N-1
C
N-1
Sommatori Carry-Lookahead
Anticipando il calcolo del carry secondo quanto descritto e possibile
Realizzare il seguente sommatore Carry-Lookahead.
Lo svantaggio principale di questa architettura e che le equazioni logiche
Diventano troppo complesse oltre lordine 4. Di conseguenza i CLA vengono
utilizzati di solito in blocchi gerarchici.
p
3
p
0
p
2
p
1
s
3
s
2
s
1
s
0
G
3
P
3
G
2
P
2
G
1
P
1
G
0
P
0
C
3
C
2
C
1
C
0
Sommatore Carry-Lookahed
Il blocco elementare ha questa struttura:
A
i
B
i
S
i
P
i
G
i
C
i
C
i
A
i
B
i
S
i
P
i
G
i
Sommatori CLA ad Albero Binario
Definiamo un operatore o
Vale la propriet associativa:
Esiste un elemento neutro:
O
(g
1,
p
1
)
(g
2
p
2
)
(g
1
+ p
1
g
2
, p
1
p
2
)
) , ( ) , ( ) , (
2 1 2 1 1 2 2 1 1
p p g p g p g p g + = o
( ) ( ) ) p , g ( ) p , g ( ) p , g ( ) p , g ( ) p , g ( ) p , g (
3 3 2 2 1 1 3 3 2 2 1 1
o o o o =
) p , g ( ) 1 , 0 ( ) p , g (
1 1 1 1
= o
Sommatori CLA ad Albero Binario
Possiamo definire, ricorsivamente, dei
PROPAGATE e GENERATE DI GRUPPO:
(risulta, se C
0
=0 G
i
= C
i
)

=
=

1 i ) P , G ( ) p , g (
1 i ) p , g (
) P , G (
1 i 1 i i i
i i
i i
se
se
o
Sommatori CLA ad Albero Binario
Quindi utilizzando la propriet associativa possiamo costruire la
seguente rete di CLA:
Nodo centrale molto carico
Ritardo:
Albero diretto
Albero inverso
[ ] N log 2 2 1 ) 1 N (log N log t
2 2 2 ADDER
= + + =
liv. alb. dir
liv.alb.inv. 1 liv. sovrapposto
calcolo G,P + calcolo somma
il ritardo (supposto identico) di
ogni blocco logico elementare
Sommatori CLA ad Albero Binario
Si pu anche ridurre il numero di livelli, sfruttando
le propriet delloperatore o
Fan out elevato. FO
max
= N/2
Ritardo: t
ADDER
= log
2
N (in realt a essere precisi non equalizzato,
dipende dal FO di ogni sommatore....)
Sommatore CLA ad Albero Binario
Possiamo introdurre degli operatori fittizi (il
cui unico compito buffering)
Si pu utilizzare lo stesso blocco logico
utilizzato per loperatore o in modo che
anche loperatore fittizio abbia gli stessi
ritardi
O
(1,0)
=
corretta
Sommatore CLA ad Albero Binario
Con gli operatori fittizi:
corretta
Sommatore CLA ad Albero Binario
Ogni blocco ha FAN-OUT = 2
Ritardi equalizzati
Struttura geometrica regolare
Ritardo di propagazione:
t
ADDER
= (log
2
N + 2)
Il numero di blocchi per la logica di CLA :
N
blocks
= N log
2
N
Per lultimo livello volendo sufficiente calcolare i G
i
(poich ci interessano i riporti)
A 3.5 ns, 64 bit, carry-lookahead adder
Dozza, D.; Gaddoni, M.; Baccarani, G.; 1996 Int. Symposium on
Circuits and Systems
Determinazione dellOverflow
Se la operazione di somma (o sottrazione) e eseguita senza segno, il bit
di overflow e semplicemente determinato dal Carry-out dello stadio N.
In caso di operazione in complemento a 2, si utilizza il seguente algoritmo:
1. Se il bit di maggior peso dei due operandi e diverso, non ci puo essere
overflow
2. Se I due operandi hanno uguale bit di maggior peso, il bit di maggior peso
del risultato deve essere uguale ai due bit degli operandi
) S A ( * ) B A ( OF 1 N 1 N 1 N 1 N =
Algoritmo di Moltiplicazione
i
i
1 N
0 i
2 x X

=
=
i
i
1 M
0 i
2 y Y

=
=
0110 *
0011 =
______
0110 +
0110- +
0000-- +
0000--- =
________
0010010
x
3
x
2
x
1
x
0
*
y
3
y
2
y
1
y
0
=
----------------------------
x
3
y
0
x
2
y
0
x
1
y
0
x
0
y
0
+
x
3
y
1
x
2
y
1
x
1
y
1
x
0
y
1
- +
x
3
y
2
x
2
y
2
x
1
y
2
x
0
y
2
- - +
x
3
y
3
x
2
y
3
x
1
y
3
x
0
y
3
- - - =
-----------------------------------------------
Z
7
Z
6
Z
5
Z
4
Z
3
Z
2
Z
1
Z
0
j i
j
N
i
M
j
i y x Y X Z
+

= = 2 *
1
0
1
0
Servono N+M bit per il prodotto
Moltiplicatore a matrice
z
0
y
0
y
1
y
2
y
3
x
3
x
2
x
1
x
0
x
3
x
2
x
1
x
0
x
3
x
2
x
1
x
0
x
3
x
2
x
1
x
0
z
1
HA HA
FA FA
z
2
HA
FA FA FA
z
3
z
4
z
5
z
6
z
7
HA
FA FA FA
Y: N bit
X: M bit
N-1 righe
M somme per riga
Moltiplicatore a matrice
Vantaggi:
Grande simmetria (layout rettangolare)
Svantaggi:
Notevole Impiego di risorse Hardware
Critical Path non ben identificabile
Delay:
T
mult
=[(M-1)+(N-2)] t
carry
+ (N-1) t
sum
+ t
and
Risorse:
N*Mporte AND + M(N-1) sommatori
Moltiplicatore Carry-Save a matrice
In questo schema i bit di riporto non
vengono sommati
subito, ma passati alla riga
successiva
Porto avanti vettori di somme
e di riporti
Quando si fanno somme
occorre che occorre che bit bit di di
somma somma e di riporto e di riporto
abbiano abbiano sempre lo sempre lo
stesso stesso peso peso
Infine serve uno stadio
finale per riallineare
gli ultimi vettori di
somme e riporti
Il cammino critico
univocamente
definito
cammino
critico
HA
corretta
Moltiplicatore Carry-Save a matrice
Il cammino critico univocamente definito
Il ritardo :
Se il Vector Merge Adder realizzato con
architettura ripple-carry si ha:
Quindi, un moltiplicatore CSA, con merge adder in
ripple-carry ha:
Serve un numero di sommatori pari a: N(M-1)
[ N-1 sommatori CSA + 1 Merge Adder, tutti a M-1 bit]
MERGE AND CARRY MULT
t t t ) 1 N ( t + + =
CARRY MERGE
t ) 1 M ( t =
) M N (se ) 1 ( 2
) 1 ( ) 1 (
= + =
= + + =
AND
CARRY AND CARRY MULT
t N
t M t t N t

Moltiplicatore Carry-Save a matrice


Possiamo
schematizzarlo nel
modo seguente
(es. N = M = 4)
Ogni stadio Carry
Save Adder (tranne il
primo) riceve in
ingresso 3 vettori di
bit, riducendoli a 2 in
uscita (1 vett. di riporti
ed 1 vett. di somme)
CSA 2:2 (h.a.)
b
0
A b
1
A b
2
A
CSA 3:2
CSA 3:2
b
3
A
Merge Adder
P
1
P
2
P
3
P
0
P
7..4
Moltiplicatore Carry-Save a matrice
Utilizzando dei soli
sommatori CSA con
riduzione 3:2 possiamo
accorpare i primi due livelli
I sommatori riallineano i
vettori di bit in ingresso in
modo da sommare i bit
dello stesso peso
N-2 livelli di CSA
+ 1 Merge Adder
Il numero di FA
complessivo :
N
FA
= N(N-2)+N = N(N-1)
b
0
A b
1
A b
2
A
CSA 3:2
CSA 3:2
b
3
A
Merge Adder
Moltiplicatore Carry-Save a 8-bit
8-bit CSA
8-bit CSA
8-bit CSA
8-bit CSA
8-bit CSA
8-bit CSA
8-bit CSA
Risultato parziale (8bit)
Carry-Save out (8bit)
Merge adder
T
delay
= o(N)
XY
4
XY
6
XY
0 XY
1
XY
2
XY
3 XY
7
XY
5
8-bit
Moltiplicatore Carry-Save ad Albero di Wallace
E possibile comporre i CSA in uno
schema ad albero
Ad ogni livello ho un fattore di
riduzione 3:2, mentre globalmente
(fino allingresso del merge adder)
lo avr N:2. Se n il numero di
livelli avremo allora:
VANTAGGIO: Ritardo logaritmico!
SVANTAGGIO: struttura irregolare,
layout e routing difficoltosi
(es. provare a sostituire i CSA con i relativi
FA e tracciare le interconnessioni.)
[ ] 1 N log 71 . 1
2
N
log 71 . 1
2
3
log
2
N
log
n
2
N
log
2
3
log n
2
N
2
3
2
2
2
2
2 2
n
=
=
|

\
|
=
= =
|

\
|


Moltiplicatore Wallace Tree Carry-Save a 8-bit
8-bit CSA
8-bit CSA
Risultato parziale (8bit)
Carry-Save out (8bit)
Merge adder
8-bit CSA
8-bit CSA
8-bit CSA
8-bit CSA
T
delay
= o(Log
2
N)
Moltiplicatore Carry-Save ad Albero di Wallace
3
2
3
2
3
N
3
N
Quanti CSA richiede questo moltiplicatore
Ad ogni livello ne abbiamo:
1.
2.
3.
4.
Abbiamo una serie geometrica:
3
2
3
N
( ) ) 1 N (log 71 . 1 n
2 N
3
2
1
3
2
1
3
N
3
2
...
3
2
3
2
1
3
N
2
n
1 n 2
=
=
|

\
|

\
|

=
|
|

\
|
|

\
|
+ +
|

\
|
+ +

dove
Computazione nel dominio dello spazio: strutture ad albero
La computazione nel dominio del tempo, tipica delle macchine
programmabili, si sviluppa tipicamente secondo una struttura
lineare:
Sum= (((a + b)+c)+d) Ritardo o(N) N=num operandi
Per sfruttare appieno i vantaggi della computazione nel dominio
dello spazio necessario esplicitare pi possibile il parallelismo
insito in un determinato tipo di calcolo, con una struttura logaritmica:
Sum= ( (a+b) + (c+d) ) Ritardo o(log
2
N)
Moltiplicatore ad albero di Wallace
Vantaggi:
Cala la complessita dellalbero, viene aumentata la prestazione
Diminuisce il numero di risorse utilizzate
Svantaggi:
Layout fortemente asimmetrico
Delay:
T
mult
= n t
carry
+t
and
+t
merge
corretta
Codifica di Booth per la moltiplicazione
Sia {x
N-1
, x
N-2
, . x
1
, x
0
} un numero in
complemento a 2. [x
N-1
sar il segno]
Il numero rappresentato sar:
Separiamo i bit di indice pari da quelli di indice
dispari:

= =
2 N
0 n
2 N
0 n
n
n
1 N
1 N
1 N
1 N
n
n
2 x 2 x 2 x 2 x X
=
(
(
(

+ =
= + =

=


1
1
1
2
1
1 2
1 2
1
2
1
1 2
1 2
1
2
0
2
2
1
1
1
2
1
1 2
1 2
1
2
0
2
2
2 2 2 2 2
2 2 2
N
N
N
n
n
n
N
n
n
n
N
n
n
n
N
N
N
n
n
n
N
n
n
n
x x x x
x x x X
Codifica di Booth
( )




=
+

=
+

=
+
+

=
=

=
= + =
= + =
= + =
= + =
=
|
|
|

\
|
+
|
|
|

\
|
+ =
1
2
0
2
1
2
0
2
1 2 1 2 2
1
2
0
2
1 2
1
2
0
2
1 2
1
2
0
2
2
1
2
0
1 2
1 2
1
2
0
2
1 2
1
2
0
2
2
2
1
1 2
1 2
1
2
1
2
1 2
1
2
0
2
2
1
1
1
2
1
1 2
1 2
1
2
1
1 2
1 2
1
2
0
2
2
2 ) 2 ( 2 2
2 2 2 2
2 2 2
2 2 2
2 2 2 2 2
N
n
n
N
n
n
n n n
N
n
n
n
N
n
n
n
N
n
n
n
N
n
n
n
N
n
n
n
N
n
n
n
N
n
n
n
N
n
n
n
N
n
n
n
N
N
N
n
n
n
N
n
n
n
N
n
n
n
n f x x x
x x x
x x x
x x x
x x x x
Definisco x
-1
=0 ed estendo la sommatoria
cambio indice n=n-1
2n-1= 2(n+1)-1=2n+1
sposto un 2 dellesponente
lindice 2n-1 varia in 1,3,..,N-3
corretta
Codifica di Booth
Abbiamo ottenuto
Considerando una moltiplicazione X*Y avremo:
( )


=

=
+
= + =
1
2
N
0 n
n n 2
1
2
N
0 n
1 n 2 n 2 1 n 2
2 ) n 2 ( f 2 x 2 x x X
( )


=

=
+
= + =
1
2
0
2 2
1
2
0
1 2 2 1 2
2 ) 2 ( 2 2
N
n
n n
N
n
n n n
n f Y x x x Y Y X
-Y -1 0 1 1
0 0 1 1 1
-Y -1 1 0 1
-2Y -2 0 0 1
2Y 2 1 1 0
Y 1 0 1 0
Y 1 1 0 0
0 0 0 0 0
f(2n)Y f(2n) x
2n-1
x
2n
x
2n+1
Otteniamo 5 possibili
configurazioni in Y:
0, Y, 2Y, -Y, -2Y
(tutte facilmente
generabili)
La moltiplicazione
consiste nella somma di
N/2 configurazioni di
f(2n)Y opportunamente
shiftate
Codifica di Booth
Sono i bit di X che mi fanno scegliere quale
configurazione di f(2n)Y utilizzare nel calcolo della
moltiplicazione (in ogni addendo)
n=0, f(0) = x
-1
+ x
0
+ 2 x
1
= 0 + x
0
+ 2 x
1
n=1, f(1) = x
1
+ x
2
+ 2 x
3
n=2, f(2) = x
3
+ x
4
+ 2 x
5
n=3, f(3) = x
5
+ x
6
+ 2 x
7
Codifica di Booth
OBIETTIVO : La complessita dei moltiplicatori e legata al numero di bit
necessari per codificare gli operandi, ed e proporzionale a N
2
.
Si puo pensare di codificare il numero binario in ingresso in modo diverso in
modo da diminuire il numero di simboli necessari a descriverlo: ad esempio, il
numero 12 in base 2 e codificato con 4 simboli, potrebbe essere rappresentato in
base 4 con 2 Simboli.
12= (1100)
2
= 1*2
3
+ 1*2
2 +
0*2
1 +
0*2
0
12 = (30)
4
= 3*4
1
+ 0*4
0
Lo svantaggio e che le operazioni di somma e prodotto simbolo a simbolo
necessarie oer realizzare lalgoritmo di moltiplicazione con base 4 potrebbero
diventare troppo complesse. Di certo lo sarebbero In base 4 usando una codifica in
complemento a 2. Ma si puo investigare un tipo di codifica base 4 che descriva
somma e prodotto Tra simboli in un modo semplice dal punto di vista della
implementazione Hardware.
Codifica di Booth
] 2 2 * [ ) 2 * ( 2 2 *
2 2 * 2 *
2 2
] 2 2 [
2
1
* 1
1 2
1
2
1
1 2
1 2
1
2
1
1 2
2
1
2
0
2
1
* 1
1 2
1
2
1
1 2
2
1
2
0
2
1
* 1
1
0
*
1
0
*
1
* 1
1
0
*

=
+ + =
+ =
=
=
=

N
N
i
N
i
i
i
N
i
i
i
N
i
i
N
N
i
N
i
i
i
N
i
i
N
N
N
i
i
i
N
i
i
i
N
N
N
i
i
i
X X X X X
X X X X
X X X
X X X
X X
(Rappr. In Complemento a 2)
Codifica di Booth



=

=
+

=
+

=
+

=
= = + + =

+ =
+ + =
J
n
i
i
N
i
i
i i i
N
i
i
i
N
i
i
N
n
i
i
i
N
n
i
N
N
i
N
i
i
i
N
i
i
i
N
i
i
M i F X X X X
i i
X X X X
X X X X X
0
1
2
0
2
1 2 2 1 2
1
2
0
2
1 2
1
2
1
1 2
1
2
1
2
1 2
2
1
2
0
2
1
* 1
1 2
1
2
1
1 2
1 2
1
2
1
1 2
2
1
2
0
2
* 4 ) 2 ( * 2 ) * 2 ( * 2
) 1 (
2 * 2 * 2 *
] 2 2 * [ ) 2 * ( 2 2 *
Codifica di Booth
0 0 1 1 1
-Y -1 0 1 1
-2Y -2 0 0 1
-Y -1 1 0 1
2Y 2 1 1 0
Y 1 0 1 0
Y 1 1 0 0
0 0 0 0 0
F
i
*Y F
i
X
2i-1
X
2i
X
2i+1
Se dovessi fare un prodotto X*Y e volessi generare i prodotti parziali usando un
moltiplicatore codificato in questa forma, dovrei sostituire nella struttura del
moltiplicatore a matrice operazioni di shift(*2) e di complemento a due in luogo dei
gates and.
Codifica di Booth
Ogni operazione di prodotto parziale viene gestita con un multiplexer che seleziona le
possibili uscite tra le operazioni imposte
MUX
X
2i+1
X
2i
X
2i-1
Ad ogni passo il prodotto parziale viene shiftato di DUE PASSI (invece che uno)
verso sinistra. Il numero di livelli necessari a realizzare questo tipo di moltiplicazione
quindi N/2 invece di N, larea e il ritardo si dimezzano praticamente, rispetto al
moltiplicatore a matrice,
anche se si introduce una logica di controllo piu complessa.
Y Y 2Y -2Y 0
BOOTH ENCODING:
Y
corretta
Booth Encoded Multiplier a 8 bit
MUX
X
1
X
0
X
-1
Y Y 2Y -2Y 0
MUX
X
3
X
2
X
1
Y Y 2Y -2Y 0
MUX
X
5
X
4
X
3
Y Y 2Y -2Y 0
7 bit
9 bit
MUX
X
7
X
6
X
5
Y Y 2Y -2Y 0
adder stage
adder stage
adder stage
9 bit
2 bit
8 bit
2 bit
9 bit
8 bit
2 bit
Slide
modificata!!!
10 bit
9
9
8
8
8
9
9
8
8
8
9
9
8
8
8
9
9
8
8
8
0
Moltiplicatore Seriale
Basato sui registri :
A Moltiplicatore
B Moltiplicando (64 bit)
P Registro accumulazione parziale (64 bit)
Il Prodotto e basato su una serie di AND bit a bit,
A (shift left)
64-bit adder
P
B (shift right)
en
Moltiplicatore Seriale (2)
Basato sui registri :
A Moltiplicatore
B Moltiplicando (64 bit)
P Registro accumulazione parziale (64 bit)
In questa soluzione P ed A sono concatenati, permettendo un notevole
risparmio di risorse:
A
32-bit adder
P/B (Shift Right)
en