Relatório Científico Parcial – PIBIC/CNPq

Relatório Científico Final
Resumo:
Este relatório trata do desenvolvimento de um circuito digital capaz de multiplicar
números binários em ponto flutuante compostos por 32 bits e representados no formato básico
de precisão simples segundo o padrão do IEEE 754. Este circuito foi desenvolvido e simulado
com o ambiente de projeto Max+Plus II da Altera, disponível no Laboratório Cientifico do
Departamento de Ciências da Computação e Estatística (DCCE) do Instituto de Biociências
Letras e Ciências Exatas (Ibilce), câmpus da Unesp de São José do Rio Preto. O circuito
resultante ocupa o equivalente a (XXX) portas lógicas e funciona a uma freqüência de
(YYY)MHz.
Índice:
Capítulo 1 – Introdução:
pg 04
Capítulo 2 – Descrição das atividades desenvolvidas:
pg 05
2.1 – Projeto do Circuito Multiplicador:
pg 05
2.2 – Módulos do circuito multiplicador:
pg 09
2.2.1 – Módulo “BIAS_C2” :
pg 09
2.2.2 – Módulo “EXP_ACRES” :
pg 10
2.2.3 – Módulo “BIT1” :
pg 10
2.2.4 – Módulo “DESLOC” :
pg 10
2.2.5 – Porta Lógica Ou – Exclusivo (“XOR2”) :
pg 10
2.2.6 – Porta Lógica Inversora (“NOT1”) :
pg 11
2.2.7 – Porta Lógica Ou (“OR2”) :
pg 11
2.2.8 - Multiplexador de 2 entradas de 8 bits cada:
pg 11
1
2.2.9 - Multiplexador de 4 entradas de 8 bits cada:
pg 13
2.2.10 - Look Ahead Carry Generator de 8 bits:
pg 13
2.2.11 - Somador completo de ponto fixo de 8 bits:
pg 16
2.2.12 - Flip Flop tipo RS:
pg 17
2.2.13 - Flip Flop tipo JK:
pg 17
2.2.14 - Flip-Flop tipo T:
pg 18
2.2.15 - Flip-Flop tipo D:
pg 19
2.2.16 - Registrador:
pg 20
2.2.17 - Registrador de Deslocamento de 4 bits:
pg 20
2.2.18 - Contador:
pg 21
2.2.19 – Módulo “Verif” :
pg XX
2.2.20 – Módulo “Multiplicando” :
pg XX
2.2.21 – Módulo “Mult_24” :
pg XX
Capítulo 3 – Análise de Resultados:
pg XX
3.1 - Resultados Obtidos:
pg XX
3.2 – Resultados Esperados:
pg XX
Conclusões:
pg XX
Referências Bibliográficas:
pg XX
Apêndice - Descrições em VHDL dos módulos
pg XX
1 - Módulo “BIAS_C2”:
pg XX
2 - Módulo “EXP_ACRES”:
pg XX
3 - Módulo “BIT1”:
pg XX
4 - Módulo “DESLOC”:
pg XX
5 - Porta Lógica Ou – Exclusivo (“XOR2”):
pg XX
6 - Porta Lógica Inversora (“NOT1”):
pg XX
7 - Porta Lógica Ou (“OR2”):
pg XX
8 - Módulo “Verif”:
pg XX
9 - Módulo “Multiplicando”:
pg XX
Lista de Figuras:
Figura 2.1.1 – Módulo “EXP”: soma dos expoentes e ajustes:
pg 05
2
Figura 2.1.2 – Determinação de overflow no cálculo dos expoentes:
pg 07
Figura 2.1.3 – Cálculo do significante resultante:
pg 08
Figura 2.1.4 - Determinação do sinal resultante:
pg 08
Figura 2.1.5 – Multiplicador de ponto flutuante:
pg 09
Figura 2.2.8 – Um multiplexador de 2 entradas:
pg 12
Figura 2.2.9 – Um multiplexador de 4 entradas:
pg 13
Figura 2.2.10.1 – Um look-ahead carry generator de 8 bits – parte 1:
pg 14
Figura 2.2.10.2 – Um look-ahead carry generator de 8 bits – parte 2:
pg 15
Figura 2.2.11 – Um somador completo de ponto fixo de 8 bits:
pg 16
Figura 2.2.12 – Um flip-flop tipo RS:
pg 17
Figura 2.2.13 – Um flip-flop tipo JK:
pg 18
Figura 2.2.14 – Um flip-flop tipo T:
pg 18
Figura 2.2.15.1 – Flip-flop tipo D a partir de um flip-flop JK:
pg 19
Figura 2.2.15.2 – Flip-flop D sensível à borda de subida:
pg 19
Figura 2.2.16 – Um registrador de 8 bits:
pg 20
Figura 2.2.17 – Um registrador de deslocamento de 4 bits:
pg 21
Figura 2.2.18 – Contador síncrono de 0 a 3:
pg 22
Figura 2.2.21.1 – Multiplicador de 24 bits:
pg XX
Figura 2.2.21.2 – Fluxograma da multiplicação binária de 24 bits:
pg XX
Figura A: Simulação do circuito multiplicador de ponto flutuante:
pg XX
Lista de Tabelas:
Tabela 2.2.5 – Comportamento da porta lógica XOR2:
pg 11
Tabela 2.2.6 – Comportamento de uma porta inversora:
pg 11
Tabela 2.2.7 – Comportamento de uma porta ou:
pg 11
Tabela 2.2.8 – Comportamento de um multiplexador de 2 entradas:
pg 12
Tabela 2.2.9 – Comportamento de um multiplexador de 4 entradas:
pg 13
Tabela 2.2.12 – Um flip-flop tipo RS:
pg 17
Tabela 2.2.13 – Um flip-flop tipo JK:
pg 18
Tabela 2.2.14 – Comportamento de um flip-flop tipo T:
pg 19
Tabela 2.2.15 – Comportamento de um flip-flop D:
pg 20
3
1 – Introdução
O objetivo deste trabalho é o desenvolvimento de um circuito digital capaz de
multiplicar números de ponto flutuante compostos por 32 bits e representados no formato
básico de precisão simples segundo o padrão do IEEE 754. O circuito multiplicador,
devidamente projetado e simulado poderá ser utilizado em um sistema digital reconfigurável.
Para tanto foi estipulado o seguinte cronograma de execução deste plano de trabalho:
•
Agosto a Outubro de 2002 - Estudo da literatura sobre projeto de circuitos aritméticos.
•
Novembro de 2002 a Janeiro de 2003 - Projeto do circuito multiplicador.
•
Fevereiro e Março de 2003 - Descrição dos módulos do multiplicador em VHDL.
•
Fevereiro de 2003 – Elaboração do relatório parcial.
•
Abril a Junho de 2003 - Simulação do circuito projetado.
•
Julho de 2003 - Elaboração do relatório final.
Este cronograma foi desenvolvido por Tiago de Oliveira até Dezembro de 2002,
quando foi substituído pelo autor deste relatório, que vem desenvolvendo o trabalho segundo
o mesmo cronograma.
Desde Novembro de 2002, o atual bolsista acompanhou as atividades do bolsista
anterior e, respeitando o seu cronograma, estudou a Linguagem de Descrição de Hardware
VHDL e aprendeu a utilizar o software Altera Max+Plus® II, para a compilação e simulação
dos circuitos.
Com isso, foram realizados a descrição dos módulos e o projeto do circuito
multiplicador, para o qual foi de extrema importância o aprendizado da caracterização de
números de ponto flutuante e o entendimento do algoritmo de multiplicação de ponto
flutuante, resumidos nos próximos 2 parágrafos.
A caracterização de números de ponto flutuante no formato básico de precisão simples
segundo o padrão do IEEE 754 se resume em um bit de sinal, um campo de 23 bits para
indicar a mantissa (significando) e outro campo de 8 bits para armazenar o expoente. Essas
informações são interpretadas da seguinte forma:
•
(-1) sinal * (significando) * 2 expoente real + bias
4
Assim, o algoritmo de multiplicação de ponto flutuante se resume em multiplicar os
significandos, somar os expoentes e verificar a ocorrência de overflow no expoente resultante.
Caso o produto dos significandos seja maior ou igual a 2, deslocá-lo uma posição para direita
e incrementar o expoente por 1. Deve ser lembrado que da soma dos expoentes, deve-se
subtrair o valor 127 referente ao bias, utilizado para normalizar o expoente.
2 – Descrição das atividades desenvolvidas:
2.1 – Projeto do Circuito Multiplicador
A figura 2.1.1 mostra como é feito o cálculo do expoente do número resultante da
multiplicação de dois números de ponto flutuante no módulo “EXP”.
Figura 2.1.1 – Módulo “EXP”: soma dos expoentes e ajustes
Para que se pudesse utilizar o mesmo somador, “ADD_8”, três vezes de forma a
economizar circuitos nesse projeto, foi de extrema importância o uso de multiplexadores, os
quais selecionam as entradas convenientes a serem somadas em ordem. Um contador síncrono
(0 a 3) externo ao módulo “EXP” controla esses multiplexadores. Quando o contador estiver
5
em 0, o multiplexador “MUX_4x8” vai selecionar “exp_A[7..0]” e o “MUX_2x8”,
“exp_B[7..0]” de forma a ser realizada a soma dos expoentes iniciais. A seguir, eles
selecionam respectivamente “BIAS[7..0]” e “EXP[7..0]” (resultado da primeira soma) de
forma que o resultado obtido sofre uma subtração de (127)10 no próprio módulo “ADD_8”
para que o expoente não receba o valor referente ao bias duas vezes. Finalmente, os
multiplexadores vão selecionar “EXP[7..0]” e “EXP_AC[7..0]”, cujo bit mais significativo é
“result_m[24]”, o bit mais significativo de “result_m[24..0]” (resultado da multiplicação dos
significandos “fracao_A[22..0]” e “fracao_B[22..0]”), e cujos outros bits têm nível lógico “0”.
Desta forma, se a multiplicação dos significantes resultar em um número maior do que 2(10), o
significante resultante, “fracao[22..0]’, é deslocado para a direita (seu valor é dividido por 2) e
o expoente é incrementado por 1 no módulo “EXP_ACRES”. Com isso, o resultado está
sempre respeitando a caracterização de números em ponto flutuante.
Para determinar a ocorrência de overflow no circuito temos de verificar dois casos:
overflow na subtração do bias e overflow na última soma que incrementa o expoente segundo
o resultado da multiplicação das mantissas.
O overflow na subtração apenas ocorre quando os valores do bit mais significativo do
resultado da subtração e do carry de saída (sinal de vai um) tiverem nível lógico distintos.
Assim, uma porta ou-exclusivo (“XOR2”) com as entradas citadas acima tem como saída, na
ocorrência de overflow, nível lógico “1”. Já o overflow na última soma é verificado quando
seu carry de saída, tiver nível lógico “1”. Assim, para determinar a ocorrência de overflow no
circuito, basta usar como entradas numa porta ou (“OR2”) os sinais de overflow citados
acima.
Como no módulo “EXP” foi utilizado o mesmo somador várias vezes, são
armazenados em registradores os valores a serem verificados para determinação de overflow.
A figura 2.1.2 destaca a determinação de overflow no módulo “EXP”, segundo o uso de tais
registradores.
6
Figura 2.1.2 – Determinação de overflow no cálculo dos expoentes
O cálculo do significante resultante da multiplicação de dois números de ponto
flutuante é ilustrado na figura 2.1.3.
Figura 2.1.3 – Cálculo do significante resultante
Os dois significantes, “fracao_A[22..0]” e “fracao_B[22..0]”, recebem em “BIT1” o
bit escondido necessário para se calcular a mantissa (significante) resultante. Após esta etapa,
ambos valores são multiplicados em “MULT_24” e o resultado é armazenado no vetor
“result_m[24..0]”. Se por acaso o bit mais significativo de “resul_m[24..0]”, o “resul_m[24]”,
tiver nível lógico “1”, o valor de “resul_m[24..0]” sofre um deslocamento para a direita (o seu
7
valor é dividido por dois) e o expoente é incrementado por 1 em “EXP_ACRES”, como já
visto anteriormente. O módulo que faz esse deslocamento é o “DESLOC” e este tem como
saída “fracao[22..0]”, o significante resultante do multiplicador de ponto flutuante. Se
“resul_m[24]” tiver nível lógico “0”, o valor de result_m[24..0] não sofrerá nenhuma
alteração em “DESLOC” e será atribuído a “fracao[23..0]”.
O módulo “EXP_ACRES”
também esconde novamente o bit escondido considerado inicialmente para a multiplicação
das mantissas.
A determinação do sinal resultante do multiplicador de ponto flutuante é muito
simples e é ilustrado na figura 2.1.4.
Figura 2.1.4 - Determinação do sinal resultante
Se ambos os sinais de entrada, “sinal_A” e “sinal_B”, tiverem o mesmo valor, o sinal
resultante, “sinal”, será positivo, o que é representado pelo nível lógico “0”. Caso contrário,
“sinal” é negativo e é representado pelo nível lógico “1”. Essa determinação é feita através de
uma porta ou-exclusivo, “XOR2”, cujas entradas são “sinal_A” e “sinal_B” e cuja saída é
“sinal”.
Finalmente, a figura 2.1.5 mostra o multiplicador de ponto flutuante com todos os
seus principais módulos reunidos.
8
Figura 2.1.5 – Multiplicador de ponto flutuante
2.2 - Descrição dos módulos do circuito multiplicador em VHDL
Os módulos de soma e subtração de ponto fixo, o módulo de multiplicação de ponto
fixo, assim como registradores e contadores foram desenvolvidos para a conclusão do projeto
em questão. Os módulos utilizados no projeto são descritos e explicados a seguir:
2.2.1 – Módulo “BIAS_C2”:
Este módulo não tem porta de entrada e a sua porta de saída é atribuído o valor
(110000001)16, o qual é o complemento de dois do valor do bias excedente, (127)10. Foi
utilizado o valor em complemento de dois para que a subtração pudesse ser feita através de
um somador, que será visto adiante.
9
2.2.2 – Módulo “EXP_ACRES”:
Este módulo é responsável em informar o valor a que somar o resultado da soma dos
expoentes, “result[7..0]”. Dependendo desse valor, o expoente poderá ser incrementado por 1.
Se “result_m[24]” tiver nível lógico “1” (resultado da multiplicação dos significantes é
maior do que 2), o módulo “EXP_ACRES retornará o valor “10000000”, o que será
somado a “result[7..0]”, resultado da soma dos expoentes, de forma a incrementar o expoente.
Caso contrário, “result[7..0]” será somado com “00000000” e não sofrerá, portanto,
nenhuma alteração, ou seja, o expoente não será incrementado.
2.2.3 – Módulo “BIT1”:
Esse módulo acrescenta o bit escondido com nível lógico “1” ao valor de
“fracao_A[22..0]” e de “fracao_B[22..0]” para que ambos sejam significantes válidos e,
assim, possam ser multiplicados. O módulo recebe um vetor de 23 bits e tem como saída um
outro vetor de 24 bits, cujo bit mais significativo apresenta nível lógico 1.
2.2.4 – Módulo “DESLOC”:
Este módulo desloca para a direita o valor de “result_m[24..0]”, resultado da
multiplicação dos significandos, caso este valor seja maior ou igual a 2. O módulo ainda
retorna o significante resultante, “fração[22..0]”, sem o bit escondido, antes acrescentado pelo
módulo “BIT1” no início do cálculo.
2.2.5 – Porta Lógica Ou – Exclusivo (“XOR2”):
Este modulo é a função lógica ‘ou exclusivo’ para duas entradas. Dadas duas entradas
binárias, a saída terá nível lógico “1” apenas se exclusivamente uma das entradas tiver nível
lógico “1”. A tabela-verdade 2.2.5 apresenta o seu comportamento.
10
Entrada A
Entrada B
Saída
0
0
0
0
1
1
1
0
1
1
1
0
Tabela 2.2.5 – Comportamento da porta lógica XOR2
2.2.6 – Porta Lógica Inversora (“NOT1”):
Este módulo é a função lógica inversora. Para toda entrada, a saída terá um nível
lógico inverso ao da entrada. A tabela-verdade 2.2.6 apresenta o seu comportamento.
Entrada
Saída
0
1
1
0
Tabela 2.2.6 – Comportamento de uma porta inversora
2.2.7 – Porta Lógica Ou (“OR2”):
Dadas duas entradas, a saída terá nível lógico “1” se pelo menos uma das entradas
também tiver o valor lógico “1”. A tabela-verdade 2.2.7 apresenta o seu comportamento.
Entrada A
Entrada B
Saída
0
0
0
0
1
1
1
0
1
1
1
1
Tabela 2.2.7 – Comportamento de uma porta ou
2.2.8 - Multiplexador de 2 entradas de 8 bits cada
A figura 2.2.8 mostra um MUX de duas entradas e uma saída, cada qual de 8 bits.
11
Figura 2.2.8 – Um multiplexador de 2 entradas
O circuito escolhe, por meio se sua variável seletora, qual dos dois vetores de bits de
entrada será atribuído à saída. A tabela-verdade 2.2.6 apresenta o seu comportamento.
Seleção
Saída (Y[7..0]
0
A[7..0]
1
B[7..0]
Tabela 2.2.8 – Comportamento de um multiplexador de 2 entradas
Caso a entrada SEL=0, a multiplexador atribuirá para a saída a entrada A[7..0]. Caso
contrário, B[7..0.]
12
2.2.9 - Multiplexador de 4 entradas de 8 bits cada
A figura 2.2.9 mostra um MUX de quatro entradas e uma saída, cada qual de 8 bits.
Figura 2.2.9 – Um multiplexador de 4 entradas
O circuito escolhe, por meio de suas duas variáveis seletoras, qual dos quatro vetores
de entrada será atribuído à saída. A tabela-verdade 2.2.9 apresenta o seu comportamento.
Seletor A
Seletor B
Saída[7..0]
0
0
E0[7..0]
0
1
E1[7..0]
1
0
E2[7..0]
1
1
E3[7..0]
Tabela 2.2.9 – Comportamento de um multiplexador de 4 entradas
O vetor E0[7..0] apenas está habilitado para a saída se A=0 e B=0. Do mesmo modo
os vetores E1[7..0], E2[7..0] e E3[7..0] se A=0 e B=1, A=1 e B=0 e A=B=1, respectivamente.
2.2.10 - Look Ahead Carry Generator de 8 bits
As figuras 2.2.10.1 e 2.2.10.2 mostram o diagrama de um look-ahead carry generator,
o qual é utilizado em um somador paralelo, que será explicado adiante.
13
Figura 2.2.10.1 – Diagrama de um look-ahead carry generator de 8 bits – parte 1
14
Figura 2.2.10.2 – Diagrama de um look-ahead carry generator de 8 bits – parte 2
Esse circuito tem a capacidade otimizar a velocidade da obtenção do resultado em um
somador, por exemplo. A expressão [1] que define o carry é dada por c(i+1)=g(i)+p(i)c(i),
onde
p(i) e g(i) são os tipos de carry propagate e generate, respectivamente, com
p(i)=x(i)⊕y(i), g(i)=x(i)y(i) (x(i) e y(i) são as parcelas da soma)
15
Para somadores com quantidades diferentes de bits, o procedimento para a construção
dos respectivos look-ahead carry generators é semelhante.
2.2.11 - Somador completo de ponto fixo de 8 bits
Este somador [1] empregou a técnica look-ahead carry generator descrita acima e faz
a soma completa de dois números de 8 bits cada. A figura 2.2.11 mostra o circuito em
questão.
Figura 2.2.11 – Um somador completo de ponto fixo de 8 bits
Os carries são propagados através do look-ahead carry generator e aplicados a
entradas de portas ou-exclusivo. Isso produz uma soma sem o atraso provocado pelo
cascateamento do sinal de carry como num somador mais simples.
16
2.2.12 - Flip Flop tipo RS
A figura 2.2.12 ilustra um flip-flop tipo RS [2], um circuito capaz de reter informações
quando a entrada do clock assumir valor 1. A tabela 2.2.12 mostra o comportamento do
circuito quando CK=1.
Figura 2.2.12 – Um flip-flop tipo RS
Entrada R Entrada S Saída
0
0
Qant
0
1
1
1
0
0
1
1
Não permitido
Tabela 2.2.12 – Comportamento de um flip-flop tipo RS
O circuito não atribui nenhuma modificação na saída se ambas entradas, S e R, forem
0. Se R=1, o flip-flop é setado e à saída Q é atribuído o valor lógico 1 e se S=1, o flip-flop é
resetado e Q=0. Para o perfeito funcionamento do circuito, deve-se evitar adotar S = R = 1,
pois tal procedimento tentaria ajustar (set) e reajustar (reset) o flip-flop ao mesmo tempo, e o
resultado seria ambíguo. Como solução a esse problema, pode-se prover terminais adicionais
nas portas de entrada e fazer ligações entre as saídas e as entradas, transformando o simples
flip-flop RS em um flip-flop tipo JK, explicado a seguir.
2.2.13 - Flip Flop tipo JK
O flip-flop JK [2] nada mais é que um flip-flop RS realimentado da maneira mostrada
na figura 2.2.13. Seu comportamento é ilustrado na tabela 2.2.13.
17
Figura 2.2.13 – Um flip-flop tipo JK
Entrada J
Entrada K Saída
0
0
Qant
0
1
1
1
0
0
1
1
(Qant)`
Tabela 2.2.13 – Comportamento de um flip-flop tipo JK
2.2.14 - Flip-Flop tipo T
Este flip-flop [2] é obtido a partir de um JK com as entradas J e K curto-circuitadas.
Logo, quando J assumir valor 1, K também assumirá valor 1, e o mesmo acontece para J=0. A
sigla T vem de “Toggle” (comutado). A figura 2.2.14 mostra a ligação citada acima e a tabela
2.2.14 ilustra seu comportamento.
Figura 2.2.14 – Um flip-flop tipo T
T
Saída
0
0
1
1
Tabela 2.2.14 – Comportamento de um flip-flop tipo T
18
2.2.15 - Flip-Flop tipo D
O Flip-Flop tipo D [2] é obtido a partir de um flip-flop JK com a entrada K invertida
(por inversor) em relação a J. Neste flip-flop, existem as seguintes entradas possíveis: J = 0 e
K = 1 ou J = 1 e K = 0. Pela capacidade de passar para a saída (Q) e armazenar o dado
aplicado na entrada D, este flip-flop foi empregado como célula de registradores do
deslocamento e outros sistemas de memória que serão vistos adiante. A sigla D vem de
“Data” (dado), termo original em inglês. A figura 2.2.15 .1 mostra como o circuito é obtido a
partir de um flip-flop tipo JK e a figura 2.2.15.2 mostra sua implementação. A tabela 2.2.15
ilustra o comportamento do circuito.
Figura 2.2.15.1 – Flip-flop tipo D a partir de um flip-flop JK
Figura 2.2.15.2 – Flip-flop D sensível à borda de subida
T
Saída
0
1
1
0
Tabela 2.2.15 – Comportamento de um flip-flop D
19
2.2.16 - Registrador
Os registradores [2] são dispositivos nos quais
se pode escrever uma "palavra"
(conjunto de números binários ou bits) e dos quais se pode ler uma palavra armazenada
quando se desejar. Os registradores são, portanto, memórias nas quais se pode escrever dados
para referência futura. Um registrador é formado por um conjunto de flip-flops conectados
entre si. Para que o registrador armazene um número binário, deverá haver para cada bit da
palavra armazenada um flip-flop que seja conectado aos demais de forma que o número
binário possa ser inserido (deslocado) no registrador e possivelmente deslocado para fora. A
figura 2.2.16 mostra como o um registrador de 8 bits é obtido.
Figura 2.2.16 – Um registrador de 8 bits
Para desenvolver um registrador de n bits, basta usar n flip-flops em vez dos quatro
usados na figura acima.
2.2.17 - Registrador de Deslocamento de 4 bits
Uma característica útil que pode ser incorporada a um registrador é a habilidade de
executar a operação de deslocamento [2]. A figura 2.2.17 ilustra um tipo de registrador de
deslocamento de quatro bits que usa flip-flops tipo D.
20
Figura 2.2.17 – Um registrador de deslocamento de 4 bits
A ligação de cada flip-flop ao anterior à esquerda é feita para que a cada transição do
relógio o estado do flip-flop anterior seja transferido ao flip-flop seguinte. O bit armazenado
no último flip-flop do registrador de deslocamento é perdido, isto é, é deslocado para o
circuito externo. É atribuída à entrada de dados uma seqüência de bits em sincronismo com o
relógio, o que implica que todos os flip-flops sejam acionados pelo mesmo sinal de relógio e
que os dados de entrada sejam alterados uma e somente uma vez por ciclo de relógio.
Para o desenvolvimento de registradores de deslocamento de n bits, basta usar n flipflops em vez dos 4 usados na figura acima.
2.2.18 - Contador
Contadores [2] são circuitos digitais que variam os seus estados, sob o comando de um
clock, de acordo com uma seqüência predeterminada. Os contadores são basicamente
constituídos de um arranjo de n flip-flops, que avança de um estado para outro em resposta a
um evento (um ciclo de um sinal de relógio, por exemplo). Em qualquer hipótese o contador
conta o número de eventos. Existem dois tipos básicos de circuitos contadores: contadores
síncronos e contadores assíncronos.
O contador síncrono, utilizado no projeto, é um contador cujos todos flip-flops
recebem o sinal do clock simultaneamente. Este circuito possui entradas clock curtocircuitadas, as quais entram em todos os flip-flops ao mesmo tempo e fazem com que todos
estes atuem de forma sincronizada. Alem disso, o contador em questão conta de 0 a 3 e
reinicia a contagem. A figura 2.2.18 mostra como o circuito é obtido.
21
Figura 2.2.18 – Contador síncrono de 0 a 3
Uma das principais características dos contadores síncronos refere-se à velocidade
pois, uma vez que todos os flip-flops são disparados ao mesmo tempo, o tempo de atraso não
é aditivo, como ocorre no contador assíncrono.
2.2.19 – Módulo “Verif”
Esse módulo faz a verificação se o contador de seqüência do módulo multiplicador já
se tornou 0. Esse procedimento é importante para determinar a conclusão do cálculo do
produto de dois números num multiplicador binário, como vai ser visto adiante.
Módulo 2.2.20 – Módulo “Multiplicando”
Este módulo determina se o multiplicando vai ser somado ou não ao produto parcial
do multiplicador. A soma apenas acontece quando o bit menos significativo do multiplicador
tem valor 1.
2.2.21 – Módulo “Mult_24”
O multiplicando está no registrador “B” (24 bits) e multiplicador no registrador “Q”
(24 bits). Os registradores A (24 bits) e E (1 bit) são utilizados, respectivamente, para
armazenar a parcela mais significativa do resultado da multiplicação e para armazenar o carry
de saída. Para armazenar a parcela menos significativa do produto será utilizado mais uma vez
22
o registrador “Q” e para determinar a quantidade de somas parciais do multiplicador será
usado o contador de seqüência “SC”. A figura 2.2.21.1 a seguir ilustra essa configuração.
Figura 2.2.21.1 – Multiplicador de 24 bits
Inicialmente, “A” e “E” são resetados e ao contador de seqüência “SC” atribui-se o
valor 24(10)=11000(2) (quantidade de bits do multiplicador). Assume-se que os operandos são
transferidos através de uma unidade de memória de 24 bits.
Após essa inicialização, o bit menos significativo do multiplicador “Q” é testado. Se
seu valor for 1, o multiplicando em “B” é adicionado ao atual produto em “A”. Mas se o seu
valor for 0, nada é feito. O registrador “EAQ” é, então, deslocado uma vez para direita para
formar o novo produto parcial. O contador de seqüência é decrementado de 1 e seu novo valor
é checado. Se este valor não for 0, o processo é repetido e um novo produto parcial é formado.
O processo pára quando “SC” = 0. Nota-se que o produto parcial formado em “A” é
deslocado para “Q” um bit por vez .
O produto final fica disponível nos registradores “A” e “Q”, sendo que “A” detém os
bits mais significativos e “Q”, os menos significativos. Além disso, em “E” fica disponível o
carry de saída. Como cada operando tem 24 bits, o resultado final da multiplicação terá 48
bits.
A figura 2.2.21.2 apresenta um fluxograma que ilustra esse comportamento.
23
Figura 2.2.21.2 – Fluxograma da multiplicação binária de 24 bits
3 – Análise de Resultados:
O projeto descrito acima foi compilado no Altera Max+Plus® II sem notificação de
erros. O compilador do software primeiro extrai informações que definem as conexões
hierárquicas entres os arquivos de design do projeto, para que então seja feita uma checagem
por erros. Depois de criar um mapa organizacional para o projeto, ele combina todos os
arquivos de design em um banco de dados para realizar processamentos, como simulação, por
exemplo.
3.1 - Resultados Obtidos:
Desde Julho desse ano, o atual bolsista realizou, além de estudos a respeito de
circuitos aritméticos, várias modificações ao projeto de forma que o mesmo foi quase que
totalmente alterado. Foram desenvolvidos vários circuitos de extrema importância para o
24
projeto, como registradores de armazenamento, registradores de deslocamento, registradores
de armazenamento e deslocamento, contadores síncronos e multiplexadores.
Com intuito de economizar o número de circuitos utilizados no projeto, foi
desenvolvido, através da técnica look ahead carry generator, um somador de ponto fixo de 8
bits, o qual tem saída realimentada, o que permite a economia de circuitos durante o cálculo
do expoente. Multiplexadores, controlados por um contador síncrono, são encarregados de
determinar as entradas convenientes ao somador de ponto fixo em cada momento diferente do
processo do cálculo do expoente final e registradores são empregados com o intuito de
armazenar valores importantes para a verificação de ocorrência de overflow nesse mesmo
cálculo.
Por fim, foi criado um multiplicador de ponto fixo de 24 bits para o cálculo do
significante resultante, o qual utiliza um somador de ponto fixo de 24 bits e também foi
desenvolvido de forma a utilizar a menor quantidade possível de circuitos.
Após algumas simulações, pode-se concluir da análise dos resultados que os
procedimentos de verificação do sinal resultante e o cálculo do expoente resultante estão
corretos. A figura A, ilustra esta análise.
Figura A: Simulação do circuito multiplicador de ponto flutuante.
Neste exemplo, os sinais dos números multiplicando (“sinal_A”) e multiplicador
(“sinal_b”) são positivos, o que resulta num outro sinal positivo após a multiplicação. Além
disso, “exp_A[7..0]” assume o valor (01111111)2 e “exp_B[7..0]”, (00000000)2. Como ambos
25
expoentes recebem o valor do bias, o resultado da soma dos expoentes, “exp[7..0]”, é
calculado da seguinte forma:
[(01111111)2 - (127)10] + [(00000000)2 - (127)10] = [(01111111)2 - (127)10].
“exp[7..0]” é ilustrado com o valor (00000000)2 pois também recebe o valor do bias.
O cálculo do significante ainda não está perfeito, pois o multiplicador de ponto fixo
ainda apresenta algumas falhas e necessita de correções, o que compromete a verificação da
ocorrência de overflow.
3.2 – Resultados Esperados:
Espera-se que o circuito multiplicador apresentado nesse relatório esteja otimizado o
suficiente para que o mesmo possa ser inserido em um sistema digital reconfigurável, como
foi dito na introdução deste relatório.
Conclusões:
Não obstante um menor tempo atribuído ao atual bolsista para realizar tanto o estudo
da literatura sobre projeto de circuitos aritméticos, quanto o projeto do circuito multiplicador,
a descrição dos módulos do multiplicador em VHDL, a simulação do circuito projetado e a
elaboração de relatórios, e, embora o mesmo ainda não tivesse realizado a disciplina
“Arquitetura e Organização de Computadores” quando assumiu o projeto, pode-se concluir
que o projeto procedeu satisfatoriamente: o atual bolsista fixou conceitos já antes estudados a
cerca de circuitos eletrônicos, aprendeu novas técnicas para o desenvolvimento de circuitos
aritméticos, familiarizou-se com a linguagem de descrição de hardware VHDL e aprendeu a
lidar com um novo ambiente de projeto, o Max+Plus II da Altera.
O aluno de graduação fica muito satisfeito com a conclusão do projeto e ansioso para
o desenvolvimento de novos projetos semelhantes. Como sugestão para trabalhos futuros,
recomenda-se incluir métodos de tratamento de overflow e correções ao cálculo do
significando resultantes. Além disso, seria muito interessante modificar o projeto do
multiplicador de ponto flutuante de modo a operar por processamento pipeline, buscando com
isso, significativo aumento na velocidade de processamento.
26
Referências Bibliográficas:
[1] – M. M. Mano Digital Design, second edition, Prentice Hall, 516 páginas, 1991
[2] – H. Taub Circuitos Digitais e Microprocessadores, McGraw-Hill
Apêndice - Códigos em VHDL dos módulos usados no projeto:
1 - Módulo “BIAS_C2”:
entity bias_C2 is
port( data_out: out bit_vector(8 downto 0));
end bias_C2;
architecture structural of bias_C2 is
begin
data_out <= "110000001";
end structural;
2 - Módulo “EXP_ACRES”:
entity exp_acres is
port(
data_in: in bit;
data_out: out bit_vector(7 downto 0));
end exp_acres;
architecture structural of exp_acres is
begin
data_out(6 downto 0) <= "0000000";
27
data_out(7) <= data_in; -- valor de result_m[24]
end structural;
3 - Módulo “BIT1”:
entity bit1 is
port(
data_in: in bit_vector(22 downto 0);
data_out: out bit_vector(23 downto 0));
end bit1;
architecture structural of bit1 is
begin
data_out(22 downto 0) <= data_in;
data_out(23) <= '1'; -- bit escondido
end structural;
4 - Módulo “DESLOC”:
entity desloc is
port( data_in: in bit_vector(24 downto 0);
data_out: out bit_vector(22 downto 0));
end desloc;
architecture behavior of desloc is
begin
process(data_in)
28
begin
if( data_in(24) = '1') then
for i in 0 to 22 loop
data_out(i)<= data_in(i + 1); -- desloca-- mento
end loop;
else
data_out <= data_in(22 downto 0);
end if;
end process;
end behavior;
5 - Porta Lógica Ou – Exclusivo (“XOR2”):
entity xor2 is PORT(
a,b: in bit;
c: out bit
);
29
end xor2;
architecture dataflow of xor2 is
begin
c <= a xor b;
end dataflow;
6 - Porta Lógica Inversora (“NOT1”):
entity not1 is port(
a: in bit;
b: out bit
);
end not1;
architecture dataflow of not1 is
begin
b <= not a;
end dataflow;
7 - Porta Lógica Ou (“OR2”):
entity or2 is port(
30
a, b: in bit;
c: out bit
);
end or2;
architecture dataflow of or2 is
begin
c <= a or b;
end dataflow;
8 - Módulo “Verif”
entity verif is
port( data_in: in bit_vector(4 downto 0);
data_out: out bit);
end verif;
architecture behavior of verif is
begin
process(data_in)
begin
31
if( data_in(4) = '0' AND data_in(3) = '0' AND
data_in(2) = '0' AND
data_in(1) = '0' AND data_in(0) = '0') then
data_out<= '1';
else
data_out<= '0';
end if;
end process;
end behavior;
9 - Módulo “Multiplicando”
entity multiplicando is
port( data_in1: in bit_vector(23 downto 0);
data_in2: in bit;
data_out: out bit_vector(23 downto 0));
end multiplicando;
architecture behavior of multiplicando is
begin
process(data_in1)
begin
32
if( data_in2 = '0') then
data_out(23 downto 0) <=
"000000000000000000000000";
else
data_out(23 downto 0) <= data_in1(23
downto 0) ;
end if;
end process;
end behavior;
33