Projeto de Operações Aritméticas de Ponto Flutuante no padrão IEEE 754 em VHDL e FPGAs

Transcrição

1 Projeto de Operações Aritméticas de Ponto Flutuante no padrão IEEE 754 em VHDL e FPGAs Galileu Santos de Jesus, Carlos Augusto Ezequiel Mendonça Junior, Dimitri Carvalho Menezes, Edward David Moreno, Felipe dos Anjos Lima. Departamento de Computação, Universidade Federal de Sergipe UFS. {galilasmb, juniorcaemj, dimitri.menezes, edwdavid, felipes1474}@gmail.com, Abstract This article presents two algorithms arithmetic: addition and multiplication of floating-point single precision (32 bits). The implementation of these algorithms follow the IEEE standard. Initially, the project was implemented in software using Java where the JUnit framework was used to perform tests to empirically prove the correctness of each algorithm and finally, we also have implemented in VHDL and prototyping in FPGAs using the Quartus and U.P. Simulator from Altera. Resumo Este artigo apresenta dois algoritmos aritméticos: a adição e a multiplicação entre números de ponto flutuante de precisão simples (32 bits). A implementação destes algoritmos segue o padrão IEEE Inicialmente, o projeto foi implementado em software na linguagem Java onde foi utilizado o framework JUnit para realização de testes unitários para comprovar empiricamente a corretude em cada algoritmo e finalmente, implementamos em VHDL aplicando em FPGAs usando o Quartus e U.P. Simulator da Altera. 1. Introdução WSCAD XV Simpósio em Sistemas Computacionais de Alto Desempenho A aritmética de pontos flutuantes é uma tarefa bastante utilizada na computação, pois vivemos em um mundo onde os dados coletados, muitas vezes analógicos, estão na forma de números reais e que são muito úteis para processamento de atividades computacionais importantes. O ponto flutuante em binário, representa o conjunto de números reais, que engloba também números irracionais cujas frações decimais são infinitas. Por esse motivo, é de extrema importância que a representação de um ponto flutuante seja a mais correta e precisa. Um ponto flutuante pode ser representado em duas precisões: a precisão simples, que é representada em um número binário de 32 bits, e a precisão dupla caracterizada por um número binário de 64 bits. Números de ponto fixo são simples de ser manipulados, porém sofrem limitações de valores que eles representam. Segundo Frank Vahid (VAHID 2008, Sistemas Digitais, pág 529), para um número fixo de bits, o aumento da precisão de um número se dá à custa do intervalo de números inteiros que se pode usar. Logo, aplicações mais exigentes, que necessitam de intervalos maiores, devem utilizar os pontos flutuantes. Fabricação de calculadoras científicas, ou até mesmo calculadoras embutidas em dispositivos são bons exemplos. Dentre os trabalhos relacionados estudados, um ponto importante a ser destacado é a abordagem utilizada nas referências [3] e [4], que permitiu uma visão, de forma simples, dos passos de adição de números de pontos flutuantes e o processo de normalização, que foi útil para a obtenção dos resultados obtidos nos testes. 224

2 Já o trabalho denominado Padrão IEEE 754 para Aritmética Binária de Ponto Flutuante feito por Gerardo Viana [5], foi um trabalho teórico bem completo, mostrando o passo a passo de cada operação aritmética, focando na abordagem matemática envolvida nas operações definidas no padrão IEE 754. O artigo está organizado em quatro seções, a seção dois explica a teoria relacionada ao trabalho, a seção três é dedicada aos resultados experimentais e a seção quatro contêm as conclusões e sugestões de trabalhos futuros. 2. Representação de Pontos Flutuantes Simples Um ponto flutuante adequado deve ser representado em notação cientifica. Um número em notação científica contém, um sinal, uma parte inteira e uma parte fracionária, uma base representativa e um expoente. A combinação das partes inteira e fracionária é chamada de mantissa ou significando. Para um número ser normalizado, é necessário garantir que a mantissa seja maior que zero e menor que o número da base. Exemplificando, um ponto flutuante de número 35 x 10² na base decimal deve ser normalizado para o número 3,5 x 10³. Para os algoritmos de aritmética de ponto flutuante, é importante converter esse número para uma base binária. Na base binária, o número inteiro normalizado deve ser somente o 1, e a base numérica deve ser 2. A representação do sinal é feita pelo bit mais significativo, indicando 1 para números negativos e 0 para números positivos. O expoente fica armazenado logo em seguida, nos próximos oito bits. Por padrão de ajuste, é necessário acrescentar 127 ao expoente, com isso, um expoente válido está na faixa de 1 a 254. Expoentes com valor 0 ou 255 não usados, pois se enquadram em casos especiais que serão listados a seguir. Se todos os bits do expoente são zeros: Se todos os bits da mantissa são zeros, o número é zero. Se todos os bits da mantissa são diferentes de zero, o número não está normalizado. Se o expoente for 255: Se todos os bits da mantissa são zeros, o número é infinito. Se todos os bits da mantissa são diferentes de zero, o número é considerado um NaN (Not a Number). Os vinte e dois bits restantes ficam à disposição da mantissa. Segundo VAHID (VAHID 2008, Sistemas Digitais, pág. 530), para economizar bits, podemos assumir que a parte inteira da mantissa é sempre um, e armazenar apenas a parte fracionária. Portanto, os 32 bits podem ser identificados como mostrado na figura a seguir Sinal Expoente Mantissa Figura 1. Representação dos 32 bits do ponto flutuante de precisão simples 2.1. Normalização de um número decimal Um número na forma decimal deve ser convertido para um número de ponto flutuante de 32 bits utilizando o padrão IEEE

3 Tomando como exemplo o número 6.75, o processo é feito da seguinte forma: 1) Transformar o número para binário: Sabe-se que o 6 é equivalente a 110 e a parte fracionária é,11, portanto, 110, , 1 1 Figura 2. Normalização 2) Colocar o número em notação cientifica na base 2, multiplicando-o por. Após isso, deslocar a vírgula até que a parte inteira fique normalizada, então 1:110,11 * se tornará 1,1011 *. 3) Após isso o processo está concluído, restando apenas sequenciar os bits. O primeiro bit é o 0 indicando um número positivo. Os dois bits do expoente são somados aos bits do número padrão 127, totalizando 129 em binário. E o restante são os bits da mantissa Sinal Expoente Mantissa Figura 3. Representação ponto flutuante normalizado 2.2. Adição No processo de adição de números reais, é possível supor que os valores a serem somados estão armazenados segundo a norma IEEE-754, ou seja, separados em (sinal, expoente e mantissa) e também normalizados. O processo de subtração é semelhante ao de soma, exceto que na subtração é necessário verificar também o sinal do resultado, e por isso esse processo não será mostrado aqui. O algoritmo de soma possui quatro passos que serão detalhados mais a seguir, são eles: 1 verificar se algum operando é zero (se sim, retornar o outro operando como resultado). 2 Alinhamento de expoentes 3 Soma das mantissas e normalização 4 Realizar arredondamentos O primeiro passo é trivial, pois para verificar se algum operando é 0, como mostrado no tópico 2, verificamos se os bits do expoente e mantissa de um dos operandos são todos zeros, caso isso seja verdade, o resultado será o outro operando. 0 Supondo agora que nenhum dos operandos é zero, e consideraremos os seguintes operandos: O próximo passo é verificarmos se os expoentes estão desalinhados, esse passo é necessário, pois é necessário que os dígitos estejam em posições equivalentes para que a soma seja feita corretamente, nesse caso, o 4 do operando Y deve ser alinhado com o 3 do operando X, para que a soma possa ser feita. Então, o algoritmo desloca os bits da mantissa do valor de menor expoente pra direita e incrementa o expoente em 1, repetindo esse processo de deslocamento até que os expoentes sejam iguais. Além disso, caso esse processo de deslocamento faça com que todos os bits da mantissa sejam zeros, o resultado da soma será o outro operando. No fim das contas, os operandos desse exemplo ficarão dessa forma: 226

4 Depois do passo de alinhamento dos expoentes, partimos para o passo 3 que é a soma das mantissas. No caso da adição, a soma é feita normalmente sem a preocupação com o sinal (diferentemente da subtração). Nesse processo existe a possibilidade de ocorrer um overflow na mantissa por 1 dígito, pois no caso do algoritmo, como estamos tratando da soma entre 2 bits, caso os dois bits sejam 1 o resultado pode ser 10 e até 11, caso exista um carry-in de outra soma e isso fará com que o resultado não esteja normalizado. Mas lembramos também que o padrão IEEE-754, não armazena o bit da parte inteira no operando, logo devemos incluir esse 24º bit significativo, que será 1, na mantissa. Depois deve-se efetuar a soma entre todos os bits dos operandos, e logo após, verificar se o resultado possui mais de 24 bits, se sim, deslocamos os bits da mantissa 1 vez pra direita e incrementamos o expoente em 1, para que a parte inteira continue sendo apenas o valor 1 (normalização). Também pode haver um overflow no expoente devido ao incremento do deslocamento, se isso ocorrer um erro é reportado e o número não pode ser somado. O passo final do processo de adição entre X e Y, é o arredondamento, pois como a parte decimal do número é definida por arredondamentos, uma soma entre dois números também deve passar por esse passo. Nos casos em que os expoentes são iguais, o arredondamento não é necessário. Já o caso em que eles forem diferentes, o algoritmo captura os bits deslocados pelo número de menor expoente, sendo que se houver mais de 3 deslocamentos, os 2 bits mais significativos são guardados normalmente e o 3º bit é um acumulador onde são feitos sucessivos OU s lógicos entre todos os outros bits menos significativos. Esses bits são chamados de guard bit, round bit e sticky bit, respectivamente, e eles são descartados no fim do processo. Se após a soma ser realizada, esses bits forem mais próximos do valor máximo representado pelos 3 bits (111), o resultado é arredondado pra cima somando 1 a mantissa. Analogamente, se os 3 bits forem mais próximos do número mínimo (000), o resultado é truncado e não é somado valor algum. Mas se os bits representarem exatamente o valor intermediário (100), segundo Stallings[2], a técnica é truncar sempre pois é a técnica mais simples, mas caso haja uma aplicação onde é necessário somar vários números que recaiam nesse caso, o acúmulo desses truncamentos pode causar uma polarização do resultado, e nesse caso, seria necessário um método de arredondamento não-polarizado, que não será detalhado nesse artigo Multiplicação A multiplicação é bem mais simples que a adição. A representação e os passos da normalização são feitos de forma similar ao somador, diferenciando apenas porque é feita a multiplicação das mantissas e a soma dos expoentes. O processo é bem simples, primeiramente é feita a soma dos dois expoentes e a multiplicação das duas mantissas, separadamente, com o cuidado de saber onde está a vírgula após a multiplicação. Para isso é feita a adição dos bits das partes inteiras às mantissas, multiplicando-as. Como cada mantissa tem 23 bits, a vírgula estará na posição 46, como mostra a figura a seguir. 1, , Parte inteira, 46 1 s ou 0 s Figura 4. Resultado da Multiplicação 227

5 Concluída a multiplicação, é necessário normalizar o resultado. Primeiramente, soma um aos expoentes dos operandos, para fazer a normalização deste valor. Isto é feito localizando-se o local da vírgula, na posição 46, com isso desloca-se 46 vezes para direita, encontrando a parte inteira, fazendo uma normalização para saber quantas vezes deve-se acrescentar um ao expoente, caso a valor após a vírgula seja 2 (10) ou 3 (11). Em VHDL houve uma otimização, bastou verificar se a posição 47 do valor era igual a 1 2, para saber a adição ao expoente. 3. Resultado das implementações Ambas as implementações não utilizaram nenhum recurso pronto de ponto flutuante disponível nas linguagens (real ou float). O código para comparação está disponível em [6] Implementação em JAVA Para testes, foi implementado em JAVA um somador e um multiplicador de números de ponto flutuante de precisão simples. Para demonstrar a corretude dos algoritmos, foram feitos testes unitários através do framework JUnit, na qual foi feito 1 milhão de operações de soma e de multiplicação de números aleatórios, no qual foi estimado um erro máximo de entre o valor esperado e o valor retornado pelo algoritmo, obedecendo o padrão IEEE Implementação em VHDL A implementação feita em VHDL foi completamente baseada no código feito em JAVA sendo que algumas estruturas tiveram que ser adaptadas pela falta de algumas funções implementadas em VHDL e também algumas otimizações puderam ser feitas para que fosse possível obter um tempo mínimo de propagação no circuito. O código foi implementado no ambiente Quartus 13.1 da Altera, no qual foi usado o Altera Simulator para simulação do circuito. É necessário destacar que, devido à complexidade de adaptação do código JAVA para o código VHDL, alguns casos de valores usados na soma entre pontos flutuantes não foram implementados por completo e também no multiplicador houveram alguns problemas de implementação em relação ao arredondamento do resultado final. A seguir, os tempos de propagação do circuito do somador e do multiplicador: Tabela 1. Tempos de execução/propagação Tempo de execução/propagação Abordagem Somador Multiplicador JAVA 2ms 1ms VHDL 9ns 8ns Outro detalhe de desempenho é que foram necessários 8 (oito) clocks para que houvesse uma propagação correta da entrada até uma saída correta. É possível ver a seguir, o diagrama de tempo sobre um exemplo em VHDL utilizando o somador e multiplicador respectivamente. Figura 5. Diagrama de tempo Somador e multiplicador, respectivamente. 228

6 Na Tabela 2 aparece informação do espaço usado pelo somador e multiplicador em uma FPGA do tipo Cyclone II. Os circuitos são pequenos, ocupam menos de 1% dos recursos disponíveis pela FPGA, o que permite que mais elementos de hardware sejam projetados e embutidos no mesmo circuito. Tabela 2. Dados de uso da FPGA. Somador Multiplicador Elementos Lógicos Total de pinos Total de Registradores Conclusão e trabalhos futuros O objetivo é mostrar a soma e multiplicação de pontos flutuantes através de sua representação descrita regulamentada pela norma IEEE-754, em linguagem de alto nível (Java) e em linguagem de descrição de hardware (VHDL). Presente hoje em todos os computadores como forma de realizar cálculos utilizando números reais. Ao contrário de números inteiros, percebe-se que a abordagem de pontos flutuantes é bem mais complexa em termos de armazenamento e também que suas operações não são 100% precisas, até pelo fato de que números reais são infinitos e o computador é uma máquina finita, e armazena bits finitos e por isso devem ser feitos diversos arredondamentos. A unidade aritmética de ponto flutuante na linguagem VHDL foi significativamente mais rápida que em numa linguagem de alto nível, pelo fato de que, trabalhar diretamente sobre o hardware sempre apresentará execuções mais rápidas que sobre o software, ratificando o uso de UPF (Unidade de Ponto Flutuantes) físicas no lugar de implementadas no software. Trabalho futuro, deve ser realizado a otimização do código da linguagem VHDL para conseguir uma redução no número de elementos lógicos e consequentemente obter menos clocks para realização das operações, assim como a implementação das operações de subtração e divisão. Referências [1] VAHID, Frank. Sistemas Digitais. Bookman, [2] STALLINGS, William. Arquitetura e organização de computadores: projeto para o desempenho. Prentice-Hall, [3] IEEE Float Converter. Disponível em: < [4] Floating-Point addition. Disponível em: < [5] VIANA, Gerardo. Padrão IEEE 754 para Aritmética Binária de Ponto Flutuante. [6] Implementação do trabalho. Disponível em: < 229