síntese do datapathaja/psd2005_06/slides/psd_2005-06_slides19… · • multiplicação -...

FEUP/DEEC, Projecto de Sistemas Digitais, 2005/2006José Carlos Alves

196

Síntese do datapathunidades 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


197

Operadores aritméticosadiçã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

A3-0

A3-0 B3-0

B3-0

1

0

4 bit add

4 bit add

C-1

C3,1

C3,0

A7-4

A7-4 B7-4

B7-4

1

0

4 bit add

4 bit add

C7,1

C7,0

C3,0

C3,1CS

A11-8

A11-8 B11-8

B11-8

1

0

4 bit add

4 bit add

C11,1

C11,0

CSC3,0

C3,1

C7,0

C7,1

S3-0S7-4S11-8

C11

C7C4


198


– carry generate, carry propagate, lookahead• generate

• propagate

• equações do somador escrevem-se

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

Gi = Ai . Bi significa que o carry é gerado no andar i

Pi = Ai ⊕ Bi significa que o andar i propaga o carry que lhe chega

Si = Ai ⊕ Bi ⊕ Ci-1 = Pi ⊕ Ci-1

Ci = Ai .Bi + Ai .Ci-1 + Bi .Ci-1 = Ai .Bi + Ai .Ci-1.Bi + Bi .Ci-1.Ai = Ai .Bi + Ci-1.(Ai.Bi + Bi.Ai)= Ai.Bi + Ci-1.(Ai ⊕ Bi )= Gi + Pi .Ci-1

C1 = G1 + C0 .P1C2 = G2 + C1 .P2 = G2 + (G1 + C0 .P1) .P2 = G2 + G1 .P2 + C0 .P1 .P2. . .Ck = Gk + Gk-1 .Pk + Gk-1 .Pk-1 .Pk + ... + C-1 .P0 .P1.....Pk


199

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 – usando portas complexas CMOS ou modelos ao nível do interruptor


200

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 00 0

1 1 + 1 0

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


• 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

a3 b3 c3

z3y3

FA

a2 b2 c2

z2y2

FA

a1 b1 c1

z1

y1

FA

a0 b0 c0

z0

y0

a+b+c = z+2y

0+1+0=011+1+0=10

z = 01001

y = 11010


201


• 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 n n n

n+1 n+1n+1

n+2 n+2

n+3

n+1 FA, 1 HA

n

... ... ...

...

...

...

6n-3 FA, 7 HA

lognK

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


202


• Árvore de CSA para adicionar n operandosa b c d e f g

2n FA

n-1 FA, 1 HA

n n n n n n n

n n n

n FA

n

6n-3 FA, 3 HA

n

n+1n

n+1n

n-1 FA, 1HAn+2

nn-1 FA, 1HA

CSA

Somador de n bits

n n n

n n

sumcarry

Half adderFull adder

bypass


203

Operadores aritméticosmultiplicaçã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

00001101

000001000001 (65 ≠ -15)

x(-3)(5)

sem sinal complemento para dois


204


• 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 Mrk = = 1Acc[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 Mrk Acc oper.1101 0101 - - 0000000001101 0101 0 1 011010000 add

001101000 shift1101 0101 1 0 001101000 add

000110100 shift1101 0101 2 1 100000100 add

010000010 shift1101 0101 3 0 010000010 add

001000001 shift


205


• 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 bitadder

Mr

Mr0

P[m+n-1:0]

Acc Mdshrld

shrld

mn

nm

ld

m+1


206


• Multiplicação binária, complemento para dois– se só for negativo o multiplicando

• basta estender o sinal dos produtos parciais

11010101

1111101000000111010000

11110001

x(-3)(5)

(-15)

extensão de sinal


207


• 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 + Xm-2.2m-2 + …+ X121 + X0.20

valor(x) = -2m + 2m-1 + Xm-2.2m-2 + …+ X121 + X0.20

valor(x) = - Xm-1.2m-1 + Xm-2.2m-2 + …+ X121 + X0.20

bit de sinal Xm-1 tem peso -2m-1


208


• Multiplicação em complemento para dois– se o multiplicador for negativo

– … e se ambos negativos

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

11011101

111110100000011101

111100011110100001001

x(-3)(-3)

(+9)

+

-

somar os 3 produtos parciaissubtraír o último produto parcial

extensão de sinal

010111010101

00000101

00110010101

11110001

x(5)

(-3)

(-15)

+

-

somar os 3 produtos parciaissubtraír o último produto parcial

se o multiplicadorfor positivo, o últimoproduto parcial é zero!


209


• 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 Acc0 0 00 1 Md1 0 2.Md1 1 2.Md+Md

m bitadder

MrMr0

Mdshrld

n

ld

m+1 bitadder

Mr1 2.MdAccm

m

m

m+1

m+2


210


• 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

2i+k - 2i = 2i+k-1 + 2i+k-2 + 2i+1 + 2i

1 0 1 0 0 1 0 0 12i+k - 2i

0010111011011000101110111010001011110010100011000100101001010001001010

factores: 0 2 3 2 3 1 2

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


211


• 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 dolsb: b-1=0

0011 1101 1001 = 512 + 256 + 128 + 64 + 16 + 8 + 1 = 985

0100 0110 1011 = 1024 - 64 + 32 - 8 + 2 - 1 = 985

bi bi-1 zi valor caso0 0 0 0 cadeia de zeros0 1 1 +1 fim dos uns1 0 1 -1 inicio dos uns1 1 0 0 cadeia de uns


212


• 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)x20

+(0)x21

+(-7)x22

-(-7)x23

7-28+56=35

x

+

10011101

0000011100000001110010011100100011

x

+

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

recodificar -5(ver tabela)

1011 01011 01011 01011 0

1101


213


• Multiplicador de Booth iterativo– multiplicador Mr acrescentado de um bit à direita: Mr-1= 0– comparados dois bits de Mr de cada vez

• se bi = bi-1 desloca produto parcial (11 ou 00 → 0)• se bi < bi-1 soma Md e desloca produto parcial (01 → 1)• se bi > bi-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 00001100 1000

1101 0 1 +7 0011 10000001 1100

1101 0 1 -7 1010 11001101 0110

1101 0 0 +0 1101 01101110 1011

Mr-1Mr opr. produto


214


• 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

bi bi-1 bi-2 zi zi-1 valor caso0 0 0 0 0 cadeia de zeros0 0 1 1 +1 fim de uns0 1 0 1 +1 1 isolado0 1 1 1 +2 fim de uns1 0 0 1 -2 início de uns 1 0 1 1 -1 zero isolado 1 1 0 1 -1 início de uns1 1 1 0 0 cadeia de uns


215


• Multiplicador de Booth (n/2 iterações)

add/sub

MultiplicadorMultiplicando

n m

recode

x2

0 1

add/sub

sel

zero

prod

b-1b0b1

recodeb1 b0 b-1 val sel zero add/sub0 0 0 0 x 1 x0 0 1 1 0 0 10 1 0 1 0 0 10 1 1 2 1 0 11 0 0 -2 1 0 01 0 1 -1 0 0 01 1 0 -1 0 0 01 1 1 0 0 1 x


216


• Multiplicação paralela (unsigned)

a4.b0 a3.b0 a2.b0 a1.b0 a0.b0a4.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 b0x

p9 p8 p7 p6 p5 p4 p3 p2 p1 p0


217


• array multiplicador (unsigned)– cada nó é um full adder

FAFA FA FA

FA FA FA FA

FA FA FA FA

FA FA FA FA

FA FA FA FA

p0p1p2p3p4p5p6p7p8p9

0

0 0 0 0a0.b0a0.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.b2a0.b3a0.b4

a1.b4

a2.b4

a3.b4

a4.b4

FA

A

B

Cin

SCout


218


• 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 b0x

(p9) p8 p7 p6 p5 p4 p3 p2 p1 p0

bit de sinal(peso -24)

termos de somanegativos


219


• array multiplicador de Pezaris (nxn, signed)– 4 tipos de full adders diferentes

• FA0, FA1, FA2, FA3

FA3

FA2 FA2

p0p1p2p3p4p5p6p7p8(p9)

0

0 0 0 0a0.b0a0.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.b2a0.b3a0.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


220


• multiplicador bi-secção (signed)– separando os termos positivos dos negativos

a3.b0 a2.b0 a1.b0 a0.b0a3.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 b0x

(p9) p8 p7 p6 p5 p4 p3 p2 p1 p0

secçãopositiva

secçãonegativa


221


• multiplicador bi-secção– só dois tipos de full-adders– fácil de expandir para mxn

FA2

FA2 FA2

p0p1p2p3p4p5p6p7p8(p9)

0

a4.b0a4.b1a4.b2a4.b3

a3.b4

a4.b4

FA2 FA2

FA2 FA2 FA2

FA0 FA0 FA0

0 0 0a0.b0a0.b1

a1.b0

a2.b0

a1.b1

a2.b1

a1.b2

a2.b2

a1.b3

a2.b3

a0.b2a0.b3

FA0 FA0 FA0

FA0 FA0 FA0

a3.b0a3.b1a3.b2a3.b3

FA0 FA0 FA0

a2.b4 a1.b4 a0.b4

0

secção positivasecção negativa


222

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 10111011 0000110100111010110011111011100

-

-

-

1 < 101110 < 1011... 111 < 1011

subtrai divisor

resto

quocientedividendo

divisor


223


• divisão unsigned - algoritmoA=0; // fica com o resto, n bitsM=Divisor; // n bitsQ=Dividendo; // “apanha” quociente, m bitscnt=m;repeat{A,Q} = {A,Q} << 1;A = A - M; // subtrai o divisor ao dividendoif (A>=0)Q[0] = 1; // divisor “coube” no dividendo

elsebeginQ[0] = 0; // divisor não “coube” no dividendoA = A + M; // repõe o valor do dividendo

endcnt = cnt - 1;until (cnt==0);

A Q0011 11000011

0111 10000110

quocientedividendo

resto


224


• 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 dividendosD = sign({A,Q});// guarda sinal do dividendorepeat{A,Q} = {A,Q} << 1;sA = sign(A); // sinal do resto actualA0 = A; // guarda Aif ( sign(A) == sign(M) )A = A - M;

elseA = A + M;

if ( sign(A) == sA || ( A == 0 && Q == 0 ) ) // trocou sinal de AQ[0] = 1;

elsebeginQ[0] = 0; // bit do quociente é zero A = A0; // restaura o valor de A

endcnt = cnt - 1;until (cnt==0);if ( sD != sign(M) ) // dividendo e divisor com sinais opostosQ = -Q;


225


• exemplo (signed): -7 / 3 ({A,Q} = -7, M = +3)

-7 / 3 = -2-7 % 3 = -1

{A,Q} = -7 = 1001M = +3 = 0011...Q = -2 = 1110R = -1 = 1111

1111 1001 dividendo com extensão do sinal1111 0010 shift e guarda A (A=1111)0011 A e M com sinais diferentes, soma M a A0010 o resultado trocou o sinal de A1111 0010 Q[0]=0 e restaura o valor de A1110 0100 shift e guarda A ( A=1110)0011 M e A com sinais diferentes, soma M a A0001 o resultado trocou o sinal de A1110 0100 Q[0]=0 e restaura o valor de A1100 1000 shift e guarda A (A=1100)0011 M e A com sinais diferentes, soma M a A1111 o resultado não trocou o sinal de A1111 1001 Q[0]=11111 0010 shift e guarda A (A=1111)0011 M e A com sinais diferentes, soma M a A0010 o resultado trocou o sinal de A1111 0010 Q[0]=0, restaura o valor de A1111 1110 dividendo e divisor com sinais opostos

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

+

+

+

+

A Q


226


• Divisor celular (combinacional)– Array divisor (non-restoring)

CAS CAS CAS CAS

CAS CAS CAS CAS

CAS CAS CAS CAS

CAS CAS CAS CAS

n6 n5 n4 n3

n2

n1

n0

r0r1r2r3

q0

q1

q2

q3

1

d3 d2 d1 d0

dividendodivisor

quociente resto

CAS(Controlled Add/Subtract)

FA

BiAi

Ci

Bi

Ci+1

Si

P P


227

Síntese do datapathoutros operadores

• Operadores aritméticos específicos de uma aplicação– quadrado

• AxA é 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


228

Exemplo: Filtro FIRsptool (MatLab)passband:

ripple=1dBFc=4KHz

stopbandFs=6KHzG=-30dB

filtro FIR 31 coeficientes

resposta impulsional:


229

Exemplo:filtro FIRmultiplicaçõ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 p8 = - ( { {3{din[7]}},din} + ( { {3{din[7]}}, din} << 2 ) ); // 11 bits


assign p10 = -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 262926 20 11 3 -3 -5 -5 -2 0 2 3 2 1 0 -2


230

Exemplo:filtro FIRadições (xk*hn-1)+(xk*hn-2)+...+xk*h0

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 };...


231

Exemplo:filtro FIRdivisã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;

end


232

Exemplo: filtro IIR

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10

20

40

60

80

100

Normalized Frequency (×π rad/sample)

Pha

se (d

egre

es)

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


Mag

nitu

de (d

B)

0 0.05 0.1 0.15 0.2 0.25 0.3

20

40

60

80


Pha

se (d

egre

es)

0 0.05 0.1 0.15 0.2 0.25 0.3

-20

-10

0


Mag

nitu

de (d

B)

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

Yk = (Xk – Xk-1 + 0.738Yk-1)*0.86


233

Exemplo: filtro IIRassign 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*/


234

Teste de sistemas digitais

• Definição– determinar se um sistema (fabricado) funciona correctamente

• aplicar estímulos seleccionados• observar as respostas• compará-las com as respostas esperadas

• Níveis de hierarquia – sistemas - interligação de cartas de circuito impresso

• defeitos em cartas ou interligações– cartas - interligação de componentes

• defeitos nas interligações, componentes mal colocados– componentes (chips) - interligações de transistores

• defeitos nos contactos, curto circuitos ou circuitos abertos nas pistas

Baseado em ”Digital Systems Testing and Testable Design”,M. Abramovici, M.A. Breuer, A.D. Friedman, Computer Science Press, 1990


235

Testar quando ?

• O teste de um CI pode ser feito– na wafer

• contactos directos aos pads ou outros pontos de teste

– após o encapsulamento• pelos terminais do CI

– após a inserção numa carta• usando autoteste ou infraestruturas residentes para teste

– integrado num sistema antes da distribuição• teste pós-produção

– integrado num sistema após instalação no utilizador final• field test


236

Testar quando ?

• Quanto mais cedo melhor– custo de detectar uma falta

wafer $0.01 - $0.1CI encapsulado $0.1 - $1carta $1 - $10sistema $10 - $100utilizador $100 - $1000

aumento de10x


237

Tipos de teste

• Quando é realizado o teste ?– em simultâneo com a operação do sistema (on-line, concurrent)– como uma actividade separada (off-line)

• O que se procura com o teste ?– erros de projecto (design verification testing)– erros de fabrico (acceptance testing)– defeitos de fabrico, falhas no processo (burn-in)– falhas físicas infantis (quality assurance testing)– falhas físicas, factores externos (field testing, maintenance)

• permanentes, intermitentes, transitórias• envelhecimento, radiações, temperatura, humidade, vibrações…


238

Tipos de teste

• Que fonte de estímulos, quem verifica resultados ?– produzida pelo próprio sistema (self testing)– proveniente de um equipamento externo dedicado (external testing)

• Como são produzidos os estímulos e respostas ?– armazenados em memória (stored pattern testing)– produzidos durante o teste (algorithmic testing, comparision testing)

• Como são aplicados os estímulos ?– numa ordem pré-determinada (non-adaptative testing)– dependendo dos resultados obtidos (adaptative testing)

• Que rapidez de aplicação dos estímulos ?– muito mais lentos do que em funcionamento normal (DC ou static)– à velocidade normal de funcionamento (AC- ou at-speed testing)


239

Tipos de teste• Que resultados são observados ?

– as respostas de todas as saídas– uma função da resposta (compact testing)

• Que sinais são usados para teste ?– só os terminais de entrada e saída (edge-pin testing, GO/NO GO)– terminais de E/S e nós internos

• guided probe testing - ao nível da carta, localizar falhas• bed of nails - contacto directo a nós internos• in-circuit - isolar componentes montados numa carta• in-circuit emulation - substituir um componente por um testador


240

Teste funcional e teste estrutural

• Teste funcional– verificar que o projecto do circuito implementa a especificação

• ao nível funcional, RTL ou lógico

– verificar que o circuito realiza a função pretendida• após a sua implementação na tecnologia alvo

• Teste estrutural– verificar que os componentes do sistema funcionam– verificar que as interligações entre os componentes funcionam


241

Qualidade e fiabilidade

• Qualidade– satisfação de especificações funcionais, eléctricas e físicas

• projecto e manufactura• qualidade de materiais• controlo do yield

• Fiabilidade– capacidade de um componente cumprir a sua função em

condições determinadas e durante um período de vida especificado


242

Yield e nível de defeitos

• Yield (processo de fabrico)

• nível de defeitos (no cliente)

nº componentes bonsnº componentes fabricados

nº componentes defeituosos

nº de componentes enviados

testefabrico enviados(bons e avariados)

rejeitados(dados como avariados)

matériaprima

fabricados

Y =

DL =


243

Modelos de faltas

• Defeitos físicos manifestam-se como– falhas ao nível eléctrico (curto circuito, circuito aberto)– falhas ao nível lógico (trocas de zero por uns)

• Modelos de faltas– representação da forma como um defeito físico afecta o

comportamento• em diferentes níveis de abstração (RTL, lógico ou eléctrico)

– o mesmo defeito físico é representado por diferentes modelos

• modelos de faltas realistas– conhecimento dos mecanismos físicos e eléctricos que podem causar faltas– fundamentais para a geração eficaz de estímulos de teste

– estímulos de teste• activar uma falta e propagar o seu efeito para um ponto observável (saída)


244

Cobertura de faltas

• Teste exaustivo é impraticável– circuito com N entradas ⇒ 2N vectores (N=75, 1µs/vector = 1.2G anos)

• Estímulos de teste– conjunto limitado de valores para as entradas– objectivo: detectar resultados errados para qualquer falta no circuito– modelos de faltas simplificados

• admite-se uma só falta de cada vez do tipo stuck-at-1, stuck-at-0

• Cobertura de faltas (fault coverage)

FC = nº faltas detectadasnº faltas consideradas

x 100%


245

Yield, Defect level, Defect coverage

DL = 1 - Y (1-DC)

0

0 .1

0 .2

0 .3

0 .4

0 .5

0 .6

0 .7

0 .8

0 .9

1

0 0 .2 0 .4 0 .6 0 .8 1

Y=1%Y=10%

Y=25%

Y=50%

Y=75%Y=90%

Y=99%

cobertura de defeitos (DC)

níve

l de

defe

itos (

DL)

DC = nº faltas detectadas

nº faltas possíveisx 100%

(DC <= FC)


246

Modelo de faltas Single Stuck-at

• Modela uma falta como colagem de um nó a 1 ou 0– considera que não ocorrem várias faltas simultâneamente

– estímulos de teste devem produzir saídas erradas se o nó em análise estiver sempre a 1 ou sempre a 0

– vantagens• simplicidade

• traduz o comportamento (ao nível lógico) de muitas falhas físicas

• independente da tecnologia

• possibilita o tratamento matemático do teste (geração de estímulos)

• testes criados para SSF também detectam outros tipos de faltas (MSF)

– num circuito combinacional grande, o número de faltas SS é nF≈2.G.f• G = número de portas lógicas

• f = fanout médio


247

Geração de testes(faltas lógicas)

• Um vector de teste t detecta uma falta– se a saída do circuito for diferente com a falta e sem a falta

• Teste de um circuito lógico– conjunto T de vectores de teste aplicados em sequência– num circuito combinacional podem ser aplicados em qualquer ordem– detecção de uma falta

• activar a falta - forçar nesse nó um valor diferente do imposto pela falta• propagar o erro para a saída - conduzir a valores diferentes na saída

– exemplo:abc

d

00

1

1

00 0/1

0/10/1sa1


248

Detecção de faltas

• Faltas indetectáveis– não são detectadas por nenhum vector de teste– invalidam a consideração uma só falta ss@ de cada vez– todas as faltas stuck-at de um circuito não-redundante (simplificado)

são detectáveis

• Equivalência funcional– duas faltas f e g são funcionalmente equivalentes se Zf(x) = Zg(x)

• Zf(x) e Zg(x) são a resposta do circuito na presença da falta f e g– nenhum teste distingue entre duas faltas funcionalmente equivalentes– basta considerar uma falta de cada classe (equivalence fault

collapsing)

• Localização de faltas– para além de detectar, interessa saber a que classe pertence uma falta


249

Equivalência funcional e estrutural

• Equivalência funcional com o modelo SS@– determinar a equivalência entre faltas é um problema NP-completo– solução é calcular a resposta do circuito com uma e outra falta

• Equivalência estrutural– um circuito com uma SSF pode ser simplificado

• removendo todas as linhas (excepto entradas) que ficam constantes com a presença da falta

– duas faltas são estruturalmente equivalentes se os circuitos simplificados forem idênticos

– faltas estruturalmente equivalentes são funcionalmente equivalentes– equivalência estrutural pode ser determinada por uma análise local da

estrutura do circuito


250

Simulação de faltas

• Simular o circuito na presença de faltas• Avaliar a qualidade de um teste

– determinar a cobertura de faltas ( FC >= DC)

• Geração de vectores de teste– construir, modificar e avaliar testes para obter uma dada

cobertura

• Construção de diccionários de faltas– identificar faltas pelas respostas do circuito

• Análise do comportamento na presença de faltas– em que medida uma falta afecta o comportamento do circuito ?


251

Simulação de faltas• Simulação série

– o circuito é acrescentado de uma falta de cada vez e simulado– processo lento, repetido para cada falta– requer apenas um simulador lógico– possibilita a simulação de qualquer tipo de falta– é impraticável para simular um número elevado de faltas

• Simulação paralela– simulação em paralelo de N circuitos, cada um com uma falta introduzida– número de iterações (simulações) é reduzido N vezes– é mantida uma lista com os estados de cada nó na presença de cada falta.

1 0 1 0 0 1 1 1 0 1

resposta do circuito bom

para cada nó i

k ssa-1 k ssa-0 l ssa-1 l ssa-1…faltas consideradas

9 8 7 6 5 4 3 2 1 0


252

Simulação de faltas

• Deductive– simula o circuito bom e deduz o comportamento de “todos” os

circuitos faltosos (para o conjunto de faltas considerado)– em cada nó i é mantida uma lista Li das faltas observáveis nesse

nó• o valor do nó i é diferente para o circuito bom e para o circuito

faltoso• se i é uma saída primária, Li é o conjunto de faltas detectáveis em i

– operação básica para simular um elemento lógico• dados os valores das entradas sem faltas e a lista de faltas para cada

entrada, calcular a saída sem falta e a lista de faltas na saída.• simulador propaga eventos de modificação das listas de faltas


253

Simulação de faltas• Concorrente

– numa simulação de faltas, a maior parte dos valores nos circuitos faltosos Nf é igual aos do circuito bom N

– simulação concorrente: • simula o circuito bom

• para cada circuito Nf são simulados apenas os elementos que diferem de N

– durante a simulação e para cada elemento x em N (xf em Nf)• a lista Vx (Vxf) das entradas, saídas e estados internos de x (xf)

• a lista CLx representa todos os elementos xf que são diferentes de x– porque Vx ≠ Vxf : a falta f foi propagada para as entradas ou saídas de x– porque a falta f é local a xf , mesmo se Vx = Vxf (falta f não activada)

• cada entrada em CLx tem a forma (f, Vxf)


254

Geração de testes

• Geração de testes - problema complexo– custo requerido para construir e avaliar a qualidade do teste– depende da complexidade do circuito - design for testability– random test generation (RTG) - testes gerados aleatóriamente– deterministic test generation - usa um modelo do circuito

• geração manual ou automática de testes• testes gerados para uma falta específica ou sem definir qualquer falta

– qualidade do teste• número de faltas que podem ser detectadas - fault coverage (FC)• extensão do teste: para a mesma FC, quanto mais curto melhor.

– custo da aplicação do teste• tempo de aplicação do teste, tempo de processamento das respostas• requisitos de memória do testador


255

Geração automática de testes (ATG)

• Faltas SSF em circuitos combinacionais fan-out free– passos básicos para gerar uma falta l do tipo s-a-v

• definir entradas primárias que activem a falta: forçar v nesse nó• propagar o erro para uma saída primária

– para cada sinal considera-se um par de valores, com e sem a falta

– operações lógicas: processando separadamente os dois valoresD . 1 = 1/0 . 1/1 = 1.1/0.1 = 1/0 = D

– operações são consistentes com a álgebra booleana

D.D = 0, D+D = 1, D+D = D.D = D, D.D = D+D = D

v/vf0/0 01/1 11/0 D0/1 D situações de erro


256

ATG para SSF (combinacionais, fan-out free)

• Algoritmo para gerar um teste para l s-a-vset all values to x (undefined logic value)justify(l,v)if (v == 0)propagate(l,D)

elsepropagate(l,D)

justify(l,v) determina as entradas primárias que forçam v no nó l

propagate(l,D) propaga D de l para uma saída primária, determinando os valores necessários para as entradas primárias

a

b

cd

e

f s-a-0

gi

h j

inicial: justify(f,1); propagate(f,D)

justify(f,1): a=1; b=1propagate(f,D): justify(g,0); propagate(h,D)justify(g,0): c=0; d=xpropagate(h,D): justify(i,1)justify(i,1): e=0Teste para f s-a-0: 110x0


257

ATG para SSF(combinacionais, fan-out)

• Em circuitos fan-out free– problemas justify() podem ser resolvidos independentemente

• os conjuntos de entradas definidas por cada são mutuamente exclusivos

• Em circuitos com fan-out– objectivos básicos iguais: activar uma falta e propagar o erro

– activar uma falta l s-a-v consiste em justificar v em l

– propagar o erro: vários caminhos até à saída, escolher um.

– dificuldade: em geral os problemas justify não são independentes

– necessário backtracking quando são encontradas inconsistências• exploração sistemática do espaço de soluções (enumeração implícita)

– se existir, encontra um teste– se falhar, não há teste que detecte a falta considerada


258

ATG para SSF(combinacionais, fan-out)

• Algoritmo recursivo para ATGsolve()if imply_and_check() = FAILreturn FAIL

if (error at PO and all lines justified)return SUCCESS

if (no error can be propagated to a PO)return FAIL

select an unsolved problemrepeatselect one untried way to solve itif Solve() = SUCCESS

return SUCCESSuntil all ways to solve the problem have been triedreturn FAIL

imply_and_check() encontra a solução para os problemas que podem ser resolvidos por implicaçãoverifica a consistência do resultadoem circuitos fan-out free encontra a solução


259

ATG - exemplo

activar f implica justificar g1=0 justificar g1=0 implica a=b=c=1o erro pode ser propagado para f1 ou f2escolhendo f1 é necessário justificar g2=1justificar g2=1 implica d=a=0: inconsistência com a=1 para justificar g1=0backtrack: propagar a falta para f2, implica justificar g4=1justificar g4=1 implica c=1, e=0teste para f f s-a-1: abcde=111x0

abc

d

e

f s-a-1

f2

f1g2

g1

g3g4

síntese do datapathaja/psd2005_06/slides/psd_2005-06_slides19… · • multiplicação -...

Documents