Síntese do datapath unidades funcionais

(1)

FEUP/DEEC : EEC0055 / Projecto de Sistemas Digitais, 2006/2007

José Carlos Alves 199

Síntese do datapath

unidades funcionais

• Unidades funcionais do datapath

– operadores aritméticos

• operandos inteiros, vírgula fixa ou vírgula flutuante

• operadores com constantes, mais eficientes do que operadores genéricos

– operadores lógicos, manipulação de bits

• funções lógicas, rotações, deslocamentos, bitreverse

– operadores específicos de uma aplicação

• AB-(C+D), x[k]x[k+t1]*x[k+t2]

• Numa abordagem top-down (HDL+síntese)

– operadores inferidos e construídos no processo de síntese

• implementados como circuitos combinacionais

– nem todos os operadores disponíveis

• FPGA Express

(V3.6.1)

suporta apenas divisões entre constantes

– arquitecturas dos operadores definidas nas bibliotecas da tecnologia alvo

• em Verilog todas as operações são consideradas com operandos sem sinal

Operadores aritméticos

adição e subtracção

– ripple carry adder (RCA)

• propagação do carry limita a rapidez de cálculo

• resultado garantido após o maior tempo de propagação do carry

– carry select adder

• dividido em secções e cada secção inclui 2 somadores de k bits

• exemplo: somador de 12 bits em secções de 4 bits:

Kay Hwang, “Computer Arithmetic - Principles, Architecture and Design”, John Wiley & Sons, 1990

A

3-0

A

3-0

B

3-0

B

3-0

1

0

4 bit add 4 bit add

C

-1

C

3,1

C

3,0

A

7-4

A

7-4

B

7-4

B

7-4

1

0

4 bit add 4 bit add

C

7,1

C

7,0

C

3,0

C

3,1

CS

A

11-8

A

11-8

B

11-8

B

11-8

1

0

4 bit add 4 bit add

C

11,1

C

11,0

CS

C

3,0

C

3,1

C

7,0

C

7,1

S

3-0

S

7-4

S

11-8

C

11

C

7

C

4

(2)

Operadores aritméticos

adição e subtracção

– carry generate, carry propagate, lookahead

• generate

• propagate

• equações do somador escrevem-se

• os carry de todos os andares podem ser obtidos em paralelo

G

i

= A

i

. B

i

significa que o carry é gerado no andar i

P

i

= A

i

⊕

B

i

significa que o andar i propaga o carry que lhe chega

S

i

= A

i

⊕

B

i

⊕

C

i-1

= P

i

⊕

C

i-1

C

i

= A

i

.

B

i

+

A

i

.

C

i-1

+

B

i

.

C

i-1

= A

i

.

B

i

+

A

i

.

C

i-1

.

B

i

+

B

i

.

C

i-1

.

A

i

= A

i

.

B

i

+

C

i-1

.(

A

i

.

B

i

+

B

i

.

A

i

)= A

i

.

B

i

+

C

i-1

.(

A

i

⊕

B

i

)

= G

i

+ P

i

.

C

i-1

C

1

= G

1

+

C

0

.

P

1

C

2

= G

2

+

C

1

.

P

2

=

G

2

+

(G

1

+

C

0

.

P

1

)

.

P

2

=

G

2

+

G

1

.

P

2

+

C

0

.

P

1

.

P

2

. . .

C

k

= G

k

+

G

k-1

.

P

k

+

G

k-1

.

P

k-1

.

P

k

+ ... +

C

-1

.

P

0

.

P

1

.

...

.

P

k

Operadores aritméticos

– adição e

subtracção

– somadores assíncronos

• tempo de propagação depende dos operandos

• circuitos para detectar que a propagação do carry está concluída

• somador de 32 bits: média de 5 bits de carry

– 6 para um somador de 64 bits

• tempo pior é igual ou pior do que um somador ripple carry

– subtractores

• em complemento para dois basta complementar o subtractor

– trocar todos os bits (com XOR) e adicionar 1 fazendo C

_-1

=1

– melhor implementação depende da tecnologia

• em FPGAs XC4000 e usando fast carry logic

– somador ripple carry melhor do que carry select ou lookahead carry

• para ASICs há arquitecturas mais eficientes

(3)

1 1 0 1 0 (a = 26 ou -6)

0 1 0 1 1 (b = 11 ou +11)

+ 1 1 0 0 0 (c = 24 ou -8)

0 1

1 0

0 0

1 1

+ 1 0

1 1 1 1 0 1 (a+b+c = 61 ou -3)

Operadores aritméticos

adição e subtracção

• Adição de vários operandos

– Carry save adder

• produz 2 resultados (z e 2y) cuja soma é igual à adição dos 3

operandos

• Os resultados y e z são gerados em tempo constante ( O(1) )

• Para obter o resultado z+2y é necessário um somador adicional

FA

a

3

b

3

c

3

z

3

y

3

FA

a

2

b

2

c

2

z

2

y

2

FA

a

1

b

1

c

1

z

1

y

1

FA

a

0

b

0

c

0

z

0

y

0

a+b+c = z+2y

0+1+0=01

1+1+0=10

z = 01001

y = 11010

Operadores aritméticos

adição e subtracção

• Adição de vários operandos com RCA

– Exemplo: adição de 7 operandos com n bits cada

Half adder

Full adder

a

b

c

d

e

f

g

3(n-1) FA, 3 HA

2n-1 FA, 3 HA

n

_n

n

n+1

n+2

n+3

n+1 FA, 1 HA

n

...

6n-3 FA, 7 HA

log

_n

K

Tempo de propagação: (n+3+1)tp

_FA

(4)

Operadores aritméticos

adição e subtracção

• Árvore de CSA para adicionar n operandos

a

b

c

d

e

f

g

2n FA

n-1 FA, 1 HA

n

n FA

n

6n-3 FA, 3 HA

n

n+1

n

n+1

n

n-1 FA, 1HA

n+2

n

n-1 FA, 1HA

CSA

Somador de n bits

n

sum

carry

Half adder

Full adder

bypass

Operadores aritméticos

multiplicação

• Multiplicação binária

– multiplicação de números com sinal

• facilmente tratados com representação em sinal e magnitude

• o produto é

– negativo se os operandos tiverem sinais diferentes

– positivo caso contrário

• custo: complementar os operandos e o resultado

1101 (13)

0101 (5)

1101

0000

1101

0000

01000001 (65

≠

-15)

x

(-3)

₍₅₎

(5)

Operadores aritméticos

multiplicação

• Multiplicador iterativo (shift-add)

– multiplicando=Md[m-1:0], multiplicador=Mr[n-1:0]

– Acc[m+n:0] = 0

– para cada bit k do multiplicador desde 0 até n-1

• se Mr

k

= = 1

Acc[m+n:n] = Acc[m+n-1:n] + Md[m-1:0]

• Acc = Acc >> 1

– produto = Acc[m+n-1:0]

– exemplo:

Md Mr

k Mr

k

Acc

oper.

1101 0101 -

-

00000 0000

1101 0101

0 1 01101 0000 add

00110 1000 shift

1101 0101 1 0 00110 1000 add

00011 0100 shift

1101 0101 2 1 10000 0100 add

01000 0010 shift

1101 0101 3 0 01000 0010 add

00100 0001

shift

Operadores aritméticos

multiplicação

• Multiplicador shift-add

– implementação

• em cada ciclo, os m+1 bits do produto parcial são carregados em Acc

• o resultado parcial é deslocado para o registo que contém

inicialmente Mr

m bit

adder

Mr

₀

P[m+n-1:0]

Acc

Md

shr

ld

shr

ld

m

n

m

ld

m+1

(6)

Operadores aritméticos

multiplicação

• Multiplicação binária, complemento para dois

– se só for negativo o multiplicando

• basta estender o sinal dos produtos parciais

1101

0101

1111101

000000

11101

0000

11110001

x

(-3)

₍₅₎

(-15)

extensão

de sinal

Operadores aritméticos

multiplicação

• Multiplicação binária em complemento para dois

– se o multiplicador for negativo

• basta subtrair o último produto parcial (é igual a zero se for positivo)

– Recordando a representação complemento para dois

• para um número positivo com m bits

• se for negativo

• para os dois casos

valor(x) = 0 + X

m-2

.2

m-2

+ …+ X

1

2

1

+ X

0

.2

0

valor(x) = -2

m

_{+ 2}

m-1

_{+ X}

m-2

.2

m-2

+ …+ X

1

2

1

+ X

0

.2

0

valor(x) = - X

m-1

.2

m-1

+ X

m-2

.2

m-2

+ …+ X

1

2

1

+ X

0

.2

0

(7)

Operadores aritméticos

multiplicação

• Multiplicação em complemento para dois

– se o multiplicador for negativo

– … e se ambos negativos

– implementação: fácil incluir no multiplicador shift-add!

1101

1111101

000000

11101

11110001

11101

00001001

x

(-3)

_(-3)

(+9)

+

-somar os 3

produtos parciais

subtraír o último

produto parcial

extensão de sinal

0101

1101

0101

0000

0101

0011001

0101

11110001

x

_(-3)

(5)

(-15)

+

-somar os 3

produtos parciais

subtraír o último

produto parcial

se o multiplicador

for positivo, o último

produto parcial é zero!

Operadores aritméticos

multiplicação

• Multiplicador shift-add

– avaliação de k bits do multiplicador de cada vez

• número de ciclos reduzido k vezes (shift de k bits de cada vez)

• exemplo para k=2

• aumento da complexidade do somador

– é necessário somar 3.Md

– somadores em cascata, tempo de atraso superior

Mr1 Mr0 somar a Acc

0 0 0

0 1 Md

1 0 2.Md

1 1 2.Md+Md

m bit

adder

Mr

0

Md

shr

ld

n

ld

m+1 bit

adder

Mr

1

_2.Md

Acc

m

m+1

m+2

(8)

Operadores aritméticos

multiplicação

• Multiplicação - recodificação de Booth

– pela propriedade:

• pode substituir-se

• por

• objectivo: eliminar sequências de uns

– permite evitar em cada ciclo a soma de 3 operandos (2.Md+Md)

1 0 0 1 1 1

0 0 1

2

i+k

_{- 2}

i

_{= 2}

i+k-1

_{+ 2}

i+k-2

_{+ 2}

i+1

_{+ 2}

i

1 0 1

0 0 1

2

i+k

_{- 2}

i

00 10 11 10 11 01 10

00 10 11 10 11 10 10

00 10 11 11 00 10 10

00 11 00 01 00 10 10

01 01 00 01 00 10 10

factores: 0 2 3

2 3

1 2

factores: 1 -1 0 -1 0 -2 -2

Operadores aritméticos

multiplicação

• Multiplicação - recodificação de Booth

– algoritmo

• percorrer todos os bits desde o lsb até encontrar um 1

• trocar esse 1 por 1 e percorrer uns até encontrar um zero

• trocar esse 0 por 1 e continuar

– exemplo

– tabela de recodificação, analisando 2 bits de cada vez

• é necessário acrescentar

um bit zero à direita do

lsb: b

-1

=0

0011 1101 1001 =

512 + 256 + 128 + 64 + 16 + 8 + 1 = 985

0100 0110 1011 =

1024 - 64 + 32 - 8 + 2 - 1 = 985

b

i

b

i-1

z

i

valor caso

0 0 0 0 cadeia de zeros

0 1 1 +1 fim dos uns

1 0 1 -1 inicio dos uns

1 1 0 0 cadeia de uns

(9)

Operadores aritméticos

multiplicação

• Multiplicação - recodificação de Booth

– multiplicação com sinal: basta recodificar o multiplicador

– para cada bit do multiplicador

• se é 0 não soma nada

• se é 1 soma o multiplicando

• se é 1 soma o simétrico do multiplicando

– exemplo

-7

-5

-(-7)

x

2

0

+(0)

x

2

1

+(-7)

x

2

-(-7)

x

2

3

7-28+56=35

x

+

1001

1101

00000111

0000000

111001

00111

00100011

x

+

(-7) x (-5) = +35

-7 = 1001

-5 = 1011

recodificar -5

(ver tabela)

1011 0

1101

Operadores aritméticos

multiplicação

• Multiplicador de Booth iterativo

– multiplicador Mr acrescentado de um bit à direita: Mr

_-1

= 0

– comparados dois bits de Mr de cada vez

• se b

i

= b

i-1

desloca produto parcial (11 ou 00 → 0)

• se b

i

< b

i-1

soma Md e desloca produto parcial (01 → 1)

• se b

i

> b

i-1

subtrai Md e desloca produto parcial (10 → 1)

• deslocamento aritmético do produto

• exemplo:

– Mr = -3 (1101)

– Md = +7 (0111)

1101 0

1 -7 1001 0000

1100 1000

1101 0 1 +7 0011 1000

0001 1100

1101 0 1 -7 1010 1100

1101 0110

1101 0 0 +0 1101 0110

1110 1011

Mr

-1

Mr

opr.

produto

(10)

Operadores aritméticos

multiplicação

• Multiplicador de Booth

– recodificando pares de bits em dígitos com sinal

• são analisados 3 bits de cada vez

• cada par de bits produz uma multiplicação por 0, +1, +2, -1 ou -2

• reduz para metade o número de iterações (shift de 2 bits de cada vez)

– tabela de recodificação

b

i

b

i-1

b

i-2

z

i

z

i-1

valor caso

0 0 0 0 0 cadeia de zeros

0 0 1 1 +1 fim de uns

0 1 0 1 +1 1 isolado

0 1 1 1 +2 fim de uns

1 0 0 1 -2 início de uns

1 0 1 1 -1 zero isolado

1 1 0 1 -1 início de uns

1 1 1 0 0 cadeia de uns

Operadores aritméticos

multiplicação

• Multiplicador de Booth

(n/2 iterações)

add/sub

Multiplicador

Multiplicando

n

m

recode

x2

0

1 add/sub

sel

zero

prod

b-1

b0

b1

recode

b1 b0 b-1 val sel zero add/sub

0 0 0 0 x 1 x

0 0 1 1 0 0 1

0 1 0 1 0 0 1

0 1 1 2 1 0 1

1 0 0 -2 1 0 0

1 0 1 -1 0 0 0

1 1 0 -1 0 0 0

1 1 1 0 0 1 x

(11)

Operadores aritméticos

multiplicação

• Multiplicação paralela (unsigned)

a4.b0 a3.b0 a2.b0 a1.b0 a0.b0

a4.b1 a3.b1 a2.b1 a1.b1 a0.b1

a4.b2 a3.b2 a2.b2 a1.b2 a0.b2

a4.b3 a3.b3 a2.b3 a1.b3 a0.b3

a4.b4 a3.b4 a2.b4 a1.b4 a0.b4

a4 a3 a2 a1 a0

b4 b3 b2 b1 b0

x

p9 p8 p7 p6 p5 p4 p3 p2 p1 p0

Operadores aritméticos

multiplicação

• array multiplicador (unsigned)

– cada nó é um full adder

FA FA FA FA FA FA FA FA FA FA FA FA FA FA FA FA FA FA FA FA

p0

p1

p2

p3

p4

p5

p6

p7

p8

p9

0

a0.b0 a0.b1 a1.b0 a2.b0 a3.b0 a4.b0 a1.b1 a2.b1 a3.b1 a4.b1 a1.b2 a2.b2 a3.b2 a4.b2 a1.b3 a2.b3 a3.b3 a4.b3 a0.b2 a0.b3 a0.b4 a1.b4 a2.b4 a3.b4 a4.b4

FA

A

B

Cin

S

Cout

(12)

Operadores aritméticos

multiplicação

• multiplicação paralela (signed)

(a4.b0) a3.b0 a2.b0 a1.b0 a0.b0

(a4.b1) a3.b1 a2.b1 a1.b1 a0.b1

(a4.b2) a3.b2 a2.b2 a1.b2 a0.b2

(a4.b3) a3.b3 a2.b3 a1.b3 a0.b3

a4.b4 (a3.b4) (a2.b4) (a1.b4) (a0.b4)

(a4) a3 a2 a1 a0

(b4) b3 b2 b1 b0

x

(p9) p8 p7 p6 p5 p4 p3 p2 p1

p0

bit de sinal

(peso -2

4

₎

termos de soma

negativos

Operadores aritméticos

multiplicação

• array multiplicador de Pezaris (n

x

n, signed)

– 4 tipos de full adders diferentes

• FA0, FA1, FA2, FA3

FA3 FA2 FA2

p0

p1

p2

p3

p4

p5

p6

p7

p8

(p9)

0

a0.b0 a0.b1 a1.b0 a2.b0 a3.b0 a4.b0 a1.b1 a2.b1 a3.b1 a4.b1 a1.b2 a2.b2 a3.b2 a4.b2 a1.b3 a2.b3 a3.b3 a4.b3 a0.b2 a0.b3 a0.b4 a1.b4 a2.b4 a3.b4 a4.b4 FA2 FA2 FA1 FA1 FA1 FA2 FA0 FA0 FA0

FA2 FA0 FA0 FA0 FA2 FA0 FA0 FA0

(13)

Operadores aritméticos

multiplicação

• multiplicador bi-secção (signed)

– separando os termos positivos dos negativos

a3.b0 a2.b0 a1.b0 a0.b0

a3.b1 a2.b1 a1.b1 a0.b1

a3.b2 a2.b2 a1.b2 a0.b2

a4.b4 0 a3.b3 a2.b3 a1.b3 a0.b3

(a4.b3) (a4.b2) (a4.b1) (a4.b0)

(a3.b4) (a2.b4) (a1.b4) (a0.b4)

(a4) a3 a2 a1 a0

(b4) b3 b2 b1 b0

x

(p9) p8 p7 p6 p5 p4 p3 p2 p1

p0

secção

positiva

secção

negativa

Operadores aritméticos

multiplicação

• multiplicador bi-secção

– só dois tipos de full-adders

– fácil de expandir para m

x

n

FA2 FA2 FA2

p0

p1

p2

p3

p4

p5

p6

p7

p8

(p9)

0

a4.b0 a4.b1 a4.b2 a4.b3 a3.b4 a4.b4 FA2 FA2 FA2 FA2 FA2

FA0 FA0 FA0

0

a0.b0 a0.b1 a1.b0 a2.b0 a1.b1 a2.b1 a1.b2 a2.b2 a1.b3 a2.b3 a0.b2 a0.b3

FA0 FA0 FA0 FA0 FA0 FA0

a3.b0 a3.b1 a3.b2 a3.b3

FA0 FA0 FA0

a2.b4 a1.b4 a0.b4

0 secção positiva

(14)

Operadores aritméticos

– divisão

• divisão de números inteiros sem sinal

– processo parecido com a multiplicação: shift-subtract

– o resultado de uma subtração define a próxima operação

• dependência entre as várias operações

• mais complexo do que a multiplicação

– exemplo (sem sinal):

147/11=13, 147%11=4

10010011 1011

1011 00001101

001110

1011

001111

1011

100 -1 < -10-1-1

10 < 1011

...

111 < 1011

subtrai divisor

resto

quociente

dividendo

divisor

Operadores aritméticos

– divisão

• divisão unsigned - algoritmo

A=0; // fica com o resto, n bits

M=Divisor; // n bits

Q=Dividendo; // “apanha” quociente, m bits

cnt=m;

repeat

{A,Q} = {A,Q} << 1;

A = A - M; // subtrai o divisor ao dividendo

if (A>=0)

Q[0] = 1; // divisor “coube” no dividendo

else

begin

Q[0] = 0; // divisor não “coube” no dividendo

A = A + M; // repõe o valor do dividendo

end

cnt = cnt - 1;

until (cnt==0);

A

Q

0011 11000011

0111 10000110

quociente

dividendo

resto

(15)

Operadores aritméticos

– divisão

• divisão de números inteiros com sinal

(compl.para 2)

M=Divisor; // n bits

{A,Q}=Dividendo; // dividendo com extensão de sinal (n+m bits)

// A fica com o resto (n bits)

cnt=m; // m bits do dividendo

sD = sign({A,Q});// guarda sinal do dividendo

repeat

{A,Q} = {A,Q} << 1;

sA = sign(A); // sinal do resto actual

A0 = A; // guarda A

if ( sign(A) == sign(M) )

A = A - M;

else

A = A + M;

if ( sign(A) == sA || ( A == 0 && Q == 0 ) ) // trocou sinal de A

Q[0] = 1;

else

begin

Q[0] = 0; // bit do quociente é zero

A = A0; // restaura o valor de A

end

cnt = cnt - 1;

until (cnt==0);

if ( sD != sign(M) ) // dividendo e divisor com sinais opostos

Q = -Q;

Operadores aritméticos

– divisão

• exemplo (signed): -7 / 3

({A,Q} = -7, M = +3)

-7 / 3 = -2

-7 % 3 = -1

{A,Q} = -7 = 1001

M = +3 = 0011

...

Q = -2 = 1110

R = -1 = 1111

1111 1001 dividendo com extensão do sinal

1111 0010 shift e guarda A (A=1111)

0011 A e M com sinais diferentes, soma M a A

0010 o resultado trocou o sinal de A

1111 0010

Q[0]=0 e restaura o valor de A

1110 0100 shift e guarda A ( A=1110)

0011 M e A com sinais diferentes, soma M a A

0001 o resultado trocou o sinal de A

1110 0100

Q[0]=0 e restaura o valor de A

1100 1000 shift e guarda A (A=1100)

0011 M e A com sinais diferentes, soma M a A

1111 o resultado não trocou o sinal de A

1111 1001

Q[0]=1

1111 0010 shift e guarda A (A=1111)

0011 M e A com sinais diferentes, soma M a A

0010 o resultado trocou o sinal de A

1111 0010

Q[0]=0, restaura o valor de A

1111 1110 dividendo e divisor com sinais opostos

troca o sinal do quociente: Q=-2, R=-1

+

(16)

Operadores aritméticos

– divisão

• Divisor celular (combinacional)

– Array divisor (non-restoring)

CAS CAS CAS CAS

n

₆

n

₅

n

₄

n

₃

n

₂

n

₁

n

₀

r

0

r

1

r

2

r

3

q

0

q

1

q

2

q

3

1 d

3

d

2

d

1

d

0

dividendo

divisor

quociente

resto

CAS

(Controlled Add/Subtract)

FA B_i Ai Ci B_i C_i+1 Si P P

Síntese do datapath

outros operadores

• Operadores aritméticos específicos de uma

aplicação

– quadrado

• A

x

A é mais eficiente do que a multiplicação

– operações com constantes

• propagação de constantes simplifica o hardware (geralmente...)

• multiplicação traduzida em shifts, adições e subtracções

– raíz quadrada

• aproximação algorítmica

– funções transcendentes

• aproximações por tabelas, polinómios ou segmentos de recta

• domínio da função e precisão pretendida condiciona o método

(17)

Exemplo: Filtro FIR

sptool (MatLab)

passband:

ripple=1dB

Fc=4KHz

stopband

Fs=6KHz

G=-30dB

filtro FIR 31 coeficientes

resposta impulsional:

Exemplo:filtro FIR

multiplicações xk*hn

assign p0 = - ( {1'b0, din } << 1 ); // 9 bits

assign p1 = 8'b0; // 8 bits

assign p2 = din; // 8 bits

assign p3 = -p0; // 9 bits

assign p4 = { {2{din[7]}},din} + ( { {2{din[7]}}, din} << 1 ); // 10 bits

assign p5 = p3; // 9 bits

assign p6 = 0; // 8 bits

assign p7 = p0; // 9 bits

assign p8 = - ( { {3{din[7]}},din} + ( { {3{din[7]}}, din} << 2 ) ); // 11 bits

assign p9 = p8; // 11 bits

assign p10 = -p4; // 10 bits

assign p11 = p4; // 10 bits

assign p12 = ( {{4{din[7]}}, din } << 3 ) + ( {{4{din[7]}}, din } << 1 ) + {{4{din[7]}}, din}; // 12 bits assign p13 = ( {{5{din[7]}}, din } << 4 ) + ( {{5{din[7]}}, din } << 2 ); // 13 bits assign p14 = ( {{5{din[7]}}, din } << 4 ) + ( {{5{din[7]}}, din } << 3 ) + ({{5{din[7]}}, din } << 1);// 13 bits assign p15 = ( {{5{din[7]}}, din } << 5 ) - ( {{5{din[7]}}, din } << 2 ) + ({{5{din[7]}}, din } );// 13 bits

Coeficientes (/128): -2 0 1 2 3 2 0 -2 -5 -5 -3 3 11 20 26

29

(18)

Exemplo:filtro FIR

adições (x

_k

*h

_n-1

)+(x

_k

*h

_n-2

)+...+x

_k

*h

₀

if ( enable )

begin

t0 <= { p0[8], p0 };

t1 <= t0 + { {2{p1[7]}}, p1 };

t2 <= t1 + { {2{p2[7]}}, p2 };

t3 <= { t2[9], t2 } + { {2{p3[8]}}, p3 };

t4 <= { t3[10], t3 } + { {2{p4[9]}}, p4 };

t5 <= t4 + { {3{p5[8]}}, p5 };

t6 <= t5 + { {4{p6[7]}}, p6 };

t7 <= t6 + { {3{p7[8]}}, p7 };

t8 <= { t7[11], t7 } + { {2{p8[10]}}, p8 };

t9 <= t8 + { {2{p9[10]}}, p9 };

t10 <= t9 + { {3{p10[9]}}, p10 };

t11 <= t10 + { {3{p11[9]}}, p11 };

t12 <= { t11[12], t11} + { {2{p12[11]}}, p12 };

t13 <= t12 + {p13[12], p13};

t14 <= { t13[13], t13} + { {2{p14[12]}}, p14 };

t15 <= t14 + { {2{p15[12]}}, p15 };

t16 <= { t15[14], t15 } + { {3{p14[12]}}, p14 };

...

Exemplo:filtro FIR

divisão final, arredondamento e clipping

always @( t30 ) begin

corr_bit = ( t30[6] & ( | t30[5:0] ) ) // add 1 if decimal part is 0.1bbbbb with at least one b==1 | ( t30[6] & t30[7] ); // add 1 if decimal part is 0.100000 and integer part is odd dout_bc = t30[15:7] + { 7'd0, corr_bit };

dout = dout_bc[7:0];

// clipping to maxint and minint

if ( dout_bc[8:7] == 2'b01 ) // overflow positive in 8 bits, set to maximum positive dout = 8'b01111111;

if ( dout_bc[8:7] == 2'b10 ) // overflow negative in 8 bits, set to minimum negative dout = 8'b10000000;

(19)

Exemplo: filtro IIR

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 0 20 40 60 80 100

Normalized Frequency (×π rad/sample)

P has e (d egr ee s) 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 -40 -30 -20 -10 0 10

M agn itude (d B ) 0 0.05 0.1 0.15 0.2 0.25 0.3 20 40 60 80

P has e (d egr ee s) 0 0.05 0.1 0.15 0.2 0.25 0.3 -20 -10 0

M agn itude (d B )

**Y/X = 0.86* 1 - z**

_{1 - 0.738z}

-1 -1

Y

k

= (X

k

– X

k

-1 + 0.738Y

k-1

**)*0.86**

Exemplo: filtro IIR

assign add1 = -{ {2{dind[15]}}, dind} + { {2{din[15]}}, din} + yd1;

always @( add1d or yd1i ) begin

yd1i = { {10{add1d[17]}}, add1d} * 27'd756; yd1 = yd1i[27:10];

end

/* // ou então: always @( add1d or yd1 ) begin

yd1 = add1d - { {2{add1d[17]}}, add1d[17:2] }; yd1 = add1d - { {4{yd1[17]}}, yd1[17:4] }; yd1 = add1d + { {1{yd1[17]}}, yd1[17:1] }; yd1 = { {1{yd1[17]}}, yd1[17:1] }; end

*/ // douti = add1d * int( 0.86 * 256 ) / 256;

always @( add1d or doutii ) begin

doutii = { {8{add1d[17]}}, add1d} * 25'd220; douti = doutii[25:8];

end

/* // uma forma alternativa de codificar o mesmo: always @( add1d or douti )

begin

douti = add1d - { {3{add1d[17]}}, add1d[17:3] }; douti = add1d + { {1{douti[17]}}, douti[17:1] }; douti = add1d + { {1{douti[17]}}, douti[17:1] }; douti = { {1{douti[17]}}, douti[17:1] }; end

Síntese do datapath unidades funcionais

Síntese do datapath

unidades funcionais

• Unidades funcionais do datapath

– operadores aritméticos

• operandos inteiros, vírgula fixa ou vírgula flutuante

• operadores com constantes, mais eficientes do que operadores genéricos

– operadores lógicos, manipulação de bits

• funções lógicas, rotações, deslocamentos, bitreverse

– operadores específicos de uma aplicação

• A*B-(C+D), x[k]*x[k+t1]*x[k+t2]

• Numa abordagem top-down (HDL+síntese)

– operadores inferidos e construídos no processo de síntese

• implementados como circuitos combinacionais

– nem todos os operadores disponíveis

• FPGA Express

(V3.6.1)

suporta apenas divisões entre constantes

– arquitecturas dos operadores definidas nas bibliotecas da tecnologia alvo

• em Verilog todas as operações são consideradas com operandos sem sinal

Operadores aritméticos

adição e subtracção

– ripple carry adder (RCA)

• propagação do carry limita a rapidez de cálculo

• resultado garantido após o maior tempo de propagação do carry

– carry select adder

• dividido em secções e cada secção inclui 2 somadores de k bits

• exemplo: somador de 12 bits em secções de 4 bits:

A

A

B

B

1

0

C

C

C

A

A

B

B

1

0

C

C

C

C

CS

A

A

B

B

1

0

C

C

CS

C

C

C

C

S

S

S

C

C

C

Operadores aritméticos

adição e subtracção

– carry generate, carry propagate, lookahead

• generate

• propagate

• equações do somador escrevem-se

• os carry de todos os andares podem ser obtidos em paralelo

G

= A

. B

significa que o carry é gerado no andar i

P

= A

• AB-(C+D), x[k]x[k+t1]*x[k+t2]