SANI CARDOSO MIYAI SCHIMITH

MODELAGEM DE UMA UNIDADE DE DIVISÃO EMPONTO FLUTUANTE

LONDRINA–PR

2014

SANI CARDOSO MIYAI SCHIMITH

MODELAGEM DE UMA UNIDADE DE DIVISÃO EMPONTO FLUTUANTE

Trabalho de Conclusão de Curso apresentadoao curso de Bacharelado em Ciência da Com-putação da Universidade Estadual de Lon-drina para obtenção do título de Bacharel emCiência da Computação.

Orientador: Prof. Dr. Wesley Attrot

LONDRINA–PR

2014

Sani Cardoso Miyai SchimithModelagem de uma Unidade de Divisão em Ponto Flutuante/ Sani Cardoso

Miyai Schimith. – Londrina–PR, 2014-62 p. : il. (algumas color.) ; 30 cm.

Orientador: Prof. Dr. Wesley Attrot

– Universidade Estadual de Londrina, 2014.

1. Divisão. 2. Ponto Flutuante. I. Prof. Dr. Wesley Attrot. II. UniversidadeEstadual de Londrina. III. Modelagem de uma Unidade de Divisão em PontoFlutuante

SANI CARDOSO MIYAI SCHIMITH

MODELAGEM DE UMA UNIDADE DE DIVISÃO EMPONTO FLUTUANTE

Trabalho de Conclusão de Curso apresentadoao curso de Bacharelado em Ciência da Com-putação da Universidade Estadual de Lon-drina para obtenção do título de Bacharel emCiência da Computação.

BANCA EXAMINADORA

Prof. Dr. Wesley AttrotUniversidade Estadual de Londrina

Orientador

Prof. Ms. Elieser Botelho Manhas Jr.Universidade Estadual de Londrina

Prof. Ms. Fábio Cezar MartinsUniversidade Estadual de Londrina

Londrina–PR, 19 de Novembro de 2014

Para Silas, André, Caroline e Lucas, minha família

AGRADECIMENTOS

Agradeço primeiramente à Deus pelo folego de vida concedido à mim e à minhafamília. Agradeço a minha família pelo apoio para que esses anos de estudos fossempossíveis.

Agradeço a todos Professores do Departamento de Computação pela paciência epelo carinho para comigo. Em especial, agradeço ao Professor Wesley Attrot pela paciênciae pelas orientações no decorrer desse trabalho.

Não poderia deixar de agradecer aos funcionários do departamento pela colabora-ção dispendida para com os alunos ao longo desses anos.

Agradeço à todos meus amigos de graduação que fizeram parte da minha históriadurante esses anos de estudos.

“Ainda que os montes se movam do lugare a terra não mais produzir.

E tudo, no mundo, pareça falhar,os fiéis vão a Cristo seguir.

Haja paz desde os céus,haja paz sobre o povo de Deus.“

(Hinos de Louvores e Suplica a Deus, 375 - segunda estrofe)

SCHIMITH, S. C. M.. Modelagem de uma Unidade de Divisão em Ponto Flutu-ante. 62 p. Trabalho de Conclusão de Curso (Bacharelado em Ciência da Computação) –Universidade Estadual de Londrina, Londrina–PR, 2014.

RESUMO

A proposta desse trabalho é elaborar e desenvolver um projeto de hardware de umaunidade de divisão para números em ponto flutuante para uma arquitetura de processadorde 32 bits. Tal projeto é parte integrante da elaboração de uma CPU RISC baseadona arquitetura MIPS que servirá para pesquisa e de desenvolvimento de otimizações dehardware e de software. O algoritmo que será desenvolvido deverá observar as normas epadrões estabelecidos pelo IEEE-754 [1] que são convencionados à maioria dos hardwaresexistentes no mercado. Sua implementação será feita na linguagem VHDL [2].

Palavras-chave: ponto flutuante, divisão, VHDL, IEEE-754

SCHIMITH, S. C. M.. Project Implementation Elaboration Development. 62 p.Final Project (Bachelor of Science in Computer Science) – State University of Londrina,Londrina–PR, 2014.

ABSTRACT

The purpose of this work is to develop a unit of hardware for floating point division usinga 32 bits processor architecture. This unit, part of the elaboration of a RISC CPU basedon MIPS architecture, will be used for research and development of hardware and softwareoptimization. The proposed algorithm will comply with IEEE-754 [1] norms, adopted bythe majority of market hardwares. This project was implemented using VHDL [2].

Keywords: floating point, division, VHDL, IEEE-754

LISTA DE ILUSTRAÇÕES

Figura 1 – Fluxograma da Primeira Parte do algoritmo SRT . . . . . . . . . . . . 30Figura 2 – Ajuste de 𝑄 no Padrão IEEE . . . . . . . . . . . . . . . . . . . . . . . 31Figura 3 – Fluxograma Newton-Raphson . . . . . . . . . . . . . . . . . . . . . . . 34Figura 4 – Fluxograma Goldschmidt . . . . . . . . . . . . . . . . . . . . . . . . . 38Figura 5 – Diagrama do Projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46Figura 6 – Diagrama do Circuito Somador . . . . . . . . . . . . . . . . . . . . . . 48Figura 7 – Diagrama do Circuito Subtrator . . . . . . . . . . . . . . . . . . . . . . 49Figura 8 – Diagrama do Circuito Complemento de Dois . . . . . . . . . . . . . . . 50Figura 9 – Diagrama do Circuito Multiplicador . . . . . . . . . . . . . . . . . . . 51Figura 10 – Etapas de um projeto [2] . . . . . . . . . . . . . . . . . . . . . . . . . . 54

LISTA DE TABELAS

Tabela 1 – Representação de Valores Especiais . . . . . . . . . . . . . . . . . . . . 25Tabela 2 – Precisão simples - 32 bits (𝑛 = 24) . . . . . . . . . . . . . . . . . . . . 28Tabela 3 – Precisão dupla - 64 bits (𝑛 = 56). . . . . . . . . . . . . . . . . . . . . . 28Tabela 4 – Buscando o valor 1

𝑏usando quatro dígitos decimais. . . . . . . . . . . . 33

Tabela 5 – Ilustração numérica do algoritmo de Goldschimidt. . . . . . . . . . . . 37Tabela 6 – Ilustração numérica do algoritmo SRT modificado. . . . . . . . . . . . 41Tabela 7 – Ilustração da latência produzida pelo SRT de acordo com o radix uti-

lizado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Tabela 8 – Sumário dos Algoritmos. . . . . . . . . . . . . . . . . . . . . . . . . . . 42Tabela 9 – Latências em Configurações Diferentes. . . . . . . . . . . . . . . . . . . 43Tabela 10 – Quantidades de instruções. . . . . . . . . . . . . . . . . . . . . . . . . 57Tabela 11 – Resultados obtidos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

SUMÁRIO

1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 Norma IEEE-754 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.1 Representação Numérica em Ponto Flutuante . . . . . . . . . . . . . . . 232.2 Arredondamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.3 Overflow e Underflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.4 Representações de Infinitos, NaN (Not a Number) e Zero . . . . . . . . . 25

3 Algoritmos de Divisão . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.1 Algoritmos de Dígitos Recorrentes . . . . . . . . . . . . . . . . . . . . . . 273.2 Iterações Funcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.2.1 Algoritmo Newton-Raphson . . . . . . . . . . . . . . . . . . . . . 313.2.2 Algoritmo Goldschmidt . . . . . . . . . . . . . . . . . . . . . . . . 34

3.3 Algoritmo Utilizando Radix Alto . . . . . . . . . . . . . . . . . . . . . . 393.3.1 SRT com Radix Alto . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.4 Comparação Entre os Algoritmos . . . . . . . . . . . . . . . . . . . . . . 414 Descrição do Projeto da Unidade de Divisão em Ponto Flutuante . . 45

4.1 Somador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.2 Subtrator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.3 Complemento de Dois . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.4 Multiplicador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504.5 Comparador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

5 Implementação da Unidade de Divisão em Pontos Flutuantes . . . . . 535.1 VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535.2 Implementação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6 Resultados Experimentais . . . . . . . . . . . . . . . . . . . . . . . . . . 577 Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

7.1 Sugestões Para Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . 59Referências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

21

1 INTRODUÇÃO

Com a crescente demanda de aplicações e as suas mais complexas funcionalidades,fez-se necessário criar hardwares e softwares mais sofisticados para a realização de tra-balhos mais específicos [3]. Assim surgiram as Unidades de Ponto Flutuants (FPU), querepresentam os números em ponto flutuante de acordo com o padrão IEEE-754 [1] quesurgiu para definir uma representação unificada de números em ponto flutuante que faci-litasse a portabilidade de programas entre processadores, e foi adotado a partir de 1985pelos fabricantes de hardwares. Essas Unidades de Ponto Flutuante são consideradas co-processadores capazes de processar e solucionar problemas algébricos envolvendo númerosreais em menos ciclos do que uma Unidade Lógica Aritmética. Com isso, o processadorfica disponível para ser utilizado para outros processos em paralelo com a FPU.

No começo dessa nova arquitetura, não foi dada muita atenção para a divisão emponto flutuante [4], pois a maioria dos problemas envolvendo álgebra de ponto flutuanteera resolvida através de somas e multiplicações. Na realidade, a divisão era emulada emuma arquitetura de ponto fixo através de um software que simulava as operações e oresultado obtido era aproximado utilizando funções elementares 1 [6].

Com isso, a taxa de latência dos divisores tem sido muito maior que a dos de-mais operadores e o desempenho de muitas aplicações que necessitam especificamentede divisões fica abaixo do possível. Por isso faz-se necessário uma atenção à unidade dedivisão entre números em ponto flutuante principalmente quando se utilizam aplicaçõesde engenharia e de âmbito científico [7].

De acordo com Oberman e Flynn [8] os algoritmos de divisão são classificados emcinco classes: dígitos recorrentes, iterações de funções, altas bases numéricas, observaçãode tabelas e latências variáveis. Dependendo do que a aplicação necessitar (alto desempe-nho por exemplo), utiliza-se uma combinação dessas classes para desenvolver o algoritmofinal que melhor atenda o requisito especificado.

Para Assoni, [9] a classe mais antiga de algoritmos de divisão é a classe de dígitosrecorrentes e, com isso, existem muitas literaturas propondo técnicas sobre essa classe.O algoritmo SRT é um algoritmo pertencente a essa classe mais comum nos processa-dores atuais e a sua sigla está relacionada aos nomes Sweeney, Robertson e Tocher, quedesenvolveram, ao mesmo tempo, a mesma técnica independentemente [10].

Dentre as classes definidas acima, será descrita a classe de dígito recorrente (SRT)

1 Os principais métodos de aproximação são: métodos utilizando tabelas que contêm valores previa-mente calculados, métodos iterativos que repetem o processo de cálculo até que uma determinadacondição seja satisfatória, método de aproximações por polinômios e métodos híbridos unindo asmelhores características dos métodos [5].

22

e a de iterações funcionais (Newton-Raphson e Goldschmidt) para melhor entendimentodo funcionamento desses algoritmos.

Esse trabalho foi estruturado como segue: o Capítulo 2 apresenta uma breve des-crição da representação numérica de números em ponto flutuante especificada pelo PadrãoIEEE - 754. O Capítulo 3 consiste em uma revisão de alguns algoritmos utilizados emhardwares de divisão de números em ponto flutuante encontrados em trabalhos semelhan-tes à este e uma comparação entre tais algoritmos. Em seguida, o Capítulo 4 é destinado àdescrição do projeto realizado. O Capítulo 5 descreve a implementação do Projeto da Uni-dade de Divisão de Números em Ponto Flutuante, e o Capítulo 6 apresenta os resultadosobtidos e sugestões para trabalhos futuros.

23

2 NORMA IEEE-754

Na década de 1970, um grupo de cientistas e engenheiros reuniu-se para fazer umestudo de modo a padronizar a representação numérica que fosse adotada pelos fabricantesde hardwares e desenvolvedores de softwares, devido a necessidade de portabilidade dosprogramas para diferentes máquinas [11].

A partir de 1985, os fabricantes de hardwares adotaram o Padrão IEEE-754 [1].Esse padrão definiu um armazenamento unificado para representar números binários emponto flutuante, facilitando, assim, a portabilidade almejada. Além dessa representação,esse padrão também define métodos de arredondamento, ocorrências de underflow e over-flow e, também, a representação de NaN (Not a Number) [11].

2.1 Representação Numérica em Ponto Flutuante

Para entender como é essa representação, o exemplo a seguir será dado com númerodecimal. A representação consiste em um deslocamento da vírgula obtendo um númerono intervalo [1 : 2) (valor fracionário ou mantissa), multiplicado pela base 10 elevado aoexpoente correspondente ao número de deslocamento que a vírgula se moveu (notação ci-entífica). Como os processadores trabalham com números binários, a base 10 é substituídapor 2. Além disso, é necessário utilizar um bit de sinal para determinar se o número épositivo ou negativo. Sendo assim, a fórmula representativa do número em ponto flutuanteé dada por:

(−1)𝑠𝑖𝑛𝑎𝑙 × 2𝑒𝑥𝑝𝑜𝑒𝑛𝑡𝑒 × 𝑚𝑎𝑛𝑡𝑖𝑠𝑠𝑎

O padrão também define dois tipos de precisão sendo uma simples para 32 bitse uma dupla para 64 bits e ambas podem ser estendidas. A precisão simples utiliza 1bit para o sinal, 8 bits para o expoente e 23 bits para a mantissa. Já a precisão dupla éformada por 1 bit para o sinal, 11 bits para o expoente e 52 bits para a mantissa [1].

Antes de ser convencionado, era necessário separar um bit para o sinal do expo-ente. Com o padrão IEEE-754, o expoente é armazenado com a notação de peso (biasednotation): para a precisão simples soma-se 127 no expoente e para precisão dupla 1023 [1].Em outras palavras, expoente abaixo de 127 para precisão simples ou 1023 para precisãodupla serão negativos. Exemplo:

𝑒𝑥𝑝𝑜𝑒𝑛𝑡𝑒 = −310 ⇒ −310 + 12710 = 12410 = 011111002

A mantissa é armazenada da esquerda para direita sendo que o primeiro e únicodígito antes da vírgula deve ser 1. Sendo assim, esse dígito fica subentendido e não tem

24

necessidade de ser armazenado. A forma genérica para precisão simples é representada aseguir (lembrando que foi somado 127 no expoente armazenado):

(−1)𝑠𝑖𝑛𝑎𝑙 × 2(𝑒𝑥𝑝𝑜𝑒𝑛𝑡𝑒−127) × (1 + 𝑚𝑎𝑛𝑡𝑖𝑠𝑠𝑎)

O mesmo é válido para precisão dupla sendo que em biased notation tem o valorde 1023.

O número 0 tem uma representação de conjunto de bits especiais designados paratal propósito, que será mostrado em uma tabela juntamente com os valores especiais.

2.2 Arredondamentos

Devido à limitação na representação numérica de ponto flutuante, a aritméticaenvolvendo tais números pode produzir um resultado não exato fazendo com que sejanecessária a utilização de métodos de arredondamento para obter um valor mais preciso[12].

A Norma IEEE-754 [1] prevê quatro tipos de arredondamento:

∙ Arredondamento para o mais próximo - É o método considerado default pelo padrãoIEEE-754. O arredondamento é feito para o valor representável mais próximo doresultado obtido.

∙ Arredondamento em direção a 0 - Simplesmente é feito o truncamento do número,ou seja, os bits em excesso são desconsiderados.

∙ Arredondamento para +∞ - O resultado é arredondado na direção de +∞, ou seja,arredondado para cima.

∙ Arredondamento para −∞ - O resultado é arredondado na direção de −∞, ou seja,arredondado para baixo.

2.3 Overflow e Underflow

A limitação imposta pela faixa do expoente pode ocasionar overflow ou underflow.

Overflow ocorre quando o expoente calculado excede o valor máximo do expoentepermitido e determinado pelo limite do expoente. Geralmente deve-se tratar o overflowcomo erro e abortar a operação.

Underflow é o contrário de overflow, que ocorre quando o expoente calculado émenor que o expoente mínimo determinado pelo limite do expoente e o expoente calculadoé considerado igual a 0. Nesse caso o resultado geralmente é invalidado e o underflow éconsiderado destrutivo.

25

2.4 Representações de Infinitos, NaN (Not a Number) e Zero

Os valores especiais tais como +∞, −∞ e NaN (Not a Number), que são valoresreservados para aritmética em máquinas e operações inválidas que resultam em NaNs, sãoconvencionados em formato especificado pela documentação do IEEE-754 [1].

Infinitos, positivo ou negativo, têm uma representação específica determinada pelopadrão IEEE-754. Já o NaN (Not a Number) é uma entidade simbólica proveniente deoperações inválidas como, por exemplo,

√−1

O NaN pode ser:

∙ Sinalizador, no qual gera uma exceção de operação inválida;

∙ Silencioso que, por sua vez, se propaga por quase toda a operação sem gerar umindicativo de erro.

A Tabela 1 mostra a definição determinada pelo Padrão IEEE-754 [1] para essesvalores especiais.

Tipo sinal expoente mantissa valorzero + 0 0 0 0zero - 1 0 0 -0

infinito + 0 255 0 +∞infinito - 0 255 0 −∞

NaN 0 ou 1 255 ̸= 0 NaN

Tabela 1 – Representação de Valores Especiais

27

3 ALGORITMOS DE DIVISÃO

Neste capítulo serão descritas as principais características e os fluxogramas dealgumas classes dos algoritmos que mais se destacam com o propósito de resolver umadivisão de números em ponto flutuante.

3.1 Algoritmos de Dígitos Recorrentes

Dentre os algoritmos pertencentes à classe de dígitos recorrentes, destaca-se oalgoritmo SRT que é muito utilizado atualmente pelos desenvolvedores de hardware.

De acordo com Muller [13], esse algoritmo remete à divisão feita utilizando lápis epapel aprendido nos primeiros anos escolares. Cada iteração realiza três tarefas básicas:

∙ Determina o próximo dígito no quociente;

∙ Multiplica-o pelo divisor;

∙ Subtrai o resultado obtido na tarefa anterior do dividendo ou do remanescente dasubtração anterior.

Nessa técnica, adota-se o padrão de representação numérica descrita no IEEE-754 [1] e, para facilitar os cálculos, o divisor é normalizado para o intervalo de [0, 5; 1)tornando, assim, o divisor menor que o dividendo. O quociente é definido como sendo𝑘 𝑟𝑎𝑑𝑖𝑥 − 𝑟 dígitos utilizando as equações:

𝑟 = 2𝑏

𝑘 = 𝑛/𝑏

sendo que 𝑛 = mantissa + bit de sinal e 𝑏 = número de bits obtidos do quociente a cadaiteração (se o quociente for obtido bit a bit, 𝑏 = 1) [14].

Sendo assim, um algoritmo de divisão que obtém 𝑏 bits do quociente a cada iteraçãoé chamado de 𝑟𝑎𝑑𝑖𝑥 − 𝑟 e requer 𝑘 iterações para computar o resultado final de 𝑛 bitstendo uma latência de 𝑘 ciclos. Cada ciclo é definido pelo tempo máximo gasto em cadaiteração e, nem sempre, esse tempo é o mesmo do ciclo do processador [14]. Para ummelhor entendimento das coligações dessas equações, é observada, nas Tabelas 2 e 3, adependência da variável 𝑏 na quantidade de iterações.

28

𝑏 𝑘 𝑟 𝑘 𝑟𝑎𝑑𝑖𝑥 − 𝑟

1 24 2 24 radix-22 12 4 12 radix-43 8 8 8 radix-84 6 16 6 radix-16

· · · · · · · · · · · ·

Tabela 2 – Precisão simples - 32 bits (𝑛 = 24)

𝑏 𝑘 𝑟 𝑘 𝑟𝑎𝑑𝑖𝑥 − 𝑟

1 56 2 56 radix-22 28 4 28 radix-43 ⌈18, 667⌉ 8 ⌈18, 667⌉ radix-84 14 16 14 radix-16

· · · · · · · · · · · ·

Tabela 3 – Precisão dupla - 64 bits (𝑛 = 56).

A recorrência em cada iteração é dada por:⎧⎨⎩ 𝑟 * 𝑃0 = 𝑑𝑖𝑣𝑖𝑑𝑒𝑛𝑑𝑜

𝑃𝑗+1 = 𝑟 * 𝑃𝑗 − 𝑞𝑗+1 * 𝑑𝑖𝑣𝑖𝑠𝑜𝑟

no qual 𝑃𝑗 é o resto parcial ou residual da iteração anterior e 𝑞𝑗 é o dígito do quocienteque se encontra na posição 𝑗. É necessário observar o valor do resíduo da última iteração,pois:

𝑃𝑛 =

⎧⎨⎩ 𝑃𝑛 se 𝑃𝑛 ≥ 0;𝑃𝑛 + 𝑑𝑖𝑣𝑖𝑠𝑜𝑟 se 𝑃𝑛 < 0.

Caso a última iteração seja 𝑃𝑛 < 0, é necessário ajustar o quociente subtraindo 1ulp1 que é dado por 𝑟−𝑘.

Por fim, o quociente é obtido através de:

𝑄 =𝑘∑︁

𝑗=1𝑞𝑗𝑟

−𝑗

ou seja:

𝑄 = 𝑞1 * 𝑟−1 + 𝑞2 * 𝑟−2 + 𝑞3 * 𝑟−3 + · · · + 𝑞(𝑘) * 𝑟−𝑘

Dado 𝑄 = 𝑎/𝑏, a Figura 1 mostra o fluxograma relacionado à primeira parte doalgoritmo SRT, o qual verifica se os números em questão são iguais a zero e, após essa

1 ulp é a abreviação de Units in the Last Place, unidade utilizada para medir o erro cometido peloarredondamento [9].

29

verificação, começa a execução do algoritmo em si , sendo que :⎧⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎩

𝐷𝑎 = recebe os dígitos de 𝑎 com exceção do último dígito;𝐷𝑏 = recebe os dígitos de 𝑏;𝑐𝑜𝑛𝑡 = contador de dígitos;𝑄 = 𝑛𝑢𝑙𝑙;𝑒𝑓 = 0 (expoente final);𝑒𝑎 = recebe expoente de 𝑎;𝑒𝑏 = recebe expoente de 𝑏;𝑃 = restos parciais.

30

a==0 Q=0

b==0 ERRO ef=128

concatena:Da="1"aDb="1"beb=eb+1

ef=0cont=0

retorno:sinal a,128,0

concatena:Da=Da"0"

início:Da>=Db ef++

Da>=Dbconcatena:Q=Q"1"

P=Da-Db

Q=Q"0"concatena:

P=P"0"Da=P

P=0

cont<qtdde dígitossignifica-

tivos

cont++

próximopasso

sim

não

sim

não

nãosim

sim

não

não

sim

sim

não

Figura 1 – Fluxograma da Primeira Parte do algoritmo SRT

31

No próximo passo mostrado na Figura 2, são feitos os ajustes da mantissa e expo-ente de acordo com o padrão IEEE-754:

ef=ef+127+(ea-eb)

verifica bitde sinal

de a e b eretorna bit

de sinal de Q

ajustar Q nopadrão IEEE(mantissa eexpoente)

retorno:sinal deQ, ef, Qajustado

Figura 2 – Ajuste de 𝑄 no Padrão IEEE

3.2 Iterações Funcionais

Os algoritmos de iterações funcionais utilizam a operação inversa dos dígitos re-correntes. Tais algoritmos beneficiam-se das convergências de séries matemáticas. Dentreeles se destacam o algoritmo Newton-Raphson [15] que utiliza a série de Taylor [16] e oalgoritmo Goldschmidt [17] que se beneficia da convergência da série de Maclaurin [8].

3.2.1 Algoritmo Newton-Raphson

Para Oberman [8], a divisão utilizando iterações de função utiliza a multiplicaçãocomo sua principal operação. Em linhas gerais, no algoritmo Newton-Raphson a divisão𝑄 = 𝑎

𝑏é transformada em 𝑄 = 𝑎 * 1

𝑏, beneficiando-se do uso de multiplicadores de

alta velocidade e convergindo, assim, para o resultado final. Para obter 1𝑏, o algoritmo

determina uma função inicial que tenha uma raiz em 1𝑏

que é a dada por

𝑓(𝑥) = 1𝑥𝑖

− 𝑏 = 0 (3.1)

.

De acordo com DeVries [18], o método de Newton-Raphson é desenvolvido atravésda série de Taylor e (𝑥 − 𝑥0) é considerado um número muito pequeno. Devido a isso,são considerados apenas os dois primeiros termos da série e, igualando a 0, a equação ficaassim:

𝑓(𝑥) ≈ 𝑓(𝑥0) + (𝑥 − 𝑥0) * 𝑓 ′(𝑥0) = 0 (3.2)

32

Manipulando a equação 3.2 tem-se:

(𝑥 − 𝑥0) * 𝑓 ′(𝑥0) = −𝑓(𝑥0)𝑥 − 𝑥0 = − 𝑓(𝑥0)𝑓 ′(𝑥0)

𝑥 = 𝑥0 − 𝑓(𝑥0)𝑓 ′(𝑥0)

(3.3)

Aplicando indução na equação 3.3, obtém-se uma equação genérica para qualquervalor 𝑖:

𝑥𝑖+1 = 𝑥𝑖 − 𝑓(𝑥𝑖)𝑓 ′(𝑥𝑖)

(3.4)

Substituindo a equação 3.1 na 3.4 obtém-se:

𝑥𝑖+1 = 𝑥𝑖 −1𝑥𝑖

− 𝑏

𝑓 ′(𝑥𝑖)

𝑥𝑖+1 = 𝑥𝑖 −1𝑥𝑖

− 𝑏−1𝑥2

𝑖

𝑥𝑖+1 = 𝑥𝑖 −(︃

1𝑥𝑖

− 𝑏 * −𝑥2𝑖

1

)︃

𝑥𝑖+1 = 𝑥𝑖 −(︃

−𝑥2𝑖

𝑥𝑖

+ 𝑏𝑥2𝑖

)︃

𝑥𝑖+1 = 𝑥𝑖 −(︁−𝑥𝑖 + 𝑏𝑥2

𝑖

)︁

𝑥𝑖+1 = 2𝑥𝑖 − 𝑏𝑥2𝑖

𝑥𝑖+1 = 𝑥𝑖 * (2 − 𝑏𝑥𝑖)

Com isso, fica constatada a característica de convergência quadrática desse algo-ritmo. É observado, também, que em cada iteração são feitas duas multiplicações e umasubtração. A subtração é equivalente a uma operação de complemento de dois, obtendoum erro de 1 ulp que, em hardware binário equivale a um inversor binário [8]. O errocorrespondente a cada iteração é dado por:

𝜖𝑖+1 = 𝜖2𝑖 (𝑏) (3.5)

A quantidade de operações em cada iteração é constante, mas o algoritmo é capazde dobrar a quantidade de dígitos obtidos a cada iteração, ou seja: 1 → 2 → 4 → 8 →16 → 32 · · ·.

33

Para ilustrar esse algoritmo, a Tabela 4 apresenta um exemplo de uma divisão combase decimal 𝑄 = 𝑎 * 1

𝑏usando 𝑥𝑖+1 = 𝑥𝑖 * (2 − 𝑏𝑥𝑖), onde 𝑎 = 1, 7841 , 𝑏 = 0, 6784 e

𝑥0 = 1 (essa atribuição é sempre 1 para divisão com números binários devido ao intervaloem que eles estarão normalizados):

índice do 𝑥 valor de 𝑥𝑖 2 − 𝑏𝑥𝑖 valor calculado de 𝑥𝑖+11 1, 0000 2 − (0, 6784 * 1) 1, 32162 1, 3216 2 − (0, 6784 * 1, 3216) 1, 458283 1, 45828 2 − (0, 6784 * 1, 45828) 1, 473884 1, 47388 2 − (0, 6784 * 1, 47388) 1, 474056585 1, 47405658 2 − (0, 6784 * 1, 47405658) 1, 4740566046 1, 474056604 2 − (0, 6784 * 1, 474056604) 1, 474056604

Tabela 4 – Buscando o valor 1𝑏

usando quatro dígitos decimais.

Obs: Os dígitos após o quarto decimal são apenas ilustrativos.

Utilizando cinco casas decimais, o algoritmo convergiu na quarta iteração, tendocomo resultado 1

𝑏= 1, 47405. Aplicando isso temos:

𝑄 = 𝑎 * 1𝑏

𝑄 = 1, 7841 * 1, 47405

𝑄 = 2, 62985

Se o cálculo for feito em uma calculadora, obtém-se o valor 2, 62986 mostrandouma pequena diferença no último dígito devido ao truncamento utilizado para efetuaressas operações. O erro em cada iteração pode ser calculado através da equação 3.5.

A Figura 3 ilustra o fluxograma do algoritmo para o problema 𝑄 = 𝑎/𝑏, lem-brando que o dividendo e o divisor devem ficar sempre no intervalo (1 ; 2] e (0,5 ; 1],respectivamente, sendo que:

⎧⎪⎪⎪⎨⎪⎪⎪⎩𝑒𝑓 = 0 (expoente final);𝑒𝑎 = recebe expoente de 𝑎;𝑒𝑏 = recebe expoente de 𝑏.

34

a==0 Q=0

b==0 ERRO ef=128

concatena:A="1"aB="1"b

eb=eb+1

x=1y=2-(B*x)

retorno:sinal a,128,0

y==1 Q=A*x

x=x*(2-(B*x))y=2-(B*x) ef=(ea-eb)+127

retorno:sinal, ef, Qajustado

normalizarQ no padrão

IEEE (mantissae expoente)

verifica bit desinal para Q

sim

não

sim

não

sim

não

Figura 3 – Fluxograma Newton-Raphson

O algoritmo descrito por Goldschimidt [17] em sua tese de mestrado, é uma deri-vação do algoritmo Newton-Raphson com algumas pequenas mudanças que o torna maispreciso que o algoritmo descrito acima.

3.2.2 Algoritmo Goldschmidt

Este algoritmo também deriva uma iteração de divisão e, como em Newton-Raphson, Goldschmidt[17] também se baseia em uma expansão serial admitindo os se-guintes termos:

35

∙ o quociente é dado por 𝑞 = 𝑎𝑏;

∙ o algoritmo encontra a expansão do inverso do divisor de modo que 𝑞 = 𝑎 * 𝑔(𝑦);

∙ e determina 𝑔(𝑦) = 1𝑏

É possível, nesse algoritmo, realizar duas multiplicações em paralelo tornando omesmo mais rápido [17].

Para utilizar a Série de Maclaurin [19], Goldschimdt [8] utiliza-se do artifício detransformar a Série de Taylor na equação:

𝑏 = 1 + 𝑦 (3.6)

para obter:𝑔(𝑦) = 1

(1 + 𝑦)que se expande na Série de Maclaurin [19]:

𝑔(𝑦) = 1(1 + 𝑦) = 1 − 𝑦 + 𝑦2 − 𝑦3 + 𝑦4 − · · · (3.7)

Como 𝑏 é normalizado como divisor, que em representação binária está compre-endido no intervalo 0, 5 ≤ 𝑏 < 1, tem-se que, a partir da equação (3.6), é satisfeita acondição |𝑦| ≤ 0, 5 [8].

Assim, substituindo 𝑏 − 1 por 𝑦 conforme a equação (3.6), obtém-se:

𝑞 = 𝑎 * 1𝑏

= 𝑎 * 1(1 + (𝑏 − 1)) = 𝑎 * 1

(1 + 𝑦) = 𝑎 * (1 − 𝑦 + 𝑦2 − 𝑦3 + 𝑦4 − · · ·)

que fatorado pode ser reescrito como:

𝑞 = 𝑎 * [(1 − 𝑦)(1 + 𝑦2)(1 + 𝑦4)...(1 + 𝑦2𝑖)] (3.8)

Deste modo, o Algoritmo de Goldschmidt alterou a Série de Maclaurin descritapela equação (3.7) e obteve esta expansão da equação (3.8) formada por uma sequênciade multiplicações que pode ser implementada iterativamente.

As iterações calculam um quociente aproximado representado por [20]:

𝑞𝑖 = 𝑁𝑖

𝐷𝑖

⎧⎨⎩ 𝑁𝑖 = 𝑛𝑢𝑚𝑒𝑟𝑎𝑑𝑜𝑟

𝐷𝑖 = 𝑑𝑒𝑛𝑜𝑚𝑖𝑛𝑎𝑑𝑜𝑟

O método faz com que cada iteração aplique um termo corretivo (1 + 𝑦2𝑖) similarà expansão da equação (3.8), e as iterações utilizam fatores no sentido de convergir 𝑁𝑖 nadireção de 𝑞 e 𝐷𝑖 na direção de 1 [17].

36

O método é implementado fazendo-se:⎧⎪⎪⎪⎨⎪⎪⎪⎩𝑁0 = 𝑎

𝐷0 = 𝑏

𝑅0 = (1 − 𝑦)

Para a primeira iteração tem-se:⎧⎨⎩ 𝑁1 = 𝑅0 * 𝑁0

𝐷1 = 𝑅0 * 𝐷0

𝑜𝑛𝑑𝑒

⎧⎨⎩ 𝑅0 = (1 − 𝑦) 𝑜𝑢

𝑅0 = (2 − 𝑏)

que é uma operação de complemento de dois com o divisor.

Em 𝐷1 = 𝑅0 * 𝐷0 = (1 − 𝑦) * 𝑏 aplica-se à equação (3.6) e obtém-se:

𝐷1 = (1 − 𝑦) * (1 + 𝑦) = (1 − 𝑦2)

Similarmente obtém-se 𝑁1 = 𝑅0 * 𝑁0 = (1 − 𝑦) * 𝑎 e o quociente para a primeiraiteração se torna 𝑞1 = 𝑎(1−𝑦)

(1−𝑦2) .

Para a próxima iteração tem-se 𝑅1 = 2−𝐷1, que é uma operação de complementode dois com o denominador 𝐷1. Assim chega-se a 𝑅1 = 2 − 𝐷1 = 2 − (1 − 𝑦2)) = (1 + 𝑦2)e tem-se: ⎧⎨⎩ 𝑁2 = 𝑁1 * 𝑅1 = (1 − 𝑦) * 𝑎 * (1 + 𝑦2)

𝐷2 = 𝐷1 * 𝑅1 = (1 − 𝑦2)(1 + 𝑦2) = (1 − 𝑦4)

Continuando, tem-se cada passo da iteração envolvendo duas multiplicações [21]:⎧⎨⎩ 𝑁𝑖+1 = 𝑁𝑖 * 𝑅𝑖𝑖→∞−→ 𝑞𝑢𝑜𝑐𝑖𝑒𝑛𝑡𝑒

𝐷𝑖+1 = 𝐷𝑖 * 𝑅𝑖𝑖→∞−→ 1

e uma operação de complemento de dois:

𝑅𝑖+1 = 2 − 𝐷𝑖+1

Após 𝑖 passos a equação 𝑁𝑖 = 𝑎* [(1−𝑦)(1+𝑦2)(1+𝑦4)...(1+𝑦2𝑖)] é obtida, sendoque a mesma converge quadraticamente à expansão (3.8) que é igual ao quociente desejado𝑞. O denominador 𝐷𝑖 = 1 − 𝑦2𝑖 tende a 1 pois como 0, 5 ≤ 𝑏 ≤ 1 e |𝑦| ≤ 0, 5, 𝑦 elevado aum expoente positivo crescente tente a zero, e portanto 𝐷𝑖 tende a 1. Deste modo tem-seque 𝑁𝑖 ≈ 𝑞, ou seja, a i-ésima iteração de 𝑁𝑖 fornece o quociente 𝑄 procurado.

A Tabela 5 ilustra um exemplo numérico (decimal) para o Algoritmo de Goldsch-midt:

37

𝑄 = 2, 6298643868643868

𝑎 = 1, 7841000000000000

𝑏 = 0, 6784000000000000

iteração 𝑁𝑖 𝐷𝑖 𝑅𝑖

0 𝑎 = 1, 7841 𝑏 = 0, 6784 2 − 𝐷0 = 1, 32161 𝑅0 * 𝑁0 = 2, 35786656 𝑅0 * 𝐷0 = 0, 89657344 2 − 𝐷1 = 1, 103426562 𝑅1 * 𝑁1 = 2, 60173258 𝑅1 * 𝐷1 = 0, 98930294 2 − 𝐷2 = 1, 010697053 𝑅2 * 𝑁2 = 2, 62956345 𝑅2 * 𝐷2 = 0, 99988557 2 − 𝐷3 = 1, 000114424 𝑅3 * 𝑁3 = 2, 62986435 𝑅3 * 𝐷3 = 0, 999999987 2 − 𝐷4 = 1, 0000000135 𝑅4 * 𝑁4 = 2, 629864387 𝑅4 * 𝐷4 ≈ 1 2 − 𝐷5 ≈ 1

Tabela 5 – Ilustração numérica do algoritmo de Goldschimidt.

Obs: Os dígitos após a quarta casa decimal são apenas ilustrativos.

Verificou-se que a sequência iterativa de duas multiplicações e uma operação decomplemento de dois funciona como método de obtenção do quociente chegando ao resul-tado esperado.

A Figura 4 apresenta o fluxograma descrevendo o algoritmo de Goldschmidt parao problema 𝑄 = 𝑎/𝑏, sendo que:

⎧⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎩

𝑒𝑓 = 0 (expoente final);𝑒𝑎 = recebe expoente de 𝑎;𝑒𝑏 = recebe expoente de 𝑏;𝑁 = 𝑛𝑢𝑙𝑙;𝐷 = 𝑛𝑢𝑙𝑙;𝑅 = 𝑛𝑢𝑙𝑙.

38

a==0 Q=0

b==0 ERRO ef=128

concatena:N="1"aD="1"b

eb=eb+1R=2-D

retorno:sinal a,128,0

N=N*RD=D*R

D==1 Q=N ef=(ea-eb)+127

R=2-Dverifica bit desinal para Q

retorno:sinal, ef, Qajustado

normalizarQ no padrão

IEEE (mantissae expoente)

sim

não

sim

não

sim

não

Figura 4 – Fluxograma Goldschmidt

É possível implementar os algoritmos SRT e Iterações Funcionais utilizando umradix alto fazendo com que a quantidade de iterações requeridas para efetuar a divisãoseja diminuída, mas isso pode ter um custo computacional mais alto descrito nas próximasseções.

39

3.3 Algoritmo Utilizando Radix Alto

Como foi descrito no algoritmo SRT, o radix é determinado de acordo com aquantidade de dígitos que está sendo colocado no quociente a cada iteração. Como a baseé sempre binária, o mais comum é trabalhar bit a bit (ou seja, radix baixo) no quocientepois, quando o resto parcial que está sendo analisado for menor que o divisor, são colocadosdígitos 0𝑠 no quociente e no resto parcial até que o resto parcial se torne maior que odivisor. Quando isso acontece, é colocado o dígito 1 e realizada a subtração do divisor como resto parcial existente naquele momento. Quando se trabalha com radix alto, existemalgumas implicações [10]:

∙ a subtração simples é trocada por uma multiplicação do divisor com o númerocontido no quociente, fazendo com que a área do hardware seja aumentada;

∙ e, com isso, o tempo gasto em cada iteração aumenta devido à essa multiplicação.

Wong e Flynn [22] propuseram um algoritmo de aproximações do quociente parao SRT mas, para que seja possível aplicar o método utilizando radix alto, o SRT utilizadoé um pouco diferente do que foi descrito no capítulo sobre dígitos recorrentes.

3.3.1 SRT com Radix Alto

De acordo com Wong e Flynn [22], os números iniciais do problema não são maisnormalizados dentro dos intervalos como era necessário anteriormente. Os números sãoconsiderados da maneira que são armazenados pelo Padrão IEEE, sem serem feitos osajustes dentro de intervalos como era requerido anteriormente. Os autores exemplificamque é possível solucionar uma divisão com números de 53 bits em 4 iterações usando 14bits no quociente a cada iteração. É necessário consultar uma look-up table, que é umatabela de consulta que, para esse exemplo de 14 bits, é uma tabela com 214 entradas, maisprecisamente 16384 entradas, para obter os ajustes do quociente atual obtido em cadaiteração. Utilizar tabelas grandes se torna plausível pelo fato de que as memórias RAM(Random Access Memory) são densas e de rápido acesso [22].

Essa tabela é utilizada para obter ajuste no quociente atual em cada iteração. Aestimativa inicial é sempre menor ou igual ao quociente real de tal forma que o ajusteadquirido em cada iteração é devidamente deslocado e adicionado no quociente previa-mente acumulado e esses ajustes são sempre positivos. Cada nova estimativa é uma versãoajustada do quociente anterior.

O algoritmo divisão por aproximação 𝑄 e subtração segue os seguintes passos,sendo que:

40

⎧⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎩

𝑋 =dividendo;𝑌 =divisor;𝑄 =quociente;𝑞 =número de bits final;𝑗 =índice de deslocamento.

1. Inicializa-se 𝑄 = 0 e 𝑗 = 0;

2. Encontre uma aproximação de 1 dígito para 𝑄𝑎 de ⌊𝑋𝑌

⌋;

3. 𝑄′ = 𝑄 + 𝑄𝑎 * ( 1𝐵

𝑗 ), no qual:⎧⎪⎪⎪⎨⎪⎪⎪⎩

𝐵 = 2 para base binária;𝐵 = 10 para base decimal;. . .

4. 𝑋 ′ = 𝑋 − 𝑄𝑎 * 𝑌 ;

5. Desloque 𝑋 ′ para a esquerda 𝑘 bits até que o bit mais significativo seja 1. Então éfeito um ajuste de 𝑗 = 𝑗 + 𝑘;

6. 𝑋 = 𝑋 ′ e 𝑄 = 𝑄′;

7. Repetir os passos de 2 a 6 até que 𝑗 ≥ 𝑞;

8. O 𝑋 final é o resto da divisão.

Wong e Flynn [22] afirmam que quanto mais precisa for a estimativa para 𝑄𝑎 maiorserá a quantidade de 𝑘 bits números reduzidos a cada iteração.

Como já descrito, esse método calcula um quociente aproximado e vai ajustandoesse quociente incrementalmente. Contudo, os bits do quociente não são garantidos até otérmino do algoritmo porque na última iteração poderá ocorrer um carry (que é o excessodo máximo possível para aquele digito em questão) e, com isso, ocorre uma soma em cadabit contido no quociente mudando, assim, o valor do quociente.

A Tabela 6 exemplifica a solução para o problema 𝑄 = 1,08030,9000 utilizando o SRT

modificado, sendo que: ⎧⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎩

𝑋 = 10803𝑌 = 9000𝑄 = 0𝑗 = 0

41

𝑋 𝑄𝑎 𝑄′ 𝑋 ′ 𝑆ℎ𝑖𝑓𝑡𝐿𝑒𝑓𝑡𝑋 ′ 𝑘 𝑗 𝑄

10803 1 1, 0000 1803 18030 1 1 1, 000018030 2 1, 2000 00030 30000 3 4 1, 200030000 3 1, 2003 3000 30000 1 5 1, 2003

Tabela 6 – Ilustração numérica do algoritmo SRT modificado.

3.4 Comparação Entre os Algoritmos

Após a pesquisa dos principais algoritmos utilizados para efetuar uma divisão emponto flutuante, essa seção faz uma comparação dos aspectos mais relevantes de taisalgoritmos.

De acordo com Oberman e Flynn [10] a demanda comercial para desenvolvimentode hardware se preocupa com a latência (quantidade de ciclos), portanto qualquer aumentona latência deve ser gerenciado.

Pode ser notado que, se usar um radix mais elevado no SRT, há redução na latência,mas a consequência disso é um aumento considerável na área do hardware e no tempo gastoem cada ciclo visto que a quantidade de operações realizada dentro do ciclo de recorrênciaé aumentada. Para amenizar isso, pode-se fazer uso de combinações de técnicas como, porexemplo, o método que utiliza a aproximação do resto para determinar um conjunto dedígitos do quociente conhecido como conjunto de dígitos redundantes. Contudo, essasmelhorias aumentam a complexidade dos algoritmos e, como consequência, impacto notamanho do hardware [14].

Apesar de todas essas dificuldades, o SRT é o algoritmo que tem o menor custopara se implementar e, devido às restrições impostas pelo tamanho dos processadoresmodernos, fica limitado à usar um radix de até 10 bits por ciclo [10].

A Tabela 7 [10] ilustra o algoritmo SRT com variações no radix e seus respectivosvalores em relação à latência gerada pelo algoritmo.

radix latência4 276 1816 14256 7

Tabela 7 – Ilustração da latência produzida pelo SRT de acordo com o radix utilizado.

Devem ser considerada, também, a quantidade e a largura dos multiplicadores,pois elas também interferem diretamente na latência dos algoritmos.

Os algoritmos de aproximações precisas (que são os algoritmos que utilizam look-up tables juntamente com radix alto e fazem duas multiplicações em série para diminuir

42

a área do hardware) e o método conhecido como short reciprocal (utiliza a fundição deum multiplicador com um somador como, por exemplo, o coprocessador Cyrix [22], entreoutros), também são utilizados para diminuir a latência nos algoritmos mas a maioriadesses métodos auxiliares requer um aumento na área do hardware [10].

Os algoritmos que utilizam expansões de séries são meios eficazes quando a latênciaé a prioridade que está sendo observada pelo fato de que a convergência do algoritmo parao quociente é quadrática e utilizam-se 2 multiplicações a cada iteração [10]. No algoritmoNewton Raphson essas multiplicações são dependentes e devem ser feitas em série, e noalgoritmo Goldshmidt elas podem ser realizadas paralelamente diminuindo a latência e,por conseguinte, aumentando a área para mais um multiplicador [10]. Mas o inconvenientedesses algoritmos é que eles não geram os restos parciais dificultando assim a tarefa dearredondamento do quociente.

A Tabela 8 [10] é um sumário dos algoritmos no qual:

∙ 𝑛 = números de bits nos operadores de entrada;

∙ 𝑖 = números de bits de precisão para uma aproximação inicial utilizando look-uptable;

∙ 𝑡𝑚𝑢𝑙 = latência, em ciclos, da unidade multiplica/acumula;

∙ 𝐶𝑆𝐴 = Carry-save adder;

∙ 𝑄𝑠𝑒𝑙 = Tabela de Seleção do Quociente.

Algoritmo Tempo por Iteração Latência (ciclos) Área AproximadaSRT Tabela Qsel + ⌈𝑛

𝑟⌉ + 𝑒𝑠𝑐𝑎𝑙𝑎 Tabela Qsel +

(formamultipla+subtração)

CSA

Newton 2 multiplicações (2⌈log2𝑛𝑖⌉ + 1)𝑡𝑚𝑢𝑙 + 1 1 multiplicador +

Raphson seriais tabela + controleSéries de 2 multiplicações (⌈log2

𝑛𝑖⌉ + 1)𝑡𝑚𝑢𝑙 + 2,𝑡𝑚𝑢𝑙 > 1 2 multiplicadores +

Expansão 2⌈log2𝑛𝑖⌉ + 3,𝑡𝑚𝑢𝑙 = 1 tabela + controle

Aproximações 1 multiplicação (⌈𝑛𝑖⌉ + 1)𝑡𝑚𝑢𝑙 3 multiplicadores +

Precisas tabela + controleShort 2 multiplicações 2⌈𝑛

𝑖⌉𝑡𝑚𝑢𝑙 + 1 1 multiplicador short+

Reciprocal seriais tabela+controle

Tabela 8 – Sumário dos Algoritmos.

A Tabela 9 [10] mostra que uma versão mais aprimorada do algoritmo de aproxi-mações precisa do quociente é a que apresenta a menor latência. Contudo a área requeridaé muito maior que as demais pois precisa da tabela de consulta para look-up table (no

43

mínimo 736Kbits) juntamente com mais 3 multiplicadores. Para implementações maisrealísticas, os algoritmos por séries de expansão, como Goldschmidt por exemplo, têm alatência menor comparadas com os demais algoritmos. Já os algoritmos implementadosbaseados em multiplicação apresentam desempenhos muito parecidos.

Latência da MultiplicaçãoAlgoritmos Pipelined Aproximação Inicial 𝑡𝑚𝑢𝑙 = 1 𝑡𝑚𝑢𝑙 = 2 𝑡𝑚𝑢𝑙 = 3

Newton-Raphson sim/não 𝑖 = 8 8 15 22𝑖 = 16 6 11 16

Séries de não 𝑖 = 8 9 17 25Expansão não 𝑖 = 16 7 13 19

(Goldschmidt) sim 𝑖 = 8 9 10 14sim 𝑖 = 16 7 8 11

Aproximações sim/não 𝑖 = 8(básico) 8 16 24Precisas 𝑖 = 16(básico) 5 10 15

𝑖 = 13 e 𝑡 = 2(aprimorado) 3 6 9Short sim/não 𝑖 = 8 15 29

Reciprocal 𝑖 = 16 9 17

Tabela 9 – Latências em Configurações Diferentes.

As latências obtidas em algoritmos de multiplicação propagam-se, de forma di-reta, nos algoritmos de divisão (citados na Tabela 9) que utilizam multiplicações paraconvergirem ao resultado.

Alguns algoritmos, como o SRT utilizando radix alto por exemplo, são mais com-plexos para implementar. Entretanto é possível fazer uso de técnicas distintas em con-junto e atingir um desempenho similar aos métodos baseados em multiplicações sem asdificuldades para que seja feito o arredondamento pois, nas implementações por iteraçõesfuncionais, tem-se dificuldade para fazer o arredondamento devido ao fato de que estasnão fornecem restos parciais para tal cálculo [10].

45

4 DESCRIÇÃO DO PROJETO DA UNIDADE DE DIVISÃOEM PONTO FLUTUANTE

Com a conclusão da fundamentação conceitual dos algoritmos descritos no capítuloanterior, foi implementado o algoritmo SRT e os dois algoritmos de iterações funcionais(Newton-Raphson e Goldschmidt) para a observação de seu comportamento. As imple-mentações foram feitas na linguagem C++ e utilizando um software Matemático.

O resultado obtido dessas implementações mostrou que o algoritmo Goldschmidtconverge para o resultado do quociente com menos iterações que os demais. Devido a essefato, foi feita a escolha deste algoritmo para a idealização do projeto de hardware.

A primeira etapa foi transcrever o fluxograma do algoritmo Goldschmidt para oDiagrama Lógico apresentado na Figura 5:

46

SOMADOR

8

M

23

01

2

M

23

01

2

25

COMPLEMENTO DE 2

MULTIPLICADORMULTIPLICADOR

COMPARADOR

SUBTRATOR

SOMADOR

25 25

25

2525 25

25

18

88

8127

8

s E M

8 231

S E M S E M

Figura 5 – Diagrama do Projeto

Dados 2 números válidos, ou seja, diferentes de 0 e não NAN, o funcionamentodesse diagrama pode ser interpretado da seguinte maneira:

1. Reposiciona o bit 1, tanto no denominador quanto no numerador, no qual foi omitidode acordo com o padrão IEEE-754 [1];

2. Em seguida, é feito o deslocamento do denominador pois, de acordo com a descriçãodo algoritmo Goldschmidt [17], o denominador deve estar no intervalo [0, 5 ; 1);

3. É necessário somar uma unidade no expoente do denominador devido ao desloca-mento feito no passo anterior;

47

4. Após obter o novo denominador pertencente ao intervalo requerido, é aplicado ocomplemento de dois nesse denominador;

5. O complemento de dois calculado é usado para fazer duas multiplicações paralelas,sendo que a primeira multiplicação é o complemento de dois com o numerador ea segunda multiplicação é o complemento de dois com o deslocamento obtido nosegundo passo (é possível notar que ambas as multiplicações podem ser feitas emparalelo devido à independência das mesmas);

6. Observou-se, nas implementações, que a quantidade de iterações necessárias pararetornar o resultado eram fixas. Devido a este fato, é feito um controle sobre a quan-tidade de iterações necessárias para se obter o resultado. A quantidade de iteraçõesé obtida através de resultados adquiridos nos testes e, nessa etapa, é feita umacomparação para verificar se a quantidade estabelecida de iterações foi alcançada;

7. Caso essa comparação seja verdadeira, o resultado da divisão é o que se obtevena primeira multiplicação, caso contrário, volta-se ao passo 4 para adquirir o novocomplemento de dois e repetir todo o processo novamente;

8. Quando a comparação é satisfatória e o resultado da divisão adquirida, é necessário,ainda, fazer a normalização do número obtido;

9. No subtrator é feito a subtração dos expoentes, lembrando que, caso tenha sidonecessário fazer deslocamentos na normalização do quociente, é preciso propagaresses deslocamentos para esse cálculo;

10. O somador retorna o biased notation que, no caso específico do diagrama, é o valorutilizado em precisão simples e, assim, é normalizado o expoente do resultado obtido;

11. O último passo é o calculado do sinal do quociente aplicando a porta lógica XORnos sinais do numerador e do denominador.

Dada a descrição do processo de divisão da unidade de ponto flutuante, será des-crito, em mais detalhes, o funcionamento de cada bloco lógico utilizado no projeto.

4.1 Somador

De acordo com Patterson [23], somar é a ação mínima que se pode esperar de umcomputador. O funcionamento do somador é bem simples: o carry-in inicial é 0 e os paresde bits são somados juntamente com o carry, começando da direita para a esquerda eo carry-out é propagado para ser somado juntamente com o próximo par de entrada debits. No final é verificado se há overflow nessa soma através da operação XOR no últimocarry-in com o último carry-out.

48

O esquemático abaixo ilustra o funcionamento de um somador no qual:⎧⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎩

𝐴 e 𝐵 são os pares de bits que serão somados𝑐𝑖𝑛 = carry-in𝑐𝑜𝑢𝑡 = carry-out𝑆 = soma dos bits

entrada A0 entrada B0

cout 0

S0

entrada A1 entrada B1

cin 1

cout 1

S1

cout n-1

entrada An entrada Bn

cin n

cout n

Sn

...

0

. .

overflow

. .

. .

. .

. .

. .

. .

. .

. .

. .

Figura 6 – Diagrama do Circuito Somador

4.2 Subtrator

O subtrator é bem parecido com o somador com algumas diferenças: o borrow-in(tem a mesma função dos bits de carry) inicial é 1 e é somado com subtraendo invertidoe com o minuendo. O cálculo também é feito da direita para a esquerda e o borrow-out épropagado para a próxima soma. No final, o último borrow-out é desconsiderado.

A seguir é apresentado o esquemático que ilustra o funcionamento de um subtratorsendo que: ⎧⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎩

𝐴 e 𝐵 são os pares de bits que serão subtraídos𝑏𝑖𝑛 = borrow-in𝑏𝑜𝑢𝑡 = borrow-out𝑆 = subtração dos bits

49

entrada A0 entrada B0

bout 0

S0

entrada A1 entrada B1

bin 1

bout 1

S1

bout n-1

entrada An entrada Bn

bin n

bout n

Sn

...

1.

..

.

. .

.

..

.

. .

.

..

. .

.

Figura 7 – Diagrama do Circuito Subtrator

4.3 Complemento de Dois

O complemento de dois é um método muito utilizado na representação de númerosem microprocessadores [24]. Esse método é igual ao subtrator com a diferença que, agora,tem-se somente uma entrada. Como o multiplicador está gerando 0 à esquerda, foi neces-sário adaptar o complemento de dois que funcionará com um subtrator que subtrairá odenominador parcial de 2 literalmente.

O esquema a seguir é referente ao complemento de dois de maneira que:⎧⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎩

𝐵 é o bits de entrada do denominadora outra entrada é referente aos bits que representa o 2𝑐𝑖𝑛 = carry-in𝑐𝑜𝑢𝑡 = carry-out𝑆 = complemento de dois dos bits

50

0 entrada B0

bout 0

S0

0 entrada B1

bin 1

bout 1

S1

bout n-1

1 entrada Bn

bin n

bout n

Sn

...

1.

..

.

. .

.

..

.

. .

.

..

. .

.

Figura 8 – Diagrama do Circuito Complemento de Dois

4.4 Multiplicador

A multiplicação é considerada mais complexa para implementar e, também, temmaior custo computacional que as demais operações [12]. Essa operação requer desloca-mentos de bits e somas parciais dos mesmos em cada ciclo da operação. A multiplicaçãosempre começa pelo bit menos significativo do multiplicador e vai avançando em direçãodo bit mais significativo. Se o bit em questão for 0, é feito somente o deslocamento dasoma parcial. Caso o bit seja 1, é somado o multiplicando com o resultado que se tem dassomas parciais e feito o deslocamento logo em seguida. A quantidade máxima de bits doproduto para 𝑛 bits de entrada equivale a 2𝑛 bits.

Segue o diagrama do multiplicador sendo que, na multiplicação há duas possibili-dades a seguir:

∙ se o bit do multiplicador que está sendo analisado for 0 será feito somente o deslo-camento da soma parcial acumulada;

∙ se o bit do multiplicador que está sendo analisado for 1 será feita uma soma domultiplicando com soma parcial acumulada, o 𝐶 recebe o último carry gerado nasoma e, logo em seguida, é realizado o deslocamento da soma obtida;

51

MULTIPLICANDO

MULTIPLICADOR

SOMA PARCIAL

SOMADOR

DESLOCAMENTOC

0n . . .

DESLOCAMENTO

SOMA PARCIAL

C

c<=0

bit=0bit=1

Figura 9 – Diagrama do Circuito Multiplicador

4.5 Comparador

O comparador funciona como um controlador que determina se os bits retornarãopara fazer novas multiplicações ou se a quantidade de iterações já são suficientes paraobter o resultado. Assim sendo, o comparador normaliza o resultado alcançado e assimfinaliza-se o cálculo da divisão.

53

5 IMPLEMENTAÇÃO DA UNIDADE DE DIVISÃO EMPONTOS FLUTUANTES

Após estruturar e projetar o algoritmo escolhido para a finalidade desse trabalho,o mesmo será modelado na linguagem VHDL [2] para que seja possível fazer a simulação evalidação do mesmo. Neste capítulo será feita uma breve descrição sobre VHDL e descritaa implementação do Divisor de Números em Ponto Flutuante.

5.1 VHDL

A VHDL (VHSIC Hardware Description Language) é uma linguagem desenvolvidaque define métodos para descrição de comportamento de circuitos [2] que surgiu devido ànecessidade de uma ferramenta computacional para projetos e documentações do Depar-tamento de Defesa dos Estados Unidos(Defense Advanced Research Projects Agency) [25].Em 1987 essa linguagem foi estabelecida como padrão pelo documento IEEE 1076-1987[26] e obteve melhorias no decorrer dos anos. Atualmente, a VHDL tornou-se uma ferra-menta indispensável para a criação de produtos eletrônicos sofisticados pelos engenheiros[27].

O código em VHDL é composto por três seções:

∙ Declaração de bibliotecas, que deverá ser usada no projeto do código em VHDL;

∙ Entidade do projeto, que contém os pinos de entrada e saída e seus respectivos tiposde dados;

∙ Arquitetura, que descreve o comportamento do circuito.

Além de utilizar tipos de dados pré definidos, é possível o usuário criar, definir einstanciar tipos de dados.

Segundo Amore [2], a Figura 10 representa as três etapas de um projeto empre-gando uma linguagem de descrição de circuito. Essas etapas são:

∙ descrição VHDL que é gerada logo após a especificação do projeto;

∙ síntese da descrição que, através da ferramenta de síntese, cria as estruturas neces-sárias para o circuito de acordo com a descrição VHDL gerando o place and route(arquivo que contém as ligações dos elementos básicos);

∙ posicionamento e interligação dos componentes utiliza o arquivo gerado na síntesede descrição para obter outro arquivo de dados necessário para a confecção dodispositivo.

54

Figura 10 – Etapas de um projeto [2]

Um código em VHDL pode ser concorrente (paralelo) no qual a saída depende so-mente da entrada do circuito, ou sequencial sendo que a saída necessita de resultados deestados anteriores e, com isso, requer o uso de memória [28]. Quando for necessário ope-rações sequenciais, estas devem ser descritas dentro de uma estrutura específica chamadade PROCESS, FUNCTION ou PROCEDURE [29].

A linguagem também permite a construção de estruturas condicionais sequenci-ais como IF - ELSE, WAIT, CASE ou LOOP que só podem ser utilizados dentro dePROCESS. Em contra partida, as estruturas condicionais concorrentes são WHEN, GE-NERATE ou BLOCK [29].

Ressalta-se, também, os objetos que são elementos que contêm valores armazena-dos. A classe de objetos define quatro tipos [2]:

∙ CONSTANT : objeto com valor estático;

∙ VARIABLE : o valor contido nesse tipo de objeto pode ser alterado e pode serempregado somente em regiões sequenciais;

∙ SIGNAL: comporta-se como a VARIABLE e pode ser usado tanto em regiões se-quenciais como em regiões concorrentes. Esse o objeto é responsável por conduzirvalores de um componente para outro componente;

∙ FILE : objeto para manipulação de arquivos podendo ser do tipo IN (leitura) ouOUT (escrita).

55

5.2 Implementação

A partir do estudo dos principais algoritmos concluído e com a elaboração dadescrição do projeto apresentado no Capítulo 4, iniciou-se a implementação do mesmoutilizando a linguagem VHDL. O projeto foi dividido em módulos respeitando os blocoslógicos descrito no diagrama lógico e especificado no Capítulo 4.

Utilizando o diagrama como guia, a primeira implementação feita foi um módulochamado "separacao" que separa o conjunto de bits recebido em sinal, expoente e mantissaconforme especificado pelo Padrão IEEE-754 [1]. Após a separação dos bits, é restituído obit oculto nas mantissas. Neste mesmo bloco, a mantissa do numerador e do denominadorsão colocadas dentro do intervalo imposto pelo algoritmo Goldschmidt [17]. Pela NormaIEEE-754, o número em ponto flutuante armazenado é normalizado no intervalo [1 , 2)e, no algoritmo Goldschmidt, é imposto que o denominador esteja no intervalo [0, 5 , 1).Com isso, faz-se necessário somar uma unidade no expoente do denominador.

Foi criado um módulo chamado "somador" que retorna a soma dois bits e o carryresultante dessa soma. Esse bloco é genérico e, através dele, podem ser construídos soma-dores para diferentes quantidades de bits.

Utilizando o módulo "somador", foi implementado o módulo "somador8bits" quefaz a soma nos expoentes. O carry é iniciado com valor 0 e os próximos carrys geradossão propagados bit a bit até o final da soma de todos os bits. Esse componente foi im-plementado de acordo com o projeto ilustrado pela Figura 6 e o resultado dessa soma éarmazenado em um registrador que será utilizado para o cálculo do expoente resultanteno módulo que ocorre a normalização do resultado no final do projeto. Nesse momentoé importante verificar se houve overflow nessa soma e tratá-lo retornando um erro. Ostratamentos de exceções e erros não foram inclusos no projeto descrito pela Figura 5 masé um módulo de suma importância que deverá ser projetado para compor o divisor final.

Após a mantissa do denominador estar em conformidade com o limite especificado,foi elaborado o módulo chamado "complemento2", que segue o mesmo padrão genéricodo módulo "somador". Aplicando o módulo "complemento2" criou-se o módulo "comple-mento24", que, a princípio, realizaria o complemento de dois nos 24 bits da mantissado denominador. Foi necessário fazer um ajuste nesse módulo para que seja realizado2 − 𝑑𝑒𝑛𝑜𝑚𝑖𝑛𝑎𝑑𝑜𝑟. O carry inicia-se com valor 1 e os bits do denominador são invertidose somados com o carry juntamente com os bits da entrada equivalente à 2. O carry égerado e propagado em cada soma de acordo com o diagrama descrito na Figura 8. Coma saída desse módulo são feitas duas multiplicações paralelas: uma com a mantissa dodenominador e outra com a mantissa do numerador.

A multiplicação é o módulo mais complexo do projeto. Foi criado um módulo cha-mado "somador24bits" o qual utiliza o módulo "somador" possibilitando a soma entre

56

números com 24 bits. O "somador24bits" é empregado no cálculo das somas parciais domultiplicador. Além de efetuar as somas parciais dos bits, esse bloco efetua o deslocamentodos mesmos. É notório que o produto de um multiplicador tem sempre o dobro da quanti-dade de bits dos números de entrada. No caso específico desse projeto, foi determinado otruncamento do excesso de bits para poder utilizar o mesmo multiplicador para que sejamefetuadas as demais multiplicações e, assim, a área do hardware não seja aumentada.

De acordo com a literatura e com os testes feitos nas implementações em C++ e emsoftware matemático foi observado que a multiplicação do numerador com o complementode dois do denominador convergia para o quociente final quando eram feitas de quatro aseis multiplicações. Para cada multiplicação é necessário fazer novamente o complementode 2 do complemento anterior.

Após as devidas iterações, é feita a subtração dos expoentes e, para tal operação,foi desenvolvido o módulo "subtrator", de acordo com o modelo especificado na Figura7. O borrow 1 é iniciado com o valor 1 e, a cada subtração dos bits é gerado um novoborrow e propagado para a próxima subtração. O subtraendo é invertido e somado com ominuendo e o borrow gerando, assim, a diferença entre os bits.

Com o valor resultante dessa subtração é feita uma soma utilizando o módulo"somador8bits" com o valor 127 que é o peso da biased notation para precisão simples quefoi anulado com a subtração anterior. Caso haja necessidade de normalizar a mantissaobtida no quociente, é feita outra soma do expoente resultante com a quantidade de casasdecimais necessária para a normalização.

Com isso é concluída a implementação de todos os módulos descritos e necessáriospara o funcionamento do hardware de acordo com a teoria estudada. Em seguida, foi feitaa junção de todos os módulos finalizando, assim, a implementação do projeto.

A etapa a seguir é testar e observar como o hardware se comporta.

1 O borrow é semelhante ao carry com a diferença que ele será incluído na subtração dos próximos bits.

57

6 RESULTADOS EXPERIMENTAIS

Implementar um hardware com a finalidade de obter divisões de números em pontoflutuante não é trivial e depende de muitos ajustes e otimizações. O projetista tem quepreocupar-se com a latência gerada em cada componente implementado para compor oprojeto final, precisões nos cálculos e a área gerada para a confecção do hardware. Coma descrição do projeto em VHDL inicia-se os testes e observações no comportamento dohardware desenvolvido observando esses três parâmetros.

A Tabela 10 mostra a quantidade aproximada de instruções obtidas em cada mó-dulo e o total final de instruções produzidas pelo hardware.

Nome do Módulo Quantidade de Instruções Total de Instruções no Móduloseparacao 33 para cada número em paralelo 33somador 3 operações no qual 2 são paralelas 2

somador8bits 2 *(8 * somador + detecta overflow) 34complemento2 2 operações paralelas 1

complemento24bits 25 * complemento2 25somador24bits 25 * somador 51

+ 2 atribuições paralelas3 *(25 *(2 comparações + 1 atribuição)

multiplicacao + 25 * somador24bits 4053+ 1 𝑎𝑡𝑟𝑖𝑏𝑢𝑖çã𝑜)

subtrator 3 operações no qual 2 são paralelas 2subtrator8bits 8 * subtrator + detecta underflow 17

xor para determinar o sinal 1 operação 1Total de Instruções Para a Divisão 4130Instruções para Normalização Caso Necessário + 17

Tabela 10 – Quantidades de instruções.

De acordo com a tabela, observa-se que o módulo responsável por realizar asmultiplicações tem a maior quantidade de instruções. Não foi possível fazer um estudodos algoritmos de multiplicação para a implementação de um multiplicador otimizadodevido ao tempo disponível para o término do trabalho. Com isso, o multiplicador foiimplementado sem as devidas otimizações e é o módulo com maior gasto computacionaldesse projeto. Mas, de acordo com Flynn [10], é possível beneficiar-se da unidade demultiplicações de números em ponto flutuante existente no processador usufruindo dasotimizações já aplicadas nessa unidade. Os outros módulos obtiveram êxito tanto no que sediz respeito ao funcionamento quanto na quantidade de instruções gasta para a realizaçãode seu propósito.

No que concerne à precisão, verificou-se que, mesmo sendo necessário realizar o

58

truncamento de 25 bits após cada multiplicação, o resultado foi muito próximo do es-perado. Na Tabela 11 é apresentado alguns resultados para o problema 𝑎

𝑏= 𝑄 e os

resultados obtidos pela implementação e suas respectivas porcentagens com referência aprecisão obtida:

𝑎 𝑏 𝑄 Resultado Obtido % Entre Q e o Resultado Obtido7, 5 2, 5 3, 0 2, 998897 99, 9632%

1, 784179688 0, 678710937 2, 62877698 2, 62847896 99, 988%11 5, 5 2, 0 1, 99982 99, 991%

100, 5 20 5, 025 5, 0232354 99, 965%

Tabela 11 – Resultados obtidos.

Através da Tabela 11 é possível observar que o hardware obteve um resultadomuito próximo ao resultado esperado. Sendo assim, a precisão superou as expectativasesperadas. É importante relembrar que tais algoritmos não geram restos parciais para serrealizado o arredondamento. Por isso são necessários estudos e aplicações de técnicas dearredondamentos para algoritmos de Iterações Funcionais.

No que se refere à área, o hardware obteve uma área aceitável devido ao bene-fício que o algoritmo disponibiliza da utilização de paralelismo nas duas multiplicações.Admitem-se, ainda, estudos e aplicações para otimização no tamanho da área.

59

7 CONCLUSÃO

Após pesquisa e análise de trabalhos e de bibliografia sobre a divisão para númerosem ponto flutuante, escolheu-se três algoritmos, que foram implementados na linguagemC++ e em software matemático.

Os algoritmos escolhidos foram:

∙ SRT: devido a variedade de literatura propondo técnicas e implementações que outilizam como base;

∙ Goldschmidt e Newton-Raphson: pela característica de convergência quadráticapara o resultado final.

Como resultado, os testes permitiram observar que o algoritmo Goldschmidt aproximava-se do resultado com menos iterações que os demais. Por esse motivo, escolheu-se essealgoritmo para ser implementado. O projeto foi implementado conforme a especificaçãoda Figura 5.

Como descrito na seção Implementação, o multiplicador não foi implementadoutilizando algum algoritmo otimizado. Isso faz com que as multiplicações estejam lentase, com isso, o hardware projetado demora alguns segundos para retornar a resposta final.As demais implementações funcionaram conforme o esperado.

A precisão obtida foi superior à 99% ao resultado esperado como pode ser obser-vado na Tabela 11. Não se esperava uma precisão grande, pois a cada multiplicação érealizado um truncamento.

De acordo com o Manual de Intel [30], se as implementações estiverem com asdevidas otimizações realizadas, um somador e um subtrator gastam 1 ciclo de latênciacada, um multiplicador gasta 5 ciclos de latência. É possível analisar, na Tabela 10, quea implementação do projeto utiliza 6 multiplicações que são feitas em paralelo, em 2multiplicadores perfazendo 3 multiplicações totais, 2 somas e 1 subtração. No final, issogera 18 ciclos de latência no projeto implementado e em um divisor pertencente a famíliax86_64 utiliza 19 ciclos. Com isso a implementação feita tem um ganho de 1 ciclo setodos os módulos estiverem otimizados.

7.1 Sugestões Para Trabalhos Futuros

Mesmo com a complexidade de implementação de Unidades de Divisão de Númerosem Ponto Flutuante, o projeto obteve sucesso na implementação. Ainda assim é possívelmelhorar o hardware através de algumas sugestões citadas a seguir:

60

∙ Primeiramente, deve-se otimizar o multiplicador através de algum algoritmo paratal propósito diminuindo, assim, a quantidade de instruções gastas nessa operação;

∙ É possível fazer um estudo para aplicação de multiplexadores para otimizar algunsmódulos no hardware

∙ Os algoritmos pertencentes à classe de iterações funcionais não geram restos parciaisdificultando o arredondamento e prejudicando a precisão. Há estudos e literaturasque descrevem soluções para esse problema sendo, assim, uma sugestão para apri-morar o projeto;

∙ É primordial elaborar um módulo de verificação dos números que estão sendo en-viados para efetuar a divisão, pois eles podem ser números especiais como NaN,infinitos ou, até mesmo, 0. Esse módulo deve verificar e tratar essas exceções casoexistam.

Essas sugestões se adequam ao propósito de um desenvolvimento de um hard-ware para divisão de números em ponto flutuante que seja ágil e preciso e que supra anecessidade das aplicações que dependem desse tipo de operação.

61

REFERÊNCIAS

[1] MICROPROCESSOR STANDARDS COMMITTEE OF THE IEEE COMPUTERSOCIETY. IEEE Standard for Floating-Point Arithmetic. 3 Park Avenue,New York, NY 10016-5997, USA, 2008, 1–58 p. Disponível em: <http://dx.doi.org/10.1109/ieeestd.2008.4610935>.

[2] AMORE, R. d. VHDL: descrição e síntese de circuitos digitais. 1st. ed. [S.l.]: LTC,2005.

[3] RODOLFO, T. A. Uma Esploração do Espaço de Projeto de Processadores comHardware de Ponto Flutuante em FPGAS. Dissertação (Mestrado) — PUC, PortoAlegre, 2010.

[4] MORENO, E. D.; ZAMBOTTI, S. F. F. IBERCHIP Workshop, 2005.

[5] LENZI, K. G.; SAOTOME, O. Implementação de funções matemáticas deponto-flutuante de alto desempenho em uma plataforma dsp ponto-fixo.

[6] BRISEBARRE, N.; MULLER, J.-M.; TISSERAND, A. Computing machine-efficient polynomial approximations. ACM Trans. Math. Softw., ACM, New York,NY, USA, v. 32, n. 2, p. 236–256, jun. 2006. ISSN 0098-3500. Disponível em:<http://doi.acm.org/10.1145/1141885.1141890>.

[7] SODERQUIST, P.; LEESER, M. Area and performance tradeoffs in floating-pointdivide and square-root implementations. ACM, 1996.

[8] OBERMAN, S.; FLYNN, M. Division algorithms and implementations. IEEETRANSACTIONS ON COMPUTERS, v. 46, n. 8, p. 833–854, 1997.

[9] ASSONI, V. T. K. Projeto de um divisor de Ponto flutuante. 46 p. Monografia(TCC) — Universidade Estadual Paulista, 2003.

[10] OBERMAN, S.; FLYNN, M. Design issues in division and other floating-pointoperations. IEEE TRANSACTIONS ON COMPUTERS, v. 46, n. 2, p. 154–161,1997.

[11] OVERTON, M. L. Numerical Computing with IEEE Floating Point Arithmetic.[S.l.]: SIAM, 2001. ISBN 978-0-89871-482-1.

[12] STALLINGS, W. Arquitetura e Organização de Computadores. [S.l.]: Pearson, 2010.ISBN 9788576055648.

[13] MULLER, J. et al. Handbook of Floating-Point Arithmetic. [S.l.]: BirkhäuserMathematics, 2009.

[14] HARRIS, D. L.; OBERMAN, S. F.; HOROWITZ, M. A. Srt division architecturesand implementations. In: Proceedings of the 13th Symposium on ComputerArithmetic (ARITH ’97). Washington, DC, USA: IEEE Computer Society, 1997. p.18–25.

62

[15] MONTUSCHI, P.; CIMINIERA, L.; GIUSTINA, A. A division architecturecombining newton-raphson approximations and direct methods iterations. In:Signals, Systems and Computers, 1992. 1992 Conference Record of The Twenty-SixthAsilomar Conference on. [S.l.: s.n.], 1992. p. 376–380 vol.1. ISSN 1058-6393.

[16] FLYNN, M. On division by functional iteration. Computers, IEEE Transactions on,C-19, n. 8, p. 702–706, Aug 1970. ISSN 0018-9340.

[17] GOLDSCHMIDT, R. Applications of Division by Convergence. [S.l.]: MassachusettsInstitute of Technology, Department of Electrical Engineering, 1964.

[18] DEVRIES, P.; HASBUN, J. A First Course in Computational Physics. [S.l.]: Jones& Bartlett Learning, 2011. ISBN 9781449657802.

[19] BOYER, C.; GOMIDE, E. História da matemática. [S.l.]: Edgard Blucher, 1996.ISBN 9788521200239.

[20] KONG, I. Improved Algorithms and Hardware Designs for Division by Convergence.Tese (Doutorado) — The University of Texas at Austin, 2009.

[21] EVEN, G.; SEIDEL, P.-M.; FERGUSON, W. E. A parametric error analysis ofGoldschmidt’s division algorithm (Extended Abstract). 2003.

[22] WONG, D.; FLYNN, M. Fast division using accurate quotient approximations toreduce the number of iterations. In: Computer Arithmetic, 1991. Proceedings., 10thIEEE Symposium on. [S.l.]: IEEE Computer Society, 1991. p. 191–201.

[23] PATTERSON, D.; HENNESSY, J. Organização e Projeto de Computadores: aInterface Hardware/Software. [S.l.]: CAMPUS - RJ, 2005. ISBN 9788535215212.

[24] TOKHEIM, R. Fundamentos de Eletrônica Digital - Vol.1: Sistemas Combinacionais.[S.l.]: MCGRAW-HILL BRASIL, 2013. (Série Tekne). ISBN 9788580551938.

[25] CAPPELATTI, D. Praticando VHDL. [S.l.]: Editora Feevale, 2011. ISBN9788577171200.

[26] IEEE standard VHDL language reference manual. [S.l.], 1988. Disponível em:<http://ieeexplore.ieee.org/xpls/abs\_all.jsp?arnumber=26487>.

[27] PERRY, D. L. VHDL: Programming by Example. 4. ed. New York, NY: McGraw-Hill,Inc., 2002.

[28] PEDRONI, V. Circuit Design with VHDL. [S.l.]: MIT Press, 2004. ISBN9780262162241.

[29] ORTIZ, J. Implementação do AES-Rijndael em FPGA usando VHDL. 95 p.Monografia (TCC) — Universidade Estadual de Londrina - UEL, 2013.

[30] INTEL. Intel 64 and IA-32 Architectures Optimization Reference Manual. [S.l.],2007. Disponível em: <http://developer.intel.com/products/processor/manuals/>.