UNIVERSIDAD NACIONAL DE CENTRO DE LA PROVINCIA DE BUENOS AIRES FACULTAD DE CIENCIAS EXACTAS – DEPARTAMENTO DE COMPUTACIÓN Y SISTEMAS

DOCTORADO EN MATEMÁTICA COMPUTACIONAL E INDUSTRIAL

Análisis e implementación de operaciones aritméticas en base diez sobre dispositivos de lógica programable

por

Martín Osvaldo Vázquez

Director: Dr. Gustavo Sutter

A mis hijos Facundo y Amparo, y a la memoria de mis padres Raúl y María

Abstract

General purpose microprocessors available on today's market does not provide

hardware support for performing mathematical operations based on decimal representation. Instead, those chips implement arithmetic units using binary representation which provide a better performance. This fact is due to the two-state nature of electronic transistors. However, many commercial and scientific applications strictly requires computed calculations to be exactly the same as human performed.

Actually, those systems that does not provide decimal floating point support, must adapt theirs operands to be computed assuming a difference with the real result. Errors inherited by precision loss may violate legal conditions, cause millionaire losses and even human life risk. The first alternative to smooth this is to give a special treatment to floating point operations at software level. This solution avoids result errors but increases computing resources and deteriorates calculation speed. A second popular alternative requires operands and result conversion from/to radix-10 and using the traditional computation. However, successive conversions could fall into precision loss. The decimal floating point arithmetic boosts the IEEE 754-1985 floating point standard adding decimal representation support and leading to IEEE 754-2008. The new standard states storage formats and treatment algorithms for handling decimal floating point numbers.There is a special interest on using FPGA programmable devices as hardware accelerators performing decimal floating point operations that meet IEEE 754-2008.

This work proposes the analysis, design and implementation of different algorithms to solve arithmetic operations based on radix-10 and targeted to Xilinx programmable devices. The addessed operations are: addition, subtraction, square root and decimal logarithm. The fundamental aim of this work is to promote the design and implementation of both soft and firm cores of arithmetic units that meet IEEE 754-2008 standard. A secondary intent is to establish synthesis strategies to be used on Xilinx tools for implementing electronic devices that supports radix-10 arithmetic operations.

Resumen

Los microprocesadores de propósito general de hoy en día no poseen soporte

hardware para operaciones decimales; implementan unidades aritméticas binarias, las cuales poseen mejor rendimiento que las unidades aritméticas decimales, dado que los sistemas electrónicos se basan en transistores de dos estados. Muchas aplicaciones comerciales, tales como transacciones bancarias, financieras, operaciones contables, cálculo de tasas, entre otras, realizan procesamiento intensivo de números en punto flotante decimal. Estas aplicaciones, requieren que los resultados obtenidos sean los mismos a los obtenidos a mano.

El tratamiento de números en punto flotante decimal en sistemas que no poseen el soporte decimal adecuado, producen errores que pueden llevar a violaciones de requerimientos legales y de precisión. Estos errores, pueden hacer además, que una compañía pierda o gane millones de dólares. Una manera de solucionar este problema, es mediante el tratamiento a nivel software de las operaciones de punto flotante decimal. Otra solución es mediante conversiones y procesamiento en binario. La primera solución evita errores pero es lenta, en cuanto a la segunda solución pueden ocurrir errores de precisión. El interés en aritmética de punto flotante decimal impulsó en la revisión del estándar de punto flotante IEEE 754-1985, con el agregado del soporte de representaciones decimales, generando así el actual estándar IEEE 754-2008. En el mismo, se definen formatos de almacenamiento y métodos para el tratamiento de números de punto flotante decimal. Resulta auspisioso la utilización de dispositivos programables FPGAs como aceleradores hardware que efectúan operaciones de punto flotante decimal conforme al estándar IEEE 754-2008.

El presente trabajo de tesis propone el análisis, diseño e implementación sobre dispositivos FPGAs de Xilinx, de diferentes algoritmos que computen operaciones aritméticas en base 10. Las operaciones aritméticas desarrolladas son: suma, resta, raíz cuadrada y logaritmo decimal. El propósito fundamental de este trabajo, es contribuir al desarrollo e implementación de soft cores y firm cores de unidades aritméticas de punto flotante decimal conforme al estándar IEEE 754-2008, sobre dispositivos programables FPGAs. Otro de los propósitos consiste en establecer estrategias para que los sintetizadores, más precisamente aquellos usados por Xilinx, puedan emplearlas al implementar operaciones aritméticas en base 10 en los dispositivos.

Agradecimientos

En primer lugar quiero agradecer a Gustavo, por haber depositado en mi su confianza y tener la visión de que mis capacidades se ajustaban perfectamente al tema de tesis propuesto. Su experiencia en el tema, tuvo un valor superlativo en el desarrollo de este trabajo.

Siento una gratitud inmensa, hacia los integrantes del laboratorio en el que desarrollo mis investigaciones, perteneciente al instituto de investigación INTIA de UNCPBA. Principalmente a Lucas, Marcelo y Quique, quiénes no solo me han dado amistad y aliento constante, sino que además, han realizado contribuciones significativas en el desarrollo de este trabajo

Quiero agradecer a Sebastián, quien con su excelente formación en ciencias matemáticas, hizo aportes invaluables en lo que respecta al uso correcto de los símbolos y expresiones matemáticas, así como también en la forma de transmitir y/o demostrar algunos conceptos o afirmaciones.

Por último, agradecer al sector de investigación de la Facultad de Informática de la Universidad FASTA, por su apoyo y soporte en cuanto a recursos otorgados a las investigaciones realizadas en esta tesis.

Contenidos

Introducción................................................................................................................. 1

1.1. Motivación ........................................................................................................ 1

1.2. Trabajo precedente .......................................................................................... 4

1.3. Trabajo propuesto............................................................................................ 4

1.4. Contribuciones ................................................................................................. 6

1.5. Organización del informe................................................................................. 7

Conceptos preliminares................................................................................................ 9

2.1. Aritmética decimal en computadoras.............................................................. 9

2.2. Soporte de aritmética decimal para sistemas de computación ..................... 10 2.2.1. Soporte software........................................................................................ 11 2.2.2. Soporte hardware....................................................................................... 11

2.3. Estándar IEEE 754-2008................................................................................ 12 2.3.1. Formatos decimales ................................................................................... 13 2.3.2. Formatos de Intercambio ........................................................................... 14 2.3.3. Excepciones............................................................................................... 16 2.3.4. Redondeo .................................................................................................. 16

2.4. Field Programmable Gate Array - FPGA ....................................................... 16 2.4.1. Tecnología de programación...................................................................... 18 2.4.2. Arquitectura.............................................................................................. 18 2.4.2.1. Otros componentes ................................................................................. 19 2.4.3. IP cores .................................................................................................... 20 2.4.4. Diseño en FPGA........................................................................................ 21

Suma y Resta punto fijo en base 10............................................................................ 23

3.1. Introducción .................................................................................................. 23 3.1.1. Convenciones acerca de simbología utilizada en este capítulo.................... 28

3.2. Propuestas y Contribuciones ......................................................................... 28

3.3. Suma de números decimales sin signo ........................................................... 29 3.3.1. Resultados experimentales......................................................................... 34

3.4. Resta de números decimales sin signo. .......................................................... 35 3.4.1. Resultados experimentales......................................................................... 40

3.5. Suma/Resta decimal en complemento a la base diez..................................... 40 3.5.1 Resultados experimentales.......................................................................... 43

3.6. Suma/Resta decimal en signo valor absoluto................................................. 45 3.6.1. Basada en sumadores/restadores de enteros en C10 ..................................... 46 3.6.2. Basada en sumadores y restadores de decimales naturales.......................... 49 3.6.3. Resultados experimentales......................................................................... 50

3.7. Conclusiones el capítulo ................................................................................. 53

Logaritmo decimal en base 10.................................................................................... 55

4.1. Introducción ................................................................................................... 55 4.1.1. Convenciones acerca de simbología utilizada en este capítulo.................... 59

4.2. Propuesta y Contribuciones ........................................................................... 59

4.3. Método propuesto........................................................................................... 60 4.3.1. Convergencia de la sucesión auxiliar ......................................................... 62 4.3.2. Convergencia de la sucesión principal ....................................................... 64 4.3.3. Algoritmo propuesto.................................................................................. 64 4.3.4. Arquitectura del logaritmo radix-10 en punto fijo con selección directa ..... 71 4.3.4.1. Multiplicación decimal de p×1-dígitos. ................................................... 75 4.3.4.2. Resultados experimentales ...................................................................... 79

4.4. Logaritmo decimal radix-10 punto flotante .................................................. 80 4.4.1. Manejo de exponentes en operandos de entrada y salida ............................ 80 4.4.2. Manejo de cifras significativas y tamaño de LUTs ..................................... 81 4.4.3. Algoritmo para logaritmo decimal DFP ..................................................... 83 4.4.4. Arquitectura del logaritmo decimal DFP.................................................... 89 4.4.4.1. Tratamiento de exponente del argumento................................................ 90 4.4.4.2. Detección de ceros y nueves iniciales ..................................................... 92 4.4.4.3. Arquitectura de Log_fixed_red con reducción de latencia ....................... 93 4.4.4.4. Post-procesamiento del resultado ............................................................ 96 4.4.5. Análisis de error de la solución propuesta ................................................ 100 4.4.6. Resultados experimentales....................................................................... 101 4.4.7. Comparaciones con solución propuesta en [Che12] ................................. 103

4.5. Conclusiones del capítulo y trabajo futuro.................................................. 106

Raíz cuadrada punto fijo en base 10 ........................................................................ 109

5.1. Introducción ................................................................................................. 109 5.1.1. Convenciones acerca de simbología utilizada en este capítulo.................. 111

5.2. Propuesta y Contribuciones ......................................................................... 112

5.3. Método propuesto......................................................................................... 112

5.2. Arquitectura para calcular raíz cuadrada radix-10 punto fijo .................. 117

5.3. Resultados experimentales ........................................................................... 120

5.4. Raíz cuadrada radix-10 punto flotante........................................................ 122

5.5. Conclusiones del capítulo y trabajo futuro.................................................. 124

Conclusiones............................................................................................................ 127

6.1. Resumen final ............................................................................................... 127

6.2. Investigación futura ..................................................................................... 130 6.2.1. Generalización para dispositivos basados en LUTs de n entradas ............. 130

6.2.2. Formato BID (Binary Integer Decimal) ................................................... 131 6.2.3. Unidades aritméticas DFP en lógica programable .................................... 132

Bibliografía .............................................................................................................. 133

Lista de Figuras

Figura 1.1 – Ejemplo de error por redondeo en un cálculo de tasa decimal usando punto flotante binario de doble precisión................................................................................. 2

Figura 1.2 – Propuestas y contribuciones de la presente tesis conjuntamente con [Vaz11]......................................................................................................................... 6

Figura 2.1 – Función programable simple (f = a.b’).................................................... 18

Figura 3.1 – Ejemplo de sucesivas correcciones utilizado sumador binario................. 25

Figura 3.2 – Ejemplo suma binaria con bias y corrección. .......................................... 25

Figura 3.3 – Ejemplo suma multioperando usando suma binaria y representación sobrecargada. .............................................................................................................. 26

Figura 3.4 - Implementación de la suma de operandos de dos bits en slice de dispositivos de Xilinx [Xil15a].................................................................................... 28

Figura 3.5 - Implementación de sumador completo de un dígito BCD, ai = xi + yi , en dispositivos con LUTs de 6 entradas con cálculo de Gi y Pi a partir de la suma inicial. 31

Figura 3.6 - Implementación de sumador completo de un dígito BCD, ai = xi + yi, en dispositivos con LUTs de 6 entradas con cálculo de Gi y Pi dependiendo de las entradas.................................................................................................................................... 32

Figura 3.7 - Implementación de sumador completo de un dígito BCD, ai = xi + yi, en dispositivos con LUTs de 6 entradas según [Din10a]. ................................................. 33

Figura 3.8 - Restador de números naturales BCD (Sub_Nat), s = x - y. ....................... 35

Figura 3.9 - Restador BCD de un dígito, si = xi - yi. .................................................... 36

Figura 3.10 - Restador binario de un bit, z[j] = x[j]-y[j].............................................. 36

Figura 3.11 - Implementación de restador de un dígito BCD, si = xi -yi, en dispositivos con LUTs de 6 entradas............................................................................................... 37

Figura 3.12 - Restador de números naturales BCD con resultado en SVA sin overflow (Sub_S), ss = x - y. ...................................................................................................... 38

Figura 3.13 - Implementación de restador de un dígito BCD con resultado en SVA sin overflow, ssi = xi - yi, en dispositivos con LUTs de 6 entradas. .................................... 39

Figura 3.14 - Implementación de sumador/restador de un dígito BCD con operandos en C10, sai = xi ± yi, en dispositivos con LUTs de 6 entradas, con cálculo de Gi y Pi

dependiendo de la suma inicial.................................................................................... 41

Figura 3.15 - Implementación de sumador/restador de un dígito BCD con operandos en C10, sai = xi ± yi, en dispositivos con LUTs de 6 entradas, con cálculo de Gi y Pi a partir de las entradas............................................................................................................. 42

Figura 3.16 - Implementación de sumador/restador de un dígito BCD con operandos en C10, sai = xi ± yi, en dispositivos con LUTs de 6 entradas basado en Adder-III. ............ 43

Figura 3.17 - Sumador/Restador de números enteros decimales representados en SVA, r = x ± y, basado en sumador/restador en C10. .............................................................. 47

Figura 3.18 - Implementación de sumador/restador en SVA en dispositivos con LUTs de 6 entradas, r = x ± y, basado en sumador/restador en C10. ....................................... 48

Figura 3.19 - Sumador/Restador de números enteros decimales representados en SVA, r = x ± y, basado en sumador, restador y multiplexor. .................................................. 49

Figura 3.20 - Implementación de sumador/restador de un dígito con operandos en SVA, ri = xi ± yi, en dispositivos con LUTs de 6 entradas, basado en sumador y restador de números naturales (con Adder-I). ................................................................................ 51

Figura 4.1 - Circuito que calcula el logaritmo punto fijo radix-10............................... 72

Figura 4.2 - Implementación de ppUi en dispositivos con LUTs de 6 entradas según

[Din10b] ..................................................................................................................... 77

Figura 4.3 - Implementación de ppLi en dispositivos con LUTs de 6 entradas según

[Din10b]. .................................................................................................................... 78

Figura 4.4 - Circuito que calcula el logaritmo DFP conforme al estándar IEEE 754-2008............................................................................................................................ 90

Figura 4.5 - Implementación de Process Exponent Input. ........................................... 91

Figura 4.6 - Circuito que implementa Bin_to_BCD.................................................... 92

Figura 4.7 - Circuito correspondiente a Leading Zeros y Leading Nines..................... 93

Figura 4.8 - Circuito Log_fixed_red........................................................................... 94

Figura 4.9 - Circuito Lut_log*.................................................................................... 96

Figura 4.10 - Circuito Post-Process Result. ................................................................ 97

Figura 4.11 - Circuito Pre-Process Significand Qs.p+2............................................... 98

Figura 4.12 - Circuito Round. .................................................................................... 99

Figura 4.13 - Circuito Process Exponent. ................................................................. 100

Figura 5.1 - Circuito que calcula la raíz cuadrada radix-10 punto fijo. ...................... 118

Figura 5.2 - Circuito que determina la división (div). ............................................... 119

Figura 5.3- Circuito que implementa Cmp. .............................................................. 120

Figura 6.1 –Sumador radix-B de p dígitos. ............................................................... 130

Figura 6.2 – Full Adder radix-B. .............................................................................. 131

Lista de Tablas

Tabla 2.1 – Codificaciones binarias de números decimales......................................... 10

Tabla 2.2- Parámetros de los formatos básicos de números DFP................................. 13

Tabla 2.3 – Tamaño (bits) de los campos pertenecientes a los formatos de intercambio de números de punto flotante decimal. ........................................................................ 14

Tabla 2.4 – Parámetros de los formatos de intercambio de números DFP. .................. 15

Tabla 2.5 – Interpretación de campo combinacional (clasificaciones especiales) ........ 15

Tabla 2.6 – Interpretación de campo combinacional (números de punto flotante finito)................................................................................................................................... 15

Tabla 2.7 – Principales compañías fabricantes de FPGAs........................................... 18

Tabla 2.8 – Compañías vendedoras de herramientas EDA. ......................................... 22

Tabla 3.1. Tiempo de cálculo (ns) de sumadores decimales sin signo en Virtex 7 con speed grade 3 .............................................................................................................. 34

Tabla 3.2. Área (LUTs) de sumadores decimales sin signo en Virtex 7 con speed grade 3 ................................................................................................................................. 34

Tabla 3.3. Penalización en área entre los diferentes sumadores en Virtex 7 con speed grade 3........................................................................................................................ 35

Tabla 3.4. Aceleraciones entre los diferentes sumadores en Virtex 7 con speed grade 3................................................................................................................................... 35

Tabla 3.5. Tiempo de cálculo (ns) en Virtex 7 con speed grade 3 ............................... 40

Tabla 3.6. Área (LUTs ) en Virtex 7 con speed grade 3 .............................................. 40

Tabla 3.7. Tiempo de cálculo (ns) de sumadores/restadores C10 en Virtex 7 con speed grade 3........................................................................................................................ 44

Tabla 3.8. Área (LUTs) de sumadores/restadores C10 en Virtex 7 con speed grade 3... 44

Tabla 3.9. Penalización en área entre los diferentes sumadores/restadores en Virtex 7 con speed grade 3........................................................................................................ 44

Tabla 3.10. Aceleraciones entre los diferentes sumadores/restadores en Virtex 7 con speed grade 3 .............................................................................................................. 45

Tabla 3.11. Operación efectiva entre los operandos en SVA y signo del resultado (sr) 45

Tabla 3.12. Tiempo de cálculo (ns) de sumadores/restadores BCD en SVA en Virtex 7 con speed grade 3........................................................................................................ 50

Tabla 3.13. Área (LUTs) de sumadores/restadores BCD en SVA en Virtex 7 con speed grade 3........................................................................................................................ 51

Tabla 3.14. Penalización en área entre los diferentes sumadores/restadores en SVA implementados en Virtex 7 con speed grade 3............................................................. 52

Tabla 3.15. Aceleraciones entre los diferentes sumadores/restadores BCD en SVA en Virtex 7 con speed grade 3.......................................................................................... 52

Tabla 4.1. Ejemplo de cálculo de logaritmo de 0.5431297 con precisión p=7 ............ 66

Tabla 4.2. Tiempo de cálculo (ns) de logaritmo punto fijo radix-10 en Virtex 7 con speed grade 3 .............................................................................................................. 80

Tabla 4.3. Área (LUTs) de logaritmo punto fijo radix-10 en Virtex 7 con speed grade 3................................................................................................................................... 80

Tabla 4.4. Rango del resultado dependiendo del formato decimal escogido ................ 81

Tabla 4.5. Características del exponente del argumento según estándar IEEE 754-2008.................................................................................................................................... 91

Tabla 4.6. Operaciones involucradas para calcular mantisa extendida Qs.p+2. ........... 98

Tabla 4.7. Tiempo de cálculo (ns) de logaritmo radix-10 DFP en Virtex 7 con speed102

Tabla 4.8. Área (LUTs) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3... 102

Tabla 4.9. Área (LUTs) de Lut_log* en Virtex 7 con speed grade 3 ......................... 103

Tabla 4.10. Tiempo de cálculo (ns) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3...................................................................................................................... 105

Tabla 4.11. Área (LUTs) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3. 105

Tabla 4.12. Tiempos de cálculo (ns) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3 de ambas propuestas. .................................................................................... 105

Tabla 4.13. Área (LUTs) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3 de ambas propuestas. ..................................................................................................... 105

Tabla 4.14. Aceleraciones producidas por las propuestas de esta tesis en Virtex 7 con speed grade 3 ............................................................................................................ 106

Tabla 4.15. Penalizaciones en área de propuestas de [Che12] en Virtex 7 con speed grade 3...................................................................................................................... 106

Tabla 5.1. Ejemplo de cálculo de 73753.0 con precisión p=5................................ 115

Tabla 5.2. Tiempo de cálculo (ns) de raíz cuadrada punto fijo radix-10 en Virtex 7 con speed grade 3 ............................................................................................................ 121

Tabla 5.3. Área (LUTs) de raíz cuadrada punto fijo radix-10 en Virtex 7 con speed grade 3...................................................................................................................... 121

Tabla 5.4. Tiempo de cálculo (ns) de raíz cuadrada punto fijo radix-10 .................... 122

Tabla 5.5. Área (LUTs) de raíz cuadrada punto fijo radix-10.................................... 122

Lista de Abreviaturas

ASIC Application Specific Integrated Circuit

BCD Binary Coded Decimal

BID Binary Integer Decimal

CLB Configurable Logic Block

CPLD Complex Programmable Logic Device

DFP Decimal Floating Point

DPD Desenly Packed Decimal

DSP Digital Signal Processor

EDA Electronic Design Automation

FPGA Field Programmable Gate Array

HDL Hardware Description Language

HPC High Performance Computing

IIoT Industrial Internet of Things

LUT Look Up Tables

PSoC Programmable System on a Chip

VHDL VHSIC Hardware Description Language

VHSIC Very High Speed Integrated Circuit

1

CAPÍTULO 1

Introducción

1.1. Motivación

Si bien las primeras computadoras implementaban unidades aritméticas decimales (en base 10 o radix-101), con el paso del tiempo prevalecieron las unidades aritméticas binarias (radix-2). Esto se debió a la generalización de todo tipo de aplicación, tanto las comerciales como las científicas, y al incremento de la demanda de aplicaciones científicas sobre las comerciales. La aritmética binaria es más adecuada para aplicaciones científicas ya que posee mejor rendimiento, dado que, en las computadoras electrónicas basadas en transistores de dos estados, los datos binarios se almacenan y procesan más eficientemente y más rápidamente que los datos decimales.

Hoy día, la demanda de aplicaciones comerciales aumentó significativamente, tal es el caso de las aplicaciones de comercio electrónico, financieras, transacciones bancarias, contables, etc. Estas aplicaciones hacen uso intensivo de números decimales (enteros y punto flotante), y con frecuencia requieren que los resultados obtenidos sean los mismos a los obtenidos “manualmente”, ya que los errores introducidos al tratar estos números como binarios pueden violar requerimientos legales o de precisión [Cow03] [Vaz09a].

Cuando se realizan operaciones decimales en sistemas que no poseen el soporte decimal adecuado, esto es, almacenar formatos decimales, tratamiento de tipos de datos decimales, u operaciones decimales; se pueden producir resultados con errores de representación, conversión o redondeo.

Para almacenar un número decimal exacto en una computadora que no posee soporte para almacenar formato decimal, existe la posibilidad que se almacene un número aproximado inexacto. Por ejemplo, cuando se almacena el número decimal 0,110, en un sistema que no posee soporte para almacenar formato decimal, se obtiene un error en la representación, ya que este número se corresponde al número binario periódico 0,00011001100…1100…2.

Los tipos de datos decimales también son necesarios. Si un valor decimal exacto, el cual se encuentra almacenado adecuadamente en un sistema con soporte para almacenar formato decimal, se usa en un entorno de programación que no posea tipos de datos decimales, posiblemente se producirá error de conversión.

1 Radix-B. Es un sistema convencional de representación de números, utiliza la base fija B y el número está dado por el conjunto de dígitos comprendido en el rango {0, 1, .., B-1}

2

Por otro lado, en un sistema sin soporte para la realización de operaciones decimales, también pueden ocurrir errores de redondeo. En [Cow03] se muestra un ejemplo interesante que permite apreciar muy bien el problema del redondeo. Considérese el cálculo de una tasa de 5% sobre las ventas de un determinado ítem, tal caso de una llamada telefónica con costo de $0,70, usando punto flotante binario de doble precisión y técnica de redondeo RoundTiesToEven (figura 1.1). Obsérvese que el resultado obtenido es un centavo menor al resultado esperado. Este tipo de errores, pueden conducir a que una compañía, al cabo de no mucho tiempo, pierda o gane millones de dólares.

Decimal Punto flotante binario

0,7 x 1,05 = 0,735 0,69999999999999998 x 1,05 = 0,73499999999999998

↓ (RoundTiesToEven) ↓ (RoundTiesToEven)

= 0,74 = 0,73

Figura 1.1 – Ejemplo de error por redondeo en un cálculo de tasa decimal usando punto flotante binario de doble precisión.

Un hecho real no vinculado con aspectos comerciales, sino con la vida de personas, demuestra la importancia de evitar este tipo de errores. Durante la guerra del golfo en 1991, un misil Patriot lanzado por EE.UU., falla en la intercepción de un misil SCUD iraquí. Un reporte oficial de Washington [Bla92], informó que la falla se debió a problemas de software en el sistema de control, relacionados a errores de redondeo en los cálculos de rangos y velocidades.

A raíz del interés en aritmética decimal en computadoras, luego de varios años de borradores, revisiones y acuerdos, en agosto del 2008 surge el estándar IEEE 754-2008 [IEEE08]. El propósito del estándar es proveer métodos para el cómputo de números punto flotante decimal (DFP, Decimal Floating Point), de modo que, ante los mismos datos de entrada, se obtienen los mismos resultados independientemente si el procesamiento se efectúa en hardware, en software, o en ambos.

Los procesadores de propósito general más difundidos y utilizados hoy en día, no proveen instrucciones o soporte hardware para aritmética DFP. Como consecuencia de esto se utilizan dos alternativas para mitigar la eventual pérdida de precisión: a) los números decimales, son leídos, convertidos a números binarios y procesados utilizando aritmética de punto flotante binario, aceptando la consecuente pérdida de precisión; b) se utilizan diferentes bibliotecas de software que realizan el cálculo sin pérdida. La primera estrategia obtiene mejores resultados en cuanto a velocidad respecto a la segunda, pero puede producir errores, inaceptables para algunas aplicaciones comerciales, producto de las conversiones y redondeos.

Las bases de datos de aplicaciones comerciales, utilizan una cantidad significativa de datos decimales. Por tanto, la mayoría de los lenguajes de alto nivel utilizados para este tipo de aplicaciones, poseen soporte de aritmética decimal, ya sea directamente o mediante el uso de librerías.

Existe soporte de aritmética decimal de punto flotante proveniente desde ambas vertientes: hardware y software. En lo que respecta a software, existen lenguajes que ofrecen librerías de DFP, tales casos de IBM C DecNumber [Cow10], Java Big Decimal

3

[Sun17] [IBM03], Lua decNumber [Cur07], Phyton Decimal [Bat03], Eiffel Decimal Arithmetic [Cri04] y Rexx [ANS96], entre otros.

Las soluciones hardware ya aparecían en las primeras computadoras electrónicas, tales como ENIAC [Gol96], UNIVAC [Hea01] e IBM 650 [Knu86], las cuáles realizaban sus funciones aritméticas en base decimal. Sin embargo, más recientemente, los mainframes de IBM proveen instrucciones con soporte hardware de aritmética DFP, tales caso de IBM Power6 [Eis07] y Power 7 [Wen10], e IBM System z9 [Dua07] y z10 [Sch09].

Las implementaciones software de operaciones DFP, se encuentran entre uno y dos órdenes de magnitud más lenta que las soluciones hardware [Erl09] [Che11]. Por otro lado, la evolución continua que interviene en el desarrollo electrónico, permite la fabricación de circuitos integrados con millones de transistores a costos moderados. Esto lleva a que para los fabricantes de microprocesadores de propósito general, sea atractivo proveer unidades aritméticas DFP hardware en sus productos [Vaz09a].

Pot otra parte, estudios realizados por investigadores de Intel, indican que la mayoría de las aplicaciones comerciales, solo consumen desde el 1% al 5% de su tiempo de ejecución, en la realización de operaciones decimales [Cor07]. Según opinión de estos investigadores, las soluciones hardware de aritmética decimal en los productos de Intel, aún no son necesarias [Erl09].

De lo expuesto anteriormente, resulta interesante la utilización de dispositivos de lógica programables FPGAs (Field Programmable Gate Array), como aceleradores hardware que efectúen operaciones aritméticas DFP conforme al estándar IEEE 754-2008. Más aún, teniendo en cuenta que en el área de supercomputación (HPC, High

Performance Computing), las principales compañías ofrecen soluciones basadas en procesadores AMD o Intel y aceleradores hardware FPGAs, tales casos de CRAY (www.cray.com) o SRC (www.srccomp.com).

El mercado de circuitos reprogramables ha crecido muy velozmente, compitiendo en mercados que tradicionalmente eran exclusivos de tecnologías ASICs (Application

Specific Integrated Circuit) o DSPs (Digital Signal Processor). Las FPGAs ofrecen características muy favorables, dependiendo con la tecnología que se la compare, tales como flexibilidad, rápida prototipación, velocidad de operación, costo de desarrollo, etc [Des06] [Gok05][Wil07][Sim15].

Una práctica muy común y útil cuando se diseña en FPGAs o ASICs, es la incorporación de IP cores (núcleos de propiedad intelectual). Éstos son bloques de lógica reusable, celdas o diseño de layout de un chip, que son de propiedad intelectual de terceras partes.

Los IP cores entran en tres categorías principales: hard IP cores, firm IP cores o soft IP cores. En un extremo, los hard IP cores son bloques pre-implementados diseñados tan eficientemente como es posible en términos de área, consumo de potencia o tiempo de cálculo. En el otro extremo, los soft IP cores hacen referencia a librerías a nivel fuente de funciones de alto nivel que pueden ser incluidos en el diseño. Presentan flexibilidad y mucha portabilidad, ya que son independientes del fabricante y tecnología seleccionada. En el caso de los firm IP cores, son librerías de funciones que ya están

4

mapeadas, ubicadas y ruteadas en los bloques lógicos (recursos) programables del dispositivo. Estos cores no son tan flexibles ni portables como los soft IP cores

[Max04].

Actualmente, no existen en el mercado, muchos cores de unidades de cálculo DFP para FPGAs. Existe una empresa SilMinds (www.silminds.com), que comercializa soft

IP cores sintetizables que efectúan ciertas operaciones DFP conforme al estándar IEEE 754-2008. Los soft cores desarrollados por esta compañía, están destinados tanto al desarrollo de procesadores comerciales o ASICs, como también al desarrollo de sistemas basados en FPGA.

Existe una gran cantidad de publicaciones de trabajos que abordan aritmética decimal de punto fijo y flotante. La mayoría de estos trabajos son adecuados para el diseño de microprocesadores de propósito general y para ASICs. Existen muy pocos trabajos publicados, que abordan aritmética decimal en FPGA.

1.2. Trabajo precedente

El autor de la presente tesis realizó un trabajo de maestría titulado “Implementación de operaciones decimales en punto fijo sobre FPGAs” [Vaz11], el cuál constituye las bases o cimientos de esta tesis doctoral. El objetivo central de [Vaz11], fue desarrollar estrategias para la implementación eficiente de diferentes algoritmos de suma, suma/resta y multiplicación radix-10 en punto fijo sobre dispositivos FPGAs de Xilinx.

Para la implementación de las operaciones suma y resta radix-10, se propuso la utilización de los recursos dedicados presentes en estos dispositivos que implementan de manera eficiente la propagación de acarreo en la suma binaria.

También se desarrollaron diversas estrategias para efectuar la multiplicación radix-10. Se abordaron diferentes técnicas, tanto para la generación de múltiplos de multiplicando, como para la acumulación y reducción de productos parciales. Para ello, se propusieron diseños basados en los sumadores radix-10 con propagación eficiente de acarreo. Además, se estudiaron, combinaron e implementaron, varias técnicas novedosas y exitosas en tecnología ASIC.

Es importante destacar que el trabajo de maestría [Vaz11] y la presente tesis doctoral son independientes, es decir, cada uno presenta sus objetivos, propuestas y contribuciones. De todas maneras, se pueden observar ambos trabajos, como etapas de un trabajo más abarcativo, más completo, que contribuye en el desarrollo de estrategias para la implementación eficiente de operaciones aritméticas radix-10 en dispositivos FPGAs de Xilinx, en donde [Vaz11] y la presente tesis, se corresponden con la primera y segunda etapa respectivamente.

1.3. Trabajo propuesto

Una unidad aritmética de punto flotante está basada, o debe implementar, operaciones de punto fijo. A modo de ejemplo, cuando se realiza la operación suma en punto flotante entre dos operandos, por un lado, se efectúa procesamiento relacionado al

5

punto flotante, como el tratamiento de exponente, identificación de casos especiales (cero, infinito, etc), desplazamiento y alineación de las mantisas considerando los exponentes, manejo de excepciones, aplicación de técnicas de redondeo, entre otras. Además, se implementa la suma punto fijo entre los operandos desplazados y alineados. Lo mismo sucede con cualquier operación aritmética punto flotante, se hace el procesamiento vinculado al punto flotante y se implementa la correspondiente operación punto fijo con los operandos procesados.

Para el desarrollo eficiente de unidades aritméticas DFP, es clave tener amplios conocimientos y experiencia en el área aritmética radix-10, especialmente en lo que respecta a punto fijo.

La presente tesis tiene como objetivo central el análisis, diseño e implementación sobre dispositivos FPGAs de Xilinx, de diferentes algoritmos que computen operaciones aritméticas radix-10. Las operaciones aritméticas desarrolladas son: suma, resta, raíz cuadrada y logaritmo decimal. La elección de Xilinx, surge como consecuencia que es la compañía líder en ventas y desarrollos de dispositivos programables FPGAs.

Se utiliza la codificación BCD (Binary Coded Decimal) para representar los operandos radix-10. Esto se debe a que es la codificación empleada en los formatos DFP definidos por el estándar IEEE 754-2008.

La operación suma es fundamental y es utilizada en todas las operaciones aritméticas. Debido a ello, los dispositivos programables de Xilinx, poseen recursos dedicados utilizados para la implementación eficiente de la propagación de acarreo de la suma binaria. Estos recursos dedicados, llevan a que la implementación de un sumador ripple-carry sea más eficiente que la implementación de sumadores basados en otras técnicas de cálculo de acarreo exitosas en ASICs. En consecuencia, las soluciones propuestas en el presente trabajo, se sustentan en la certeza que muchas soluciones que son eficientes (o ineficientes) en tecnologías ASICs, no lo son en FPGAs.

Para las operaciones suma y resta en punto fijo BCD, los diseños propuestos aplican y extienden los diseños presentados en [Vaz11]. Las soluciones se basan en la utilización de los recursos dedicados para la implementación de la suma binaria. Se propone el desarrollo de diferentes estrategias para las operaciones de suma y resta de números naturales y enteros. Para la representación de números enteros, se utilizan los sistemas signo y valor absoluto (SVA), y complemento a la base diez (C10).

En lo que respecta a las operaciones raíz cuadrada y logaritmo decimal, los diseños propuestos utilizan métodos iterativos mediante recurrencia de dígitos. Para la operación cuadrada radix-10, la propuesta involucra operandos en punto fijo. Para la operación logaritmo decimal radix-10, se realizan soluciones en punto fijo y DFP conforme al estándar con el soporte de todos los formatos: decimal32, decimal64 y decimal128.

El propósito fundamental de este trabajo es establecer bases sólidas, que posibiliten el desarrollo e implementación de soft cores y firm cores, de unidades aritméticas DFP conforme al estándar IEEE 754-2008, sobre dispositivos FPGAs. Además, poder contribuir a que los sintetizadores, particularmente aquellos utilizados

6

por Xilinx, puedan emplear las estrategias expuestas en este trabajo para la implementación de operaciones aritméticas radix-10 en punto fijo y punto flotante.

La figura 1.2 muestra las propuestas y contribuciones realizadas en la presente tesis conjuntamente con las del trabajo precedente [Vaz11]. Se observa cuáles son los alcances y las intersecciones existentes en ambos trabajos. Además, se puede apreciar ambos trabajos como dos etapas que constituyen un trabajo más abarcativo y completo, cuyo objetivo y propósito son los mismos a los expuestos en la presente tesis.

Primera Etapa:

Maestría

Suma

LUT-6 Suma/Resta C

10

LUT-6

Suma

LUT-4 Multiplicación

LUT-6

Segunda Etapa:

Doctorado (LUT-6)

Raíz

cuadrada

Resta

Suma Suma/Resta

SVA y C10

Logaritmo

decimal

[Din10a]

Figura 1.2 – Propuestas y contribuciones de la presente tesis conjuntamente con [Vaz11].

1.4. Contribuciones

Se publicaron dos trabajos de relevancia internacional en donde se exponen las ideas desarrolladas en la presente tesis respecto a las operaciones de suma, resta [Vaz15] y raíz cuadrada [Vaz14]. Resulta importante mencionar, que un artículo con los aportes involucrados el diseño e implementación del logaritmo decimal radix-10 en punto fijo y DFP conforme al estándar IEEE 754-2008, se encuentra en evaluación en el momento de la redacción de esta memoria.

A continuación, se realiza una breve descripción, de las principales contribuciones de esta tesis en el área aritmética radix-10 en punto fijo y punto flotante conforme al estándar IEEE 754-2008, sobre dispositivos FPGAs de Xilinx basados en LUTs (Look

Up Tables) de 6 entradas:

- Estudio y determinación de las mejores técnicas de diseño de sumadores BCD en arquitecturas de dispositivos con LUT de 6 entradas [Vaz15]. Para ello se describen y comparan los diseños de sumadores radix-10 de dos operandos expuestos en [Vaz11], con el diseño novedoso de la suma BCD multioperando presentada en [Din10a].

7

- Diseño e implementación de un restador BCD de números naturales. Se presenta una técnica novedosa que aprovecha la lógica perteneciente al diseño de restador binario para efectuar la resta BCD entre números naturales decimales [Vaz15].

- Estudio y determinación de las mejores técnicas de diseño de sumadores/restadores BCD con operandos en C10 en dispositivos con LUTs de 6 entradas [Vaz15]. Se describen y analizan los diseños presentados en [Vaz11], y además se efectúa la comparación con una adaptación del trabajo de [Din10a] de modo que posibilite realizar la suma/resta BCD de números en C10.

- Diseño e implementación eficiente de sumador/restador BCD con operandos representados en SVA en dispositivos con LUTs de 6 entradas. El SVA es usado para la representación de la mantisa de los números DFP conforme al estándar IEEE 754-2008 [Vaz15].

- Diseño e implementación del logaritmo decimal radix-10 en punto fijo. Se propone un método iterativo mediante recurrencia de dígitos (digit-recurrence) basado en una técnica novedosa de selección directa del dígito de convergencia. La ruta de datos no se basa en la implementación de lógica redundante con ahorro de acarreo (carry-save) como sucede con los principales trabajos de la bibliografía para tecnología ASIC en recurrencia de dígitos, tales caso [Piñ02a], [Piñ02b] y [Che12].

- Diseño e implementación del logaritmo decimal DFP conforme al estándar IEEE 754-2008. La solución se basa en el método propuesto para el logaritmo decimal radix-10 en punto fijo y soporta todos los formatos: decimal32, decimal64, decimal128.

- Diseño e implementación de la operación raíz cuadrada radix-10 en punto fijo. Se propone un método iterativo con recurrencia de dígitos basado en la técnica de restauración (restoring), con un novedoso mecanismo de selección del dígito perteneciente al resultado en cada iteración. Este mecanismo se basa en una división simple y posterior verificación de dos dígitos adicionales en caso que se requiera restaurar.

Las implementaciones propuestas no utilizan los núcleos embebidos que se encuentran en los dispositivos, tales como memorias, multiplicadores, etc. Por otro lado, las descripciones de los diseños realizan la instanciación de módulos LUTs y multiplexores dedicados utilizados para la implementación de la lógica de acarreo. De este modo, para que los diseños se puedan implementar en cualquier dispositivo de lógica programable (o tecnología ASIC) independientemente del fabricante, solo se requiere reemplazar la instanciación de estos componentes por su descripción correspondiente en un lenguaje de descripción de hardware (VHDL en esta tesis).

1.5. Organización del informe

El presente informe se encuentra comprendido por 6 capítulos. Los capítulos 3, 4 y 5; contienen todo lo referente al diseño e implementación de las operaciones aritméticas desarrolladas. Cada uno de estos capítulos es autocontenido, se corresponde con una operación y se puede leer de manera independiente respecto a los otros.

Primero, en el capítulo 2 se detallan conceptos preliminares que son importantes para abordar este informe. Éstos están relacionados con la aritmética decimal en

8

computadoras, soporte hardware y software existentes, un resumen de las especificaciones que contiene el estándar IEEE 754-2008 en lo que respecta a DFP, y por último, una introducción a los dispositivos programables FPGAs y conceptos referentes al diseño de sistemas digitales en esa tecnología.

En el capítulo 3 se aborda las operaciones suma y resta radix-10 punto fijo. Se comienza con una breve descripción de las publicaciones, para ASICs y FPGAs, existentes en suma y resta decimal punto fijo y flotante. Luego se expone la propuesta junto con las contribuciones referente a las operaciones suma y resta decimal. A continuación se desarrollan las estrategias implementadas en dispositivos de Xilinx con

LUTs de 6 entradas para la suma y resta de números naturales y suma/resta de números enteros. Se efectúan comparaciones y análisis de los resultados; y se determinan expresiones matemáticas que estiman el tiempo de cálculo y área. Al final del capítulo se exhiben las conclusiones.

A continuación, en el capítulo 4, se desarrolla la solución propuesta para la operación logaritmo decimal radix-10 en punto fijo y punto flotante. Primero, se efectúa un resumen de los trabajos existentes, tanto en ASICs como en FPGAs, de soluciones para la implementación hardware de la operación de logaritmo en radix-2, radix-10 y radix-2b. Luego se detalla la propuesta y las contribuciones realizadas para la implementación en FPGAs de la operación de logaritmo radix-10. Se prosigue con el diseño de una estrategia basada en recurrencia de dígitos para la implementación de logaritmo decimal radix-10 punto fijo. Posteriormente, se presenta el logaritmo decimal DFP basado en el uso del logaritmo punto fijo desarrollado. Se muestran y analizan los resultados de las implementaciones de los diseños propuestos en dispositivos con LUTs de 6 entradas. Se realizan comparaciones entre la propuesta y la implementación en el mismo dispositivo de la mejor solución existente, según el conocimiento del autor de la presente tesis, para el cálculo de logaritmo decimal DFP mediante recurrencia de dígitos. Por último, se describen las conclusiones y trabajos futuros.

El capítulo 5, presenta la propuesta para la implementación de la operación raíz cuadrada radix-10. Comienza el capítulo con una descripción de los trabajos existentes acerca de la implementación hardware de la operación raíz. A continuación, se expone la propuesta y las contribuciones obtenidas para la implementación en FPGA de esta operación. Luego, se detalla el diseño e implementación del método propuesto basado en recurrencia de dígitos, se muestran los resultados de las implementaciones en dispositivos basados en LUTs de 6 entradas, se realizan comparaciones con los métodos mas significativos en la bibliografía existente cuya solución se basa en técnicas mediante recurrencia de dígitos. Por último, se describen las conclusiones y trabajos futuros.

Finalmente, en el capítulo 6, se elaboran las conclusiones generales y se propone el trabajo futuro.

9

CAPÍTULO 2

Conceptos preliminares

En este capítulo se abordan conceptos que posibilitan la correcta interpretación de los términos y temas que se encuentran en los siguientes capítulos de la presente tesis. Primero se realiza una introducción a la aritmética decimal en computadoras, detallando las formas más conocidas de representación de números decimales. Luego se menciona el soporte existente de aritmética decimal en computadoras a partir de los dos ejes principales: hardware y software. En la sección 2.3, se presentan conceptos fundamentales que intervienen en el estándar en relación a la aritmética de punto flotante decimal, IEEE 754-2008. Por ultimo, se detallan aspectos significativos involucrados en el desarrollo en FPGAs: diferentes tecnologías de programación, cómo son las arquitecturas de las FPGAs, qué son los núcleos de propiedad intelectual y cuáles son las principales herramientas para desarrollo en esta tecnología existentes en el mercado.

2.1. Aritmética decimal en computadoras

La representación de los números ha evolucionado paralelamente a la del lenguaje. En el transcurso de la historia se emplearon muchos métodos para representar números, desde el uso de palos y piedras hasta el sistema numérico romano, en los cuales la representación de números grandes y realización de operaciones aritméticas son complicadas [Par00].

Los chinos fueron los primeros en utilizar el sistema posicional para representar números. La principal característica de este tipo de sistemas, es que el valor asociado a un símbolo no depende solo de él sino también de la posición respecto a los demás símbolos.

En un sistema posicional de base constante, una unidad en una correspondiente posición es un múltiplo constante de una unidad posicionada a la derecha. El sistema decimal es un sistema posicional de base diez.

El sistema decimal se origina en India aproximadamente en el siglo V d.C. [Ifr00] Según los antropólogos, el origen está en los diez dedos que poseen los humanos, los cuales han servido de base para contar. En este sistema una unidad en una posición es diez veces mayor a una unidad posicionada inmediatamente a la derecha. Los árabes adoptaron este sistema en el siglo IX y lo propagaron por Europa. Razón por la cual, los europeos se refieren al conjunto de símbolos {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} como números árabes [Erl09].

10

Los sistemas digitales implementan lógica de dos estados debido a los procesos físicos involucrados en el funcionamiento del transistor. Motivo importante por el cual, los números a menudo se representan mediante dígitos binarios o bits.

Existen muchas maneras de representar números decimales con codificaciones binarias [Rich55]. La tabla 2.1 muestra las codificaciones binarias BCD más usuales, algunas de ellas utilizadas en esta tesis.

Tabla 2.1 – Codificaciones binarias de números decimales.

Valor

decimal BCD-8421 BCD-4221 BCD-5421 BCD-5211 BCD-XS3

0 0000 0000 0000 0000 0011 1 0001 0001 0001 0010 ó 0001 0100 2 0010 0010 ó 0100 0010 0100 ó 0011 0101 3 0011 0011 ó 0101 0011 0110 ó 0101 0110 4 0100 1000 ó 0110 0100 0111 0111 5 0101 1001 ó 0111 1000 ó 0101 1000 1000 6 0110 1100 ó 1010 1001 ó 0110 1010 ó 1001 1001 7 0111 1101 ó 1011 1010 ó 0111 1100 ó 1011 1010 8 1000 1110 1011 1110 ó 1101 1011 9 1001 1111 1100 1111 1100

Obsérvese que la codificación de cuatro bits y (y3, y2, y1, y0) del valor decimal x

utilizando BCD-abcd, se interpreta de la siguiente manera: x = y3 a+ y2 b+ y1 c+ y0 d. La codificación BCD-8421, comúnmente conocida como BCD, es la más simple y directa ya que usa los pesos binarios de un entero binario de cuatro bits.

Por su parte, la codificación BCD-XS3 es un código BCD-8421 con exceso 3 (00112). Esta codificación no posee ceros en la representación y presenta como ventaja principal la suma de dos números. Esto se debe a que las combinaciones inválidas de códigos BCD que surgen al operar, se evitan mediante una corrección ±3. Otra ventaja es que es self-complementing, significa que el complemento a nueve (usado para la operación resta) de un dígito se realiza mediante la inversión lógica de cada bit perteneciente a la representación.

Las codificaciones redundantes BCD-4221, BCD-5421 y BCD-5211, también son self-complementing. BCD-4221 posee beneficios significativos relacionados a la suma carry-save binaria. En cuanto a las codificaciones BCD-5421 y BCD-5211, se usan para duplicar valores y obtener el resultado en codificación BCD-8421 y BCD-4221 respectivamente.

2.2. Soporte de aritmética decimal para sistemas de computación

Esta sección expone un breve resumen del soporte de aritmética decimal existente para sistemas de computación desde ambos ejes: software y hardware. Los contenidos que se desarrollan a continuación se basan en los contenidos del General Decimal

Arithmetic website (http://speleotrove.com/decimal/) reproducido con permiso de IBM, así como también de contenidos detallados en [Erl09].

11

2.2.1. Soporte software

Muchos lenguajes de programación incluyen tipos de datos primitivos decimal. Tal caso de Ada [ISO01], .NET Framework (C# [ISO03], Visual Basic [Mic11]), COBOL [ANS02], PL/I [ANS76] y SQL [ISO92].

Existen otros lenguajes que se adhieren al General Decimal Arithmetic

Specifications [Cow09] (GDAS) desarrollado por Mike Cowlishaw. Esta especificación se basa en el estándar IEEE 854-1987 [IEEE87], y forma la base de las especificaciones de aritmética decimal detalladas en el estándar IEEE 754-2008 [IEEE08] (sección 2.3). De este modo, los lenguajes que soportan GDAS operan conformes al estándar IEEE 754-2008. Varios lenguajes ofrecen librerías con soporte según GDAS: IBM C DecNumber [Cow10], Java Big Decimal [Sun17] [IBM03], Lua decNumber [Cur07], Phyton Decimal [Bat03], Eiffel Decimal Artithmetic [Cri04] y Rexx [ANS96].

Compiladores como C y C++ incorporaron extensiones para el soporte DFP conforme a IEEE 754-2008 [ISO15] [ISO17] [FSF08]. Por su parte Intel, desarrolló una librería matemática en C, que implementa aritmética DFP según estándar IEEE 754-2008 con mantisa codificada en binario (sección 2.3) [Cor07].

Muchos compiladores utilizan las instrucciones hardware DFP sujetas al estándar IEEE 754-2008 sobre las plataformas IBM Power6 [Eis07] y Power 7 [Wen10], e IBM System z9 [Dua07] y z10 [Sch09]. Tal es el caso de GCC (GNU Collection Compiler) [FSF17], IBM XL C/C++ [IBM17], IBM Enterprice PL/I [IBM07a], IBM DB2 [IBM07b], IBM High-level Assembler [IBM15], IBM DFPAL [IBM07c], etc.

2.2.2. Soporte hardware

Algunas de las primeras computadoras electrónicas, tales como ENIAC [Gol96], UNIVAC [Hea01] e IBM 650 [Knu86], realizaban sus funciones aritméticas en base diez. Aún con la llegada de las computadoras basadas en transistores de dos estados, se continuaban fabricando computadoras que procesaban datos en base diez mediante la codificación de cada dígito decimal en BCD. Sin embargo, con motivo de generalizar todo tipo de aplicación, ya sean tanto comerciales como científicas, y debido al incremento de la demanda de cálculos científicos rápidos, emergió y prevaleció la aritmética binaria.

Más recientemente, varios microprocesadores comerciales ofrecen instrucciones para aritmética BCD en punto fijo. Tal es el caso de los procesadores pertenecientes a las series x86 de Intel [Int01a], 68k de Motorola [Mot92] y HP PA-RISC [Kan96].

Los mainframes de IBM poseen un soporte más completo y extenso de hardware en aritmética decimal. En S/390 [IBM08] las operaciones básicas en punto fijo decimal, como suma, resta, multiplicación y división, mediante la utilización de la suma decimal directa. La plataforma System z9000 [Bus01] efectúa las mismas operaciones en punto fijo decimal mediante el empleo de sumadores decimal/binario combinados.

Por otro lado, los mainframes IBM Power6 [Eis07] y Power 7 [Wen10], e IBM System z9 [Dua07] y z10 [Sch09], proveen instrucciones con soporte de aritmética DFP conforme al estándar IEEE 754-2008.

12

La corporación SilMinds (www.silminds.com) comercializa núcleos (cores) sintetizables escritos en VHDL y Verilog que efectúan operaciones de suma, resta, multiplicación, división y raíz cuadrada conforme al estándar IEEE 754-2008. Los cores que ofrece SilMinds no solo están destinados para el desarrollo de procesadores comerciales o ASICs, sino que también al desarrollo de sistemas basados en FPGAs.

2.3. Estándar IEEE 754-2008

El estándar para aritmética de punto flotante IEEE 754-2008 [IEEE08], es un producto del Floating Point Working Wroup de IEEE Computer Society. El estándar provee mecanismos, normativas y reglas para realizar computación en punto flotante decimal y binario. Especifica formatos y métodos, tales como funciones estándares y extendidas con precisiones simple, doble, extendida y extendible, y además recomienda formatos de intercambio. También se definen las condiciones de excepciones así como su tratamiento.

El propósito de este estándar es proveer métodos para el cómputo de números en punto flotante, de modo que ante los mismos datos de entrada, se obtienen los mismos resultados independientemente si el procesamiento se realiza en hardware, en software, o en ambos.

La existencia de un estándar para aritmética de computadoras beneficia tanto a los desarrolladores de hardware, como a los desarrolladores de software y también a los usuarios finales. Los desarrolladores de hardware tienen confianza de sus implementaciones, las cuales ofrecen las mismas soluciones que implementaciones de otros desarrolladores. Pero cuando implementan una función estándar específica, pueden comparar el rendimiento de su solución con la de otros para determinar su competitividad. Por otro lado, un estándar le permite a los desarrolladores de software, realizar códigos portables para sistemas compatibles y obtener resultados consistentes. En cuanto a los usuarios finales, ellos pueden migrar sus datos de una plataforma a otra, posibilitando que no se encuentren sujetos a un formato de almacenamiento propietario [Erl09].

Este estándar surge de la combinación y ampliación de los estándares para aritmética de punto flotante binario IEEE 754-1985 [IEEE85] y punto flotante de radix independiente IEEE 854-1987 [IEEE87]. El estándar IEEE 854-1987 carece de descripciones para los formatos de almacenamiento de números DFP. Otra limitación es que no está determinado si los operandos y resultados deben estar normalizados o no. Estas limitaciones llevaron a una moderada recepción por parte de la comunidad de usuarios y a la inclusión de aritmética DFP en una versión revisada del estándar IEEE 754-1985.

El estándar IEEE 754-1985 define cuatro formatos para representar números de punto flotante binario (BFP, Binary Floating Point), incluyendo el cero negativo, números subnormales, infinitos y NaN (Not a Number). Además define un conjunto de operaciones sobre esos valores BFP, un conjunto de cuatro modos de redondeo y cinco tipos de excepciones. Este estándar se extendió varias veces, hasta que en el año 2000 se impulsa la revisión del IEEE 754-1985 para actualizar el estándar. Una parte de esta revisión es la incorporación de DFP (con consideraciones del IEEE 854-1987 [IEEE87])

13

Luego de ocho años de borradores, revisiones y acuerdos, en Agosto del 2008 surge el estándar IEEE 754-2008 [IEEE08]. Éste define cinco formatos de números de punto flotante (tres binarios y dos decimales), así como también formatos de intercambio decimal y binario. Además define cinco modos de redondeo y cinco tipos de excepciones con sus respectivos tratamientos.

El resto de esta sección describe los aspectos más significativos del estándar vinculados a aritmética DFP.

2.3.1. Formatos decimales

El conjunto de números DFP representable en un formato en particular se define con los siguientes parámetros:

- b = 10, correspondiente a la base

- p es el número de dígitos de la mantisa (precisión)

- emax el máximo exponente e

- emin el mínimo exponente e (con emin = 1- emax para todos los formatos)

La tabla 2.2 muestra los valores de los parámetros para cada formato básico correspondiente a la base decimal (b = 10).

Tabla 2.2- Parámetros de los formatos básicos de números DFP.

Formatos Parámetro

decimal64 decimal128

p (dígitos) 16 34 emax 384 6144

El conjunto de datos de punto flotante representados es el siguiente:

- números de punto flotante con signo, (-1)s×10e×m, donde

- s es el signo: 0 ó 1.

- e corresponde al exponente, con ∴∈ Ze emin ≤e≤ emax.

- m determina la mantisa, con m = d0.d1d2··dp-1 y { }9,..,1,0∈id , (0≤ m<10).

- dos infinitos: ±∞ - dos NaNs: qNaN (quiet) y sNaN (signaling).

En la descripción anterior, la mantisa se expresa de forma científica, con el punto decimal después del primer dígito. Dependiendo de la aplicación, muchas veces es conveniente observar a la mantisa como un entero. Por lo anterior, una manera equivalente de "entender" los números de punto flotante finitos es (-1)s×10q×c, donde

- s es el signo: 0 ó 1.

- ∴∈ Zq emin ≤ q+p-1 ≤ emax.

- c es un número entero con la forma c = d0d1··dp-1, con { }9,..,1,0∈id , (0≤ c<10p).

14

Se define número normal como un número punto flotante decimal diferente a cero cuya magnitud es mayor o igual que 10emin. De este modo, un número normal x se representa de la siguiente manera:

x = (-1)s×10e×m, con m≥1 y ∴∈ Ze emin ≤e≤ emax.

o alternativamente (mantisa como entero): x = (-1)s

×10q×c, con ∴∈ Zcq, emin-(p-1)≤ q ≤ emax-(p-1) y c≥10p-1.

Por otro lado, un número subnormal se define como un número de punto flotante decimal diferente a cero, cuya magnitud es menor que 10emin. Por consiguiente, un número subnormal x se representa de la siguiente manera:

x = (-1)s×10emin×m, con m<1, significa que d0=0.

o alternativamente (mantisa como entero), donde qmin = emin-(p-1):

x = (-1)s×10qmin

×c, con c<10p-1, significa que d0=0.

2.3.2. Formatos de Intercambio

El estándar especifica tres tipos de formatos de intercambio para números DFP: decimal32, decimal64 y decimal128. Cada formato está codificado en k bits y poseen tres campos: un campo de signo (S), un campo combinacional (G) y un campo de final de mantisa (T).

1 bit w+5 bits t = 10×J bits S

(signo) G

(campo combinacional) T

(campo final de mantisa) G[0] .. G[w+4] 3J=p-1

En la tabla 2.3 se aprecia la cantidad de bits involucrados en cada campo para

cada uno de los formatos. La tabla 2.4 muestra características, como cantidad de bits o rangos, de los parámetros involucrados en los distintos formatos de intercambio para números DFP.

Tabla 2.3 – Tamaño (bits) de los campos pertenecientes a los formatos de intercambio de números de punto flotante decimal.

Campo decimal32 decimal64 decimal128

S 1 1 1 G 11 13 17 T 20 50 110

k 32 64 128

En el campo final de mantisa (T), se encuentran codificados los p-1 dígitos menos

significativos correspondientes a la mantisa. Este campo posee J declets (3J=p-1) de 10 bits cada uno, en los cuales el final de mantisa se encuentra codificado en decimal o directamente en binario, BID (Binary Integer Decimal).

15

Tabla 2.4 – Parámetros de los formatos de intercambio de números DFP.

Parámetro decimal32 decimal64 decimal128

exponente (bits) 8 10 14 mantisa (dígitos) 7 16 34 bias de exponente 101 398 6176

e -95≤e≤96 -383≤e≤384 -6143≤e≤6144 q -101≤q≤90 -398≤q≤369 -6176≤q≤6111

Para la codificación decimal, se utiliza el formato desenly-packed decimal (DPD)

para empaquetar 3 dígitos BCD en un declet. Para poder empaquetar tres dígitos en BCD (doce bits) en diez bits, este formato se basa en el aspecto que con 4 bits, existen varias codificaciones no usadas para la representación de un número decimal en BCD. Tanto la codificación de BCD a DPD como la decodificación de DPD a BCD son simples [Cow02].

El campo combinacional (de tamaño w+5 bits) determina cómo es el dato almacenado o representado, esto es si es un valor infinito, o un número punto flotante finito, o NaN. Para el caso en que se almacene un número finito, en este campo se encuentra además codificados el exponente y el dígito más significativo de la mantisa. En las tabas 2.5 y 2.6 se observa como se decodifican los números DFP a partir de campo combinacional.

Tabla 2.5 – Interpretación de campo combinacional (clasificaciones especiales)

G[0..4] G[5..w+4] T Dato representado

11111 1x..x -- qNaN

11111 0x..x -- sNaN

11110 0..0 0..0 ±∞

Obsérvese que un número punto flotante decimal puede tener múltiples

representaciones. Al conjunto de representaciones para un número punto flotante determinado se lo denomina cohorte del número. Por ejemplo, si c es múltiplo de 10 y q

es menor al valor máximo permitido, entonces (s, q, c) y (s, q+1, c/10) son dos representaciones del mismo número punto flotante pertenecientes al mismo cohorte.

Tabla 2.6 – Interpretación de campo combinacional (números de punto flotante finito)

Codif. de

mantisa G[0..4] Exponente Mantisa (m=d0..dp-1)

0xxxx ó 10xxx G[0]&G[1]&G[5..w+4] – bias d0 = 4G[2] + 2G[1] + G[0]

d1..dp-1 = DPDtoBCD(T)

Decimal

110xx ó 1110x G[2]&G[3]&G[5..w+4] – bias d0 = 8 + G[4]

d1..dp-1 = DPDtoBCD(T)

Nota 1: x significa que puede tomar tanto el valor 0 como 1.

Nota 2: el símbolo “&” significa “concatenado con”.

Nota 3: la función DPDtoBCD, transforma declets en formato DPD a BCD.

16

2.3.3. Excepciones

El estándar especifica cinco tipos de excepciones que se indican cuando suceden. Esta indicación invoca al manejo, por defecto o alternativo, de la correspondiente excepción identificada. La implementación debe proveer el correspondiente flag de estado para cada tipo de excepción.

A continuación se detallan los cinco tipos de excepciones:

- Operación inválida: se indica cuándo no existe ningún resultado definible por el estándar. En este caso, los operandos son inválidos para la operación que se desea realizar. Ejemplos: ∞-∞, ∞×0, ∞/∞, etc.

- División por cero: se indica cuando un resultado infinito se produce por una operación entre operandos finitos.

- Overflow: cuando se excede en magnitud al número finito más grande.

- Underflow: si el resultado es diferente a cero y se encuentra estrictamente entre ±b

emin.

- Inexacta: si el resultado redondeado de una operación requiere de una precisión mayor a la soportada por el formato de representación utilizado.

2.3.4. Redondeo

Este estándar define cinco tipos de redondeo que pueden ser seleccionados por el usuario mediante el correspondiente seteo de atributos:

- RoundTiesToEven: se escoge la representación más cercana al resultado obtenido. Si dos representaciones se encuentran igualmente cerca, se escoge aquella cuyo dígito menos significativo sea par.

- RoundTiesToAway: se escoge la representación más cercana al resultado obtenido. Si dos representaciones se encuentran igualmente cerca, se escoge la de mayor magnitud.

- RoundTowardPositive: se escoge la representación más cercana mayor al resultado obtenido.

- RoundTowardNegative: se escoge la representación más cercana menor al resultado obtenido.

- RoundTowardZero: se escoge la representación más cercana menor en magnitud al resultado obtenido.

2.4. Field Programmable Gate Array - FPGA

Las FPGAs fueron inventadas en el año 1984 por Ross Freeman y Bernard Vonderschmitt, co-fundadores de Xilinx, y surgen como una evolución de los CPLDs (Complex Programmable Logic Device). Las FPGAs son circuitos integrados digitales que poseen bloques lógicos configurables (programables) e interconexiones entre esos bloques también configurables. Los diseñadores pueden configurar (o programar) estos

17

dispositivos para poder llevar a cabo gran variedad de tareas [Max04] [Kil07] [Gok05] [Sim15].

Al basarse en bloques lógicos pre-construidos y recursos para ruteo programables, se pueden configurar para poder implementar funcionalidades a medida de la aplicación en hardware. Para ello, solo se debe desarrollar sistemas digitales en software y compilarlas en un archivo de configuración o bitstream, que contenga información de cómo deben conectarse y configurarse los componentes. Otro aspecto significativo, es que muchas FPGAs son completamente reconfigurables, este tipo de dispositivo puede cambiar su funcionalidad en un instante, requieriendo solamente compilar un nuevo diseño, generar el archivo de configuración y programar el chip. Antiguamente los ingenieros requerían sólidos conocimiento de diseño de hardware para trabajar en esta tecnología. Sin embargo, con el aumento y evolución continua de las herramientas diseño de alto nivel, están cambiando las reglas involucradas en el uso y desarrollo en este tipo de tecnología [Nat17].

La adopción de FPGAs en la industria ha sido impulsada por el hecho que las FPGAs combinan lo mejor de los ASICs y los sistemas basados en procesadores. Ofrecen características ventajosas, dependiendo de la tecnología con que se las compare, tales como flexibilidad, rápida prototipación, rendimiento, costo de desarrollo, tiempo de llegada al mercado, fiabilidad y mantenimiento a largo plazo. Razón por la cuál, estos dispositivos se están empleando en forma creciente en aplicaciones que usualmente se implementaban con otras tecnologías, tal es el caso de ASICs, DSPs o microcontroladores genéricos.

La tecnología de los circuitos integrados ha evolucionado en las últimas cuatro décadas siguiendo la ley de Moore [Mor65], la cuál establece que la cantidad de transistores en un simple circuito integrado se duplica cada 18 (a 24) meses. Esta ley no es ajena en lo que respecta a la tecnología FPGAs, las mismas evolucionaron para poder incorporar complejos sistemas embebidos en un simple dispositivo. Pasaron de la concepción inicial de bloques configurables con interconexiones también configurables, a dispositivos que además incluyen módulos DSPs programables [Xil17a], bloques de memorias [Xil16a], procesadores [Int15] [Xil17b], entre otras.

Dos de sus principales fabricantes, Xilinx e Intel-Altera, ofrecen soluciones muy competitivas, tanto de plataformas hardware como herramientas EDA (Electronic

Design Automation) de co-diseño Hardware/Software, para áreas tales como supercomputación (HPC), IIoT (Industrial Internet of Things), Cloud Computing, sistemas de visión, conectividad 5G, desarrollo de PSoC (Programmable System on a

Chip), etc. [Xil17c] [Int17a].

En la tabla 2.7 se presenta un listado de las principales compañías fabricantes de FPGAs. Debido a la solidez de sus productos, Xilinx y Intel-Altera son las compañías líderes en el mercado de FPGAs. En un artículo publicado recientemente [Dil16], se expone que Xilinx e Intel-Altera controlaron el 90% del mercado en el 2016, donde Xilinx dominó con el 53% .

18

Tabla 2.7 – Principales compañías fabricantes de FPGAs

Compañía Sitio web

Xilinx Inc. www.xilinx.com Intel-Altera Corp. www.altera.com Microsemi Corp. www.microsemi.com Lattice Semiconductor Corp. www.latticesemi.com QuickLogic Corp. www.quicklogic.com

2.4.1. Tecnología de programación

A modo de ejemplo, en la figura 2.1 se aprecia una función programable simple de dos variables. Se observa que las celdas programables están vinculados a cada posible entrada. Significa que si se desea programar la función f (f = a.b’), se debe programar o conectar la entrada a y la entrada b’ (salida de compuerta not).

Existen diversas tecnologías que se pueden emplear para programar dispositivos programables como FPGAs. Las celdas programables pertenecientes a estos dispositivos pueden estar implementadas por fusibles, antifusibles, o memorias EPROM, EEPROM/Flash, static RAM (SRAM), etc. Cada alternativa presenta ventajas y desventajas respecto de las otras.

Figura 2.1 – Función programable simple (f = a.b’).

Tanto Xilinx como Intel-Altera, fabrican sus dispositivos con celdas programables basadas en SRAM. La principal ventaja de esta tecnología, es que los dispositivos pueden ser configurados una y otra vez, permitiendo que nuevos diseños sean testeados e implementados rápidamente con facilidad. Una desventaja significativa, es que la configuración del sistema (programación) es volátil y se pierde cuando se apaga la potencia eléctrica. Este problema se puede solucionar mediante el almacenamiento de un archivo de configuración en memorias externas al dispositivo, el cual se usa para programar las celdas SRAM cada vez que se suministra potencia eléctrica. Esta alternativa lleva a la vulnerabilidad de la propiedad intelectual del diseño.

2.4.2. Arquitectura

La arquitectura de las primeras FPGAs, comprendían básicamente un “mar” de boques lógicos configurables interconectados por puntos de interconexión también configurables. Estos bloques lógicos podían implementar una función muy simple, como por ejemplo una función lógica de tres entradas o un elemento de almacenamiento.

19

Con el paso de los años, la arquitectura de los bloques lógicos evolucionó de manera significativa. Por ejemplo, un CLB (Configurable Logic Block) de dispositivo perteneciente a la familia 7-series de Xilinx [Xil16b], posee 2 slices, donde cada slice contiene cuatro LUTs (Look-up Table) de 6 entradas, 8 elementos de almacenamiento, multiplexores (utilizados para implementar funciones de hasta 8 entradas por slice) y cadenas de acarreo en la suma.

La mayoría de las arquitecturas de las FPGAs de hoy están basadas en LUTs. Una LUT de n entradas, puede implementar cualquier función lógica de n variables. A mayor cantidad de entradas en la LUT, mayor es la funcionalidad que se puede implementar. Pero cada vez que se agrega una entrada, se duplica la cantidad de celdas SRAM. Existen estudios que indican que las LUTs de 4 entradas presentan un balance óptimo de pros y contras [Max04]. Como consecuencia de los avances en los procesos tecnológicos, Xilinx ofrece dispositivos, como es el caso de aquellos pertenecientes a las familias Virtex 5 [Xil15a], Spartan 6 [Xil11], Virtex 6 [Xil15b] y 7-series (Spartan 7, Artix-7, Kintex-7 y Virtex-7) [Xil17d], cuyas arquitecturas se basan en LUTs de 6 entradas y 2 salidas.

Debido a que la LUT es un componente basado en celdas SRAM, posee características interesantes. Una LUT no solo se puede utilizar para implementar funciones lógicas, sino que además se puede emplear para almacenar datos de manera distribuida. Por ejemplo, una LUT de 6 entradas puede configurarse como RAM de 64x1. Por lo anterior, se dice que estas FPGAs tienen la capacidad de almacenar datos en RAM distribuida mediante la configuración de las LUTs [Xil17d].

Para poder configurar (o programar) la FPGA, las celdas SRAM que componen las LUTs se encuentran conectadas en cadena. Este hecho posibilita que la LUT pueda usarse también para desplazar datos. Debido a esto, una LUT posee también la capacidad de configurarse como registro de desplazamiento. Por ejemplo, una LUT de 6 entradas se puede configurar como registro de desplazamiento de 64 bits.

Además de LUTs, multiplexores y filp-flops, los bloques lógicos configurables poseen otros elementos, tal caso es la lógica de propagación de acarreo rápida. Esta característica es de gran utilidad para la implementación eficiente de operaciones aritméticas. Tanto los slices de Xilinx como los elementos lógicos de Intel-Altera poseen esta importante capacidad.

2.4.2.1. Otros componentes

La arquitectura de las FPGAs de hoy, no solo poseen un arreglo de bloques lógicos configurables basado en LUTs, sino que además contienen componentes embebidos que mejoran el rendimiento en determinadas aplicaciones.

Muchas aplicaciones requieren de almacenamiento de datos, de hecho la memoria es un componente elemental en la mayoría de los sistemas digitales. En la actualidad, Intel-Altera, Xilinx, Microsemi, Atmel, Quicklogic, y otros vendedores de FPGAs incluyen bloques de memorias embebidas. Los dispositivos de Xilinx poseen memorias (blocks RAM ) que se pueden configurar para que operen con modalidad dual port o single port, para que funcionen como FIFO (First Input First Output), o incluso se puede determinar sus tamaños de celda [Xi16b] [Alf05]. La capacidad de

20

almacenamiento puede ir desde miles de bits hasta millones de bits en los dispositivos más nuevos.

Otro componente muy requerido, principalmente en aplicaciones de procesamiento digital de señales son los multiplicadores. En lo que respecta a Xilinx, los primeros dispositivos en incluir multiplicadores eran los pertenecientes a las familias Virtex II [Xil05a] y Spartan 3 [Xil05b], los cuáles poseen multiplicadores embebidos de 18x18 bits [Xil04]. Con la llegada de los dispositivos Virtex 4 [Xil05c], surgen los slices XtremeDSP programables [Xil08]. Estos bloques DSP se usan para efectuar de manera muy eficiente operaciones de acumulación y multiplicación que intervienen en aplicaciones de procesamiento de señal digital. Proveen suma/resta, multiplicación y multiplicación/acumulación (MAC) con un alto grado de configurabilidad. En la actualidad, los slices DSP de los dispositivos con arquitectura UltraScale de Xilinx [Xil17a], incorporan mejoras respecto a los slices DSP de familias anteriores, como es el aumento de tamaño de los multiplicadores, sumadores y registros, más flexibilidad en la configuración de los sumadores, incorporación de operandos en la unidad de aritmética/acumuladora, entre otros.

Últimamente los fabricantes han incorporado microprocesadores dedicados en sus productos. El primer FPGA comercial en integrar un microprocesador fue Altera Excalibur [Int01b]. Las soluciones Excalibur, integran lógica programable con núcleos (cores) de procesadores RISC ARM. Xilinx incorpora los primeros microprocesadores embebidos en los dispositivos Virtex-II Pro [Xil05d]. Los cores utilizados son los microprocesadores RISC PowerPC 405 de IBM [Xil10a]. Los PowerPC se utilizaron en familias posteriores, tales caso son Virtex 4 [Xil10b] y Virtex 5 [Xil15a]. Las familias más nuevas de Xilinx incorporan cores de RISC Cortex-XX de ARM, tales caso de Zynq-7000 con cores de Cortex-A9 [Xil17e] o Zynq UltraScale con ARM-v8 Cortex-A59 [Xil17b].

Los dispositivos de Xilinx poseen además otros elementos embebidos, tal es el caso de manejadores de reloj (CMT, Clock Management Tiles) [Xil17e], bloques de manejadores de señales analógicas XADC [Xil16c], lógica dedicada para trasmisión y recepción serial de datos a muy alta velocidad (low-power gigabyte tranceivers) [Xil06] [Xil14], bloques de interfaz para tecnología PCI Express de manera que se puedan configurar como Endpoint o Root Port [Xil09], entre otros.

2.4.3. IP cores

Cuando se diseña en FPGAs o ASICs, se pueden incorporar IP cores. Éstos pueden ser bloques de lógica reusable, celdas o diseño de layout de un chip, que son de propiedad intelectual de terceras partes. Es deseable que el IP core sea portable, esto es que tenga la capacidad de poder usarse en dispositivos de diferentes fabricantes o en diferentes metodologías de diseño.

Los IP cores entran en tres categorías principales: hard IP cores, firm IP cores o soft IP cores. Los hard IP cores son bloques pre-implementados, tal es el caso de cores de microprocesadores, interfaces gigabit, multiplicadores, memorias, funciones MAC, entre otros. Estos bloques son diseñados lo más eficiente posible en términos de consumo de potencia, área y velocidad. Cada familia de FPGA posee diferentes

21

combinaciones de estos bloques. Son los menos flexibles y portables de las tres categorías.

En el otro extremo, los soft IP cores, hacen referencia a librerías de funciones de alto nivel que los usuarios pueden usar en sus diseños. Las funciones son típicamente representadas usando lenguajes de descripción de hardware como VHDL (VHSIC

Hardware Description Language, VHSIC: Very High Speed Integrated Circuit), Verilog, etc. Son los más portables y flexibles de las tres categorías.

En cuanto a los firm IP cores, son librerías de funciones que ya están mapeadas, ubicadas y ruteadas en los bloques lógicos programables del dispositivo. Estos cores no son tan flexibles ni portables como los soft IP cores. Tienen en cuenta aspectos como consumo de potencia, velocidad y área. Se los puede incorporar a un diseño y posteriormente sintetizarlos en los bloques lógicos programables.

Existe numerosa cantidad de vendedores que ofrecen IP cores. Por razones de portabilidad y flexibilidad en los diseños sobre FPGAs, hay muchos sitios web que comercializan soft IP cores. Otros sitios ofrecen soft cores de manera gratuita. El sitio web más importante, en dónde diferentes usuarios ofrecen soft cores con códigos abiertos y buena documentación, es www.opencore.org.

Xilinx ofrece una herramienta Xilinx CORE Generator System [Xil17g], que posibilita incorporar IP cores parametrizables en los diseños. Provee un catálogo de arquitecturas específicas para diferentes dominios de aplicación (diseños embebidos, conectividad y DSP), y mercados específicos. Intel-Altera por su parte, ofrece un portfolio de cores IP (soft cores y firm cores), junto con referencias de diseños que permiten complementar el desarrollo de las aplicaciones [Int17b].

Actualmente no existen muchos cores de unidades de cálculo de punto flotante decimal para FPGAs en el mercado. Como se menciona en la sección 2.2.2, existe una corporación SilMinds, que comercializa soft cores que efectúan ciertas operaciones en punto flotante decimal según estándar IEEE 754-2008.

2.4.4. Diseño en FPGA

Las herramientas EDA son un conjunto de aplicaciones de software que posibilitan el diseño de sistemas electrónicos, tales como ASICs, PCBs (Printed Circuit

Boards) o FPGAs. En lo que respecta a diseño en FPGA, el flujo de diseño involucra la utilización de varias herramientas CAD. Este flujo de diseño se encuentra muy modularizado como consecuencia de la continua evolución de las herramientas de síntesis, emplazado y ruteo [Des12].

Mediante el uso de lenguajes de descripción de hardware de alto nivel (HDL, Hardware Description Language) como VHDL [Ash90] [Ash08], Verilog [Pal03], o SystemC [Bha04], entro otros, es posible realizar diseños de sistemas digitales basados en FPGAs sin la necesidad de poseer nociones complejas de electrónica. Las descripciones hechas en estos lenguajes, deben ser mapeadas a bloques lógicos de bajo nivel de la FPGA. Esto se realiza mediante procesos de síntesis a diferentes niveles de abstracción y posterior implementación y programación del dispositivo [Wil07].

22

En este último tiempo está creciendo significativamente el uso de lenguajes de alto nivel como C, C++, OpenCL, etc, para diseñar en FPGA [Sim15]. Principalmente en áreas tales como HPC, PSoC o desarrollos de sistemas embebidos basados en procesadores y lógica programable. El empleo de estos lenguajes no solo posibilita el desarrollo del programa que se ejecuta en el procesador, sino que además permite la generación de hardware basado en lógica programable de rutinas software.

Los diferentes niveles de síntesis e implementación del dispositivo se llevan a cabo de manera automática. Existen gran cantidad de herramientas EDA en el mercado que posibilitan la realización de estas tareas. Por su parte, cada vendedor de FPGA ofrece un conjunto de herramientas para poder diseñar con sus productos.

Xilinx ofrece un conjunto de herramientas EDA dependiendo del tipo de diseño que se desee realizar. Xilinx Vivado Design Suite [Xil17h], involucra herramientas de síntesis, simulación, implementación, programación, etc. Además provee una familia de ambientes de desarrollo SDx (SDAcces, SDNet, SDSoC) [Xil17i], con soporte para cualquier combinación de kernels C, C++, OpernCL, junto con librerías y placas de desarrollo basadas en dispositivos FPGAs. Estas herramientas permiten la realizar aceleración hardware en sistemas heterogéneos, desarrollo de PSoC con procesadores embebidos, entre otras. Los entornos SDSoC y SDAcces se encuentran integrados con el ambiente Vivado Design Suite.

Intel-Altera por su parte también ofrece un conjunto de herramientas integradas en Quartus Prime, ediciones estándar [Int17c] y Pro [Int17d]. Provee un completo ambiento de diseño multiplataforma para Intel FPGA, SoCs y CPLDs.

Los vendedores de FPGA pueden obtener licencias para incluir herramientas de software desarrolladas por terceras partes en sus sistemas. En la tabla 2.8 se aprecia un listado de las compañías vendedoras de herramientas EDA que dominan el mercado.

Tabla 2.8 – Compañías vendedoras de herramientas EDA.

Compañía Sitio web Comentario

Altium Ltd. www.altium.com Ambientes de diseño software-hardware para sistemas basados en FPGA

Cadence Design Systems. www.cadence.com Diseño, simulación y síntesis. Mentor Graphics Corp. www.mentor.com Diseño, simulación y síntesis. Synopsys Inc. www.synopsys.com Diseño, simulación y síntesis.

.

23

CAPÍTULO 3

Suma y Resta punto fijo en base 10

En este capítulo se presentan diferentes estrategias para implementaciones de las operaciones de suma y resta radix-10 en punto fijo, para dispositivos programables con LUTs de 6 entradas.

Al comienzo del capítulo se expone una introducción con los aspectos más relevantes a considerar en el momento de diseñar soluciones hardware para la operación suma radix-10. Además, se efectúa una clasificación de los trabajos existentes relacionados con implementaciones de operaciones de suma y resta de operandos decimales. A continuación, se detalla la propuesta y contribución en lo que respecta a las operaciones mencionadas.

En la sección 3.3, se describen y determinan las mejores técnicas desarrolladas para la implementación de la suma de números decimales sin signo en dispositivos basados en LUTs de 6 entadas. El apartado 3.4 presenta técnicas novedosas para la implementación de restadores de números decimales. Los apartados 3.5 y 3.6, detallan diferentes estrategias para la implementación eficiente en este tipo de dispositivos, de la operación suma/resta de números decimales con signo, para operandos en complemento a la base diez y signo y valor absoluto.

Al final de este capítulo se presentan las conclusiones.

3.1. Introducción

Las computadoras de hoy utilizan transistores de dos estados para implementar el almacenamiento y el procesamiento de los datos. Los dígitos en radix-10 poseen diez estados. Debido a que diez no es potencia de dos, en la representación binaria de dígitos decimales existe redundancia o combinaciones que no se utilizan. Se necesitan al menos 4 bits para representar un número decimal.

En la sección 1 del capítulo 2, se observan diferentes codificaciones de dígitos decimales. Si se utiliza la codificación BCD-8421, en adelante se la denomina sólo BCD, para representar dígitos radix-10, la suma entre dos dígitos x e y, se puede llevar a cabo mediante la utilización de un sumador binario de 4 bits. Este sumador puede generar desbordamiento (overflow) debido a que puede producir resultados mayores a 9 (entre 10 y 18). Por ejemplo, si se desea sumar los dígitos decimales 710 y 510, efectuando la suma binaria entre las correspondientes representaciones BCD, 710 es 0111BCD y 510 es 0101BCD, se obtiene como resultado 1100BCD. Debido a que el resultado obtenido no es un dígito BCD se produce overflow, de este modo se debe realizar

24

alguna corrección para transformar el resultado a su correspondiente representación BCD, (0001 0010)BCD = 1210.

Si se utilizan sumadores binarios para realizar la suma BCD de dos operandos x e y, en donde r = (c,s) = x + y, con r expresado mediante el acarreo (c) y el resultado módulo 16 (s). Se identifican dos casos para los cuáles se debe hacer corrección del resultado obtenido: i) r en {10, …,15}, esto es s en {10, …, 15} y c = 0; y ii) r en {16, 17, 18}, esto es c = 1 y s en {0, 1, 2}.

Para el caso i), s = 10 + (s mod 10) y c = 0, la representación BCD de r es la concatenación de 0001BCD y la representación BCD de la expresión s mod 10. Para realizar esta corrección se necesitan dos pasos: 1) se suma 16 para producir la decena y 2) se resta 10 para generar la representación BCD de las unidades (s mod 10)

paso 1: 11002 + 100002 = 111002 paso 2: 111002 – 10102 = 100102

De lo anterior, se infiere que para este caso, los dos pasos involucrados en la

corrección (sumar 16 y restar 10) se pueden simplificar mediante la suma de 6 al dígito mayor a 9. En el ejemplo, 11002 + 01102 = 100102 = (0001 0010)BCD.

En cuanto al caso ii), el resultado es la concatenación de (0001)BCD (correspondiente a la decena) y la codificación BCD de 6, 7 u 8, según corresponda. Al utilizar el acarreo (c) para producir la decena en la representación, como el peso del acarreo es 16 y se lo usa como 10, se debe compensar mediante la suma de 6. Por ejemplo, para el resultado 1710, se efectúa 100012 + 01102 = 1 01112.

Por los casos expuestos, cuando se realiza la suma de dos operandos codificados en BCD utilizando un sumador binario de 4 bits, si el resultado se encuentra en {10, …,18} se efectúa una corrección mediante la suma de 01102.

En [Erl09] se identifican tres estrategias principales para abordar la suma radix-10 (decimal) entre operandos de p dígitos: suma decimal directa, suma binaria con corrección y suma binaria con exceso (bias) y corrección.

Cuando se utiliza un sumador binario con propagación de acarreo para la suma decimal, puede necesitarse realizar una sucesión de correcciones para obtener el resultado final. A modo de ejemplo, en la figura 3.1 se aprecia que al utilizar el sumador binario para sumar 235810 y 464510, se deben realizar tres correcciones, significa que en total se deben efectuar cuatro operaciones de suma binaria con propagación de acarreo.

Una alternativa para evitar la sucesión de correcciones, es mediante la especulación de que cada dígito excederá nueve [Rich55]. De esta manera, se realiza a priori el paso de corrección de sumar 6. Hecho esto, el acarreo es ahora de peso 10 y no de peso 16. A esta alternativa se la denomina suma binaria con bias y corrección. Esta estrategia requiere solo un paso de corrección que se produce cuando no se genera un acarreo (suma menor a diez). La corrección consiste en restar 6 (o sumar 10), sin afectar al próximo dígito más significativo. La figura 3.2, muestra un ejemplo de la suma decimal usando un sumador binario con bias y corrección.

25

+ 0010 0100

0011 0110

0101 0100

1000 0101

= =

235810 464510

0110 1001 1001 1101 = 699D16 primer resultado de suma x dígito decimal inválido + 0000 0000 0000 0110 = 000616 primer corrección 0110 1001 1010 0011 = 69A316 segundo resultado de suma x dígito decimal inválido + 0000 0000 0110 0000 = 006016 segunda corrección 0110 1010 0000 0011 = 6A0316 tercer resultado de suma x dígito decimal inválido + 0000 0110 0000 0000 = 060016 tercer corrección 0111 0000 0000 0011 = 700310 resultado final

Figura 3.1 – Ejemplo de sucesivas correcciones utilizado sumador binario.

+ 0010 0110

0011 0110

0101 0110

1000 0110

= =

235810 primer operando 666616 biases

1000 1001 1011 1110 = 89BE16 + 0100 0110 0100 0101 = 464516 segundo operando 1101 0000 0000 0011 = D00316 primer resultado de suma x no se produce acarreo + 1010 0000 0000 0000 = -600016 corrección 0111 1001 1001 0011 = 700310 resultado final de la suma

Figura 3.2 – Ejemplo suma binaria con bias y corrección.

Las ventajas de esta alternativa es la capacidad de emplear sumadores binarios optimizados y la posibilidad de que el mismo circuito soporte tanto la suma decimal como la suma binaria [And79] [Flo91]. Existen trabajos más recientes que abordan esta estrategia para llevar a cabo la suma decimal en punto fijo [Tho04] [Wan07] [Ant09] [Din10a] [Dor14]. En estos trabajos, a excepción de [Tho04] que utiliza codificación en exceso 3, los operandos se representan en BCD.

En [Ken04], [Ken05] y [Gor09], se aborda la suma decimal mediante la suma binaria y corrección permitiendo dígitos decimales en {0, … ,15} (representación decimal sobrecargada). Estos trabajos se aplican a la suma BCD multioperando y permiten que los dígitos que componen los resultados parciales también se encuentren en {10, … ,15}. Cuando se produce un acarreo al efectuar la suma binaria entre dos dígitos decimales, el peso del mismo es 16. Debido a que en esta representación el acarreo en realidad posee peso 10, se suma 6 al resultado. Al finalizar la suma binaria

26

multioperando con correcciones parciales producida en la medida que suceden los acarreos, se tiene el resultado final con dígitos que pueden estar en {0, …,15}. Debido a esto, es necesario realizar una corrección final (o sucesión de correcciones) para obtener el resultado definitivo. En estos trabajos se presentan varias alternativas de implementación, algunas de ellas utilizan la técnica de carry-save decimal para efectuar la suma entre múltiples operandos evitando la propagación de acarreo. En la figura 3.3, se aprecia un ejemplo de la suma decimal multioperando entre 295810, 176910 y 232310, usando suma binaria y representación decimal sobrecargada.

Otra estrategia según [Erl09], es implementar la suma decimal directamente. Significa que el circuito que implementa la suma entre dos dígitos decimales genera directamente el acarreo y el resultado correcto.

+ 0010 0001

1001 0111

0101 0110

1000 1001

= =

295810 primer operando 176910 segundo operando

0100 0000 1100 0001 = 40C116 x x se produce acarreo + 0000 0110 0000 0110 = 060616 corrección parcial 0100 0110 1100 0111 = 46C716 resultado parcial + 0010 0011 0010 0011 = 232310 tercer operando 0110 1001 1110 1010 = 69EA16 primer resultado de suma x x dígito decimal inválido + 0000 0000 0110 0110 = 006616 primera corrección 0110 1010 0101 0000 = 6A5010 resultado final de la suma x dígito decimal inválido + 0000 0110 0000 0000 = 060016 segunda corrección 0111 0000 0101 0000 = 705010 resultado final de la suma

Figura 3.3 – Ejemplo suma multioperando usando suma binaria y representación sobrecargada.

Los trabajos [Sch71], [Vee07], [You06], [Bay07] y [Jua12], implementan la suma decimal directa mediante la técnica de cálculo de acarreo anticipado (carry-look ahead). Otros trabajos como [Svo69], [Shi88], [Sch89] [Mos07], [Reb09a], [Reb09b], [Han11], [Han13] y [Yeh10], implementan la suma decimal directa utilizando códigos redundantes (formato signed-digit) para representar los dígitos decimales [Par00]. En estos trabajos, se extiende el rango de valores de los dígitos de manera tal que intervienen también los valores negativos. El empleo de estos códigos redundantes posibilita reducir la complejidad del sumador, evitando la propagación del acarreo (carry free) y correcciones. Si se desean realizar operaciones decimales con dígitos representados en BCD, las implementaciones basadas en códigos redundantes, deben poseer conversores entre ambos formatos, BCD y signed-digit. Estos conversores, dependiendo del formato redundante empleado, pueden ser muy costosos, tal es el caso del formato utilizado en [Svo69]

27

Existen trabajos que emplean lógica reversible para la implementación de la suma decimal directa [Bab05] [Nad08] [Bis08] [Tha06a] [Tha06b] [Tha06c] [Zho14]. El propósito de esta lógica es disminuir la disipación de energía asociada a cada evento de cálculo. En los circuitos que implementan lógica reversible, la cantidad de entradas es igual a la cantidad de salidas y existe un mapeo uno a uno entre vectores de entradas y salidas. Esto posibilita que los estados de entradas se puedan reconstruir a partir de los estados de salidas. Existen compuertas específicas para implementar estos circuitos.

En [Dad07] se presenta un enfoque híbrido para la implementación de un sumador BCD multioperando. Consiste primero en efectuar la suma binaria para cada “columna” de n dígitos de 4 bits con el mismo peso decimal (100, 101,... , 10n-1), luego realizar la conversión binaria-BCD de cada “columna”, y por último alinear las columnas decimales para llevar a cabo la suma BCD final. Para la suma binaria entre los n dígitos del mismo peso se emplea la técnica carry-save binario.

Otra alternativa es realizar la suma BCD mediante la suma binaria equivalente y las correspondientes conversiones entre formatos. Es decir, efectuando la conversión BCD-binario de los operandos en formato BCD, luego la suma binaria entre los operandos binarios y por último realizando la conversión binario-BCD del resultado final. Esta solución no es recomendable y no aparece en la literatura existente, debido al costo, en términos de área y tiempo de cálculo, proporcional a la cantidad de dígitos que interviene en la implementación de los conversores [Kai70] [Nic71] [Kan65] [Ben77] [Igu07] [Sas05] [Sch68].

En [Tho04], [Ant09], [Wan07], [Wan09a], [Wan09b] y [Gon13], se aborda la suma decimal entre operandos representados en DFP según el estándar IEEE 754-2008. En estos trabajos se presentan diferentes soluciones para afrontar aspectos involucrados en el tratamiento de operandos en punto flotante, como es el caso del redondeo, alineación de operandos, determinación de cantidad de ceros iniciales en la mantisa, etc. En [Tho04] y [Gon13], se utiliza el formato BID (Binary Integer Decimal) para codificar los operandos, debido al formato utilizado la suma decimal se lleva a cabo mediante un sumador binario. El resto de los trabajos manejan operandos en DPD.

Existen muy pocos trabajos publicados acerca de la suma decimal, particularmente suma BCD, en dispositivos programables como FPGAs. En [Din10a] se propone una suma decimal multioperando basada en sumadores binarios con pre- y post-corrección para dispositivos basados en LUTs de 6 entradas de Xilinx. En [Far09] se efectúa la suma/resta decimal según el estándar IEEE 754-2008 con el uso del formato BID en dispositivos FPGAs de Xilinx.

Otros trabajos como [Bae09], [Bae10], [Jam09] y [Yix10], se ocupan de la multiplicación decimal en FPGAs. Para efectuar la multiplicación decimal, es necesario analizar y diseñar la suma multioperando. Estos trabajos evitan la propagación de acarreo en la acumulación de productos parciales mediante celdas reductoras tipo carry-

save. Sin embargo, estos trabajos proponen la realización de la suma directa BCD con propagación de acarreo para obtener el resultado definitivo.

28

3.1.1. Convenciones acerca de simbología utilizada en este capítulo

En el resto del capítulo, las variables minúsculas denotan una secuencia de múltiples dígitos, las que poseen subíndices denotan dígitos y aquellas con subíndices e índices entre paréntesis describen bits. Por ejemplo, xi representa el dígito i del operando x, y xi[j] corresponde el bit j del dígito i. Por otro lado, las mayúsculas se utilizan para representar funciones booleanas que toman como argumento dígitos BCD.

3.2. Propuestas y Contribuciones

La principal contribución de este trabajo es el diseño e implementación eficiente de la operaciones de suma y resta en radix-10 sobre dispositivos FPGAs de Xilinx. Muchos de los diseños expuestos en el presente capítulo, aplican, extienden y generalizan los diseños propuestos en un trabajo precedente del autor de esta tesis [Vaz11], los cuáles se publicaron en [Vaz09b] y [Bio10]. Estas soluciones se basan en la utilización de los recursos dedicados que se encuentran en estos dispositivos para la implementación de la suma binaria con propagación de acarreo.

Estos dispositivos poseen lógica dedicada que posibilita la realización de la operación suma clásica binaria ripple-carry en forma optimizada [New96] [Xil00]. Cada slice de las FPGAs de Xilinx, posee rutas de comunicación y multiplexores de acarreo dedicados (muxcy), para que la propagación de acarreo en la suma consuma poca área y poco tiempo de cálculo. Las herramientas de síntesis llevan a cabo la lógica de acarreo mediante diseños compactos y eficientes. Obsérvese en la figura 3.4 como se implementa la suma de dos bits en estos dispositivos

Figura 3.4 - Implementación de la suma de operandos de dos bits en slice de dispositivos de Xilinx [Xil15a].

La señal de acarreo ci y la función de propagación de acarreo pi se determinan de la siguiente manera:

ci+1 = ci-1.pi v pi’.bi

pi = ai ⊕ bi

La secuencia de acarreo ci-1, ci y ci+1 pasa por multiplexores dedicados (muxcy). Estos multiplexores se comunican con conexiones muy rápidas dedicadas para implementar la suma binaria. Dichas conexiones existen en todo el dispositivo y

29

comunican todos los muxcy pertenecientes a una misma columna de slices. Según los reportes de síntesis [Xil13a], el tiempo de ruteo entre multiplexores de acarreo más el tiempo cómputo del mismo es de 0.015ns, aproximadamente 5 veces menos que el tiempo de cómputo de una LUT.

A continuación, se detallan contribuciones específicas de este trabajo:

- Estudio y determinación de las mejores técnicas de diseño de sumadores decimales en arquitecturas de dispositivos con LUT de 6 entradas. Para ello se describen y comparan los diseños de sumadores decimales de dos operandos expuestos en [Vaz11], con el diseño novedoso y eficiente de la suma decimal multioperando presentada en [Din10a].

- Diseño e implementación de un restador de números decimales naturales. Se presenta una técnica novedosa que aprovecha la lógica perteneciente al diseño de restador binario para efectuar la resta entre números naturales decimales.

- Estudio y determinación de las mejores técnicas de diseño de sumadores/restadores con operandos decimales en complemento a la base diez (C10) en dispositivos con LUTs de 6 entradas. Para ello se describen y analizan los diseños presentados en [Vaz11], y además se efectúa la comparación con una adaptación del trabajo de [Din10a] de modo que posibilite realizar la suma/resta de números decimales en C10.

- Diseño e implementación eficiente de sumador/restador con operandos decimales representados en SVA en dispositivos con LUTs de 6 entradas. El SVA es usado para la representación de la mantisa de los números en punto flotante decimal conforme al estándar IEEE 754-2008. Según el conocimiento del autor de este trabajo, en la bibliografía no existen publicaciones relevantes que aborden este tipo de operación en FPGAs.

3.3. Suma de números decimales sin signo

En [Vaz11] se diseñaron e implementaron dos estrategias para realizar la suma decimal sin signo en dispositivos FPGAs de Xilinx con LUTs de 6 entradas. Ambas estrategias aprovechan el uso de los canales y recursos programables dedicados en el dispositivo utilizados comúnmente para la implementación eficiente de la operación de suma binaria, más precisamente la propagación en la cadena de acarreo (carry-chain).

Las dos estrategias se basan en el cálculo de las funciones de propagación y generación de acarreo entre operandos representados en BCD, de modo que Gi

determina si la suma entre dos dígitos BCD, xi e yi, genera acarreo y Pi si la suma entre esos dígitos propaga el acarreo de entrada

if (xi+yi) > 9 then Gi = 1 else Gi = 0

if (xi+yi) = 9 then Pi = 1 else Pi = 0 (3.1)

por consiguiente, el acarreo ci+1 producido por la suma de los dígitos xi e yi, se determina de la siguiente manera

ci+1 = Pi ·ci v Pi '·Gi (3.2)

30

donde ci corresponde al acarreo de entrada. El propósito es que la secuencia de acarreo, ci ( { }pi ,..,1,0∈ ), con p tamaño de los operandos), transite los multiplexores dedicados (muxcy) en el dispositivo para la implementación de la carry-chain de la suma binaria. El siguiente algoritmo describe la suma decimal con propagación de acarreo con operandos de p dígitos desarrollada en [Vaz11], considere a = x + y

Algoritmo 3.1 - Suma decimal con propagación de acarreo: a = x + y

c0 = cin; for i in 0 to p-1 loop

generate Pi , Gi; ci+1 = Pi ·ci v Pi ´·Gi

ai = (xi + yi + li ) mod 16;

end loop;

donde li es la corrección que se aplica cuando la suma binaria entre xi e yi es mayor a 9. El valor li es 6 si se genera acarreo decimal al sumar xi e yi , es decir que se produce ci+1, además tiene en cuenta si existe acarreo que provenga de la iteración anterior ci. Por consiguiente, li es igual a 0, 1, 6, ó 7, siendo li = (0 ci+1 ci+1 ci)2.

En [Vaz11] se desarrollaron dos estrategias para determinar las funciones Gi y Pi. En la primer estrategia, Gi y Pi se calculan a partir de la suma binaria ui = xi + yi, es decir que son funciones de 5 variables

Gi ≡ Gi (ui[4], ui[3], ui[2], ui[1], ui[0]) ≡ Gi (ui[4..0]) y

Pi ≡ Pi (ui[4..0]) (3.3)

Una vez determinado ui, las dos funciones se pueden implementar utilizando una sola LUT6:2 (LUT de 6 entradas de dos salidas). Obsérvese que una LUT6:2 puede implementar dos funciones de hasta 5 variables cada una [Xil11].

Por otro lado, en la segunda estrategia, las funciones de generación y propagación de acarreo decimal, Gi y Pi, se determinan directamente a partir de las entradas, xi e yi, sin requerir del cálculo previo de ui. Significa que Gi y Pi, son funciones de 8 variables

Gi ≡ Gi (xi[3..0], yi[3..0]) y

Pi ≡ Pi (xi[3..0], yi[3..0]) (3.4)

Para poder implementar las funciones de generación y propagación en función de

las entradas, se descompone Gi y Pi de manera de aprovechar las LUTs de 6 entradas. Se definen las expresiones Ri y Qi:

if (xi/2+yi/2) = 4 then Ri = 1 else Ri = 0

if (xi/2+yi/2) ≥ 5 then Qi = 1 else Qi = 0 (3.5)

entonces

31

Gi = Qi v Ri·(xi[0]·yi[0])

Pi = Ri·(xi[0]⊕ yi[0]) (3.6)

De esta manera, se requieren 2 LUTs de 6 entradas para implementar Ri y Qi, y una LUT6:2 para determinar Gi y Pi. Esta alternativa presenta como ventaja respecto a la anterior, que tanto los cálculos de Gi y Pi como ui se realizan en paralelo.

Las figuras 3.5 y 3.6, muestran las implementaciones en dispositivos FPGAs de Xilinx con LUTs de 6 variables, de la instancia i de los sumadores decimales propuestos en [Vaz11]. En la figura 3.5 se aprecia el sumador correspondiente a la estrategia de cálculo de Gi y Pi a partir de la suma inicial (Adder-I). Por otro lado, la figura 3.6 muestra el sumador que implementa la alternativa de cálculo Gi y Pi dependiendo exclusivamente de las entradas (Adder-II).

0 1xi[0]

yi[0]

xor0

and0

0

0 1xi[1]

yi[1]

xor1

and1

ui[0]

0 1xi[2]

yi[2]

xor2

and2

0 1xi[3]

yi[3]

xor3

and3

ui[1]

ui[2]

ui[3]

ui[4]

0 1Pi

Gi

ci

ci+1

ui[3..0]

4

ai[0]

ai[1]

ai[2]

ai[3]

LUT-6:2

LUT-6

LUT-6

LUT-6

LUT-6

LUT-6

LUT-6

LUT-6

Figura 3.5 - Implementación de sumador completo de un dígito BCD, ai = xi + yi , en dispositivos con LUTs de 6 entradas con cálculo de Gi y Pi a partir de la suma inicial.

Para las dos alternativas, el tiempo de cálculo (expresiones 3.7 y 3.8), es proporcional al tamaño de los operandos p con la misma constante de proporcionalidad, o pendiente de crecimiento, la cuál es el tiempo del multiplexor de acarreo dedicado en el dispositivo (Tmuxcy). En lo que respecta al tiempo de cálculo, la diferencia entre ambas alternativas se encuentra en los términos independientes bAdder-I y bAdder-II . El término independiente bAdder-I, involucra el tiempo de la suma inicial de 4 bits, el tiempo de la LUT que determina Gi y Pi, el tiempo de corrección y tiempos de ruteo entre tres slices. Por otro lado, bAdder-II contiene dos tiempos de LUT que determinan Gi y Pi, tiempo de corrección y tiempos de ruteo entre tres slices.

TAdder-I = pTmuxcy + bAdder-I (3.7)

TAdder-II = pTmuxcy + bAdder-II (3.8)

Las expresiones 3.9 y 3.10, determinan el consumo de área en términos de ocupación de LUTs de ambas estrategias

32

CAdder-I = 8p LUTs (3.9)

CAdder-II = 10p LUTs (3.10)

Figura 3.6 - Implementación de sumador completo de un dígito BCD, ai = xi + yi, en

dispositivos con LUTs de 6 entradas con cálculo de Gi y Pi dependiendo de las entradas.

Un trabajo posterior a las alternativas detalladas en [Vaz11], propone la suma decimal multioperando aprovechando los recursos dedicados para la implementación de la carry-chain de la suma binaria y el uso óptimo de las LUTs de 6 entradas [Din10a]. Se dirige principalmente a la suma decimal multioperando debido a la importancia de ésta en la multiplicación. Las técnicas empleadas en [Din10a] se utilizaron exitosamente por los mismos autores en [Din10b] para la implementación eficiente de un multiplicador decimal paralelo en dispositivos con LUTs de 6 entradas.

Este trabajo propone el cálculo de la suma decimal a partir de la suma binaria entre los operandos BCD y una pre- y post- corrección. La pre-corrección consiste en sumar de manera condicional el valor 6 (01102) a los operandos de entrada. Por otro lado, la post-corrección es simple y solo requiere de un latch al final de la suma multioperando. La pre-corrección para la instancia i del sumador se efectúa de la siguiente manera

if (xi/2+yi/2)≥4 then ui = (xi+ yi +6+ci) mod 16 else ui = (xi+ yi +ci) mod 16

(3.11)

donde ci es el acarreo de entrada a la instancia i del sumador. Este tipo de pre-corrección, lleva a que ui obtenga 14 (11102) ó 15 (11112), en lugar de 8 (10002 ) ó 9 (10012), en el resto de los casos, ui no requiere corrección ya que obtiene el resultado correcto.

33

Para utilizar eficientemente las LUTs de 6 entradas se decompone el cálculo ui. Para ello se calcula el resultado intermedio ti, que opera con los 3 bits más significativos de los operandos de entrada

if (xi[3..1]+yi[3..1])≥4 then ti [3..0] = xi[3..1]+yi[3..1]+3 else ti [3..0] = xi[3..1]+yi[3..1]

(3.12)

de este modo

ui[0] = xi[0]⊕yi[0]⊕ci; ui[3..1] = ti[2..0]+ci0

(3.13)

donde ci0 es el acarreo producido entre xi[0], yi[0] y ci. El acarreo generado, ci+1, se produce cuando ti + ci0 es mayor a 7, es decir

ci+1 = ti[3] v (ti[2]·ti[1]·ti[0]·ci0) (3.14)

Cada ti[j], con { }3,2,1,0∈j , requiere de una LUT de 6 entradas ya que son funciones de 6 variables. Por consiguiente, una vez calculado ti, para determinar ui se requiere del uso de los multiplexores dedicados de acarreo junto a las compuertas xor que se encuentran en el dispositivo. Finalmente, para efectuar la corrección se pueden utilizar los latchs que se encuentran en el mismo slice en el que se efectúa el cálculo de ui, de modo que pongan a cero los correspondientes bits ui[2] y ui[1], en el caso que ui[3] sea uno (figura 3.7). La implementación del sumador completo BCD de un dígito según [Din10a] requiere solo de un slice, más una LUT que determina ti[3].

0 1xi[0]

yi[0]

xor0

and0

0 1

ui[0]

0 1

0 1

ui[1]

ui[2]

ui[3]

0

0

3

3

xi[3..1]

yi[3..1]

ti[0]

LUT-6:2

LUT-6

LUT-6

LUT-6

LUT-6

ti[1]

ti[2]

ti[3]

ci

ci0

ci+1

LATCH ai[2]

ai[1]

rst

LATCH

rst

ai[0]

ai[3]

Figura 3.7 - Implementación de sumador completo de un dígito BCD, ai = xi + yi, en dispositivos con LUTs de 6 entradas según [Din10a].

La expresión 3.15, postula el tiempo estimado de cálculo involucrado en la suma decimal de dos operandos de p dígitos según [Din10a], en adelante Adder-III. Obsérvese que el tiempo es proporcional al tamaño de los operandos, con una pendiente de crecimiento cuatro veces mayor a las alternativas Adder-I y Adder-II. El término

34

independiente, bAdder-III, posee un tiempo de LUT, un tiempo de latch, más el tiempo de ruteo entre dos slices. Los términos independientes de las expresiones 3.7 y 3.8 involucran mas ruteo y mas demoras que el tiempo independiente de la expresión 3.15. Esto lleva a que exista una fuerte dependencia de la precisión utilizada, para saber si ésta influye más o menos que el término independiente.

Por otro lado, la expresión 3.16 describe el consumo de área en términos de ocupación de LUTs. La ocupación de LUTs de las alternativas Adder-I y Adder-II es significativamente mayor respecto a Adder-III, en un 60% y 100%, respectivamente.

TAdder-III = 4pTmuxcy + bAdder-III (3.15)

CAdder-III = 5p LUTs (3.16)

3.3.1. Resultados experimentales

Se implementaron las tres alternativas de sumadores decimales expuestas en el presente trabajo en dispositivos de Xilinx Virtex 7 con speed grade 3 (tablas 3.1 y 3.2). La síntesis e implementación se realizaron con el XST (Xilinx Synthesis Technology) [Xil13a] y Xilinx ISE versión 14.7 [Xil13b]. Esto se llevó a cabo dejando los parámetros de síntesis por defecto. Para todas los implementaciones que aparecen en el resto de este capítulo, se utilizaron las mismas herramientas de síntesis e implementaciones con los mismos parámetros. El tamaño de los operandos empleado en las correspondientes implementaciones se encuentra relacionado con las precisiones definidas en el estándar IEEE 754-2008.

Tabla 3.1. Tiempo de cálculo (ns) de sumadores decimales sin signo en Virtex 7 con speed grade 3

p Adder-I Adder-II Adder-III

7 2.93 2.48 2.11 16 3.10 2.59 2.56 34 3.33 2.82 3.46

Tabla 3.2. Área (LUTs) de sumadores decimales sin signo en Virtex 7 con speed grade

3

p Adder-I Adder-II Adder-III

7 56 70 35 16 128 160 80 34 272 340 170

En términos de ocupación de LUTs, la alternativa Adder-III es la mejor opción y

la propuesta Adder-II es la peor. Sea Pi,j la penalización en área de la estrategia Adder-i respecto a la estrategia Adder-j, la tabla 3.3 muestra las penalizaciones en área entre los diferentes sumadores implementados. La alternativa Adder-II posee una penalización en área de 100% respecto a Adder-III y Adder-I posee una penalización de 60% respecto a Adder-III.

La alternativa Adder-III obtiene mejores tiempos de cómputo para operandos de tamaño pequeño (p = 7), pero empeora respecto a las otras alternativas en la medida que

35

aumenta la precisión. Esto se debe a que a mayor precisión, los valores de los términos independientes dejan de ser relevantes respecto al tiempo total

Tabla 3.3. Penalización en área entre los diferentes sumadores en Virtex 7 con speed

grade 3

Relación Penalización

P2,1 1.25 P2, 3 2.00 P1, 3 1.60

Considere Ai,j la aceleración de la estrategia Adder-i respecto a la estrategia

Adder-j, definida como el cociente entre los respectivos tiempos de cómputo, Ai,j = tiempo(Adder-j)/tiempo(Adder-i), la tabla 3.4 muestra las aceleraciones entre los diferentes sumadores decimales sin signo implementados.

Tabla 3.4. Aceleraciones entre los diferentes sumadores en Virtex 7 con speed grade 3

p A2,3 A2,1 A3,1

7 0.85 1.18 1.38 16 0.98 1.19 1.21 34 1.22 1.18 0.96

Para p = 7 ó 16, la alternativa Adder-III presenta un buena opción, ya que posee

una ocupación significativamente menor de LUTs, y mejores tiempo de cómputo. Para el caso de p=34, la alternativa Adder-II obtiene una aceleración del 22% respecto a Adder-III pero con el doble de área. La elección entre las alternativas propuestas dependerá del requisito o restricción de diseño que se desee priorizar o cumplir.

3.4. Resta de números decimales sin signo.

Una estrategia para implementar la resta entre dos números radix-10 sin signo de p dígitos, consiste en realizar restadores de un dígito BCD (SUB_BCD), para el cuál, a diferencia de la suma, el acarreo ci+1, significa la petición de una unidad al dígito siguiente (figura 3.8). Nótese que cuando el minuendo es menor al sustraendo la última instancia del restador solicita un dígito, por consiguiente se genera overflow debido a que el resultado es negativo.

Figura 3.8 - Restador de números naturales BCD (Sub_Nat), s = x - y.

Se implementó el restador BCD de un dígito mediante la resta binaria de los operandos de entrada y posterior corrección condicional. Cuando se realiza la resta binaria entre dos dígitos BCD, zi = xi - yi, si xi es mayor o igual a yi, el resultado no requiere corrección. Pero si se da el caso que yi es mayor a xi, como la unidad solicitada del siguiente dígito tiene peso 1610 en vez de 1010, se debe realizar una corrección

36

mediante la resta de 610 (figura 3.9). Nótese que cuando se produce una petición (ci+1 = 1), el resultado { }15,..,7,6∈iz .

Figura 3.9 - Restador BCD de un dígito, si = xi - yi.

Para la resta de números naturales BCD con operandos de p dígitos, se propone utilizar un restador binario de números naturales de 4p bits, seguido de una etapa de corrección que consiste de restadores binarios de 4 bits. Esto lleva a que la implementación en dispositivos FPGAs sea eficiente, debido a que el restador binario se realiza mediante la utilización de la lógica dedicada que se encuentra en el dispositivo para la suma binaria. La figura 3.10 muestra el restador binario de un bit implementado, z[j] = x[j]-y[j], donde ps[j] = (x[j]⊕y[j])', se corresponde a la propagación de la petición de una unidad a la siguiente instancia del restador. Para obtener el resultado z[j], solo se requiere invertir la salida, nz[j], producida por la compuerta xor.

Figura 3.10 - Restador binario de un bit, z[j] = x[j]-y[j].

Cuando se utiliza la implementación del restador binario propuesto sin el inversor final, entre los operandos de p dígitos BCD, x e y, se obtiene nz = (x - y)'. Donde z = nz', es el resultado de 4p bits de la resta binaria entre x e y. Considere nz de 4p bits,

nz[4p-1..0] = (nzp-1, nzp-2, nzp-3,.., nz0) (3.17) es decir nzi = nz[4i+3..4i], con { }1,..,1,0 −∈ pi . Significa que nzi = (xi -yi)', donde xi e yi son dígitos BCD, y además que zi = 15-nzi.

Por todo lo expuesto, para efectuar la resta BCD, s = x-y, basada en el uso de un restador binario, se debe corregir zi mediante la resta del valor 6 cada vez que se produce un acarreo, o petición, correspondiente al dígito i (figura 3.9).

if ci+1=1 then si = zi -6 = 9-nzi else si = zi =nzi' (3.18)

37

Debido a que cuando se produce una petición el resultado { }15,..,7,6∈iz , entonces

{ }9,..,1,0∈inz . Las siguientes son las expresiones booleanas que determinan si en función de nzi y ci+1

si[0] = nzi[0]'

si[1] = (nzi[1]⊕ci+1)'

si[2] = ((nzi[2]⊕nzi[1])·ci+1) v (nzi[2]'·ci+1') si[3] = (nzi[3]'·nzi[2]'·nzi[1]'·ci+1) v (nzi[3]'·ci+1')

(3.19)

La figura 3.11 muestra la implementación de la instancia i del restador BCD, en

dispositivos FPGAs de Xilinx con LUTs de 6 entradas. Nótese que psi[j] = (xi[j]⊕yi[j])'.

0 1xi[0]

yi[0]

0 1

nzi[0]

0 1

0 1

nzi[1]

nzi[2]

nzi[3]

LUT-6

LUT-6

LUT-6

LUT-6

psi[2]

ci

ci+1

si[2]

xi[1]

yi[1]

xi[2]

yi[2]

xi[3]

yi[3]

psi[1]

psi[0]

psi[3]

LUT-6:2si[3]

LUT-6:2si[0]

si[1]

Figura 3.11 - Implementación de restador de un dígito BCD, si = xi -yi, en dispositivos

con LUTs de 6 entradas.

El tiempo de cálculo estimado para la resta BCD de dos operandos de p dígitos, es proporcional a p con constante de proporcionalidad 4 veces el tiempo del multiplexor de acarreo (expresión 3.20). El término independiente, bSub_Nat, involucra dos tiempos de LUTs, y tiempo de ruteo entre dos slices. Por otro lado, la expresión 3.21 postula la ocupación de LUTs del restador propuesto

TSub_Nat = 4pTmuxcy + bSub_Nat (3.20)

CSub_Nat = 6p LUTs (3.21)

El restador propuesto, Sub_Nat, solo admite resultados naturales, significa que en el caso que el sustraendo es mayor al minuendo, y>x, el restador indica que se ha producido overflow. Muchas veces es deseable evitar el overflow mediante una corrección y generación de signo. El algoritmo 3.2 detalla la estrategia empleada para efectuar la resta entre números naturales, ss = x-y, con resultado en SVA sin overflow. En la figura 3.12 se observa el restador de números naturales BCD propuesto, con resultado en SVA sin overflow.

38

Algoritmo 3.2 - Resta BCD con resultado en SVA

s = x-y; // resta de números naturales propuesta if (y>x) then ss = 0-s; // resta de números naturales propuesta else ss = s; end if;

SUB_NAT

y

ovf

x

sign

0 1

SUB_NAT

0

1 0

s

ss

Figura 3.12 - Restador de números naturales BCD con resultado en SVA sin overflow (Sub_S), ss = x - y.

Para el módulo Sub_Nat encargado de realizar la operaciones 0-s ó s-0, se puede modificar el restador binario de modo que contenga los multiplexores que determinan la operación a realizar. Para ello, se realizan cambios en las funciones de propagación, pps, y generación, gss, de la petición de un dígito binario. Considérese pss y gss de 4p bits

pss[4p-1..0] = (pssp-1, pssp-2, pssp-3, …, pss0) y gss[4p-1..0] = (gssp-1, gssp-2, gssp-3, …, gss0)

(3.22)

es decir pssi = pss[4i+3..4i] y gssi = gss[4i+3..4i], con { }1,..,1,0 −∈ pi .

Una instancia del restador binario propaga la petición de dígito binario proveniente de la instancia anterior, cuando s[j]=0. Esto se debe que se realiza 0-0, independientemente si el primer restador Sub_Nat genere o no genere overflow. Para el caso que s[j]=1, si la operación a realizar es 0-1 se genera una petición, de lo contrario si se efectúa 1-0 se "mata" la petición. Esto lleva que no se propague la petición de la instancia anterior cuando s[j] es igual a 1. De este modo, la función de petición de dígito binario del segundo restador Sub_Nat es la siguiente

pssi[j]= pssi[4i+j]=si[j]', con { }1,..,1,0 −∈ pi y { }3,2,1,0∈j (3.23)

En cuanto a la generación de petición de dígito binario entre dos instancias del restador, en el caso que el primer restador (Sub_Nat) produce overflow, cp=1, se genera petición si s[j]=1. Por otro lado, en el caso que cp = 0, ninguna instancia del restador binario genera petición. Por consiguiente, la función de generación de petición de dígito binario del segundo módulo restador se postula de la siguiente manera

39

gssi[j]= gssi[4i+j]=si[j]·cp, con { }1,..,1,0 −∈ pi y { }3,2,1,0∈j (3.24)

La petición de dígito binario, cci+1, correspondiente al i-ésimo restador binario de 4 bits se determina utilizando la lógica de propagación de acarreo presente en los dispositivos FPGAs (figura 3.13). En el caso que cp=1, se obtiene nzz = (0-s)'; caso contrario, si cp=0 se obtiene nzz = s'. En consecuencia, para el resultado final ss, se realiza lo siguiente

if ci+1=1 then ssi = 9-nzzi else ssi = nzzi' (3.25)

Para reducir tiempo de cómputo y la ocupación de LUTs de la implementación de Sub_S, se combina la fase de corrección del primer restador, con la etapa de resta binaria del segundo restador. Significa que las funciones de propagación y generación de petición de dígito binario en el segundo restador, pssi[j] y gssi[j] respectivamente, se realizan a partir de nzi en vez de si, de este modo se evita la fase de corrección del primer restador.

Cada par de funciones pssi[j] y gssi[j], se puede implementar con una sola LUT6:2. La figura 3.13 muestra la implementación de la instancia i del restador BCD con resultado en SVA sin overflow, en dispositivos FPGAs de Xilinx con LUTs de 6 entradas.

0 1

0 1

nzzi[0]

0 1

0 1

nzzi[1]

nzzi[2]

nzzi[3]

LUT-6:2

LUT-6:2

LUT-6:2

LUT-6:2

pssi[2]

cci

cci+1

ssi[2]

pssi[1]

pssi[0]

pssi[3]

LUT-6:2ssi[3]

LUT-6:2ssi[0]

ssi[1]

gssi[3]

gssi[2]

gssi[1]

gssi[0]

0 1xi[0]

yi[0]

0 1

nzi[0]

0 1

0 1

nzi[1]

nzi[2]

nzi[3]

LUT-6

LUT-6

LUT-6

LUT-6

psi[2]

ci

ci+1

xi[1]

yi[1]

xi[2]

yi[2]

xi[3]

yi[3]

psi[1]

psi[0]

psi[3]

cp

Figura 3.13 - Implementación de restador de un dígito BCD con resultado en SVA sin

overflow, ssi = xi - yi, en dispositivos con LUTs de 6 entradas.

Las expresiones 3.26 y 3.27, detallan el tiempo de cómputo estimado y ocupación de LUTs respectivamente, correspondientes a la implementación del restador BCD, Sub-

S, entre dos operandos de p dígitos. El término independiente bSub_S, contiene tres tiempos de LUTs y tiempo de ruteo entre tres slices.

TSub_S = 8pTmuxcy + bSub_S (3.26)

CSub_S = 10p LUTs (3.27)

40

3.4.1. Resultados experimentales

Las tablas 3.5 y 3.6, detallan los resultados obtenidos en la síntesis de los restadores BCD con operandos de p dígitos propuestos en este trabajo, en dispositivos de Xilinx Virtex 7 con speed grade 3.

Tabla 3.5. Tiempo de cálculo (ns) en Virtex 7 con speed grade 3

p Sub_Nat Sub_S

7 2.02 3.43 16 2.46 4.33 34 3.36 6.14

Tabla 3.6. Área (LUTs ) en Virtex 7 con speed grade 3

p Sub_Nat Sub_S

7 42 70 16 96 160 34 204 340

3.5. Suma/Resta decimal en complemento a la base diez

En [Vaz11] se diseñaron e implementaron dos estrategias para realizar la suma/resta decimal BCD con operandos representados en C10 sobre dispositivos FPGAs de Xilinx con LUTs de 6 entradas. Ambas estrategias utilizan los sumadores decimales propuestos Adder-I y Adder-II. Para realizar la resta x-y, se efectúa la operación de suma x+(-y), donde -y = C10(y). Sea A'/S la señal que indica si se desea realizar la adición, A'/S=0, ó substracción, A'/S=1, entre x e y, el sumador/restador tiene el siguiente comportamiento

if A'/S=1 then sa = x+C9(y)+1 else sa = x+y (3.28) donde C9(y) es el complemento a nueve del operando BCD y, es decir C9(y) = 9-y. De este modo, el sumador/restador propuesto siempre realiza la operación de suma decimal entre números naturales.

Por consiguiente, en [Vaz11] una estrategia propuesta es el sumador/restador, AS-

I, basado en el sumador Adder-I con el cálculo de Gi y Pi a partir de la suma inicial. La otra propuesta, AS-II, se basa en Adder-II con el cálculo de Gi y Pi en función de las entradas.

En el sumador/restador AS-I, se modifica el sumador decimal Adder-I de modo que en lugar de realizar la suma inicial para cada dígito BCD, ui = xi+yi, efectúa lo siguiente

if A'/S=1 then vi=xi+c9i else vi=xi+yi (3.29)

donde c9i = C9(yi). De este modo, en el caso que se requiera una resta, se debe ingresar una unidad por la carry-chain. Las siguientes expresiones determinan el C9 de un dígito BCD yi

c9i[0] = yi[0]' (3.30)

41

c9i[1] = yi[1] c9i[2] = yi[2]⊕ yi[1] c9i[3] = yi[3]'·yi[2]'·yi[1]'

Nótese que las funciones de propagación de acarreo en la suma inicial de 4 bits, pasi[j], entre xi e yi , ó entre xi y c9i, dependiendo de A'/S, se pueden determinar con una única LUT de 6 entradas. En la figura 3.14, se aprecia la implementación de la instancia i del sumador/restador BCD con operandos en C10, AS-I, en dispositivos con LUTs de 6 entradas.

Figura 3.14 - Implementación de sumador/restador de un dígito BCD con operandos en

C10, sai = xi ± yi, en dispositivos con LUTs de 6 entradas, con cálculo de Gi y Pi

dependiendo de la suma inicial.

Las expresiones 3.31 y 3.32, postulan el tiempo de cómputo estimado y ocupación de LUTs respectivamente, correspondientes a la implementación del sumador/restador BCD AS-I, entre dos operandos de p dígitos en C10. El término independiente bAS-I, involucra el tiempo del sumador inicial de 4 bits, un tiempo de LUT para el cálculo de Pi y Gi, el tiempo de LUT asociado a la corrección, más tiempo de ruteo entre tres slices.

TAS-I = pTmuxcy + bAS-I (3.31)

CAS-I = 8p LUTs (3.32)

La otra alternativa propuesta en los mencionados trabajos para la implementación del sumador/restador BCD con operandos en C10, AS-II, se basa en el sumador Adder-II con el cálculo de Gi y Pi a partir de las entradas. Para utilizar las LUTs de 6 entradas de manera eficiente se descomponen las funciones Gi y Pi

if (xi/2+ yi/2) = 4 then Rai = 1 else Rai = 0

if (xi/2+ yi/2) ≥ 5 then Qai = 1 else Qai = 0

if (xi/2+ c9i/2) = 4 then Rsi = 1 else Rsi = 0

if (xi/2+ c9i/2) ≥ 5 then Qsi = 1 else Qsi = 0

(3.33)

42

if A'/S = 1 then Ri = Rsi else Ri = Rai if A'/S = 1 then Qi = Qsi else Qi = Qai

En consecuencia, las funciones de generación y propagación de acarreo se determinan de la siguiente manera

Gi = Qi v (Ri·xi[0]·(yi[0]⊕A'/S))

Pi = Ri·(xi[0]⊕ yi[0]⊕A'/S) (3.34)

La figura 3.15 muestra la implementación de la instancia i del sumador/restador BCD con operandos en C10, AS-II, en dispositivos con LUTs de 6 entradas.

0 1

0

0 1

vi[0]

0 1

xi[3]

vi[1]

vi[2]

vi[3]vi[3..0]

4

sai[0]

sai[1]

sai[2]

sai[3]

LUT-6:2

LUT-6

LUT-6LUT-6

LUT-6

LUT-6

LUT-6

pasi[2]

pasi[3]

pasi[1]

pasi[0]

xi[2]

xi[1]

xi[0]

Ri

QaiLUT-6

LUT-6

LUT-6

LUT-6

3

3

0 1Pi

Gi

ci

ci+1

LUT-6:2xi[0]yi[0]

Qsi

Qi0

1

xi[3..0]

yi[3..0]

yi4

Rai

Rsi

0

1

A/S

Figura 3.15 - Implementación de sumador/restador de un dígito BCD con operandos en C10, sai = xi ± yi, en dispositivos con LUTs de 6 entradas, con cálculo de Gi y Pi a partir

de las entradas.

En las expresiones 3.35 y 3.36, se describen las respectivas expresiones de tiempo de cómputo y ocupación de LUTs correspondientes a la implementación de AS-II. El término independiente bAS-II, involucra dos tiempos de LUT más el tiempo de un multiplexor dedicado para determinar Gi y Pi, un tiempo de LUT asociado a la corrección, y el tiempo de ruteo entre tres slices.

TAS-II = pTmuxcy + bAS-II (3.35)

CAS-II = 12p LUTs (3.36)

43

En el presente trabajo, se propone una tercer alternativa para implementar sumador/restador entre operandos en C10 (AS-III), basada en el diseño del sumador decimal Adder-III. Debido a que cada LUT de este sumador decimal utiliza las 6 entradas para determinar la propagación del acarreo de los sumadores binarios, no se puede ingresar a las LUTs la entrada adicional A'/S. Esto lleva a que se requiera una etapa más de LUTs que implemente lo siguiente

if A'/S=1 then qi=c9i else qi=yi (3.37) donde c9i se determina según la expresión (3.30).

En la figura 3.16 se muestra la implementación de la instancia i del sumador/restador BCD con operandos en C10 basado en el sumador Adder-III en dispositivos con LUTs de 6 entradas.

Figura 3.16 - Implementación de sumador/restador de un dígito BCD con operandos en

C10, sai = xi ± yi, en dispositivos con LUTs de 6 entradas basado en Adder-III.

En la expresión 3.38 se postula el tiempo de cómputo estimado para el sumador/restador AS-III con operandos de p dígitos. El término independiente, bAS-III, contiene dos tiempos de LUT, un tiempo de latch, y el tiempo de ruteo entre tres slices.

TAS-III = 4pTmuxcy + bAS-III (3.38)

La expresión 3.39 detalla el consumo de área en términos de ocupación de LUTs de la alternativa AS-III con operandos de p dígitos.

CAS-III = 7p LUTs (3.39)

3.5.1 Resultados experimentales

Las tablas 3.7 y 3.8, muestran los resultados obtenidos en la síntesis de los sumadores/restadores BCD con operandos de p dígitos en C10 propuestos en este trabajo, en dispositivos de Xilinx Virtex 7 con speed grade 3.

44

Obsérvese que en términos de ocupación de LUTs, la alternativa AS-III es la mejor opción y la propuesta AS-II es la peor. La tabla 3.9 muestra las penalizaciones en área entre los diferentes sumadores/restadores en C10 implementados. La alternativa AS-II posee una penalización en área del 71% respecto a AS-III, y AS-I posee una penalización de 14% respecto a AS-III. Nótese que la alternativa AS-I redujo el consumo relativo de LUTs respecto a las estrategias AS-II y AS-III, comparado a la relación entre los consumo de LUTs que ocurre con los sumadores Adder-I, Adder-II y Adder-III. Esto se debe a que el sumador/restador AS-I posee la misma cantidad de LUTs que el sumador Adder-I, mientras que las otras dos alternativas, agregan 2p LUTs en relación a los respectivos sumadores.

Tabla 3.7. Tiempo de cálculo (ns) de sumadores/restadores C10 en Virtex 7 con speed

grade 3

p AS-I AS-II AS-III

7 3.09 2.67 2.77 16 3.21 2.78 3.26 34 3.44 3.01 4.16

Tabla 3.8. Área (LUTs) de sumadores/restadores C10 en Virtex 7 con speed grade 3

p AS-I AS-II AS-III

7 56 84 49 16 128 192 112 34 272 408 238

Tabla 3.9. Penalización en área entre los diferentes sumadores/restadores en Virtex 7

con speed grade 3

Relación Penalización

P2,1 1.50 P2, 3 1.71 P1, 3 1.14

Apréciese en la tabla 3.7 que la alternativa AS-II obtiene los mejores tiempos de

cómputo. Por otro lado, la solución AS-I posee mejores tiempos de cómputo que AS-III para operandos con tamaño mayor a 7. El término independiente asociado a la expresión matemática que determina el tiempo de cómputo en AS-III (3.38), posee mayor relevancia respecto a los términos independientes de AS-I y AS-II, que lo que ocurre relativamente con Adder-III respecto a Adder-I y Adder-II. Esto se debe a que el sumador/restador AS-III, debe agregar una etapa al sumador decimal Adder-III, ya que no se puede en una LUT determinar la propagación de acarreo con la opción de un operando negado como sucede con las otras alternativas.

La tabla 3.10 muestra las aceleraciones entre los diferentes sumadores/restadores en C10 implementados. Nótese que las aceleraciones de las alternativas AS-I y AS-II respecto a AS-III se incrementa en la medida que aumenta el tamaño de los operandos, debido a que prevalece la constante de proporcionalidad de las expresiones de tiempo de cómputo 3.31, 3.35 y 3.38. Por otro lado, la alternativa AS-II disminuye la aceleración respecto a AS-I aproximadamente en un 4%, comparado a los sumadores Adder-II y Adder-I.

45

Tabla 3.10. Aceleraciones entre los diferentes sumadores/restadores en Virtex 7 con speed grade 3

p A2,3 A2,1 A1,3

7 1.03 1.15 0.89 16 1.17 1.15 1.01 34 1.38 1.14 1.20

La solución AS-III es una buena opción cuando el tamaño de los operandos es 7,

ya que posee ocupación considerablemente menor de LUTs que las otras alternativas y una desaceleración respecto a AS-II de 3%. Para el resto de los tamaños de operandos, p=16 ó 34, la elección entre las diferentes alternativas depende del requisito o restricción de diseño que se quiera priorizar o cumplir.

3.6. Suma/Resta decimal en signo valor absoluto

Se proponen diferentes estrategias para la suma/resta decimal entre operandos representados en SVA sobre dispositivos FPGAs con LUTs de 6 entradas. Sea xx e yy dos representaciones en SVA de los enteros x e y respectivamente, entonces

x = (-1)sx|x|

y = (-1)sy|y|

xx = (sx, |x|), |x| = xp-110p-1 + xp-210p-2 + . . . + x1101 + x0

yy = (sy, |y|), |y| = yp-110p-1 + yp-210p-2 + . . . + y1101 + y0

donde sx e sy, representan los signos de x e y respectivamente. El valor 1 se utiliza cuando el entero es negativo, y 0 para el entero positivo. Además |x| e |y| se representan de la siguiente manera

|x| = xp-1, xp-2, . . . , x1, x0 |y| = yp-1, yp-2, . . . , y1, y0

con xi e yi dígitos decimales representados en BCD.

Sea op la operación que se desea realizar entre los operandos en SVA, con op=1 se realiza substracción y con op=0 la adición, la operación efectiva, ope, se determina de la siguiente manera (tabla 3.11). El valor de sr se corresponde con el signo del resultado.

Tabla 3.11. Operación efectiva entre los operandos en SVA y signo del resultado (sr)

sx sy op ope signo resultado

+ + + |x|+|y| sr = 0 + + - |x|-|y| if (|x|≥|y|) then sr = 0 else sr = 1 + - + |x|-|y| if (|x|≥|y|) then sr = 0 else sr = 1 + - - |x|+|y| sr = 0 - + + |y|-|x| if (|x|≥|y|) then sr = 1 else sr = 0 - + - |x|+|y| sr = 1 - - + |x|+|y| sr = 1 - - - |y|-|x| if (|x|≥|y|) then sr = 1 else sr = 0

46

en consecuencia

ope = sx ⊕ sy ⊕ op

sr = (ope'·sx) v (ope·((sx ·(|x|≥|y)) v (sx'·(|x|<|y|)))) (3.40)

En este trabajo se proponen dos estrategias principales, cada una con diferentes

variantes. Una se basa en el uso de sumadores/restadores enteros en C10 (apartado 3.5). La otra se basa en el empleo de sumadores naturales (apartado 3.3) y restadores naturales con resultado en SVA sin overflow (apartado 3.4).

3.6.1. Basada en sumadores/restadores de enteros en C10

Una estrategia directa para efectuar la suma/resta entre operandos decimales de p dígitos representados en SVA, es mediante el uso de sumadores/restadores en C10 sin consideración de overflow. Nótese que cuando la operación efectiva es la suma de los valores absolutos de los operandos, |x|+|y|, ésta se puede llevar a cabo mediante la utilización de un sumador/restador en C10. Por otro lado, para el caso que la operación efectiva es la resta de los valores absolutos de los operandos, es decir |x|-|y|, el sumador/restador en C10 hace la siguiente operación

(|x|+(10p-|y|)) mod 10p (3.41)

En la expresión 3.41 se identifican dos casos: i) |x|-|y|≥0 y ii) |x|-|y|<0. Para el caso i), la operación 3.41 genera acarreo ya que el resultado es mayor o igual 10p, entonces

(|x|+(10p-|y|)) mod 10p = |x|-y| (3.42)

en consecuencia, el valor absoluto del resultado obtenido es el correcto. En el caso ii), no se genera acarreo ya que el resultado es menor a 10p, entonces

(|x|+(10p-|y|)) mod 10p = 10p+|x|-|y| (3.43)

nótese que como en este caso, como |y|>|x|, se debe negar el resultado obtenido aplicando el complemento a la diez, entonces

10p-(10p+|x|-y|) = |y|-|x| (3.44)

Basada en la expresión 3.40, la expresión 3.45 determina el signo del resultado,

sr, de la suma/resta decimal en SVA, donde c es el acarreo producido por el sumador/restador en C10.

sr = (ope'·sx) v (ope·sx·c) v (ope·c'·sx') = ((ope' v c)·sx) v (ope·c'·sx') = (ope·c') ⊕ sx

(3.45)

La figura 3.17 muestra el sumador/restador de números enteros decimales en SVA

basado en sumador/restador en C10 propuesto. Para la implementación del módulo AddSub_C

10 se utilizan las implementaciones de sumadores/restadores decimales en C10 detallados en apartado 3.5 (AS-I, AS-II y AS-III). Por otro lado, el módulo Neg es el

47

encargado de realizar el complemento a diez del operando de entrada. La señal ne indica si el resultado del sumador/restador en C10 se debe complementar, ne = c'·ope. Considérese que A'/S indica la operación a realizar, cuando A'/S es uno se realiza la resta y cuando A'/S es cero la suma.

yx

A’/SAddSub

C10

sxsy

NEG

10

ope

ne

r sr

c

A’/S

sa

Figura 3.17 - Sumador/Restador de números enteros decimales representados en SVA, r = x ± y, basado en sumador/restador en C10.

Una estrategia para la implementación del módulo Neg y el multiplexor, es mediante la suma decimal eficiente entre el complemento a nueve de la salida del sumador/restador, C9(sa), y uno

if ne=1 then r=C9(sa)+1 else r=sa (3.46)

Para realizar la suma eventual con el número 1, se ingresa ne por la entrada de la carry-chain del sumador decimal. Considérese c9i, como el complemento a nueve del dígito i del resultado sa, c9i = C9(sai). Defínase Pni, como la función de propagación de acarreo determinada por la instancia i del sumador decimal correspondiente a la expresión 3.46. La función Pni obtiene uno cuando c9i es 910 , es decir

Pni = sai[3]'·sai[2]'·sai[1]'·sai[0]' (3.47)

el acarreo producido por la instancia i del sumador expresado en 3.47, nci+1, se determina de la siguiente manera

nci+1 = Pni·nci (3.48) con nc0 = ne. Nótese que cuando nci+1 = 1, entonces ncj = 1, con { }ii ,..,1,0∈ . Significa

que cuando ne = 0, toda la cadena de acarreo es nula, ncj = 0 para { }pi ,..,1,0∈ , donde p es el tamaño del operando sa.

Cada dígito del resultado se determina de la siguiente manera

if ne=0 then ri = sai else ri = (c9i + ci) mod 10

(3.49)

48

La figura 3.18 muestra la implementación en dispositivos con LUTs de 6 entradas

del sumador/restador de números enteros decimales representados en SVA propuesto, basado en sumador/restador en C10, para operandos de tamaño p.

0 1

0

Pn0

LUT-6

LUT-6:2

LUT-6

sa0[2..0]

sa0[3..0]

3

4

nc1

0 1

0

Pnp-1

LUT-6

LUT-6:2

LUT-6

rp-1[0]

sap-1[2..0]

sap-1[3..0]

3

4 rp-1[1]

rp-1[2]

ncp-1

4sa0

4sap-1

.

.

....

.

.

....

AS-i

LUT-6:2

sr

ne

LUT-6

saxy

cp

.

.

.

sa

ope

sx

syA/S

A/S

|X|

|Y|

LUT-6 r0[3]

r0[2]

r0[1]

r0[0]

LUT-6 rp-1[3]

Figura 3.18 - Implementación de sumador/restador en SVA en dispositivos con LUTs

de 6 entradas, r = x ± y, basado en sumador/restador en C10.

Se identifica AS_SM_CB-i, como la implementación del sumador/restador decimal en SVA que utiliza el sumador/restador AS-i (apartado 3.5). En las expresiones 3.50, 3.51 y 3.52, se postulan los tiempos de cómputo estimados de las tres alternativas implementadas para operandos de tamaño p. Los términos independientes bAS_SM_CB-i, contienen a los correspondientes bAS-i, más 3 tiempos de LUTs y 3 tiempos de ruteo entre slices.

TAS_SM_CB-I = 2pTmuxcy + bAS_SM_CB-I (3.50)

TAS_SM_CB-II = 2pTmuxcy + bAS_SM_CB-II (3.51)

TAS_SM_CB-III = 5pTmuxcy + bAS_SM_CB-III (3.52)

Por otro lado, las expresiones 3.53, 3.54 y 3.55, determinan la ocupación de LUTs de la implementación de las alternativas propuestas para operandos de tamaño p. Cada alternativa posee la ocupación de LUTs del correspondiente sumador/restador en C10, AS-i, más 4p LUTs asociadas a Neg, más 2 LUTs que determinan ope, ne y sr.

CAS_SM_CB-I = 12p+2 LUTs (3.53)

CAS_SM_CB-II = 16p+2 LUTs (3.54)

49

CAS_SM_CB-III = 11p+2 LUTs (3.55)

3.6.2. Basada en sumadores y restadores de decimales naturales

Otra estrategia propuesta en este trabajo para llevar a cabo la suma/resta entre operandos decimales de p dígitos representados en SVA, es mediante la realización en paralelo de la suma y la resta decimal entre los valores absolutos de los operandos, y posterior selección del resultado correcto considerando la operación efectiva (figura 3.19).

La suma se puede implementar con cualquier alternativa presentada en el apartado 3.3. Por otro lado, la resta se realiza mediante restador de números naturales con resultado en SVA (Sub_S), de este modo se evita el overflow y se puede efectuar tanto |x|-|y|, como |y|-|x|. La señal cc indica que la resta requiere de un dígito, en tal caso el resultado de la misma es negativo (x<y). El signo del resultado del sumador/restador en SVA, sr, se basa en la expresión 3.40 pero considerando cc.

sr = (ope'·sx) v (ope·sx·cc') v (ope·cc·sx') = ((ope' v cc')·sx) v (ope·cc·sx') = (ope·cc) ⊕ sx

(3.56)

SUB

sxsy

10

ope

r sr

cc

A’/S

ss

yx

ADD

a

Figura 3.19 - Sumador/Restador de números enteros decimales representados en SVA, r = x ± y, basado en sumador, restador y multiplexor.

Para reducir el tiempo de cómputo y la ocupación de LUTs, se propone realizar un cambio menor al restador Sub_S, para que incluya la selección del resultado correcto. Esta variante consiste en combinar la etapa de corrección del restador Sub_S, expresión 3.25, con el multiplexor que selecciona el resultado correcto según la operación efectiva ope. Significa que para la instancia i del sumador/restador en SVA, la variante de la etapa de corrección de Sub_S realiza lo siguiente

if ope=0 then ri = ai

elsif cci+1=1 then ri = 9-nzzi

else ri = nzzi' (3.57)

es decir

50

ri[0] = ai[0]·ope' v nzzi[0]'·ope

ri[1] = ai[1]·ope' v ((nzi[1]⊕ ci+1)'·ope)

ri[2] = ai[2]·ope' v ((((nzi[2] ⊕ nzi[1])·ci+1) v (nzi[2]'·ci+1')·ope))

ri[3] = ai[3]·ope' v (((nzi[3]'·nzi[2]'·nzi[1]'·ci+1) v (nzi[3]'·ci+1')·ope))

(3.58)

En la figura 3.20, se aprecia la implementación de la instancia i del

sumador/restador con operandos en SVA basado en sumador y restador de números naturales, en dispositivo con LUTs de 6 entradas. En esta figura se utilizó la instancia i del sumador Adder-I, pero se puede utilizar la instancia i de cualquiera de los sumadores propuestos en el apartado 3.3. La señal cp, indica el requerimiento de un dígito de la última instancia, p, de la etapa correspondiente al restador de números naturales con overflow.

Se identifica a AS_SM_MX-i, como la implementación del sumador/restador decimal en SVA basado en sumador y restador de números decimales, que utiliza Adder-i. El tiempo estimado de cómputo de las tres alternativas implementadas para operandos de tamaño p, se postulan por la misma expresión (3.59). Esto se debe a que el peor retraso se encuentra en el restador Sub_S/Mux, siendo éste el mismo para las tres alternativas. El término independiente bAS_SM_MX, contiene tres tiempos de LUTs, y tiempo de ruteo entre tres slices

TAS_SM_MX-I = TAS_SM_MX-II = TAS_SM_MX-III =8pTmuxcy + bAS_SM_MX (3.59)

Por otro lado, las expresiones 3.60, 3.61 y 3.62, determinan la ocupación de LUTs de la implementación de las alternativas propuestas para operandos de tamaño p Cada alternativa posee la ocupación de LUTs del correspondiente sumador, Adder-i, más la ocupación del restador y multiplexor (ocupación de Sub_S sin corrección y 4p LUTs para corrección y multiplexor), más dos LUTs que determinan ope y sr

CAS_SM_MX-I = 20p+2 LUTs (3.60)

CAS_SM_MX-II = 22p+2 LUTs (3.61)

CAS_SM_MX-III = 17p+2 LUTs (3.62)

3.6.3. Resultados experimentales

Las tablas 3.12 y 3.13, muestran los resultados obtenidos en la síntesis de los sumadores/restadores BCD con operandos de p dígitos representados en SVA propuestos, en dispositivos de Xilinx Virtex 7 con speed grade 3.

Tabla 3.12. Tiempo de cálculo (ns) de sumadores/restadores BCD en SVA en Virtex 7 con speed grade 3

p AS_SM_

CB-I

AS_SM_

CB-II

AS_SM_

CB-III

AS_SM_

MX-I

AS_SM_

MX-II

AS_SM_

MX-III

7 4.88 4.28 4.37 3.44 3.43 3.43 16 5.00 4.40 4.86 4.33 4.33 4.33 34 5.23 4.65 5.77 6.14 6.14 6.14

51

Tabla 3.13. Área (LUTs) de sumadores/restadores BCD en SVA en Virtex 7 con speed

grade 3

p AS_SM_

CB-I

AS_SM_

CB-II

AS_SM_

CB-III

AS_SM_

MX-I

AS_SM_

MX-II

AS_SM_

MX-III

7 86 114 79 142 156 121 16 194 258 178 322 354 274 34 410 546 376 682 750 580

0 1

0 1

nzzi[0]

0 1

0 1

nzzi[1]

nzzi[2]

nzzi[3]

LUT-6:2

LUT-6:2

LUT-6:2

LUT-6:2

pssi[2]

cci

cci+1

pssi[1]

pssi[0]

pssi[3]

gssi[3]

gssi[2]

gssi[1]

gssi[0]

0 1xi[0]

yi[0]

0 1

nzi[0]

0 1

0 1

nzi[1]

nzi[2]

nzi[3]

LUT-6

LUT-6

LUT-6

LUT-6

psi[2]

ci

ci+1

xi[1]

yi[1]

xi[2]

yi[2]

xi[3]

yi[3]

psi[1]

psi[0]

psi[3]

cp

ope LUT-6 ri[2]

LUT-6 ri[1]

0 1xi[0]

yi[0]

xor0

and0

0

0 1xi[1]

yi[1]

xor1

and1

ui[0]

0 1xi[2]

yi[2]

xor2

and2

0 1xi[3]

yi[3]

xor3

and3

ui[1]

ui[2]

ui[3]

ui[4]

0 1Pi

Gi

cyi

cyi+1

ui[3..0]

4

ai[0]

ai[1]

ai[2]

ai[3]

LUT-6:2

LUT-6

LUT-6

LUT-6

LUT-6:2

LUT-6:2

LUT-6:2

LUT-6:2

LUT-6 ri[3]

LUT-6 ri[0]

Figura 3.20 - Implementación de sumador/restador de un dígito con operandos en SVA, ri = xi ± yi, en dispositivos con LUTs de 6 entradas, basado en sumador y restador de

números naturales (con Adder-I).

Obsérvese que las alternativas basadas en la estrategia de suma, resta y multiplexor (AS_SM_MX-*), obtienen peor ocupación de LUTs que las alternativas basadas en sumador/restador en C10 y negador (AS_SM_CB-*). Se cumple la estimación de tiempo de cálculo (expresión 3.59), la cuál postula que todas las opciones poseen el mismo retraso asociado a la resta y al multiplexor. Debido a esto, la mejor alternativa de sumador/restador SVA basada en suma, resta y multiplexor, AS_SVA_MX-*, es la que

52

utiliza el sumador Adder-III basado en las ideas de [Din10a], ya que es el sumador con menor ocupación de LUTs.

En cuanto a las tres estrategias AS_SVA_CB-*, la alternativa que utiliza AS-III, basada en ideas de [Din10a], obtiene la menor ocupación de LUTs. Por otro lado, la estrategia que utiliza AS-II, con cálculo de funciones de propagación y generación de acarreo a partir de las entradas, posee la mayor ocupación de LUTs pero los menores tiempos de cómputo.

La tabla 3.14 muestra las penalizaciones promedio en área entre los diferentes sumadores/restadores en SVA implementados. En lo que respecta a las alternativas basadas en sumadores/restadores en C10, la que utiliza AS-II posee una penalización en área de 44% respecto a la que utiliza AS-III, y del 32% respecto a la que usa AS-I Además la solución basada en AS-I posee una penalización menor al 10% respecto a la basada en AS-III. Por otro lado, comparando las mejores alternativas en lo que refiere a ocupación de LUTs entre ambas estrategias, la solución basada en suma, resta y multiplexores (AS_SM_MX-III), posee una penalización en área del 53% respecto a la basada en C10 (AS_SM_CB-III).

Tabla 3.14. Penalización en área entre los diferentes sumadores/restadores en SVA implementados en Virtex 7 con speed grade 3

Relación Penalización

PAS_SM_CB-II, AS_SM_CB-I 1.32 PAS_SM_CB-II, AS_SM_CB-III 1.44 PAS_SM_CB-I, AS_SM_CB-III 1.08 PAS_SM_MX-III, AS_SM_CB-II 1.06 PAS_SM_MX-III, AS_SM_CB-III 1.53

Apréciese en la tabla 3.12 que para tamaño de operandos menores (p≤16), las

soluciones basadas en suma, resta y multiplexores obtienen tiempos de cómputo menores que las basadas en sumadores/restadores en C10. Para p=34, las soluciones basadas en sumadores/restadores en C10 son más rápidas, siendo la alternativa AS_SM_CB-II la que posee menor tiempo de cálculo.

La tabla 3.15 muestra las aceleraciones entre los diferentes sumadores/restadores implementados. Las alternativas AS_SM_MX-* se desaceleran respecto a las alternativas AS_SM_CB-*, en la medida que aumenta el tamaño de los operandos.

Tabla 3.15. Aceleraciones entre los diferentes sumadores/restadores BCD en SVA en Virtex 7 con speed grade 3

p AAS_SM_CB-II,

AS_SM_CB-III

AAS_SM_CB-II,

AS_SM_CB-I

AAS_SM_CB-I,

AS_SM_CB-III

AAS_SM_MX-III,

AS_SM_CB-II

AAS_SM_MX-III,

AS_SM_CB-III

7 1.02 1.14 0.89 1.24 1.27 16 1.10 1.13 0.97 1.01 1.12 34 1.24 1.12 1.10 0.75 0.93

La elección entre las diferentes alternativas AS_SM_CB-I, AS_SM_CB-II,

AS_SM_CB-III y AS_SM_MX-III, depende de los requisitos de diseño que se deseen priorizar o satisfacer.

53

3.7. Conclusiones del capítulo

En este capítulo se propone el diseño e implementación eficiente en dispositivos FPGAs de Xilinx con LUTs de 6 entradas, de diferentes alternativas para las operaciones de suma y resta entre operandos en radix-10. Muchas de las soluciones expuestas en el presente trabajo son una extensión de trabajos precedentes del autor de esta tesis. Los diseños, implementaciones y resultados detallados en este capítulo, se publicaron en [Vaz15].

Las soluciones propuestas se basan en la utilización eficiente de los recursos dedicados presentes en los dispositivos para la implementación de la propagación de acarreo de la suma binaria. Se adaptaron los diseños de modo que la propagación de acarreo para las operaciones suma y resta radix-10 utilice la lógica dedicada en el dispositivo para propagación de acarreo en operaciones binarias de suma y resta. Además, se utilizaron las LUTs de manera eficiente para implementar las funciones lógicas.

Se analizaron y determinaron las mejores técnicas de diseño en radix-10 para la suma de naturales y suma/resta de enteros, para este tipo de dispositivos presentadas en [Vaz09b], [Bio10] y [Din10a]. Las técnicas que provienen de [Vaz09b] y [Bio10], se basan en el cálculo eficiente de las funciones de propagación y generación de acarreo decimal, y la utilización de los recursos dedicados en el dispositivo para la implementación de la suma binaria. La otra técnica [Din10a], realiza la suma decimal mediante una suma binaria eficiente con pre- y post- corrección.

Se diseñaron dos estrategias principales para implementar la suma/resta de números enteros decimales representados en SVA en estos dispositivos. Una se basa en sumadores/restadores en C10, la otra en un multiplexor que selecciona el resultado correcto que proviene de la suma, o de la resta, de números naturales decimales. Para ello, se diseñó un restador de números naturales con resultado en SVA que utiliza de manera eficiente los recursos dedicados para la implementación de la suma o la resta binaria. Para cada estrategia de suma/resta en SVA, se diseñaron tres alternativas asociadas directamente a las técnicas de diseño de suma natural [Vaz09b], [Bio10] y [Din10a].

Se obtuvo que todos los diseños que emplean o adaptan la técnica de suma decimal según [Din10a], tienen menor consumo de LUTs que los correspondientes diseños que utilizan las técnicas de suma decimal mediante el cálculo de las funciones de propagación y generación de acarreo [Vaz09b] y [Bio10]. Por otro lado, las soluciones basadas en [Din10a], obtienen desaceleraciones respectos a las correspondientes soluciones basadas en [Vaz09b] y [Bio10], en la medida que aumenta el tamaño de los operandos.

Las alternativas que se basan en sumadores con cálculo de Pi y Gi a partir de las entradas, si bien presentan la mayor ocupación de LUTs, obtienen los mejores tiempos de cálculo respecto a las alternativas con sumadores basados en las otras dos técnicas. Por otro lado, las soluciones basadas en sumadores con cálculo de Pi y Gi a partir de suma binaria inicial, tienen mayor consumo de LUTs que las correspondientes basadas en [Din10a], y menor que las basadas en Pi y Gi a partir de las entradas. Además, las soluciones que usan sumadores con Pi y Gi en función de la suma inicial binaria,

54

obtienen mejores tiempos de cálculo que aquellas que usan sumadores basados en [Din10a], para operandos de mayor tamaño (p>16).

En cuanto al sumador/restador con operandos decimales en SVA, la estrategia basada en el sumador natural y restador natural con multiplexor, presenta mayor consumo de LUTs, pero obtiene menor tiempo de cómputo para p≤16, respecto a la alternativa basada en sumador/restador en C10.

55

CAPÍTULO 4

Logaritmo decimal en base 10

En este capítulo se presenta el diseño y la implementación eficiente del logaritmo decimal radix-10 en punto fijo y punto flotante conforme al estándar IEEE 754-2008, en dispositivos programables con LUTs de 6 entradas de Xilinx.

Se comienza el capítulo con la exposición y clasificación de los trabajos existentes relacionados con las implementaciones de las operaciones de logaritmos radix-10. Luego se detalla brevemente la propuesta y contribuciones del presente capítulo.

En la sección 4.3 se describe el método propuesto, y se desarrolla el diseño e implementación eficiente en dispositivos de Xilinx del logaritmo decimal radix-10 punto fijo.

El apartado 4.4 detalla la propuesta para la implementación hardware del logaritmo DFP conforme al estándar. Primero se analiza todo lo referente al manejo de exponentes, en argumento y resultado, así como también al manejo de la precisión efectiva en lo que respecta a las cifras significativas del resultado. A continuación se describen el algoritmo y la arquitectura propuesta. Luego se analiza y muestra la implementación en dispositivos programables de Xilinx. Por último, en este apartado se observan los resultados experimentales y se realizan comparaciones con trabajos de significativa relevancia en la literatura.

Al final de este capítulo se exhiben las conclusiones y los trabajos futuros.

4.1. Introducción

El diseño de algoritmos y arquitecturas para el cálculo de funciones elementales (logaritmo, raíz cuadrada, exponenciación, potencia, etc), toma especial relevancia en algunas áreas, tales caso de computación gráfica, procesamiento de señal digital, comunicación, computación científica, simulación, entre otras.

El cálculo de muchas de estas funciones tradicionalmente ha sido realizado por rutinas de software, esto lleva a la obtención de soluciones con mucha precisión, pero lentas en términos de tiempo de cómputo para aplicaciones que requieren tiempo real. Por lo anterior, el desarrollo de hardware dedicado para el cómputo de funciones elementales, es un desafío instalado desde hace años en el área diseño y desarrollo de circuitos aritméticos o aritmética de computadoras [Bru13].

56

Según [Che11], las soluciones para resolver en hardware este tipo de funciones se separan principalmente en dos grupos: métodos iterativos y no iterativos. Los métodos no iterativos, incluyen el uso directo de LUTs, aproximaciones racionales y polinomiales, y estrategias basadas en tablas. En lo que respecta a los métodos iterativos, éstos se encuentran conformados por algoritmos con recurrencia de dígitos y por técnicas basadas en iteración funcional.

Los métodos no iterativos son comúnmente utilizados cuando existe la necesidad de realizar unidades aritméticas en aplicaciones que requieran bajo costo, alta velocidad de cálculo y tolerancia a errores con cómputo de baja precisión. En cuanto a los métodos iterativos, se utilizan para aplicaciones que requieren tanto baja como alta precisión, son muy utilizados en aplicaciones científicas que requieren alta precisión para las cuáles los métodos no iterativos son inaplicables.

La función elemental de logaritmo es fundamental, además de su importancia en las áreas mencionadas, en el dominio LNS (Logarithmic Numeric System-sistema numérico logarítmico) y en el uso de unidades aritméticas logarítmicas. Estas unidades se utilizan para transformar las operaciones multiplicación y división, con el costo que implica realizarlas, en operaciones de suma y resta respectivamente, mediante previa transformación de los operandos al dominio logarítmico y posterior transformación del resultado al dominio original [Sto01] [Kou13] [Gau16].

[Lih15] menciona que las estrategias para implementar la función de logaritmo se encuentran en tres categorías: recurrencia de dígitos, basados en tablas LUTs y basadas en Mitchell [Mit62]. Los métodos basados en recurrencia de dígitos obtienen alta precisión y son eficientes en cuanto al consumo de área, pero poseen mucha latencia debido a su naturaleza iterativa. En lo que respecta a los métodos basados en LUTs, se pueden utilizar en aplicaciones de alta precisión, pero requieren gran tamaño de memoria y/o mucho tiempo de cómputo. Existen trabajos que emplean aproximaciones lineales para reducir el tamaño de la memoria y aumentar la velocidad. Por último, los métodos basados en Mitchell, proponen mejoras al trabajo [Mit62] en cuanto a precisión, considerando aspectos como área, tiempo de cómputo y consumo de potencia.

[Mit62] es el pionero en el uso de aproximaciones polinomiales para resolver el logaritmo binario (radix-2). Divide el logaritmo en intervalos de potencia de dos usando la aproximación log(1+x) con x para cada intervalo. La principal contra de este método es que posee un error de aproximación de 0.08639 (3.53 bits).

Se desarrollaron diferentes métodos para mejorar la solución de [Mit62] mediante técnicas de corrección de error. Una de las técnicas más empleadas para disminuir el error en [Mit62] es la aproximación lineal por tramos (piecewise), esta técnica requiere solo un multiplicador-acumulador y una pequeña memoria, o LUT, que almacena los coeficientes del polinomio [Gut11] [Car11] [Gao12] [Lih15] [Liu16] [Zhu16] [Cha13] [Cha15][Kap15] [Che08].

En [Gut11] el error de [Mit62] es aproximado por una interpolación lineal piecewise, con los factores que corresponden a las pendientes de las rectas, potencia de dos para evitar multiplicaciones. En [Car11] se propone una técnica para obtener valores óptimos de coeficientes polinomiales de modo que se minimice el error máximo

57

relativo. [Lih15] se basa en el trabajo de [Mit62] aumentando la precisión hasta 14 bits, presenta un modelo de hardware genérico y analiza los parámetros que impactan en la precisión y en los recursos de hardware requeridos. [Liu16] presenta mecanismos para adquirir el número de regiones y coeficientes de las rectas a partir de restricciones de error, de modo que sean óptimas las unidades logarítmicas basadas en sumas y desplazamientos. [Zhu16] propone el uso de regiones no uniformes para la interpolación lineal, de este modo obtiene una disminución del error máximo relativo.

En [Cha13] y [Cha15], se plantean diseños en FPGAs basados en aproximaciones lineales que obtienen resultados con precisión fraccionaria de 23 bits, para ello se utilizan los recursos de memoria y multiplicadores embebidos en el dispositivo.

[Che08], propone dos soluciones para realizar el logaritmo decimal radix-10 punto fijo de 7 dígitos basados en aproximaciones lineales. Una solución se basa en el trabajo de [Mit62], para ello utiliza conversores decimal-binario y binario-decimal. La otra solución efectúa la aproximación lineal directamente en radix-10, obteniendo una disminución significativa del error, debido a que se evita las conversiones decimal-binario.

Entre los métodos basados en tablas, una de las principales técnicas radica en el uso de tablas bipartitas (o multipartitas) [Din05] [Sch99] [Gut10]. Esta técnica consiste en aproximar la función elemental en dos tablas paralelas, cuyo contenido usualmente posee aproximaciones en formato carry-save, y luego esas dos aproximaciones son sumadas para producir el resultado aproximado final. La utilización de estos métodos prevalece en aplicaciones que requieren precisión de hasta 24 bits, debido a que presentan poco uso de hardware y mejor tiempo de cómputo respecto a las soluciones basadas en recurrencias de dígitos o aproximaciones polinomiales y racionales.

En [Pau09] se presenta una implementación en FPGA de una aproximación del logaritmo y antilogaritmo binario, la idea principal es usar LUTs e interpoladores cuadráticos o lineales. La interpolación se implementa en lógica combinacional. La contribución principal de este trabajo es que la multiplicación requerida en la interpolación se efectúa utilizando el mismo circuito para el cálculo de logaritmo y antilogaritmo.

[Kha11] propone un algoritmo eficiente para determinar la aproximación del logaritmo radix-10 con operandos en punto flotante de 32 bits, basado en el almacenamiento de algunos logaritmos precalculados, como es el caso de logaritmo de 256, 16, 4, 2, 3/2, 5/4, etc. Utiliza solo las operaciones básicas de suma y resta en la implementación.

Los métodos basados en la recurrencia de dígitos son conocidos como métodos iterativos dígito por dígito [Che11]. Basan su implementación en el uso de las operaciones suma y desplazamiento, cuando se trabaja en radix-2b, obteniéndose una precisión especifica en el resultado. Esta técnica tiene como ventaja respecto a los métodos basados en tablas o basados en la aproximación de Mitchell, la obtención de resultados de alta precisión. En términos de tiempo de cómputo, debido a que posee una convergencia lineal de un dígito radix-r en cada iteración, la latencia se encuentra directamente vinculada con la precisión deseada. Para poder desarrollar soluciones eficientes, la selección del radix se debe hacer cuidadosamente. El incremento de b en

58

soluciones con radix-2b, reduce la cantidad de ciclos que involucra el cálculo, pero incrementa el tiempo de ciclo de reloj y la complejidad de la implementación.

En [Bak73], se presentan algoritmos de alto radix para algunas funciones elementales, particularmente el logaritmo natural (ln). Estas implementaciones utilizan multiplicadores rápidos paralelos por un dígito de b-bits (radix-2b). Los algoritmos se basan en multiplicaciones por el factor (1 + d×r

i ), donde r es el radix.

[Kos91] propone una solución para realizar el logaritmo base dos en binario, con la obtención de un dígito binario de precisión en cada paso. Utiliza un multiplicador binario paralelo costoso de p bits (p relacionado con la precisión definida).

[Taj09] plantea un algoritmo para computar en FPGA, el logaritmo decimal radix-10 con operandos en punto flotante de 32 bits. Se basa en la computación iterativa dígito por dígito, sin la utilización de tablas, ni de la operación división o de conversores binario-decimal.

[Wan13] utiliza el algoritmo iterativo CORDIC (Coordinate Rotation Digital

Computer) para realizar el cálculo de la función logaritmo natural en FPGA. En el algoritmo CORDIC, se descompone la operación en rotaciones sucesivas, donde cada rotación se efectúa con operaciones de suma y desplazamiento.

[Ant12] propone un novedoso algoritmo CORDIC redundante radix-10 usando representaciones en punto flotante para el manejo de funciones elementales. Los operandos se encuentra conforme al estándar IEEE 754-2008. Se mapea el algoritmo al uso de unidades de bajo costo basadas en sumadores carry-save decimal.

[Piñ02a], [Piñ02b] y [Piñ04], aportan soluciones relevantes para la implementación de la función logaritmo mediante recurrencia de dígitos de alto radix (radix-2b). En estos trabajos, se reduce el tiempo de ciclo de reloj mediante el uso de lógica redundante, y se disminuye la latencia un factor de b como consecuencia del uso del radix. Además, utilizan el método de selección por redondeo para determinar el dígito a procesar en la sucesión auxiliar de convergencia.

En [Che09] y [Che12], se realiza la implementación en FPGA y ASIC, de la función logaritmo decimal con operandos en DFP de 32 bits conforme al estándar IEEE 754-2008. Se basa en el trabajo con recurrencia de dígitos y selección por redondeo planteado en [Piñ04], pero adaptando la implementación a un radix que no es potencia de dos.

Muchos del los trabajos expuestos en este apartado, proponen soluciones en dispositivos programables FPGAs, tales caso de [Cha13], [Cha15], [Che08], [Che09], [Det06], [Din05], [Gut10], [Gut11], [Kap15], [Pau09], [Taj09], [Tro07] y [Wan13]. A excepción de [Wan13] que se implementa en un dispositivo perteneciente a Intel-Altera, el resto de las propuestas se implementan en dispositivos de Xilinx. Los trabajos [Cha13], [Cha15], [Det06], [Gut10], [Gut11], [Pau09], utilizan recursos embebidos en el dispositivo FPGA de Xilinx, como memorias (block RAM) o multiplicadores (mult_18x18 o slices DSP), esto lleva a que los diseños sean dependientes no solo del fabricante, sino también de la familia de dispositivos donde se implementa la solución.

59

Según el conocimiento del autor de la presente tesis, no existe en la bibliografía una cantidad significativa de trabajos que propongan soluciones para llevar a cabo en hardware la función logaritmo en radix-10. [Che08] aporta soluciones para aproximar el logaritmo radix-10 en punto fijo. [Taj09] opera con operando radix-10 en punto flotante de 32 bits, pero obtiene resultado en punto fijo con 4 dígitos de precisión. Los trabajos [Che09], [Che12], [Kha11] y [Ant12], proponen soluciones en punto flotante radix-10 conforme al estándar IEEE 754-2008. En [Che08], [Che09], [Taj09] y [Kha11], si bien las implementaciones se realizan en FPGA, los diseños son genéricos y no están pensados para esta tecnología, no efectúan la utilización eficiente de los CLBs, así como tampoco utilizan los núcleos, multiplicadores o memorias, embebidos en el dispositivo FPGA.

4.1.1. Convenciones acerca de simbología utilizada en este capítulo

En el resto del capítulo, las mayúsculas con superíndices entre corchetes denotan sucesiones de números. El superíndice entre corchetes corresponde al valor que posee la sucesión en el i-ésimo paso o iteración, y los subíndices indican la posición del dígito decimal que posee el número. Por ejemplo, Lj

[i] representa el dígito decimal en la

posición j del i-ésimo término de la sucesión {L[i]}. Además, en adelante se utiliza log()

cuando se referencia al logaritmo decimal log10().

Por otro lado, en lo que respecta a las arquitecturas detalladas en las figuras del presente capítulo, los almacenamientos y señales involucradas se modelan o describen con rango descendente. Significa que para un registro o señal s que describe una variable v con formato Qn.p, los n dígitos de la parte entera de v se describen en sp+n-1··p

y los p dígitos de la parte fraccionaria de v se modelan en sp-1··0.

Además, en las figuras que describen circuitos, los valores que aparecen junto a la barra inclinada (símbolo / ) denotan el tamaño del bus. En cuanto a los rangos o valores que se encuentran entre corchetes asociados a un bus, describen el o los dígito/s seleccionado/s. Por otro lado, los tamaños se expresan en cantidad de dígitos BCD o dígitos binarios (bits). Lo mismo sucede con los dígitos seleccionados, éstos pueden ser BCD o binario.

4.2. Propuesta y Contribuciones

En esta sección se propone la implementación eficiente en FPGA de Xilinx del logaritmo radix-10 en punto fijo y punto flotante conforme al estándar IEEE 754-2008. En los que respecta DFP, las soluciones soportan todos los formatos del estándar: decimal32, decimal64 y decimal128.

La propuesta implementa un método iterativo con recurrencia de dígitos. El método posee como novedad la selección directa del dígito de convergencia mediante el scaling de los valores de la sucesión auxiliar. Para ello, la ruta de datos no se basa en la implementación de lógica redundante carry-save como ocurre con las soluciones presentes en los principales trabajos de la bibliografía para tecnología ASIC en recurrencia de dígitos, tales como los casos de [Piñ02a], [Piñ02b] y [Che12].

Esta propuesta se encuentra fuertemente basada en la certeza que los diseños en dispositivos FPGAs, particularmente los pertenecientes a las familias de Xilinx, poseen

60

lógica dedicada para efectuar propagación de acarreo en la suma binaria. En consecuencia, no es imprescindible recurrir a soluciones con redundancia, como el caso de las técnicas basadas en carry-save, para evitar la propagación de acarreo.

Para las implementaciones propuestas no se utilizaron los núcleos embebidos que se encuentran en los dispositivos, tales como memorias, multiplicadores, etc. En cambio, se emplearon y utilizaron las técnicas novedosas detalladas en el capítulo 3 para la implementación eficiente de la lógica de propagación de acarreo en los sumadores y sumadores/restadores BCD. Además, para la multiplicación radix-10 se utilizó el multiplicador [Din10b], basado en el uso eficiente de los CLBs y lógica de acarreo pertenecientes en los dispositivos.

Debido a esto, los diseños propuestos instancian módulos LUTs y muxcy

dedicados utilizados en la implementación del acarreo binario en dispositivos de Xilinx basados en LUTs de 6 entradas. Por consiguiente, para que esta propuesta se pueda implementar en cualquier dispositivo de lógica programable (o tecnología ASIC) independientemente del fabricante, solo se requiere sustituir la instanciación de estos componentes por su descripción correspondiente en un lenguaje de descripción de hardware (VHDL en esta tesis).

Se realizaron comparaciones con las propuestas del trabajo de [Che12]. Según el conocimiento del autor de esta tesis, el mencionado trabajo es el de mayor relevancia en la literatura en cuanto a la implementación hardware basada en recurrencia de dígitos del logaritmo DFP conforme al estándar IEEE 754-2008. Con la finalidad de efectuar comparaciones más objetivas, se realizaron algunas modificaciones a las soluciones de [Che12] de modo que utilice más eficientemente los recursos de los dispositivos FPGAs de Xilinx.

4.3. Método propuesto

El método propuesto para la implementación del logaritmo decimal en radix-10 utiliza la técnica de recurrencia de dígitos. El algoritmo se basa en la identidad utilizada en otros trabajos [Piñ02a], [Piñ02b], [Piñ04] y [Che12]:

( ) [ ]( ) [ ]( )∑∏ −= ii CCvv logloglog (4.1)

Si se cumple lo siguiente:

[ ] 1→∏ iCv (4.2)

entonces [ ]( ) ( )vC i loglog →−∑ (4.3)

La expresión 4.2 se realiza mediante el uso de una normalización multiplicativa,

la cuál consiste en determinar una sucesión {C[i]} (i=0,1, ...), tal que v se transforma a

uno mediante multiplicaciones sucesivas. Para que el cálculo de 4.2, el cuál involucra una multiplicación decimal entre operandos cuyo tamaño es mayor a uno, se optimice a una operación shift-and-add y una multiplicación por un dígito decimal, se define C[i] de la siguiente manera:

61

[ ] [ ] iiiAC

−+= 101 ; con [ ] { }10,9,..,8,9 −−∈iA (4.4)

A continuación se definen las sucesiones, {L[i]} y {V

[i]} (i=0,1, ...), mediante las cuáles se realiza la transformación de v y el cómputo del logaritmo

[ ] [ ] [ ]iiiCVV =+1

[ ] [ ] [ ]iii CLL log1 −=+ (4.5)

donde {L

[i]} se identifica como sucesión principal y {V[i]} como sucesión auxiliar.

Para que la sucesión auxiliar converja a uno y la sucesión principal converja a

log(v), se setean los valores iniciales V[0] = v y L[0] = 0. Además en cada iteración, se determina el valor de A[i] de la siguiente manera:

si [ ] 1≥iV ⇒ [ ] [ ]i

i

i VA −=

si [ ] 1<iV ⇒ [ ] [ ]i

i

i VA −= 10 (4.6)

El dígito Vi

[i] de la sucesión auxiliar seleccionado para calcular A[i], en adelante se lo denomina dígito de convergencia. Es importante destacar, que la manera de determinar A[i] (expresión 4.6), es la deferencia principal que posee el método propuesto en este trabajo respecto a los métodos propuestos en [Piñ02a], [Piñ02b], [Piñ04] y [Che12], para el cómputo del logaritmo. Esto posibilita que la implementación física del algoritmo propuesto, presente diferencias muy significativas respecto a los trabajos mencionados.

Considérese que si V[i] = 0.18032899, entonces [ ]iV1 =1, [ ]iV2 =8, [ ]iV3 =0, [ ]iV4 =3,

etc. Los valores de las sucesiones {V[i]} y {L

[i]}, es decir V[i] y L[i] (con i = 0,1,...), se encuentran en formato Q1.p, donde p es la precisión de la parte fraccionaria. Nótese que si el argumento v se encuentra en [0.1, 1), la parte entera de V[i] y L[i] (con i=0,1,...) puede ser 0 ó 1.

Si V[0]=v y L[0]=0, y asumiendo que luego de p+1 pasos , o iteraciones, [ ] 11 →+pV ,

resulta por expresiones 4.2 y 4.3 que [ ] ( )vL p log1 →+ :

[ ] [ ] [ ] 10

01 →= ∏=

+p

i

ip CVV ⇒ [ ]

vC

p

i

i 1

0

→∏=

[ ] [ ] [ ]( ) [ ] ( )vCCLLp

i

ip

i

ip logloglog00

01 →−=−= ∏∑==

+

Cuando se quiere obtener el logaritmo de un valor que no se encuentra en el rango

[0.1, 1), se debe realizar un ajuste de modo que

svv 10'= ; con v' en [0.1, 1)

de este modo el algoritmo computa el log(v’) (setea V[0]=v'), y al finalizar se realiza la corrección sumando s.

62

4.3.1. Convergencia de la sucesión auxiliar

A continuación se muestra que la sucesión auxiliar {V[i]} converge a 1, obteniendo

un dígito de convergencia en cada iteración, es decir que para la iteración k-ésima (con Nk ∈ ) se cumple:

-10-k+1 ≤ V[k]-1 <10-k+1 (4.7)

Identifíquense dos casos:

i) Caso V[k] ≥ 1

Se asume:

[ ] [ ] [ ]kkk

k

kVV α++= −101 (4.8)

con [ ] { }9,..,1,0∈k

kV , [ ] pkk −− −≤≤ 10100 α y { }pk ,..,2,1∈

Reemplazando (4.6) en (4.4) y luego en (4.5) se obtiene:

[ ]1+kV = [ ] [ ]( )kk

k

kVV

−− 101

= [ ] [ ]( ) [ ]( )kk

k

kkk

k VV−− −++ 101101 α

= [ ]( ) [ ] [ ] [ ] kk

k

kkkk

k VV−− −+− 10101 22

αα

como [ ] pkk −− −≤≤ 10100 α , entonces [ ]( ) kk

kV22

101 −− ≤ [ ]1+kV < [ ]kα+1

Si [ ] pkk −− −= 1010α , entonces

[ ]1+kV < 1 + 10-k

significa que [ ]1+k

V cumple con la expresión 4.7. Para el caso que [ ] 0=kα

[ ]1+kV = [ ]( ) kk

kV22

101 −−

en consecuencia cuando k≥2, entonces [ ] kk

V−+ −≥ 1011 (cumple con expresión 4.7). Por

otro lado cuando k=1, entonces [ ] [ ]( ) 2211

2 101 −−= VV , significa que V1[1] debe estar en

{0, 1, 2, 3} para que se cumpla con la expresión 4.7, es decir [ ] 9.0101 12 =−≥ −V .

Por lo anterior, considerando que V

[1] debe estar en [1,1.4), se obtiene que V[k+1]

aumenta la exactitud del valor uno en un dígito respecto a V [k]. ii) Caso V

[k] < 1

63

Se asume:

[ ] [ ]kkkTV α+−= −101 (4.9)

con [ ]k

kVT −= 10 , [ ] { }9,..,1,0∈k

kV , [ ] pkk −− −≤≤ 10100 α y { }pk ,..,2,1∈

Reemplazando (4.6) en (4.4) y luego en (4.5) se obtiene:

[ ]1+kV = [ ] [ ]( )kk

k

kVV

−−+ 10)10(1

= [ ]( )( )kkkTT

−− ++− 101101 α = [ ] [ ] kkkk TT −− ++− 10101 22 αα

como [ ] pkk −− −≤≤ 10100 α , entonces

[ ] kk

kV2210)10(1 −−− ≤ [ ]1+k

V = [ ] [ ] kkkk TT −−−++ 10)10(1 αα

como { }10,..,2,1∈T , se obtiene

[ ] kk

kV2210)10(1 −−− ≤ [ ]1+k

V < [ ]kα+1

Si [ ] pkk −− −= 1010α , entonces

[ ]1+kV < 1 + 10-k

significa que [ ]1+k

V cumple con la expresión 4.7.

Para el caso que [ ] 0=kα

[ ]1+kV = [ ] kk

kV2210)10(1 −−−

en consecuencia cuando k≥2, entonces [ ] kk

V−+ −≥ 1011 (cumple con expresión 4.7). Por

otro lado cuando k=1, entonces [ ] [ ] 2211

2 10)10(1 −−−= VV , significa que V1[1] debe estar

en {7, 8, 9} para que se cumpla con la expresión 4.7, es decir [ ] 9.0101 12 =−≥ −V .

Por consiguiente, considerando que V[1] debe estar en [0.7, 1), V[k+1] se acerca al

valor uno incrementando la precisión en un dígito respecto a V [k].

Finalmente, teniendo en cuenta ambos casos, i) y ii), para que la sucesión {V[i]} en

cada iteración converja al valor uno, incrementando su precisión en un dígito (expresión 4.7), V

[1] se debe encontrar en el rango de convergencia [0.7, 1.4). Entonces para calcular [ ] [ ] [ ] [ ]0001

vCCVV == , se debe seleccionar un valor para C[0] de manera tal que

V[1] se encuentre en el rango de convergencia.

Por todo lo expuesto, a modo de ejemplo, sea v un valor con formato Q0.5, la

sucesión {V [i]} en cada paso posee la siguiente forma:

64

V[0] = v

V[1] = 0.V1

[1] V2

[1] V3

[1]V4

[1]V5

[1], ó V[1] = 1.V1[1]

V2[1]

V3[1]

V4[1]

V5[1]

V[2] = 0.9V2

[1] V3

[1]V4

[1]V5

[1], ó V[2] = 1.0V2[1]

V3[1]

V4[1]

V5[1]

V[3] = 0.99V3

[1]V4

[1]V5

[1], ó V[3] = 1.00V3

[1]V4

[1]V5

[1] V

[4] = 0.999V4[1]

V5[1], ó V[4] = 1.000V4

[1]V5

[1]

V[5] = 0.9999V5

[5], ó V[5] = 1.0000V5

[3]

V[6] = 0.99999 , ó V

[6] = 1.00000

donde [ ] { }9,..,1,0∈j

iV .

4.3.2. Convergencia de la sucesión principal

En este apartado se analiza la convergencia de la sucesión principal {L[i]} hacia el

resultado log(v). Reemplazando (4.5) en (4.7) se obtiene:

[ ] [ ] kk

i

ikkCvV

−

=

+− +<=≤− ∏ 1011010

1

entonces

( ) [ ] ( )kk

i

ikCv

−

=

− +<

≤− ∏ 101loglog101log

0

como

[ ] [ ]( ) [ ]

−=−= ∏∑

==

+k

i

ik

i

ikCCL

00

1 loglog

se obtiene

( ) [ ] ( )kkk Lv −+− +<−≤− 101log)log(101log 1

[ ] kkk Lv −+− <−≤− 10)log(10 1 (4.10) Por todo lo anterior, la sucesión {L

[i]} converge al resultado log(v) obteniendo un dígito de la solución en cada paso.

4.3.3. Algoritmo propuesto

A continuación se describe el algoritmo propuesto en este trabajo que computa la expresión y = log(v). Para asegurar la convergencia de la sucesión auxiliar al valor 1, es decir que V

[1] se encuentre en el rango de convergencia, C[0] se determina de la

siguiente manera:

if v está en [0.1, 0.2) then C[0] = 7 elsif v está en [0.2, 0.3) then C[0] = 4 elsif v está en [0.3, 0.4) then C[0] = 3 elsif v está en [0.4, 0.6) then C[0] = 2 else C[0] = 1

(4.11)

65

Por otro lado, la sucesión principal debe ajustarse

L[1] = - log(C[0])

Para el algoritmo considere:

- p la precisión del argumento v y del resultado obtenido y = log (v).

- v en [0.1, 1) con formato Q0.p, donde v = 0.v1v2v3··vp-1vp

- y en (-1, 0) con formato Q0.p, donde y = 0.y1y2y3··yp-1yp

- funciones logaritmos almacenadas en ROMs

El resultado log(v) se encuentra en [-1, 0), éste posee la forma -0.X ó -1.0. Nótese que el resultado es -1 (y = -1) solo para el caso que v = 0.1. Para contemplar esto, la sucesión {L

[i]} opera con p+1 dígitos, formato Q1.p, en donde el resultado final toma los p dígitos menos significativos de L

[p+1] en el caso que L0[p+1] =0. En el caso que

L0[p+1] =1, se aproxima la solución a 0.99··99. De este modo se evita el almacenamiento

del 0 ó 1 posibilitando la ganancia de un dígito de precisión, obteniéndose que el resultado y se encuentre en el rango (-1, 0).

Algoritmo 4.1 - Algoritmo por recurrencia de dígitos para calcular el valor y=log(v) en punto fijo, con p dígitos de precisión

V

[0] = v; L

[0]= 0;

case V1[0]

of 1: C[0]

= 7; 2: C[0]

= 4; 3: C[0]

= 3; 4,5,6: C[0]

= 2; others: C[0]

= 1; end case; // computo del paso 1 V

[1] = V

[0] ×C

[0];

L [1]

= L[0]

– log(C[0]

); for k = 1 to p loop // computo desde paso 2 hasta paso p+1

if (V [k]

≥1) then V

[k+1] = V

[k] - (V

k[k]

×V [k]

×10-k);

L[k+1]

= L[k]

- lut_logP(V k[k]

,k); else (V

[k] <1)

V [k+1]

= V [k]

+ ( (10-V k[k])

) ×V [k]

x10-k

); L

[k+1] = L

[k] - lut_logN(V

k[k]

,k ); end if;

end loop if (L0

[p+1]=1) then

y = 99··99 else y = L1

[p+1]L2

[p+1] ··Lp-1

[p+1]Lp

[p+1]

end if

66

Donde:

- lut_logP(d, k): función que realiza log(1-d10-k)

- lut_logN(d, k): función que realiza log(1+(10-d)10-k)

Obsérvese que estas funciones están basadas en tablas que almacenan resultados

precalculados con precisión Q0.p. La función lut_logP posee 9 tablas, TablePd (d=1, 2, .. ,9). Por otro lado, lut_logN posee 10 tablas, TableNd (d=0, 1, .. ,9). Cada una de las tablas posee p logaritmos almacenados. Significa que:

- lut_logP(d, k) = TablePd[k] = log (1-d10-k); { }9,..,2,1∈d y { }pk ,..,2,1∈

- lut_logN(d, k) = TableNd[k] = log (1+(10-d)10-k); { }9,..,1,0∈d y { }pk ,..,2,1∈

Nótese que para almacenar los logaritmos se requieren 19 LUTs con p resultados de p dígitos decimales. Significa que se necesita almacenar 19p

2 dígitos decimales, esto es 76p

2 bits si se utiliza BCD para representar cada dígito.

Obsérvese en la tabla 4.1, que después de p+1 pasos, o iteraciones, y = -0.2650965. Nótese que log 0.5431297 = -0.2650964, significa que el error producido para este ejemplo es de 1x10-7.

Tabla 4.1. Ejemplo de cálculo de logaritmo de 0.5431297 con precisión p=7

Ini V[0] = 0.5431297 C

[0] = 2 L[0] = 0

1 V[1] = V[0]×C

[0] = 1.0862594

C[1] = 1 log C

[0] = 0.3010299 L[1] = L[0] -0.3010299 =

-0.3010299

2 V[2] = V[1]×C

[1] = 1.0862594

C[2] = 0.92 log C

[1] = 0 L[2] = L[1] - 0 =

-0.3010299

3 V[3] = V[2]×C

[2] = 0.9993586

C[3] = 1.001 log C

[2] = -0.0362121 L[3] = L[2] + 0.0362121=

-0.2648178

4 V[4] = V[3]×C

[3] = 1.0003580

C[4] = 0.9997 log C

[3] = 0.0004340 L[4] = L[3] - 0.0004340=

-0.2652518

5 V[5] = V[4]×C

[4] = 1.0000578

C[5] = 0.99995 log C

[4] = -0.0001303 L[5] = L[4] + 0.0001303=

-0.2651215

6 V[6] = V[5]×C

[5] = 1.0000078

C[6] = 0.999993 log C

[5] = -0.0000217 L[6] = L[5] + 0.0000217=

-0.2650998

7 V[7] = V[6]×C

[6] = 1.0000007

C[7] = 0.9999993 log C

[6] = -0.0000030 L[7] = L[6] + 0.0000030=

-0.2650968

8 V[8] = V[7]×C

[7] = 0.9999999

C[8] = -- log C

[7] = -0.0000003 L[8] = L[7] + 0.0000003=

-0.2650965

A continuación se describe una versión del algoritmo 4.1 discriminada en bloques de códigos (algoritmo 4.2), con el fin de identificar de forma más directa el camino crítico respecto a tiempo de cálculo, ocupación de área y concurrencia de los módulos intervinientes. Obsérvese que se introdujo el primer paso del algoritmo 4.1 dentro del loop que calcula el resto de los pasos, para ello, como V[0]<1, se efectúa los siguientes cálculos: V[1] = V[0] + (C[0]-1)V[0]10-0) y L[1] = L[0]-log (C[0]).

67

Algoritmo 4.2 - Algoritmo discriminado en bloques para calcular el y=log(v) en punto fijo, con p dígitos de precisión

V

[0] = v; L

[0]= 0;

case V1[0]

of 1: C[0]

= 7; 2: C[0]

= 4; 3: C[0]

= 3; 4,5,6: C[0]

= 2; others: C[0]

= 1; end case; for k = 0 to p loop // computo desde paso 1 hasta paso p+1 //** block 1: Selección de dígito de convergencia d = select (V

[k], k);

if (k = 0) then a = C[0]

- 1 elsif (V

[k] ≥ 1) then a = d;

else a = 10- d; //** end block 1 //** block 2: Cálculo de V

[k+1]

t = V[k]

×10-k; // mantiene t en formato Q1.p

tt = t x a; // considera p+1 dígitos mas significativos de la // multiplicación de (p+1)×1-dígitos.

V[k+1]

= V[k]

-tt when (V

[k] ≥ 1) else V

[k]+

tt;

//** end block 2 //** block 3: Cálculo de L

[k+1]

if (k=0) then L

[k+1] = - lut_log_ini(V1

[0]); // -log(C

[0])

elsif (V [k]

≥1) then L

[k+1] = L

[k] - lut_logP(d, k);

else (V [k]

<1) L

[k+1] = L

[k] - lut_logN(d, k );

end if; //** end block 3 end loop; if (L0

[p+1]=1) then

y = 99··99 else

y = L1[p+1]

L2[p+1]

··Lp-1[p+1]

Lp[p+1]

end if

Considérese que:

- select(A, k): función que devuelve el dígito que se encuentra en la posición k del registro A. Selecciona el dígito de convergencia.

- lut_log_ini(V1[0]) = Table[V1

[0]] = log (C[0]); [ ] { }9,..,2,101 ∈V

La función lut_log_ini posee una tabla con 9 logaritmos precalculados y se accede

mediante V1[0] solo en el paso inicial.

68

Nótese en el algoritmo 4.2, que los bloques 2 y 3 se realizan en paralelo. El tiempo crítico se encuentra asociado a los tiempos que intervienen en el cálculo de los bloques 1 y 2. La función select se implementa con un multiplexor de p entradas de p dígitos. Por otro lado, en el bloque 2 intervienen un barrel-shifter de p dígitos, un multiplicador de p+1 dígitos por un dígito y un sumador/restador de p+1 dígitos, en donde todos los dígitos son decimales.

A continuación se desarrolla una optimización del algoritmo 4.2 de manera que no requiera el multiplexor en la selección del dígito de convergencia. Para ello, sabiendo que la sucesión {V

[i]} posee la siguiente forma (iteración k-ésima, con { }pk ,..,2,1∈ )

V[k] = 0.9··9Vk

[k]Vk+1

[k]··Vp [k] , o bien V[k] = 1.0··0Vk

[k]Vk+1

[k]··Vp[k]

defínase f_one

[k] tal que:

f_one[k] = 1 when (V0

[k] = 1) else 0; con { }1,..,1,0 +∈ pk

a partir de f_one[k] se puede inferir que Vi

[k] (con { }1,..,2,1 −∈ ki ) son ceros o nueves. Significa que para saber cuál es el valor de V[k], solo se requiere registrar f_one

[k] y los dígitos comprendidos entre Vk

[k] y Vp[k]. Esto permite la eliminación del multiplexor que

realiza la obtención de Vk[k], debido a que el dígito a seleccionar se encuentra siempre en

el primer lugar. Por consiguiente, la selección del dígito de convergencia se realiza de manera directa.

Por lo anterior se define la sucesión {W[i]}(i=0,1,...) mediante scaling de la

sucesión {V[i]}, donde cada elemento W

[k] (con { }1,..,2,1 +∈ pk ), es la parte fraccionaria de V[k] con la eliminación de los nueves o ceros iniciales dependiendo de f_one

[k]

W [k] = (V [k] -1)10k-1

when f_one[k]

= 1 W

[k] = (V [k] -(1-10-k+1))10k-1 when f_one

[k] = 0

(4.12)

por otro lado, W [0] = V [0] = v. Nótese que W[k], con { }1,..,1,0 +∈ pk , tiene formato Q0.p. Donde f_one

[k] aporta el resto de la información para poder inferir el valor de V[k], esto es:

V [k] = f_one

[k] + W [k]10-k+1+(1- f_one[k])×(1-10-k+1); y { }1,..,2,1 +∈ pk (4.13)

Algoritmo 4.3 - Algoritmo optimizado para calcular el y=log(v) en punto fijo, con selección de dígito de convergencia sin multiplexor

W[0]

= v; L[0]

= 0; case W1

[0] of

1: C[0] = 7;

2: C[0] = 4;

3: C[0] = 3;

4,5,6: C[0] = 2;

others: C[0] = 1;

end case; f_one

[0] = 0;

69

for k = 0 to p loop // cómputo desde paso 1 hasta paso p+1 //** block 1: Selección de dígito de convergencia d = W1

[k];

if (k = 0) then a = C[0]

- 1 elsif (f_one

[k] = 1) then a = d;

else a = 10-d; //** end block 1 //** block 2: Cálculo de W

[k+1]

t = sh_right_complete(W[k]

, k, f_one[k]

) ; // t=V [k]

tt = mult(t, a); f_aux = int(tt) when (k=0) else 0; // int(tt) es la parte entera de tt if (k>0) then tt = tt /10; else tt = fractional(tt); // fractional(tt) es la parte fraccionaria de tt end if; (f_aux2, W'

[k+1]) = addsub(W

[k], tt, f_one

[k]);

f_one

[k+1] = f_aux + f_aux2; // nunca los dos valen uno

if (k=0) then W

[k+1] = W'

[k+1]; // W'

[k+1] tiene formato 0.X

elsif (f_one[k+1]

=1) then W

[k+1] = W'

[k+1]×10; // W'

[k+1] tiene formato 0.0X

else // f_one

[k+1]=0

W[k+1]

= (W'[k+1]

- 0.9)×10; // W'[k+1]

tiene formato 0.9X end if; //** end block 2 //** block 3: Cálculo de L

[k+1]

L[k+1]

= L[k]

- lut_log (k, d, f_one[k]

); //** end block 3 end loop; if (L0

[p+1]=1) then

y = 99··99; else y = L1

[p+1]L2

[p+1]··Lp-1

[p+1]Lp

[p+1]

end if

Donde:

- lut_log(k, d, f_one): si k=0 realiza lut_log_ini(V1[0]), sino cuando (k>0 y f_one=1)

realiza lut_logP(d, k) y cuando (k>0 y f_one=0) realiza lut_logN(d, k).

- shift_right_complete(A, k, f_one): Para el caso que k>0 realiza la expresión 4.13. Desplaza el registro A, k-1 lugares a la derecha insertando k-1 ceros si f_one = 1, ó k-1 nueves si f_one = 0. Además, inserta inicialmente un uno o un cero dependiendo de la señal f_one. En el caso k=0 devuelve A.

- mult(A, B): realiza la multiplicación decimal (p+1)×1-dígitos entre los operandos multiplicando A y multiplicador B. El operando A posee formato Q1.p y el resultado formato Q1.p.

70

- add_sub(A, B, f_one): Si f_one=1 realiza A-B, de lo contrario computa A+B. Debido a que el resultado puede ser de la forma 0.X ó 1.X, la función devuelve (0 ó 1, y la parte fraccionaria X).

En el algoritmo, t = V[k], significa que el bloque 2 primero computa W'

[k+1]

W' [k+1] = W [k] + (C [0]-1)W[k]

when k=0,

W' [k+1] = W [k] - V [k]

a10-1 when { }pk ,..,2,1∈ and V [k]≥1,

W' [k+1] = W [k] +V

[k]a10-1

when { }pk ,..,2,1∈ and V [k]<1

(4.14)

y luego determina W[k+1] dependiendo de k y f_one[k+1]. Nótese que W'

[k+1] tiene formato 0.0X cuando V[k+1]≥1 (f_one

[k+1]=1), o formato 0.9X cuando V[k+1]<1 (f_one[k+1]=0). En

consecuencia, W [k+1] se determina de la siguiente manera:

W

[k+1] = W' [k+1] when k=0,

W [k+1] = 10W'

[k+1] when { }pk ,..,2,1∈ and V [k+1]≥1,

W [k+1] = 10(W'

[k+1]-0.9) when { }pk ,..,2,1∈ and V [k+1]<1

(4.15)

A continuación, se demuestra que el cálculo realizado en el bloque 2 del algoritmo

4.3, es el mismo que el cálculo realizado por el bloque 2 del algoritmo 4.2. Se identifican cuatro casos dependiendo de los valores de la sucesión auxiliar en los pasos k-ésimo y k+1-ésimo, considérese k˃0.

i) Caso V[k]≥1 y V[k+1]

≥1

[ ]1' +kW = [ ] 1][ 10−− aVW

kk (por expresión 4.14)

[ ] 11 10−+kW = [ ] 1][ 10−− aVW

kk (por expresión 4.15) [ ]1+k

W = [ ]aVW

kk ][10 − [ ]1+k

W = [ ]( ) aVV kkk ][101 −− (por expresión 4.12) [ ]1+k

W = [ ]( ) kkkk aVV 10101 ][ −−− [ ] 1101 +−+ kk

W = [ ] kkkaVV

−− 10][ [ ]1+k

V = [ ] kkkaVV

−− 10][ (por expresión 4.12)

ii) Caso V[k]<1 y V[k+1]≥1

[ ]1' +kW = [ ] 110 1][ −+ −

aVWkk (por expresión 4.14)

Nótese que a la expresión de la derecha se le debe restar el valor 1. Esto sucede como consecuencia que el módulo sumador/restador genera un valor de peso 1 debido a que el resultado posee la forma 1.0X. Por consiguiente:

[ ] 110 11 +−+kW = [ ] 1][ 10−+ aVW

kk (por expresión 4.15) [ ] 110 11 +−+k

W = [ ] ( )( ) 1][11 1010101 −−+− +−− aVV kkkk (por expresión 4.12) [ ] 11 10−+k

W = [ ] 1][11 101010 −−− +− aVVkkkk

[ ]1+kW = [ ]( ) kkkk aVV 10101 ][ −+−

[ ] 1101 +−+ kkW = [ ] kkk

aVV−+ 10][

71

[ ]1+kV = [ ] kkk

aVV−+ 10][ (por expresión 4.12)

iii) Caso V[k]<1 y V[k+1]<1

[ ]1' +kW = [ ] 1][ 10−+ aVW

kk (por expresión 4.14)

( ) [ ] 111 10101 −+− +− kW = [ ] 1][ 10−+ aVWkk (por expresión 4.15)

( ) [ ] 111 10101 −+− +− kW = ( ) 1][11][ 1010101 −−+− ++− aVV kkkk (por expresión 4.12) [ ]1+k

W = ( ) 10110101 ][1][ −+++− +− aVV kkkk [ ]1+k

W = 11010 ][][ ++− aVVkkkk

[ ]( ) kkW −+ − 1011 = kkkaVV

−+− 101 ][][ [ ] 110101 +− −−+ kkk

W = kkkaVV

−+ 10][][ [ ]1+kV = kkk

aVV−+ 10][][ (por expresión 4.12)

iv) Caso V[k]≥1 y V[k+1] <1

[ ]1' +kW = [ ] 110 1][ +− −

aVWkk (por expresión 4.14)

A la expresión de la derecha se le suma el valor 1. Esto se debe a que el módulo sumador/restador requiere un valor de peso 1, para evitar que la resta en formato Q0.p

genere un resultado negativo. Debido a esto, el resultado tiene la forma 0.9X. Por consiguiente:

( ) [ ] 111 10101 −+− +− kW = [ ] 110 1][ +− −aVW

kk (por expresión 4.15) [ ] 11 10−+k

W = ( ) 11][1][ 1010101 −−− +−− aVV kkk (por expresión 4.12) [ ]1+k

W = ( ) 1101 ][][ +−− aVV kkk [ ] kk

W−+ 101 = kkkk

aVV−− +−− 10101 ][][

[ ] kkkW

−−+ −+ 101101 = kkkaVV

−− 10][][ [ ]1+kV = kkk

aVV−− 10][][ (por expresión 4.12)

Por otro lado, cuando k=0, se computa [ ] [ ] [ ]( ) ]0[001 1' WCWW −+= . Pero como

W'[0]=W

[0]=V [0], mediante sustitución y aplicación de expresiones (4.12) y (4.15), se

computa [ ] [ ] ]0[01VCV = .

4.3.4. Arquitectura del logaritmo radix-10 en punto fijo con selección directa

En este apartado se detalla la arquitectura propuesta para llevar a cabo el logaritmo radix-10 en punto fijo mediante selección directa (figura 4.1). Obsérvese que step se corresponde con la variable k del algoritmo y es generado por una Unidad de Control simple. Es importante destacar que en el step-ésimo paso de la implementación, se computa el (step+1)-ésimo paso del método propuesto. En consecuencia, esta propuesta posee una latencia p+1 ciclos de reloj.

En esta arquitectura, los módulo Sub_SM y Add_Sub, implementan cualquiera de las propuestas detalladas en capítulo 3, para las operaciones de suma/resta SVA (configurado para resta) y suma/resta en complemento a la base diez (C10), entre operandos en formato BCD.

72

En el módulo Sub_SM, las entradas sa y sb se corresponden con los signos y las entradas a y b con los valores absolutos de los operandos. Considerando que el resultado de log(v), con v en [0.1, 1), es siempre negativo, los resultados que produce este modulo son siempre negativos.

El módulo Set Output es el encargado de generar la salida y, de modo que se encuentre en el formato Q0.p en el rango (-1, 0), la parte entera no es necesario almacenarla ya que siempre es 0.

Set Multiplicand, determina el dígito a multiplicar y se corresponde con el bloque 1 y el case del algoritmo 4.3, con una variante para el caso particular que reg_w<1, step>0 y reg_wp-1=0, en el que el algoritmo genera un valor de 10 (dos dígitos decimales). Este módulo realiza lo siguiente:

if (step = 0) then out = Lut(reg_wp-1) elsif (f_one = 1) then out = reg_wp-1 elsif (reg_wp-1 != 0) then out = 10- reg_wp-1

else out = 1

(4.16)

Lut(reg_wp-1) implementa el case del algoritmo 4.3 restando uno como se aprecia en el bloque 1. Obsérvese que el módulo produce siempre un dígito decimal. Debido a que para el caso especial mencionado se genera el digito uno (en lugar de diez), la multiplicación no cambia el valor producido por el módulo Shift Right Complete. En consecuencia, el módulo Shift Right Complete debe contemplar este caso en el desplazamiento, de modo que se produzca la multiplicación por el valor diez y obtener así el valor deseado en el resultado de la multiplicación.

y

reg_w

f_one

Set OperandSet

Multiplicand

Shift Right

Complete

p1

step

Mult_px1

1 p

A/S coAdd_Sub

p-digits

p+1

p

1 [p]

[p-1:0]

p

Set One

p

p+1-digitsSub_SM

p+1

p

0

reg_l

Set Output

lsLut_log

p+1

1

sa sba b

Figura 4.1 - Circuito que calcula el logaritmo punto fijo radix-10.

73

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

BCD.

El módulo Shift Right Complete implementa la función

shift_right_complete(reg_w, step, f_one) que se expresa en el algoritmo 4.3 con una variante para el caso especial (reg_w<1, step>0 y reg_wp-1=0). Además, tampoco se genera el uno o cero inicial dependiendo de f_one. A continuación, se detalla la implementación de este módulo:

if (step = 0) then out = reg_w elsif (f_one = 1) then out = ([0]step-1

& reg_wp-1··step-1) elsif (reg_wp-1 != 0) then out = ([9]step-1

& reg_wp-1··step-1) else out = ([9]step-2

& reg_wp-1··step)

(4.17)

donde [d]i denota una secuencia comprendida por i dígitos d, y & es el operador de concatenación de secuencias. En el caso especial (reg_w<1, step>0 y reg_wp-1=0), desplaza el contenido del registro reg_w, step-2 lugares a la derecha (en vez de step-1). Nótese que cuando step=1, el valor de V[1] se encuentra en [0.7, 1.4), significa que el caso especial mencionado no puede suceder.

El módulo Mult_px1, realiza la multiplicación de p×1-dígitos en formato BCD. Este multiplicador implementa las ideas expuestas en [Din10b] para la generación de productos parciales. Apréciese que el operando multiplicando producido por el módulo Shift Right Complete, no posee la forma 0.X ó 1.X (formato Q1.p) como indica el método propuesto y el algoritmo 4.3, sino que posee la formato Q0.p. A continuación se analiza como serían los resultados del multiplicador si se respetara el formato de este producto establecido en el algoritmo. Para ello, se considera que el multiplicador genera un valor m con formato Q1.p, es decir m posee forma mp.mp-1··0.

- caso step=0. El operando multiplicando es igual a reg_w y se encuentra en [0.1, 1), significa que f_one

[0]=0. En este caso, el producto es un valor que se encuentra en [0.7, 1.4).

- caso step>0 y reg_w≥1. El operando multiplicando posee forma 1.0X (ó 1.X para step=1). En este caso el operando multiplicador es el valor reg_wp-1. Por consiguiente, para la alternativa que step>1, mp=reg_wp-1. Por otro lado cuando step=1, mp=reg_wp-1, ó mp=reg_wp-1+1 si se produce acarreo en la parte fraccionaria.

- caso step>0 y reg_w<1. El operando multiplicando posee forma 0.9X (ó 0.X para step=1). En este caso el operando multiplicador es el valor 10-reg_wp-1 (1 para el caso que reg_wp-1=0), significa que cuando step>1, mp es igual al operando multiplicador menos uno, debido a que el acarreo debe realizar la operación 9×(10-reg_wp-1) es siempre 10-reg_wp-1-1. Por otro lado, cuando step=1 el operando multiplicador puede ser 3 (reg_wp-1 =7), 2 (reg_wp-1=8) o 1 (reg_wp-1=9). Significa que cuando realiza el producto reg_wp-1×(10-reg_wp-1) también genera un acarreo igual a 10-reg_wp-1-1.

Sea cf el acarreo generado por la parte fraccionaria de la multiplicación, considerando los tres casos expuestos, mp puede obtener los siguientes valores:

74

- caso step=0 ⇒ mp= cf

- caso step>0 y reg_w ≥1 ⇒ mp = reg_wp-1 + cf

- caso step>0 y reg_w <1 ⇒ mp = cf = 9 - reg_wp-1

Según el algoritmo 4.3, una vez obtenido el resultado de la multiplicación, para determinar el próximo valor de reg_w se computa lo siguiente:

- caso step=0 ⇒ reg_w + mp-1··0 (reg_w + fractional(m))

- caso step>0 y reg_w ≥1 ⇒ reg_w - mp··1 (reg_w - m/10)

- caso step>0 y reg_w <1 ⇒ reg_w + mp··1 (reg_w + m/10)

Los operandos y resultado de estas sumas y restas poseen formato Q0.p. Donde para cada uno de los casos sucede lo siguiente:

- caso step=0: la operación suma reg_w + mp-1··0, genera un resultado de forma

0.X ó 1.X. Significa que si la suma genera un acarreo se setea el f_one en uno y se deja al siguiente valor de reg_w con la parte fraccionaria del resultado. Nótese que en este caso, f_one también obtiene uno cuando la multiplicación genera acarreo, es decir mp=cf=1.

- caso step>0 y reg_w≥1: se realiza la operación reg_w - mp··1. Debido a que mp=reg_wp-1+cf, en función del valor cf se identifican dos subcasos:

� cuando cf =1: se obtiene que resultado de la resta posee la forma 0.9X y f_one =0.

� cuando cf=0: si reg_w<m, también se obtiene que f_one = 0 y el resultado con forma 0.9X. Por otro lado, si reg_w≥m, f_one=1 y el resultado posee la forma 0.0X.

Nótese que cuando cf=0 (mp=reg_wp-1), se puede operar directamente con los p-1 dígitos menos significativos de reg_w y m. Por otro lado, cuando cf=1, también se puede operar los p-1 dígitos menos significativos de reg_w y m, y setear f_one=0.

- caso step>0 y x<1: se realiza la operación reg_w + mp··1. Debido a que mp=9-reg_wp-1, se obtiene resultado con la forma 0.9X y f_one=0, cuando la suma entre los p-1 dígitos menos significativos de reg_w y m no genera acarreo. Por otro lado, el resultado posee la forma 0.0X y f_one=1, cuando la suma entre los p-1 dígitos menos significativos de reg_w y m genera acarreo.

Por todo lo anterior, se infiere que el acarreo generado por la parte fraccionaria de la multiplicación (cf), determina como va ser el dígito más significativo del resultado de la operación suma/resta y seteo de f_one. Por consiguiente, tomar la parte fraccionaria del operando multiplicando para realizar la multiplicación y considerar el acarreo (cf), es suficiente para las operaciones posteriores. Para el caso step>0, se puede trabajar con los p-1 dígitos menos significativos de reg_w y la parte fraccionaria del resultado de la multiplicación.

De este modo, el módulo Set Operand realiza lo siguiente:

if (step = 0) then out = reg_w else out = reg_wp-2··00

(4.18)

75

El módulo Add_Sub, realiza la suma/resta entre operandos en C10:

if (step = 0) then reg_w + mp-1··0 elsif (f_one = 0) then reg_wp-2··00 + mp-1··0 else reg_wp-2··00 + C

9(mp-1··0) + 1 (4.19)

donde C9(m) es el complemento a 9 de m. Nótese que la operación genera acarreo en la suma cuando el resultado es mayor o igual a 1. Por otro lado, en la resta (o suma con sustraendo en C10), la operación genera acarreo cuando reg_wp-2··00 ˃ mp-1··0.

El módulo Set One es el encargado de generar el próximo valor de f_one. Considerando lo expuesto, el funcionamiento del módulo es el siguiente:

if (step = 0) then out = co or cf elsif (step = 1 and f_one = 1) then out = co and not(cf ) else out = co

(4.20)

donde co es el acarreo producido por el módulo Add_Sub.

4.3.4.1. Multiplicación decimal de p×1-dígitos.

El módulo Mult_px1 es un multiplicador decimal que opera con un multiplicando de p dígitos decimales y un multiplicador de un dígito decimal, ambos operandos en formato BCD. La arquitectura de este módulo se basa en la implementación eficiente en dispositivos FPGAs con LUTs de 6 entradas de la generación de productos parciales planteado en [Din10b]. En el mencionado trabajo, se recodifica el operando multiplicador en la forma radix-5 con signo, de este modo se determinan dos productos parciales que posteriormente son sumados utilizando el sumador decimal eficiente expuesto en [Din10a] que se detalla en el capítulo 3. El operando multiplicador es un dígito BCD, h, recodificado en dos dígitos de la siguiente manera

h = 5hU + hL (4.21)

con h

U en {0, 1, 2} y hL en {-2, -1, 0, 1, 2}. La codificación de los dígitos h

U y hL

requieren dos y tres bits. Esta recodificación lleva a que se requieran cinco funciones de cuatro variables que se pueden implementar en tres LUTs. Sea m el operando multiplicando, se generan dos productos parciales, pp

U = m x hU y pp

L =m x hL, donde

para ppU:

if (hU=2) then pp

U=10m elsif (hU=1) then pp

U=10m/2 elsif (hU=0) then pp

U=0 (4.22)

y para pp

L:

if (hL=2) then pp

L=2m elsif (hL=1) then pp

L=m elsif (hL=0) then pp

L=0 elsif (hL=-1) then pp

L= -m

(4.23)

76

elsif (hL=-2) then ppL= -2m

El algoritmo 4.4 determina el cálculo del producto 2m. Nótese que los pasos son independientes, es decir, se pueden calcular todos los dígitos, (2m)i con { }pi ,..,1,0∈ , en paralelo.

Para el cálculo de los bits de cada dígito se requieren funciones de 4 variables (expresión 4.24). Lo que lleva a que se utilicen 4p LUTs para implementar eficientemente 2m.

Algoritmo 4.4 - Algoritmo que determina el doble de un número de p dígitos en BCD

for i = 0 to p-1 loop

if (i=0) then (2m)i[0] = 0; else // (k>0) (2m)i[0] = mi-1[3] v auxi-1[3]; end if; auxi[3..0] = mi[2..0] + 3; if (mi≤4) then (2m)i[3..1] = mi[2..0]; else // (mi>4) (2m)i[3..1] = auxi[2..0]; end if;

end loop (2m)p[0] = mp-1[3] v auxp-1[3]; (2m)p[3..1] = 0

(2m)i[j] = Func(mi[3], mi[2], mi[1], mi[0]); con { }3,2,1∈j e { }1,...,1,0 −∈ pi

(2m)i[0] = Func(mi-1[3], mi-1[2], mi-1[1], mi-1[0]); con { }pi ,...,2,1∈

(4.24)

Para implementar eficientemente pp

U, [Din10b] plantea lo siguiente (algoritmo 4.5):

Algoritmo 4.5 - Algoritmo que determina ppU

if (hU=2) then

ppU

0 = 0; elsif (h

U=1) then

ppU

0 = 5m0[0]; else pp

U0 = 0;

end if; for i = 1 to p loop

if (hU=2) then

ppU

i = mi-1; // ppU

i=10mi elsif (h

u=1) then

77

ppU

i= mi-1/2 + 5mi[0]; // ppU

i=5mi else pp

Ui = 0;

end if; end loop

La figura 4.2 muestra la implementación en dispositivos FPGA de Xilinx basados en LUTs de 6 entradas del cálculo de pp

Ui con { }pi ,..,2,1∈ . Nótese que se requieren

4p+2 LUTs para implementar ppU.

0

0 1

0 1LUT-6

LUT-6:2

2

pi[0]

gi[0]

hU

0

pi[1]

ppU

i[1]

0 1

mi-1[3]

LUT-6:2

pi[2]

gi[2]

LUT-6pi[3]

mi-1[2]

mi[0]

mi-1[1]

mi-1[0] ppU

i[0]

ppUi[2]

ppU

i[3]

Figura 4.2 - Implementación de pp

Ui en dispositivos con LUTs de 6 entradas según [Din10b]

Nota: tamaños asociados a buses describen dígitos binarios (bits).

Donde: if (hU=2) then pi[3..0] = mi-1[3..0] gi[2] = gi[0] = 0 elsif (hU=1) then pi[3] =0 pi[2] = mi-1[3] ⊕ mi[0] pi[1] = mi-1[2] pi[0] = mi-1[1] ⊕ mi[0] gi[2] = mi-1[3]·mi[0] gi[0] = mi-1[1]·mi[0] elsif (hU=0) then pi[3] = pi[2] = pi[1] = pi[0]= 0

gi[2] = gi[0] = 0

(4.25)

Por otro lado, para la implementación de ppL, [Din10b] plantea lo siguiente:

Algoritmo 4.6 - Algoritmo que determina ppL

for i = 0 to p loop if (h

L=2) then

ppL

i = 2mi; elsif (h

L=1) then

78

ppL

i= mi; elsif (h

L=0) then

ppL

i= 0 elsif (h

L=-1) then

ppL

i= (mi'+10) mod 16; else // (h

L=-2)

ppL

i = ((2m)i'+10) mod 16; end if;

end loop

donde mi' y (2m)i' son el complemento a uno de mi y (2m)i respectivamente, con { }pi ,..,1,0∈ .

Nótese que cuando hL = -1 ó -2, se debe realizar el C10 de m ó 2m respectivamente.

Para ello se efectúa el C9 de cada dígito 9 - mi = (15 - mi +10) - 16 = (mi' +10) mod 16

y se suma el valor uno al bit menos significativo de ppL. Para evitar la propagación de

acarreo, este valor es agregado cuando se realiza la suma final entre los dos productos parciales pp

U y ppL.

La figura 4.3 muestra la implementación en dispositivos basados en LUTs de 6 entradas del cálculo de pp

Li. Obsérvese que se requieren 4(p+1) LUTs para implementar

ppL.

Figura 4.3 - Implementación de pp

Li en dispositivos con LUTs de 6 entradas según [Din10b].

Nota: tamaños asociados a buses describen dígitos binarios (bits).

Donde: if (hL=2) then pi[3..0] = 2mi[3..0] elsif (hL=1) then pi[3..0] = mi[3..0] gi[1] = 0 elsif (hL=0) then pi[3] = pi[2] = pi[1] = pi[0]= 0

(4.26)

79

gi[1] = 0 elsif (hL=-1) then pi[3] = mi[3] pi[2] = mi[2]' pi[1] = mi[1] pi[0] = mi[0]' gi[1] = mi[1]' elsif (hL=-2) then pi[3] = 2mi[3] pi[2] = 2mi[2]' pi[1] = 2mi[1] pi[0] = 2mi[0]'

gi[1] = 2mi[1]'

Por último, para la suma BCD final entre los dos productos parciales generados, se utilizan los sumadores eficientes detallados en el capítulo 3. Por tanto, el área que consume el multiplicador p×1-dígitos utilizado en este trabajo es de 17p+14 LUTs.

4.3.4.2. Resultados experimentales

Se implementó el diseño de logaritmo radix-10 punto fijo con selección directa propuesto en este trabajo en dispositivos de Xilinx Virtex 7 con speed grade 3 (tablas 4.2 y 4.3). Las precisiones, p, utilizadas se corresponden al estándar IEEE 754-2008. Para las operaciones de suma y suma/resta C10, se emplearon las estrategias expuestas en el capítulo 3. La síntesis e implementación se realizaron con el XST (Xilinx Synthesis

Technology) [Xil13a] y Xilinx ISE versión 14.3 [Xil13b]. Esto se llevó a cabo dejando los parámetros de síntesis por defecto. Para todas las implementaciones que aparecen en el resto de este capítulo, se utilizaron las mismas herramientas de síntesis e implementaciones con los mismos parámetros.

Nótese que el tiempo de cómputo máximo se relaciona con el cómputo de los registros reg_w y f_one, esto corresponde a los tiempos que involucran los módulos Shift Right Complete, Mult px1, Add_Sub y Set One. Debido a esto, se consideraron las diferentes alternativas detalladas en el capítulo 3, tanto para suma BCD involucrada en la multiplicación de los productos parciales pp

U y ppL de Mult px1 (alternativas Adder-I,

Adder-II y Adder-III), como para la suma/resta BCD en C10 de Add_Sub (estrategias AS-

I, AS-II y AS-III).

Obsérvese que como el cálculo del registro reg_l (log10) no interviene en el tiempo crítico, para el módulo Sub_SM se utilizó la estrategia que ocupa menos cantidad de LUTs, ya que no existen diferencias significativas en los tiempos de cálculo obtenidos de las implementaciones de las alternativas suma/resta en SVA propuestas en capítulo 3. Por lo anterior, para la resta en SVA de operandos BCD, se utilizó la estrategia basada en sumadores/restadores en C10 que utiliza las ideas expuestas en [Din10a] (módulo AS_SM_CB-III del capítulo 3).

80

Tabla 4.2. Tiempo de cálculo (ns) de logaritmo punto fijo radix-10 en Virtex 7 con speed grade 3

p Adder-I y AS-I Adder-II y AS-II Adder-III y AS-III

7 8.5 7.71 6.86 16 9.34 8.63 8.06 34 9.84 9.07 9.21

Tabla 4.3. Área (LUTs) de logaritmo punto fijo radix-10 en Virtex 7 con speed grade 3

p Adder-I y AS-I Adder-II y AS-II Adder-III y AS-III

7 700 735 665 16 2012 2127 1859 34 6340 6501 5971

Apréciese que para precisiones 7 y 16, las soluciones basadas en [Din10a] obtienen mejores tiempos de cálculo y menor ocupación de LUTs que las técnicas basadas en sumadores y sumadores/restadores con funciones de cálculo de propagación (P) y generación (G) de acarreo decimal [Bio10][Vaz09b].

Por otro lado, para 34 dígitos de precisión, la alternativa basada en sumadores y sumadores/restadores con cálculo de P y G a partir de las entradas obtiene el menor tiempo de cómputo. En cuanto al área, para esta precisión las técnicas basadas en [Din10a] utilizan menos LUTs. Nótese que para 34 dígitos de precisión, las implementaciones basadas en el cálculo de P y G a partir de las entradas, tienen una aceleración del 1% respecto a las basadas en [Din10a] con una penalización en área del 8%.

4.4. Logaritmo decimal radix-10 punto flotante

Para implementar un circuito que compute el logaritmo decimal con operandos en punto flotante decimal conforme al estándar IEEE 754-2008 [IEEE08], si bien el núcleo principal del mismo es la implementación del algoritmo que determina el logaritmo punto fijo, se deben considerar aspectos como el tratamiento del exponente, redondeo, manejo de precisión considerando las cifras significativas, entre otros.

En el siguiente apartado se detalla y analiza el diseño e implementación en dispositivos FPGA de Xilinx del cómputo del logaritmo DFP propuesto en este trabajo. Primero se analiza todo lo referente al manejo de exponente del argumento y del resultado. Luego se describe el algoritmo y la arquitectura propuesta. Finalmente se muestran y examinan los resultados experimentales obtenidos de la implementación en FPGA, y se efectúan comparaciones con las soluciones de [Che12].

4.4.1. Manejo de exponentes en operandos de entrada y salida

Un valor en punto flotante decimal según el estándar (véase capítulo 2, sección 2.3), está conformado por el signo, la mantisa y el exponente. Para soportar este tipo de operandos, se debe realizar un tratamiento especial del exponente y de la mantisa. El formato del operando v, es (-1)s

x10qxvm, donde s corresponde al signo, vm a la mantisa y

q al exponente. Nótese que vm no se encuentra normalizado y se interpreta como entero (véase tabla 2.4). Cuando se realiza el logaritmo de un operando en punto flotante, y = log(v) con v˃0, la operación que se realiza es y = q+log(vm).

81

Para poder utilizar el algoritmo propuesto del logaritmo punto fijo, se debe ajustar el exponente de modo que considere vm con el formato Q0.p. Para ello

v = vmx10q = 0.vm x10q+p

por consiguiente y = q+p+log(0.vm), donde 0.vm posee formato Q0.p y se encuentra en [0, 1), debido a que puede poseer ceros iniciales luego del punto. En consecuencia, se deben eliminar estos ceros iniciales y realizar el ajuste de exponente 0.vm = vm'10-z, donde z es la cantidad de ceros iniciales y vm' posee formato Q0.p en [0.1, 1).

Las operaciones que se realizan son y = q+p-z+y' e y' = log(vm'). Donde log(vm') es el logaritmo punto fijo radix-10 propuesto en este trabajo. Si bien y' posee formato Q0.p y se encuentra en (-1, 0), el resultado final posee formato punto flotante decimal y su rango depende del formato requerido (tabla 4.4).

Tabla 4.4. Rango del resultado dependiendo del formato decimal escogido

Formato Rangos

decimal32 -101≤ q≤90 -101<y<97 decimal64 -398≤ q≤369 -398< y<385 decimal128 -6176≤ q≤6111 -6176< y<6145

4.4.2. Manejo de cifras significativas y tamaño de LUTs

Nótese que para obtener y', en el método propuesto para el cómputo del logaritmo punto fijo con precisión de p dígitos se realizan p+1 pasos. Esto es, se determinan los valores correspondientes de las sucesiones auxiliar y principal desde el paso 1 (V[1],L[1]) hasta el paso p+1 (V[p+1], L[p+1]). Cuando se opera en punto flotante con una mantisa de p dígitos, con frecuencia para obtener p cifras significativas en la solución, se requieren más pasos que los involucrados en punto fijo.

A modo de ejemplo, cuando se determina el logaritmo punto flotante de 0.993, si la mantisa del resultado posee 7 dígitos de precisión, se debe obtener como resultado -0.3050751×10-2. Pero cuando se utiliza el algoritmo propuesto para el cómputo del logaritmo punto fijo, se setea vm'=0.9930000, y luego de 8 pasos se obtiene y'=-0.0030507. Lo que lleva a un resultado con 5 cifras significativas en lugar de 7. Por lo anterior, para obtener y' con tantas cifras significativas como el tamaño de la mantisa, se debería realizar dos pasos adicionales como consecuencia de los ceros iniciales. Significa que se computa un total de 10 pasos. La cantidad de pasos adicionales se relaciona directamente con el exponente del resultado.

La detección de los nueves iniciales en vm' es importante porque define la cantidad de ceros existente en el resultado. Se puede verificar mediante análisis numérico que cuando existen n nueves iniciales en vm', existen n o n+1 ceros iniciales en y'. Significa que si

1-10-n≤ vm' <1-10-(n+1) con { }pn ,..,2,1∈ (4.27)

entonces -10-m< y'<0, con m = n ó n+1, esto lleva a que se requieren al menos p+n+2 pasos para obtener la p cifras significativas en el resultado.

82

Obsérvese que si se setea V[1]=vm' y vm' cumple con la expresión 4.27, entonces V

[1] se encuentra en el rango de convergencia [0.7, 1.4). Además, como V[1]<1 posee forma:

[ ] ( ) [ ]111 101 α+−= +− nTV (4.28)

donde [ ]1

110 +−= nVT , [ ] ( ) pn −+− −≤≤ 10100 11α y { }1,..,2,1 −∈ pn . Se puede evitar el

cómputo de los n+1 pasos iniciales, y solamente calcular los valores de las sucesiones auxiliar y principal desde el paso n+2-ésimo hasta el paso n+p+2-ésimo. Es decir, se puede iterar desde el paso dos al paso p+2-ésimo, seleccionando el dígito de

convergencia de modo que contemple n.

En consecuencia, en el caso que n˃0 se requiere computar p+1 pasos. Para el caso n=0, se itera desde el paso uno, para ajustar al rango de convergencia, hasta el p+2-ésimo paso, para contemplar un eventual cero inicial en el resultado. De este modo, en este caso se realizan p+2 pasos.

Por lo anterior, para poder soportar la operación logaritmo en punto flotante y obtener p cifras significativas, se pueden redefinir la expresiones 4.4 y 4.6. La expresión 4.4 se redefine de la siguiente manera:

[ ] [ ] )(101 iniiAC

+−+= , con [ ] { }10,9,..,8,9 −−∈iA (4.29) Por otro lado, la expresión 4.6 se redefine así:

if [ ] 1≥+

i

inV ⇒ [ ] [ ]i

in

i VA +−=

if [ ] 1<+

i

inV ⇒ [ ] [ ]i

in

i VA +−= 10 (4.30)

tanto para 4.29 como para 4.30, si n˃0, { }1,..,1 +∈ pi , de lo contrario si n=0,

{ }1,..,1,0 +∈ pi . Nótese que los elementos correspondientes a las sucesiones {V[i]} y

{L[i]} se encuentran en formato Q1.2p+1. En el caso n=0, se setea V

[0]= vm' y se computa el paso uno (V[1]) mediante la expresión 4.5 determinando C[0] según expresión 4.11. Por otro lado, cuando n˃0, se evita el cómputo del paso uno y directamente se setea V[1]=vm'.

Teniendo en cuenta el tratamiento que posibilita el soporte de punto flotante mediante las redefiniciones de las expresiones 4.4 y 4.6, por las expresiones 4.29 y 4.30 respectivamente, se redefine la expresión 4.12 correspondiente a la sucesión {W

[i]} (i=0,1,...):

W [k] = (V [k] -1)10n+k-1

when f_one[k]

= 1

W [k] = (V [k] -(1-10-k-n+1))10n+k-1

when f_one[k]

= 0 (4.31)

donde { }.,..,2,1 pk ∈ Cuando n=0, W[0]=V

[0]=vm'. Por otro lado cuando n˃0, directamente se setea W

[1]=1+(vm'-1)×10n (vm' sin los nueves iniciales en parte fraccionaria) y f_one

[1]=0. Vale mencionar que los elementos de la sucesión {W[i]} se encuentran en

formato Q0.p.

83

Los logaritmos precalculados y almacenados en las LUTs deben poseer 2p+1

dígitos de precisión. Luego de p+1 pasos (cuando n˃0) ó p+2 pasos (cuando n=0), el valor acumulado en y' posee n o n+1 ceros iniciales que deben ser eliminados para contemplar los p dígitos significativos en la solución.

Para poder efectuar redondeo que soporte los métodos definidos por el estándar, en esta tesis particularmente RoundTiesToEven, se requiere un dígito adicional en la precisión de los logaritmos precalculados y en el tratamiento de la sucesión {L

[i]}.

A partir de la expresión 4.29 se observa que los logaritmos almacenados deben contemplar dos parámetros: k ( { }1,..,2,1 +∈ pk ) correspondiente al paso que se

computa, y n ( { }pn ,..,1,0∈ ) correspondiente a los nueves iniciales en vm'. Por ello, si actual_k=n+k, cuando n˃0, ó actual_k=k cuando n=0, entonces cada una de las tablas que almacenan los logaritmos asociados a lut_logP y lut_logN posee 2p+1 resultados:

lut_logP(d, actual_k) =TablePd[actual_k] =log (1-d10-actual_k) (4.32)

con { }9,..,2,1∈d y { }12,..,2,1_ +∈ pkactual .

lut_logN(d, actual_k) = TableNd[actual_k] = log (1+(10-d)10-actual_k) (4.33)

con { }9,..,1,0∈d y { }12,..,2,1_ +∈ pkactual .

Cada valor almacenado en la tabla posee formato Q0.2p+2. Es importante destacar, que como resultado de un análisis numérico se obtiene que

TablePd[p+2+l] = TablePd[p+2]x10-l con { }1,..,2,1 −∈ pl

TableNd[p+2+l] = TableNd[p+2]x10-l con { }1,..,2,1 −∈ pl (4.34)

Lo anterior lleva a que solo se requiera almacenar p+2 resultados en cada tabla.

Significa que se necesitan 19 tablas con p+2 resultados de 2p+2 dígitos de precisión cada una, para implementar las funciones lut_logP y lut_logN. El resto de los valores se obtienen mediante el desplazamiento a la derecha del último logaritmo almacenado en cada tabla.

4.4.3. Algoritmo para logaritmo decimal DFP

A continuación, se describe el algoritmo propuesto en este trabajo que computa el logaritmo decimal DFP conforme al estándar IEEE 754-2008, y = log(v). Las mantisas de los argumentos, vm e ym, se interpretan como enteros.

Las entradas y salidas del algoritmo son:

- argumento v = vmx10q y resultado y = -ymx10t.

- p la precisión de las mantisas vm e ym.

- s la precisión de los exponentes q y t.

84

- vm e ym con formato Qp.0

- q y t con formato Qs.0

Los formatos de las variables utilizadas son:

- e: Qs.0

- vm', vm'': Q0.p

- y', y2 : Q1.p+2

- y3 : Qs.p+2

- y4 : Q0.s+p+2

Algoritmo 4.7 - Algoritmo para calcular el logaritmo radix-10 punto flotante y=log(v) conforme al estándar.

z = leading_zeros(vm); vm' = vm×10

-p+z; // lleva a formato Q0.p sin ceros iniciales en parte fraccionaria

e = p+q-z; n = leading_nines(vm'); // devuelve cantidad 9's iniciales de la parte fraccionaria de vm' vm'' = 1+ (vm' -1)×10

n; // elimina 9's iniciales de parte fraccionaria de vm'

y' = log_fixed(n, vm''); y2 = y' x 10

-n when (e!=0) else y';

// si la parte entera del resultado es diferente a 0, entonces agrega tantos // ceros como cantidad de nueves detectados en vm'.Para y'=1, n es siempre 0 y3 = y2 + e; // y2 es negativo z2 = leading_zeros(y3); // 0≤z2 ≤s+1, con s depende del formato decimal elegido y4 = y3×10

-s+z2;

t = -p+s-z2; ym = RoundTiesToEven(p, y4); // redondea tomando los p dígitos iniciales de parte fraccionaria, más un //dígito adicional para el redondeo RoundTiesToEven

La función log_fixed() implementa el algoritmo 4.3 con cambios menores que consideran los aspectos relacionados al manejo de punto flotante detallados en sección anterior. Estos son:

� Logaritmos precalculados:

- para los valores almacenados en las tablas se aumenta de precisión a 2p+2 dígitos, para contemplar nueves iniciales en vm' y el redondeo.

- cada tabla, TablePd y TableNd, posee p+2 resultados.

- el acceso a las tablas se realiza considerando el paso corriente y n.

- los valores que retorna la función lut_log posee formato Q0.p+2. Para el caso que actual_k˃0, devuelve los p+2 dígitos significativos de las tablas (sin los n ceros iniciales). Un dígito adicional se debe a la posible existencia del cero inicial. El otro dígito adicional es requerido para efectuar el redondeo RoundTiesToEven.

� Argumento:

- el argumento es vm'' se encuentra en [0.1, 0.9).

85

� Salida:

- el cálculo que se efectúa es el logaritmo punto fijo de vm''. El módulo retorna y' =

log(vm'')x10n. Significa que el resultado no posee los n ceros iniciales.

- si el resultado es y'=-1, no se realiza la aproximación valor -1+10-p que se efectúa en el algoritmo 4.3. Esto se debe a que igual se requiere la parte entera en la solución para procesar el exponente del argumento. Por consiguiente, el rango de y' es [-1, 0).

- como la acumulación de los valores obtenidos de la función lut_log puede generar el valor -1, la precisión de y' y L[k] tiene formato Q1.p+2.

� Iteraciones: - no siempre se realiza la iteración cero (cómputo de paso uno en método propuesto)

del algoritmo 4.3. En el caso n˃0, W[1] se setea directamente con el argumento vm''.

- para contemplar la posible existencia de un cero inicial en el resultado, se realiza una iteración adicional. Por ello, si n˃0, el recorrido de la variable que rige el loop del algoritmo, k, es { }1,..,2,1 +∈ pk , significa que se computa desde el paso 2 hasta el paso p+2-ésimo del método propuesto. De lo contrario, para n=0, el recorrido de k es { }1,..,1,0 +∈ pk , se computa desde el paso uno hasta el paso p+2-ésimo del método propuesto.

A continuación se detalla el algoritmo 4.8 basado en 4.3 con los respectivos

cambios que determina log_fixed(n, vm''). Considere lo siguiente:

- vm'' sin nueves iniciales, con formato Q0.p en [0.1,0.9).

- L[k] e y' con formato Q1.p+2 en [-1,0).

Algoritmo 4.8 - Algoritmo correspondiente a y'=log_fixed(n, vm'').

L

[0]= 0;

if (n=0) then j = 0; W

[0] = vm'';

f_ one[0]

= 0; case W1

[0] of

1: C[0] = 7;

2: C[0] = 4;

3: C[0] = 3;

4,5,6: C[0] = 2;

others: C[0] = 1;

end case; else j = 1; W

[1] = vm'';

f_ one[1]

= 0; end if; for k = j to p+1 loop // cómputo desde paso j+1 hasta paso p+2 actual_k = k + n; //** block 1: Selección de dígito de convergencia

86

d = W1[k]

; if (k = 0) then a = C

[0] - 1

elsif (f_one[k]

= 1) then a = d; else a = 10-d; //** end block 1 //** block 2: Cálculo de W

[k+1]

t = sh_right_complete(W[k]

, actual_k, f_one[k]

) ; //t=p mas significativos de V [k]

tt = mult(t, a); f_aux = int(tt) when (k=0) else 0; // int(tt) es la parte entera de tt if (k>0) then tt = tt /10; else tt = fractional(tt); // fractional(tt) es la parte fraccionaria de tt end if; (f_aux2, W'

[k+1]) = addsub(W

[k], tt, f_one

[k]);

f_one

[k+1] = f_aux + f_aux2; // nunca los dos valen uno

if (k=0) then W

[k+1] = W'

[k+1]; // W'

[k+1] tiene formato 0.X

elsif (f_one[k+1]

=1) then W

[k+1] = W'

[k+1]×10; // W'

[k+1] tiene formato 0.0X

else // f_one

[k+1]=0

W[k+1]

= (W'[k+1]

- 0.9)×10; // W'[k+1]

tiene formato 0.9X end if; //** end block 2 //** block 3: Cálculo de L

[k+1]

u = lut_log (actual_k, d, f_one[k]

); // en formato Q0.p+2 L

[k+1] = L

[k] - u ; // en formato Q1.p+2

//** end block 3 end loop; y' = L0

[p+2] L1

[p+2].. Lp+1

[p+2] Lp+2

[p+2] // formato Q1.p+2

Donde:

- lut_log(actual_k, d, f_one): Cuando actual_k=0 realiza log(C[0]). De lo contrario, cuando (actual_k>0 y f_one=1) realiza lut_logP(d, actual_k) según expresión 4.32, y cuando (actual_k>0 y f_one=0) realiza lut_logN(d, actual_k) según expresión 4.33.

En la implementación del algoritmo 4.8, realizando una iteración en cada ciclo de reloj, se obtiene una latencia de p+2 ciclos. Por otro lado, en el algoritmo 4.7 se requieren dos pasos adicionales. Un paso inicial correspondiente al tratamiento del exponente del argumento y obtención de vm'', y un paso final relacionado con el manejo de resultado considerando redondeo, exponente, etc. Estos dos pasos se pueden realizar en dos ciclos de reloj. En consecuencia, la implementación del logaritmo decimal DFP según estándar IEEE 754-2008 planteado en 4.7, que utiliza log_fixed según el algoritmo 4.8 posee una latencia de p+4 ciclos de reloj.

87

Una manera de reducir la latencia en un ciclo, es combinar el paso inicial del algoritmo 4.7 con la iteración 0 del algoritmo 4.8. De este modo, el cómputo del paso uno condicional del método propuesto para realizar el logaritmo punto fijo se realiza en el paso inicial. Por consiguiente, el loop que determina L[p+2], obtiene una latencia de p+1 ciclos.

Para llevar a cabo la reducción de latencia en un ciclo, existe un costo en cuanto a área, ya que se requiere un multiplicador adicional en el paso inicial para computar el paso uno del método propuesto. Como se observó en la sección 4.3.4.1, el multiplicador decimal de p×1-dígitos utilizado es muy eficiente en cuanto a tiempo de cómputo y consumo de área. El multiplicador implementado ocupa 17p+14 LUTs, para tener una noción de lo que esto significa, si se sintetiza un multiplexor de dos entradas de p dígitos en formato BCD (4p bits) en un dispositivo programable que dispone de LUTs de 6 entradas, se requieren p/2×4 LUTs configuradas como LUT6:2. En consecuencia, el multiplicador p×1-dígitos utilizado en este trabajo, ocupa menor cantidad de LUTs que 9 multiplexores de dos entradas de p dígitos BCD.

Por otro lado, realizar el cómputo del paso uno del método propuesto en el paso inicial, lleva a que se requiera menos lógica de control del loop. Esto se debe a que no se requiere la funcionalidad que se efectúa cuando k=0.

En consecuencia, la reducción de la latencia en un ciclo, conlleva a la incorporación de un multiplicador eficiente, pero también a la eliminación de lógica adicional. En este trabajo se decide reducir la latencia, ya que el incremento de área no resulta tan significativo como lo es la reducción de un ciclo de reloj en el tiempo total de cómputo.

A continuación, se detalla el algoritmo (4.9) que computa el logaritmo decimal DFP conforme al estándar IEEE 754-2008 con reducción de latencia en un ciclo. El algoritmo utiliza la función log_fixed_red(), la cuál se encarga de realizar logaritmo punto fijo que implementa el método propuesto. Dicha función es similar a la función log_fixed(), pero sin el paso uno condicional. Las variables w_ini, l_ini y f_ini, se corresponden con los valores computados en el paso uno de las sucesiones {W

[i]}, {L[i]}

y {f_one[i]} (i=1,2...) respectivamente.

Los formatos de las variables agregadas respecto al algoritmo 4.7:

- tm: Q1.p

- w_ini: Q0.p

- l_ini: Q1.p+2

Algoritmo 4.9 - Algoritmo para calcular el logaritmo decimal DFP y=log(v) conforme al estándar (latencia p+3).

z = leading_zeros(vm); vm' = vm ×10

-p+z; // lleva a formato Q0.p sin ceros iniciales en parte fraccionaria

e = p+q-z; n = leading_nines(vm'); // devuelve cantidad 9's iniciales de la parte fraccionaria de vm' if (n=0) then case ( int(vm

'x10) ) of // pregunta por el primer dígito de vm

'

88

1: c = 7; 2: c = 4; 3: c = 3; 4,5,6: c = 2; others: c = 1;

end case; tm = mult(vm', c); w_ ini = fractional(tm); f_ ini = int(tm); l_ini = - log(c); else // (n>0) w_ini = 1+ (vm' -1)×10

n; // elimina 9's iniciales de parte fraccionaria de vm'

f_ini = 0; l_ini = 0; end if y' = log_fixed_red(n, w_ini, l_ini, f_ini); y2 = y'×10

-n when (e!=0) else y';

// si la parte entera del resultado es diferente a 0, entonces agrega tantos // ceros como cantidad de nueves detectados en vm'.Para y'=1, n es siempre 0 y3 = y2 + e; // y2 es negativo z2 = leading_zeros(y3); // 0≤z2 ≤s+1, con s depende del formato decimal elegido y4 = y3×10

-s+z2;

t = -p+s-z2; ym = RoundTiesToEven(p, y4); // redondea tomando los p dígitos iniciales de parte fraccionaria, más 2 // adicionales para el redondeo RoundTiesToEven

A continuación se detalla el algortimo que implementa la función log_fixed_red(). La eliminación del paso condicional uno, lleva a que se simplifique la funcionalidad dentro del loop, así como también el comportamiento de la función lut_log.

Algoritmo 4.10 - Algoritmo correspondiente a y'=log_fixed_red(n, w_ini, l_ini, f_ini).

W

[1]= w_ini;

L[1]

= l_ini; f_one

[1]= f_ini;

for k = 1 to p+1 loop // computo desde paso 2 hasta paso p+2 actual_k = k + n; //** block 1: Selección de dígito de convergencia d = W1

[k];

if (f_one[k]

= 1) then a = d; else a = 10-d; //** end block 1 //** block 2: Cálculo de W

[k+1]

t = sh_right_complete(W[k]

, actual_k, f_one[k]

) ; //t=p mas significativos de V [k]

tt = mult(t, a); tt = tt /10; (f_ one

[k+1], W'

[k+1]) = addsub(W

[k], tt, f_one

[k]);

if (f_one

[k+1]=1) then

89

W[k+1]

= W'[k+1]

×10; // W'[k+1]

tiene formato 0.0X else //

f_one

[k+1]=0

W[k+1]

= (W'[k+1]

- 0.9)×10; // W'[k+1]

tiene formato 0.9X end if; //** end block 2 //** block 3: Cálculo de L

[k+1]

u = lut_log (actual_k, d, f_one[k]

); // en formato Q0.p+2 L

[k+1] = L

[k] - u ; // en formato Q1.p+2

//** end block 3 end loop; y' = L0

[p+2] L1

[p+2].. Lp+1

[p+2] Lp+2

[p+2] // formato Q1.p+2

Donde:

- lut_log(actual_k, d, f_one): cuando f_one=1, realiza lut_logP(d, actual_k) según expresión 4.32, de lo contrario cuando f_one=0, efectúa lut_logN(d, actual_k) según expresión 4.33.

4.4.4. Arquitectura del logaritmo decimal DFP.

En esta sección se detalla la arquitectura propuesta (figura 4.4) para calcular el logaritmo decimal DFP conforme al estándar IEEE 754-2008. Este circuito implementa el algoritmo 4.9. El argumento es v = vmx10q y el resultado y = -ymx10t. Por otro lado, q_cd es la representación en cero desplazado que se corresponde con el exponente q en formato decimal. Lo mismo sucede con t_cd respecto al exponente del resultado t.

En la arquitectura propuesta s es la precisión del exponente tanto del argumento como del resultado en términos de cantidad de dígitos decimales. Significa que s=3, para los formatos DFP decimal32 y decimal64, y s=4 para el formato decimal128.

Una Unidad de Control simple genera la señal step, que rige el comportamiento del circuito representando los diferentes pasos que se computan. En el caso particular del componente Log_fixed_red, step se corresponde con la variable k del algoritmo 4.10. Este módulo de control, además genera las señales de selección de los multiplexores y señales de habilitación de los diferentes registros, éstas son: en_vm, en_q, en_regs_ini, ctrls_mux, en_exp, en_regs_fx y en_regs_res.

El módulo Lut_ini a partir del primer dígito de reg_vm sin los ceros iniciales (o_vm'p-1), determina el valor de c y log(c) en formato Q0.p+2 (expresión 4.35). Este módulo posee logaritmos decimales precalculados de p+2 dígitos BCD en una tabla de 10 celdas. Nótese que reg_l_ini>0, ya que el módulo Log_fixed_red es el encargado de tratar este valor como negativo.

if o_vm'p-1=1 then c = 7; l_ini = log(7) elsif o_vm'p-1=2 then c = 4; l_ini = log(4) elsif o_vm'p-1=3 then c = 3; l_ini = log(3) elsif (4≤ o_vm'p-1 and o_vm'p-1≤6) then c = 2; l_ini = log(2) else c = 1; l_ini = 1;

(4.35)

El módulo Shift Left implementa un barrel-shifter que desplaza a la izquierda

reg_vm y o_vm', z y n lugares respectivamente. Mediante este módulo se eliminan los

90

ceros iniciales que se encuentran en reg_vm obteniéndose o_vm'. Así como también se determina o_vm'', a partir de la eliminación de los nueves iniciales de o_vm'.

p

reg_vm reg_q

vm q_cd

Leading Zeros

Leading Nines l_inic

Lut_ini

[p-1]

Mult_px1

p

1

p

1

p+1

Bin_to_BCD

s

reg_n reg_w_ini

>0

01

p1

[p]

[p-1:0]

reg_f_ini

01

0

reg_l_ini

01

0

p+2

Log_fixed_red

w_ini f_ini l_inin

en_vm en_q

y_fx

en_expclk

clk

ctrls_mux

en_regs_fx

step

Post-Process

Result

exp_bcdy_fx

ym

clk

en_regs_res

p

t_cd

p+3

ym t_cd

sign

sign

en_regs_ini

s_exp

reg_s_exp

Process

Exponent Input

s_exp v_exp

start b

d

n

i

z

i

o_vm’

o_vm’’

Shift Left

Shift Left

n

p

Figura 4.4 - Circuito que calcula el logaritmo DFP conforme al estándar IEEE 754-2008.

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

BCD.

4.4.4.1. Tratamiento de exponente del argumento

Este apartado se detalla la transformación del exponente del argumento, q_cd, que se encuentra en cero desplazado con bias según formato (véase tabla 2.4), al formato decimal con s dígitos en formato BCD modelado por exp_bcd. Los módulos involucrados en la arquitectura encargados de realizar esto son: Process Exponent Input y Bin_to_BCD.

91

La tabla 4.5 detalla la cantidad de bits de la representación en cero desplazado (lm), el bias utilizado, la cantidad de dígitos decimales (s) y el rango, para el exponente del argumento en todos formatos DFP soportados por el estándar IEEE 754-2008.

Tabla 4.5. Características del exponente del argumento según estándar IEEE 754-2008.

Formato cantidad de bits

de q_cd (lm) bias del

exponente

rango de exponente

del argumento

cantidad de dígitos BCD de

exp_bcd (s)

decimal32 8 101 -101≤q≤90 3 decimal64 10 398 -398≤q≤369 3

decimal128 14 6176 -6176≤q≤ 6111 4

El módulo Process Exponent Input (figura 4.5), determina el exponente en signo y

valor absoluto (s_exp, v_exp) en binario del valor que representa q_cd. Para ello, primero realiza el ajuste del exponente asociado a vm' (algoritmo 4.9), mediante el cálculo e = q+p-z. Donde q es el exponente, p la precisión y z los ceros iniciales, asociados vm. Nótese que en la implementación se obtiene la representación en cero desplazado de e (e_cd) con el bias utilizado en q_cd. Una vez determinado el e_cd, se resta el bias para obtener su representación en complemento a la base (e_cb = C10(e_cd). Por último, a partir de e_cb se determina la representación del exponente en signo (s_exp) y valor absoluto (v_exp). En el caso que e_cb representa un valor negativo, se lo debe negar mediante la aplicación de C10 para obtener el valor absoluto.

+

-

zp

q_cd

lm

+

C10

(bias)

lm

0 1

C10

lm

1 lmlm

[lm-1]

v_exps_exp

lm

Figura 4.5 - Implementación de Process Exponent Input.

Nota: tamaños y dígitos seleccionados asociados a buses describen dígitos binarios

(bits).

El módulo Bin_to_BCD realiza la conversión de binario a BCD. Este módulo implementa el algoritmo clásico shift add-3 [Alf97] (algoritmo 4.11). El algoritmo realiza la conversión binario a BCD, del valor v_exp de lm bits al valor exp_bcd de s dígitos BCD. En cada paso k, se computa d

[k+1] con { }1,..,1,0 −∈ lmk , donde cada

dígito di[k] con { }1,..,1,0 −∈ si es un dígito decimal en formato BCD. Nótese que si se

implementa el algoritmo 4.11 de modo que en cada ciclo de reloj se procese un bit de

92

v_exp mediante un desplazamiento a izquierda, se obtiene que la latencia es de lm ciclos de reloj (figura 4.6).

Algoritmo 4.11 - Algoritmo shift add-3 procesando un bit por paso.

for k = 0 to lm-1 loop // computo desde paso 1 hasta paso lm a-1 = v_exp[lm-1-k]; for i = 0 to s-1 loop // computo desde dígito 0 hasta dígito s-1 di

[k+1][0] = ai-1;

if (di[k]

≤4) then di

[k+1][3..1] = di

[k][2..0];

ai = 0; else di

[k+1][3..1] = di

[k][2..0] + 310;

ai = 1; end if; end loop; end loop

Figura 4.6 - Circuito que implementa Bin_to_BCD.

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

binarios (bits).

4.4.4.2. Detección de ceros y nueves iniciales

Para determinar la cantidad de ceros iniciales y nueves iniciales de un registro in de p dígitos decimales en formato BCD, este trabajo propone una solución basada en la utilización eficiente de los recursos del dispositivo.

Este módulo primero determina cg (tamaño p bits), el cuál posee un uno en el bit (utilizando rango descendente) correspondiente al dígito que conforma la secuencia de

93

ceros ó nueves iniciales de in. A modo de ejemplos, en el caso de Leading Zeros, para p=7:

si in = 000123110 , entonces cg = 00001112 si in = 002403010 , entonces cg = 00000112

en el caso de Laeding Nines, para p=16:

si in = 999996009123181210, entonces cg = 0000000000111112 si in = 992991211008231910, entonces cg = 0000000000000112

Una vez determinado cg, se realiza una codificación con prioridades en el bit más significativo de cg, para obtener la cantidad de ceros iniciales ó nueves iniciales de la entrada in. La figura 4.7 detalla la arquitectura propuesta del módulo Leading Zeros ó Leading Nines. Obsérvese que para determinar cg se utiliza los recursos programables dedicados en el dispositivo utilizados comúnmente para la implementación eficiente del cálculo de acarreo (carry-chain) en la suma binaria. Donde para Leading Zeros,

Gi = 1 when (inp-1-i = 0) else 0; con { }1,..,1,0 −∈ pi (4.36)

y para Leading Nines,

Gi = 1 when (inp-1-i = 9) else 0; con { }1,..,1,0 −∈ pi (4.37)

Figura 4.7 - Circuito correspondiente a Leading Zeros y Leading Nines.

Nota: los tamaños asociados a buses describen cantidad de dígitos binarios (bits).

4.4.4.3. Arquitectura de Log_fixed_red con reducción de latencia

La figura 4.8 detalla la arquitectura del logaritmo punto fijo con reducción de latencia propuesto para realizar el logaritmo DFP conforme al estándar. Este módulo implementa el algoritmo 4.10 correspondiente a la función log_fixed_red(n, w_ini, l_ini, f_ini).

94

Respecto a la arquitectura de logaritmo punto fijo (figura 4.1), ésta propuesta presenta algunas diferencias significativas detalladas en apartado 4.4.3:

� se evita el cómputo del paso uno debido a la reducción de latencia

� se considera la cantidad de nueves iniciales (n) en el paso (step). En consecuencia, se utiliza el paso actual_step=step+n.

� tratamiento distinto de los logaritmos precalculados. Se modifica la cantidad de resultados almacenados, así como también el tamaño de cada resultado. Esto se debe al manejo de las cifras significativas y soporte de redondeo.

Como el cómputo del paso uno se realiza en el paso inicial (figura 4.4) del cálculo

del logaritmo DFP, los registros reg_l, reg_w y f_one, se inicializan con los valores l_ini, w_ini y f_ini respectivamente. Para ello la Unidad de Control realiza el seteo correspondiente de las señales de control de los multiplexores ctrls_mux y escritura de registros en_regs_fx.

reg_w f_one

Set

Multiplicand

Shift Right

Complete

p1

step

Mult_px1

1 p

A/S coAdd_Subp-digits

p+1

p

1 [p]

[p-1:0]

p-1

Set One

p+3-digitsSub_SM

p+2

0

reg_l

y_fx

logs

Lut_log

1

sa sba b

w_ini n

ctrls_mux

en_regs_fx

* **

0 1

p

*

[p-1:1]

0

p

p

0 1

p+3 p+3

l_ini f_ini

0 1

p+3

0

Addactual_step

Figura 4.8 - Circuito Log_fixed_red.

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

BCD.

El resultado obtenido, y_fx, está comprendido por p+3 dígitos en formato Q1.p+2, en el rango [-1, 0). El bit correspondiente al signo no requiere su almacenamiento debido a que el resultado es siempre negativo. Por otro lado, el resultado proveniente de la etapa inicial, l_ini, es negativo y posee formato Q0.p+2, por ello se lo lleva a formato Q1.p+2 concatenando un cero al inicio.

Los módulos Set Multiplicand*, Shif Right Complete* y Set One*, poseen funcionalidad muy similar a Set Multiplicand (expresión 4.16), Shift Right Complete

95

(expresión 4.17) y Set One (expresión 4.20) respectivamente. La diferencia se encuentra en que los módulos detallados en log_fixed_red no consideran el cómputo del paso uno (step=0) y además consideran la cantidad de nueves iniciales (n) que se encuentran o_vm'. En consecuencia, el módulo Set Multiplicand* realiza lo siguiente:

if (f_one = 1) then out = reg_wp-1 elsif (reg_wp-1 != 0) then out = 10- reg_wp-1

else out = 1 (4.38)

En cuanto al módulo Shift Right Complete*, para actual_step≤p:

if (f_one = 1) then out = ([0]actual_step-1& reg_wp-1··actual_step-1)

elsif (reg_wp-1 != 0) then out = ([9]actual_step-1& reg_wp-1··actual_step-1)

else out = ([9]actual_step-2& reg_wp-1··actual_step)

(4.39)

y para actual_step>p:

if (f_one = 1) then out = [0]p elsif (reg_wp-1 != 0) then out = [9]p elsif (actual_step=p+1) out = ([9]p-1

& reg_wp-1) elsif (actual_step>p+1) out = [9]p

(4.40)

El módulo Set One* implementa:

if (actual_step = 1 and f_one = 1) then out = co and not(cf ) else out = co

(4.41)

La figura 4.9 detalla la arquitectura correspondiente al módulo Lut_log*. Cada

una de las Tablas, TablePd con { }9,..,2,1∈d y TableNd con { }9,..,1,0∈d , almacenan los logaritmos precalculados (expresiones 4.32 y 4.33). Como se detalló en la sección 4.4.3, cada tabla posee p+2 resultados (expresión 4.34), en donde cada resultado almacenado posee 2p+2 dígitos de precisión en formato Q0.2p+2. Para cada tabla, el puerto o posee el logaritmo precalculado correspondiente a actual_step. El puerto [p+2]

contiene el último resultado almacenado.

El módulo Lut_Log* devuelve los p+2 cifras significativas del resultado seleccionado. Para ello se eliminan los n ceros iniciales como consecuencia de los n nueves iniciales presentes en o_vm'. Como se detalló en sección 4.4.2, debido a que pueden existir n o n+1 ceros iniciales en los resultados precalculados almacenados en las tablas, el resultado final del módulo, log, puede poseer un cero inicial.

El módulo Shift Left p+2 correspondiente a la rama actual_step≤p+2, obtiene los p+2 dígitos más significativos de la entrada i desplazada a la izquierda n dígitos BCD, es decir sin los n ceros iniciales.

Por otro lado, según expresión 4.34 cuando actual_step>p+2, se debe realizar el desplazamiento de l lugares a la derecha a la entrada i, con l=actual_step-(p+2). Luego, se desplaza n lugares a la izquierda el valor obtenido, para la eliminación de los ceros iniciales. Debido a que actual_step=step+n, entonces

96

Shift Left (Shif Right (i, l), n) = Shift Left (i , p+2-step) (4.42)

Por todo lo anterior, módulo Shift Left p+2 correspondiente a la rama actual_step>p+2, obtiene los p+2 dígitos más significativos de la entrada i desplazada a izquierda p+2-step dígitos BCD.

Figura 4.9 - Circuito Lut_log*.

Nota: los tamaños asociados a buses describen cantidad de dígitos BCD.

4.4.4.4. Post-procesamiento del resultado

El componente Post-Process Result (figura 4.10) se encarga de realizar el paso final del algoritmo del logaritmo DFP conforme al estándar IEEE 754-2008. Este módulo se encarga de calcular la mantisa y el exponente del resultado final.

Para ello, primero realiza un pre-procesamiento de mantisa de modo que se considera el exponente del argumento (exp_bcd) y el resultado obtenido del logaritmo punto fijo (y_fx), y así obtener la mantisa extendida con formato Qs.p+2.

Luego, se detectan y eliminan los ceros iniciales de la mantisa extendida, para finalmente poder determinar la mantisa del resultado aplicando la técnica de redondeo RoundTiesToEven. Además, se determina el exponente del resultado de modo que la mantisa se interprete como entero, es decir con formato Qp.0. Vale mencionar que no se requiere que el resultado este normalizado para cumplir con el estándar.

En la tabla 4.6 se detallan las operaciones involucradas en el pre-procesamiento de la mantisa, o generación de mantisa extendida en formato Qs.p+2. Además, se aprecia

97

el signo del resultado final. Cuando se determina la mantisa extendida, en el caso que exp_bcd ≥0, se efectúa la operación resta entre exp_bcd e y_fx. Por otro lado, en el caso que exp_bcd<0, se realiza la operación suma entre esos operandos. En cuanto al signo del resultado final, éste es positivo cuando exp_bcd>0 y negativo en el caso contrario (exp_bcd≤0).

Figura 4.10 - Circuito Post-Process Result.

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

BCD.

La mantisa extendida se genera a partir de la concatenación de la parte entera y la parte fraccionaria. Ambas partes se pueden tratar en forma independiente, en la arquitectura los s dígitos más significativos corresponden con la parte entera y los p+2 dígitos menos significativos a la parte fraccionaria. Para el caso en que se requiera la operación resta (op=1), exp_bcd<˃0 e y_fx˃-1, el procesamiento de la parte fraccionaria se determina con el C9 de y_fx desplazado n lugares a la derecha. El C10 se completa en la fase de redondeo mediante la suma del valor uno. Obsérvese que la operación suma o resta se realiza exclusivamente en el procesamiento de la parte entera. En donde se efectúa exp_bcd-1 cuando se requiere la resta (op=1), ó exp_bcd+1 en el caso que se requiera la suma (op=0).

El módulo Pre-Process Significand Qs.p+2 (figura 4.11), realiza las operaciones involucradas en la tabla 4.6 para el cálculo de la mantisa extendida.

98

Tabla 4.6. Operaciones involucradas para calcular mantisa extendida Qs.p+2.

exp_bcd y_fx s_exp operación (s+p+2)

parte entera (s)

parte fraccionaria (p+2)

signo

resultado

+

_ _ ·· _.00 ·· 00

00 ·· 01.00 ·· 00 -

s p+2

exp_bcd -1 0

(y_fx) +

=-1

-

exp_bcd +1 0

(y_fx) -

+

exp_bc-1 C9(Shift Right(y_fx ,n)) +

<>0

˃-1

-

exp_bc Shift Right(y_fx ,n) -

=-1 +

1

0 (y_fx)

-

=0

˃-1 +

0 y_fx -

Shift Right

p+3

exp_bcd y_fx n e_0 opy_1

1

[p+1..0]

p+2

p+2

0

C9

0 1

10

p+2 p+2

1 0

s

A/S Add_Subs-digits

00..01

1[p+2]

s

s-1

0..0

s

p+2

s+p+2

yy

Figura 4.11 - Circuito Pre-Process Significand Qs.p+2.

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

BCD.

99

En la figura 4.10, el módulo Leading_Zeros detecta los ceros iniciales de la mantisa extendida. La misma puede tener como máximo s+1 ceros iniciales. Esto sucede en el caso que exp_bcd=0 y la parte fraccionaria y_fx posee un cero inicial. Por otro lado, el componente Shift Left, desplaza la mantisa extendida a la izquierda eliminando los ceros iniciales agregando nueves a la derecha (expresión 4.43).

out = (yys+p+1-z··0 &[9]z) (4.43)

El agregado de nueves a la derecha, o ceros complementados a nueve, se encuentran en a los sumo los s+1 dígitos menos significativos, los cuáles únicamente son requeridos en el caso que op=1, exp_bcd<˃0 e y_fx˃-1.

La figura 4.12 detalla la arquitectura que genera la mantisa del resultado final considerando el redondeo según la técnica RoundTiesToEven. Para ello, la entrada ysh se corresponde con la salida generada por el componente Shif Left.

0

1

opysh e_0 y_1

Adds+2-digits

co

Addp-digits

Set Round

p+s+2

p

[p+s+1..s+2]

s+3

[s+2..0]

in

out

s+2

2[s+2..s+1]

00..1

s+2

ci

p

0..0

Set Round

in

out

1 [s+1]

s+2

p

[s+1..0]

[s+2]1

2

Figura 4.12 - Circuito Round.

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

BCD.

El módulo Set Round (expresión 4.44) genera el valor uno en el caso que se requiera sumar el valor decimal uno a los p dígitos más significativos de ysh.

if (in0<5) then out = 0 elsif (in0˃5) then out = 1 elsif IsOdd(in1) then out = 1 else out = 0

(4.44)

Para el caso que op=1, exp_bcd<˃0 e y_fx˃-1, se realiza la resta mediante el C10 de los s+2 dígitos menos significativos de ysh. Si la operación genera acarreo, no es necesario redondear ya que el resultado de la misma se comprende de s+2 ceros. En el caso que no se genere acarreo, se debe realizar el redondeo considerando el dígito más significativo del resultado. Por otro lado, en el resto de los casos, es decir cuando op=0

100

ó exp_bcd=0 ó y_fx=-1, para efectuar el redondeo se procesan los dígitos s+2 y s+1 de ysh.

Tanto para la implementación del componente Add_Sub de s dígitos BCD de la figura 4.11, como para la implementación de los sumadores Add de p dígitos y s+2 dígitos BCD de la figura 4.12, se utilizan cualquiera de las propuestas detalladas en el capítulo 3.

Al igual que el exponente del argumento, el exponente del resultado final también se representa en cero desplazado con los mismos parámetros (véase tabla 4.5), es decir mismos bias, rango y tamaño en cuanto cantidad de bits (lm). La figura 4.13 muestra la arquitectura correspondiente al procesamiento del exponente del resultado final Process

Exponent.

Para que la mantisa del resultado se interprete como entero, identifíquense dos casos. Cuando el exponente del argumento es diferente a cero (exp_bcd<˃0), donde el resultado generado por el módulo Round posee parte entera (s-z dígitos decimales) y parte fraccionaria (p-s+z dígitos). Por otro lado, en el caso que el exp_bcd=0, posee dos subcasos, cuando el resultado generado por Round es -1.0 (parte entera igual a uno y parte fraccionaria igual a cero), o el subcaso que el resultado no posee parte entera y posee p dígitos de parte fraccionaria.

Para el subcaso que el resultado no posee parte entera, se debe considerar los desplazamientos realizados a la mantisa del argumento o_vm', como consecuencia de la existencia de nueves iniciales (n). Además, en este subcaso, si z=s+1, se debe considerar el desplazamiento realizado de un dígito a la izquierda de la parte fraccionaria.

e_0

-

z

bias-p+s

lm

=s+1

n

+

-

bias-p

0 1

lmbias-p+1

0 1

lm

y_1

Figura 4.13 - Circuito Process Exponent.

Nota: tamaños asociados a buses describen dígitos binarios (bits).

4.4.5. Análisis de error de la solución propuesta

Cuando se analiza el error de la solución propuesta en este trabajo (Er), se deben considerar dos errores: el error inherente al método, Em, (expresión 4.10), y el error por discretización o cuantización de los valores calculados (Eq). Donde:

101

Er = Em + Eq (4.45)

En la solución propuesta para computar el logaritmo DFP, se realizan p+3 pasos, en donde desde el cómputo del paso 2 al cómputo de paso p+2-ésimo (p+1 pasos), se efectúa el cálculo del logaritmo punto fijo (módulo log_fixed_red). Esto lleva a que el error inherente al método sea de 10-p-1. Considerando que puede existir un cero inicial en la solución, al tomar las p cifras más significativas el error máximo inherente al método propuesto es:

p

mE−≤ 10 (4.46)

Por otro lado, cuando se analiza el error por cuantización, se debe considerar el

error producido en la acumulación de los logaritmos precalculados obtenidos de las LUTs. El módulo Lut_log*, retorna las p+2 cifras más significativas de los logaritmos precalculados seleccionados. Significa que se acumulan los logaritmos precalculados obtenidos desde Lut_log* y Lut_ini con error de cuantización 0.5×10-p-2

. Debido a que puede existir un cero inicial, el error efectivo máximo por cuantización de cada valor obtenido es de 0.5×10-p-1. De este modo, para precisión p:

p

q pE −×+×≤ 10)2(05.0 (4.47)

En consecuencia, el error máximo de la solución propuesta en este trabajo para

determinar el logaritmo DFP conforme al estándar IEEE 754-2008 es:

( ) ( ) ppp

qm ppEEEr −−− ×+×+=×+×+≤+= 10)2(05.0110)2(05.010 (4.48)

Considérese las precisiones del estándar, para p=7:

pEr

−×≤ 1045.1 (4.49) para p=16:

pEr

−×≤ 109.1 (4.50) y para p=34:

pEr

−×≤ 108.2 (4.51)

4.4.6. Resultados experimentales

Se implementó el diseño de logaritmo radix-10 DFP conforme al estándar en dispositivos de Xilinx Virtex 7 con speed grade 3. Las tablas 4.7 y 4.8 muestran los resultados obtenidos de las diferentes implementaciones. Para el módulo Log_fixed_red, en el caso de los sumadores BCD del componente Mult px1 y los componentes Add_Sub y Sub_SM, se utilizaron las diferentes estrategias de sumadores BCD, sumadores/restadores BCD en C10 y sumadores/restadores BCD en SVA detalladas en el capítulo 3.

102

En los reportes de síntesis, se obtuvo que para las diferentes configuraciones involucradas en la tabla 4.7, para p=7 los mayores tiempos de cómputo se encuentran asociados a la último paso (Post-Process Result). Por otro lado, para p=16 ó 34, los peores tiempos se encuentran vinculados al módulo Log_fixed_red, más precisamente al cómputo de reg_w y f_one. Esto comprende los tiempos involucrados en el procesamiento de módulos Set Right Complete*, Mult_px1, Add_Sub y Set One. Debido a que el cálculo del registro reg_l (log_fixed_red) no interviene en el tiempo crítico, para el módulo Sub_SM no se consideró la estrategia basada en sumadores y restadores BCD con multiplexores.

Tabla 4.7. Tiempo de cálculo (ns) de logaritmo radix-10 DFP en Virtex 7 con speed

grade 3 p Adder-I, AS-I

y AS_SM_CB-I

Adder-II, AS-II

y AS_SM_CB-II

Adder-III, AS-III

y AS_SM_CB-III

7 8.98 8.38 8.09 16 9.70 9.17 9.57 34 10.46 9.87 10.68

Tabla 4.8. Área (LUTs) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3

p Adder-I, AS-I

y AS_SM_CB-I

Adder-II, AS-II

y AS_SM_CB-II

Adder-III, AS-III

y AS_SM_CB-III

7 2212 2505 2338 16 6544 7233 6782 34 13075 13353 12532

Obsérvese que para p=7 ó 16, las estrategias con cálculo de P y G en función de la

suma binaria inicial poseen menor ocupación de LUTs. En donde las penalizaciones en área del resto de las alternativas respecto a éstas son: para p=7, 5% ([Din10a]) y 13% (P y G en función de entradas); y para p=16, 3% ([Din10a]) y 10% (P y G en función de entradas). Por otro lado, para el caso p=34, la implementación basada en [Din10a] poseen la menor ocupación de LUTs. Las penalizaciones en área del resto de las soluciones respecto a la basada en [Din10a] son: 4% (P y G a partir de suma inicial) y 6% (P y G a partir de entradas).

En cuanto a los tiempos de cálculos, para p=7, la solución basada en [Din10a] presenta el mejor tiempo de cómputo, con una aceleración del 11% y 3%, respecto a las alternativas basadas en cálculos de P y G en función de suma binaria inicial y de las entradas respectivamente. Por otro lado, para p=16 ó 34, las estrategias con cálculo a partir de P y G en función de las entradas poseen los mejores tiempos de cálculo. Obtienen una aceleración del 5% respecto a las variantes basadas en el cálculo de P y G a partir de la suma inicial. Respecto a [Din10a], obtienen una aceleración del 4% para p=16 y del 8% para p=34.

Vale mencionar que la última etapa, realizada en Post-Process Result, también utiliza sumadores y sumadores/restadores BCD. Para implementarlos se escogieron las soluciones basadas en [Din10a], la razón por tal elección fue priorizar la ocupación de LUTs.

La tabla 4.9 muestra la ocupación de LUTs del módulo que contiene los logaritmos precalculados (Lut_log*) para las diferentes precisiones soportadas. Además,

103

detalla el porcentaje de ocupación de Lut_log* respecto a la implementación de las diferentes alternativas. Nótese que cuando mayor es la precisión, mayor es el porcentaje de ocupación del módulo Lut_log* respecto a la solución final.

Tabla 4.9. Área (LUTs) de Lut_log* en Virtex 7 con speed grade 3

Porcentaje de ocupación

p Luts

(Lut_log*) Adder-I, AS-I

y AS_SM_CB-I

Adder-II, AS-II

y AS_SM_CB-II

Adder-III, AS-III

y AS_SM_CB-III

7 930 42% 37% 39% 16 3559 54% 49% 52% 34 7543 57% 56% 60%

4.4.7. Comparaciones con solución propuesta en [Che12]

Debido a la relevancia significativa que tienen los aportes del trabajo de [Che12], en cuanto a las soluciones basadas en recurrencia de dígitos para el cómputo del logaritmo radix-10 DFP conforme al estándar IEEE 754-2008, en este apartado se analizan y comparan las implementaciones de las propuestas de la presente tesis con las propuestas planteadas en [Che12].

Para que estas comparaciones sean lo mas objetivas posibles, se implementaron las propuestas de [Che12] en los mismos dispositivos, esto es Xilinx Virtex 7 con speed

grade 3. Además, se realizaron mejoras a las soluciones originales con el propósito de aprovechar los beneficios de la tecnología escogida para su implementación.

El mencionado trabajo también se basa en el tratamiento de dos sucesiones. Una sucesión auxiliar {W

[i]} y una sucesión principal {L[i]} que computa el logaritmo. La

solución propuesta posee una latencia de p+3 ciclos de reloj, donde p es la precisión requerida.

La selección de dígito de convergencia utilizada en [Che12], se basa en las ideas

expuestas en [Piñ04] pero con operandos en radix-10. Este mecanismo de selección, posibilita que para el cálculo de la sucesión auxiliar se empleen exitosamente las técnicas de redundancia carry-save. A continuación, se exponen los aportes más significativos en el trabajo de [Che12]:

� usa representación de carry-save redundante para la ruta de datos

� reducción de iteraciones debido a la determinación de la iteración inicial

� selección de dígito por redondeo basado en estimación residual

La ruta de datos de la arquitectura propuesta en [Che12] se encuentra segmentada

y balanceada en cuatro estados:

� estado inicial IPS (Initial Processing Stage): se computa en el primer ciclo de reloj. Se determina el dígito de convergencia y el número de iteración inicial. Además, se normaliza la mantisa del argumento en [0.1, 1) y se efectúa el tratamiento del exponente.

104

� estado DRS (Digit-Recurrence Stage): computa desde el ciclo 2 hasta el ciclo de reloj p+1-ésimo. Determina todos los valores que pertenecen a la sucesión auxiliar.

� estado LCS (Logarithm Computation Stage): computa desde el ciclo 2 hasta el ciclo p+2-ésimo. Determina los valores de la sucesión principal.

� estado FPS (Final Processing Stage): computa el p+3-ésimo ciclo de reloj. Determina el resultado final mediante normalización de mantisa y ajuste de exponente. Aplicación de la técnica RoundTiesToEven para el redondeo.

A continuación se detallan las adaptaciones efectuadas a la solución propuesta en

[Che12] para que utilice los recursos del dispositivo FPGA de Xilinx de forma más eficiente:

- se cambió el sumador binario carry look-ahead (CLA) utilizado para el ajuste del exponente en IPS, por un sumador binario con propagación de acarreo utilizando los recursos dedicados del dispositivo.

- para la detección de ceros iniciales en la mantisa del argumento en IPS, se utilizó la implementación eficiente del módulo Leading Zeros propuesto en este trabajo (sección 4.4.4.2).

- la implementación de las operaciones de multiplicación BCD (×2, ×4 y ×5) de los estados IPS y DRS, se basaron en el uso de sumadores binarios con propagación de acarreo y memorias LUTs.

- en lugar de efectuar una implementación combinacional del conversor binario a BCD de la etapa final FPS, se utilizó la solución secuencial implementada en este trabajo Bin_to_BCD (sección 4.4.4.1). Para ello se realiza este componente en el estado DRS, de modo que cuando se requiera el resultado en el p+3-ésimo ciclo en el estado FPS, el componente Bin_to_BCD haya finalizado correctamente de operar. En consecuencia, se obtiene una implementación con una ocupación de LUTs significativamente menor.

- para la obtención del resultado final en el estado FPS, se reemplazaron las operaciones de sumas BCD basadas en técnicas especulativas y cálculo anticipado de acarreo [Ant06] [Kog73], por los sumadores eficientes BCD planteados en el capítulo 3 del presente trabajo.

En las tablas 4.10 y 4.11, se aprecian los tiempos de cómputo y la ocupación de LUTs de las implementaciones de la propuestas en [Che12], sobre dispositivos de Xilinx Virtex 7 con speed grade 3. Se consideraron para la implementación de los sumadores BCD y sumadores/restadores BCD en C10 de la etapa FPS, las estrategias detalladas en el capítulo 3.

En los reportes de síntesis se obtuvo que en todas las implementaciones realizadas, los máximos tiempos de cómputo se encuentran asociados a la etapa IPS. Obsérvese que no sucede lo mismo con los resultados de las implementaciones sobre ASICs expuestos en [Che12] para 16 dígitos de precisión (p = 16), en donde el tiempo de cómputo crítico se encuentra en la etapa DRS.

105

En consecuencia, debido a que la elección de las diferentes estrategias de sumadores y sumadores/restadores no impacta en el tiempo de cómputo crítico, las diferentes implementaciones vinculadas a cada precisión obtienen el mismo tiempo de cálculo.

Tabla 4.10. Tiempo de cálculo (ns) de logaritmo radix-10 DFP en Virtex 7 con speed

grade 3

p Adder-I y AS-I Adder-II y AS-II Adder-III y AS-III

7 9.84 9.84 9.84 16 12.01 12.01 12.01 34 14.36 14.36 14.36

Tabla 4.11. Área (LUTs) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3

p Adder-I y AS-I Adder-II y AS-II Adder-III y AS-III

7 3008 3065 2962 16 7788 7966 7676 34 18408 18939 18170

En cuanto a la ocupación de LUTs, las implementaciones con sumadores y

sumadores/restadores inspirados en las técnicas basadas de [Din10a] obtienen los mejores resultados.

En las tablas 4.12 y 4.13, se realizan las comparaciones de las implementaciones en dispositivos FPGAs, entre las propuestas de la presente tesis y las propuestas de [Che12]. Para ello, se eligieron las soluciones con las estrategias más competitivas. Obsérvese que las soluciones propuestas en esta tesis poseen mejores tiempos de cómputo y menor ocupación de LUTs que las propuestas de [Che12].

Tabla 4.12. Tiempos de cálculo (ns) de logaritmo radix-10 DFP en Virtex 7 con speed

grade 3 de ambas propuestas.

p Esta tesis

Adder-II, AS-II

y AS-SM-CB-II

Esta tesis

Adder-III, AS-III

y AS-SM-CB-III

[Che12]

7 --- 8.09 9.84 16 9.17 9.57 12.01 34 9.87 10.68 14.36

Tabla 4.13. Área (LUTs) de logaritmo radix-10 DFP en Virtex 7 con speed grade 3 de

ambas propuestas.

p Esta tesis

Adder-II, AS-II

y AS-SM-CB-II

Esta tesis

Adder-III, AS-III

y AS-SM-CB-III

[Che12]

7 --- 2338 2962 16 7233 6782 7676 34 13353 12532 18170

La tabla 4.14 muestra las aceleraciones de las propuestas de esta tesis respecto a [Che12]. Por otro lado, la tabla 4.15 detalla las penalizaciones en área de las implementaciones de [Che12].

106

Tabla 4.14. Aceleraciones producidas por las propuestas de esta tesis en Virtex 7 con speed grade 3

p Esta tesis

Adder-II, AS-II

y AS-SM-CB-II

Esta tesis

Adder-III, AS-III

y AS-SM-CB-III

7 --- 1.21 16 1.30 1.25 34 1.45 1.34

Tabla 4.15. Penalizaciones en área de propuestas de [Che12] en Virtex 7 con speed

grade 3

Esta tesis

Adder-II, AS-II

y AS-SM-CB-II

Esta tesis

Adder-III, AS-III

y AS-SM-CB-III

7 --- 1.26 16 1.06 1.13 34 1.36 1.44

4.5. Conclusiones del capítulo y trabajo futuro

En este capítulo se ha propuesto la implementación eficiente en dispositivos basados en LUTs de 6 entradas de Xilinx del logaritmo radix-10 en punto fijo y punto flotante conforme al estándar IEEE 754-2008. En los que respecta DFP, las soluciones soportan todos los formatos del estándar: decimal32, decimal64 y decimal128.

Para la realización hardware de la operación logaritmo decimal radix-10, la solución propuesta implementa el método iterativo mediante recurrencia de dígitos

basado en el tratamiento de dos sucesiones, {V[i]} y {L

[i]} (i=0,1, ...), por las cuáles se realiza la transformación del argumento y el cómputo del logaritmo.

Esta propuesta posee como novedad, la selección directa del dígito de

convergencia de la sucesión auxiliar. En consecuencia, la ruta de datos de la implementación no se basa en lógica redundante carry-save. Lo anterior se encuentra sustentado, en que los dispositivos seleccionados para la implementación poseen lógica dedicada eficiente para la realización de la propagación de acarreo en la suma binaria. Debido a esto, no es necesario, incluso muchas veces es perjudicial, recurrir a la utilización de técnicas con redundancia en la ruta de datos de los diseños sobre este tipo de dispositivos.

Se desarrollaron diferentes implementaciones considerando las estrategias expuestas en el capítulo 3 para los sumadores y sumadores/restadores en formatos C10 y SVA. Además, se consideraron las ideas de [Din10b] para efectuar el multiplicador decimal BCD de p dígitos por un dígito, el cuál según el conocimiento del autor de esta tesis, presenta los diseños para dispositivos con LUTs de 6 entradas de Xilinx más eficientes en cuanto a tiempo cómputo y ocupación de área.

Si bien esta propuesta no instancia los núcleos embebidos que se encuentran en los dispositivos seleccionados, como es el caso de multiplicadores, o bloques de memoria RAM, etc, instancia los componentes genéricos LUTs y muxcy utilizados en la implementación de la propagación de acarreo que interviene en la suma binaria. Esto

107

lleva a que el diseño no sea genérico, solo puede ser aplicable a los dispositivos pertenecientes a las familias de dispositivos de Xilinx basados en LUTs de 6 entradas. Para que la propuesta se pueda implementar en cualquier dispositivo de lógica programable (o tecnología ASIC) independientemente del fabricante, lo único que se requiere es sustituir la instanciación de estos componentes, memorias LUTs de 6 entradas y multiplexores muxcy, por su descripción correspondiente en un lenguaje de descripción de hardware (VHDL en esta tesis).

Las implementaciones se realizaron sobre dispositivos Virtex 7 con speed grade 3, se consideraron las precisiones involucradas en el estándar, esto es p=7,16 ó 34. Para el logaritmo punto fijo, teniendo en cuenta las mejores alternativas, se obtuvo que las velocidades de operación son aproximadamente: 145 MHz para p=7, 124 MHz para p=16 y 110 MHz para p=34. Donde la latencia del circuito es p+1 ciclos de reloj.

Por otro lado, para el logaritmo DFP conforme al estándar, considerando las mejores alternativas, se obtuvo que las velocidades de operación son aproximadamente: 123 MHz para p=7, 109 MHz para p=16 y 101 MHz para p=34. Donde la latencia del circuito es de p+3 ciclos de reloj. En cuanto a la ocupación de LUTs, el módulo que posee los logaritmos precalculados posee una ocupación significativa de LUTs respecto al resto del circuito. Esto es, 42% para p=7, 54% para p=16 y 60% para p=34.

El error del logaritmo DFP calculado se encuentra entre 1.45×10-p y 2.8×10-p dependiendo de la precisión. Se realizaron comparaciones con las propuestas del trabajo de [Che12]. Para ello se implementaron las propuestas de [Che12] en los mismos dispositivos que se implementaron las propuestas de esta tesis. Se realizaron modificaciones a las soluciones de [Che12] de modo que utilice más eficientemente los recursos de los dispositivos FPGAs. Considerando las mejores alternativas, se obtuvo que las soluciones propuestas en esta tesis poseen aceleraciones del 21% (p=7), 30% (p=16) y 45% (p=34), respecto a las soluciones de [Che12]. Significa que a mayor precisión mayor es la aceleración. En cuanto a ocupación de LUTs, las soluciones de [Che12] poseen penalizaciones en área de 26% (p=7), 13% (p=16) y 44% (p=34).

A continuación se propone una serie de líneas de trabajo que se pueden abordar en el futuro relacionados con la propuesta del presente capítulo:

- Modificación y adaptación de la presente solución para efectuar la implementación hardware del logaritmo natural (o neperiano) radix-10.

- Realizar el logaritmo en cualquier base. Se puede adoptar la estrategia de cambio de base.

- Diseño e implementación basada en recurrencia de dígitos de la función antilogaritmo punto fijo y punto flotante: 10x y ex.

- Desarrollo e implementación unidades aritméticas logarítmicas radix-10.

109

CAPÍTULO 5

Raíz cuadrada punto fijo en base 10

En este capítulo se presenta el diseño e implementación eficiente de la función raíz cuadrada radix-10 en punto fijo sobre dispositivos programables con LUTs de 6 entradas de Xilinx.

Se comienza el capítulo con una clasificación de los trabajos existentes relacionados con las implementaciones hardware de la operación raíz cuadrada. A continuación, se expresa la propuesta y exponen las contribuciones realizadas.

Luego se describe el método propuesto y se desarrolla el diseño e implementación en dispositivos de Xilinx de la operación raíz cuadrada radix-10 punto fijo. Se muestran los resultados de las implementaciones y se realizan comparaciones con los trabajos de mayor relevancia existente en la literatura. Al final de este capítulo se detallan las conclusiones y trabajos futuros.

5.1. Introducción

La función raíz cuadrada (√) es la función elemental más importante [Par00]. Tal es así que el estándar IEEE de punto flotante especifica a la raíz cuadrada como una operación aritmética básica más, junto con las usuales cuatro operaciones aritméticas básicas (suma, resta, multiplicación y división).

La implementación hardware de esta operación tiene mucho en común con la operación división. Las operaciones de división y raíz cuadrada son relativamente poco frecuentes en aplicaciones de propósito general, pero son indispensables en operaciones involucradas en el procesamiento de gráficos 3D o en herramientas CAD [Kow08]. Otra aplicación en donde la raíz cuadrada es utilizada de manera intensiva es en la detección de envolventes en los receptores de sistemas de comunicaciones digitales [Saj12] [Skl01] [Rap02] [Fre03].

El primer método para resolver la raíz cuadrada fue el antiguo algoritmo clásico de los babilonios [Fla05]. Éstos describían los procedimientos involucrados mediante ejemplos [Kos09]. Fueron los griegos quienes formularon estos procedimientos en términos abstractos [Hea21], basándose para ello en el cálculo de una sucesión que converja a la raíz cuadrada de un número.

Existen diferentes propuestas que determinan la raíz cuadrada mediante aproximaciones polinomiales que utilizan multiplicadores [Din10c] [Kwo08] [Lac08]. En [Din10c] se divide el dominio del argumento en cuatro sub-intervalos, donde para

110

cada uno de éstos se realiza una aproximación polinomial cuyos coeficientes se obtienen de una tabla. [Kwo08] propone una estrategia basada en la expansión de las series de Taylor de tercer orden, con optimizaciones en cuanto al uso de multiplicadores en una arquitectura segmentada. Por otro lado, [Lac08] realiza el cálculo basándose en aproximaciones lineales mediante el uso de tablas de rango variables, esto lleva a una optimización de las tablas en cuanto al espacio requerido.

Otra manera de resolver esta operación es mediante el uso de estrategias basadas en CORDIC (Coordinate Rotation Digital Computer) [Yan12] [Bru13]. CORDIC es un algoritmo de iteración basado en rotaciones de vectores que para su cálculo solo requiere desplazamientos y sumas. Esta técnica se puede utilizar para determinar funciones trigonométricas y transcendentales. Si bien su implementación es eficiente en términos de área y frecuencia de operación, involucra una cantidad significativa de ciclos de reloj para aplicaciones que requieren mucha precisión.

Los algoritmos e implementaciones hardware de la raíz cuadrada se dividen principalmente es dos familias: basados en recurrencia de dígitos y basados en iteraciones funcionales [Din10c]. Las estrategias basadas en recurrencia de dígitos producen un dígito del resultado final en cada paso o iteración, donde cada iteración se basa en las operaciones de suma/resta y multiplicaciones de un número por un dígito (o desplazamientos si el dígito está en radix-2b). El segundo grupo de algoritmos utiliza costosas multiplicaciones en lugar de operaciones suma/resta y desplazamientos, pero posee la ventaja de obtener varios dígitos del resultado final en cada iteración [Ama12].

A diferencia de los métodos basados en recurrencia de dígitos cuya velocidad de convergencia es lineal y proporcional a la precisión, los basados en iteración funcional presentan mayor velocidad de convergencia al resultado final, siendo la misma proporcional al logaritmo de la cantidad de dígitos de precisión deseada [Par00]. Entre los métodos más utilizados basados en iteración funcional, se encuentran Golsdsmith [Piñ02c] y Newton-Raphson [Kab94] [Ram72] [Wan05].

Por otro lado, entre las estrategias basadas en recurrencia de dígitos más comunes se encuentran los métodos con restauración (restoring), sin restauración (non-

restoring) y SRT (por sus creadores Sweeney RobertsonTocher). Estos métodos son los mismos a los utilizados para la resolver la operación división, pero con algunas variantes en las fórmulas que determinan los restos y resultados parciales. Determinan los valores de dos sucesiones {Y

[i]} y {R[i]} (i=0,1, ...), en donde los valores de {Y

[i]} se corresponde con la raíz cuadrada y {R

[i]} al resto de la operación involucrada. El objetivo es que la sucesión {R

[i]} converja al valor cero y la sucesión {Y[i]} converja al

resultado (raíz) [Par00].

El método restoring no permite que los valores de R[i] sean negativos, en

consecuencia, cuando esto ocurre se restaura al valor previo del resto en la sucesión [Tha06d] [Wan03]. No sucede lo mismo en el algoritmo non-restoring, el cuál posibilita que los valores de R[i] sean negativos, evitando de este modo la restauración, donde en el paso final existe un ajuste potencial para que el resto sea correcto [Ban85] [Cor99] [Jun14] [Li96] [Li97a] [Li97b] [Rah14] [Saj12] [Sur13] [Tak06] [Vij12]. La estrategia non-restoring es generalmente utilizada en radix-2, en donde cada dígito del resultado parcial, Yj

[i], puede tomar 1 ó -1, pero posibilita que cada iteración sea computacionalmente más simple.

111

Por otro lado, el método SRT es muy similar al método non-restoring, pero para el caso de radix-2, permite que los valores de Yj

[i] se encuentren en {-1, 0, 1} [McQ93] [Mon03]. El SRT se aplica frecuentemente a radix mayores (usualmente radix-2b) con el objeto de aumentar la velocidad de convergencia, pero esto conlleva a que la función de selección del dígito del resultado parcial Yj

[i] y las operaciones involucradas en el cálculo de R

[i] tengan mayor complejidad [Fan87] [Fan89] [Lan95] [Lan99]. El incremento del radix disminuye la cantidad de pasos, pero incrementa el área y el tiempo de la iteración debido a que se requieren multiplicadores y memorias ROM de mayor tamaño para la selección del dígito.

En [Ama12] [Erc03] [Erc09] [Erc10] [Erc12] se aportan otras soluciones para resolver la operación raíz cuadrada mediante recurrencia de dígitos. En [Ama12] se propone una solución de mayor radix mediante el prescaling del radicando de modo que la función de selección de dígito se reduzca al truncamiento del resto parcial. Esto lleva a un incremento de tiempo de cómputo producido por el factor de prescale y los operandos de prescaling. En [Erc03] y [Erc10], se proponen diseños de unidades de cálculo que combinan de manera eficiente las operaciones de división y raíz cuadrada. Los trabajos [Erc09], [Erc10] y [Erc12], proponen soluciones en radix-10 mediante el uso de primitivas de precisión limitada. Se consideran precisiones de 7 (precisión simple), 8, 14 (doble precisión), 16, 24 y 32 dígitos decimales.

De los trabajos expuestos anteriormente, algunos se implementaron en dispositivos FPGAs [Ama12] [Din10c] [Erc09] [Erc10] [Rah14] [Saj12] [Sur13] [Tha06d] [Wan03] [Yan12]. A excepción de [Yan12], el cuál emplea dispositivos de Intel-Altera, en el resto de los trabajos se utilizaron dispositivos FPGAs de Xilinx. En la mayoría de estas propuestas no se instancian los componentes dedicados para multiplicación y/o memorias, solo en el caso de [Ama12] y [Din10c], cuyos métodos propuestos basados en el uso de multiplicaciones, instancian multiplicadores, slices DSP y bloques RAM que se encuentran embebidos en estos dispositivos.

Muy pocos trabajos proponen la solución hardware para calcular la raíz cuadrada radix-10 [Erc09] [Erc10] [Erc12] [Wan05]. En [Wan05], se propone una aproximación lineal piecewise para obtener la inversa de la raíz que solo requiere un coeficiente por subintervalos, y una versión modificada de iteración de Newton-Raphson, el cuál se aplica muy bien a aritmética decimal conforme al estándar IEEE 754-2008 (formato decimal64). Por otro lado, como se mencionó anteriormente, la serie de trabajos de Milos Ercegovac [Erc09] [Erc10] [Erc12], aportan soluciones a la raíz cuadrada radix-10 en punto fijo mediante recurrencia de dígitos para diferentes precisiones usando multiplicadores simples de 1x1.

5.1.1. Convenciones acerca de simbología utilizada en este capítulo

En el resto del capítulo, las mayúsculas con superíndices entre corchetes denotan sucesiones de números. El superíndice entre corchetes corresponde al valor que posee la sucesión en el i-ésimo paso o iteración, y los subíndices indican la posición del dígito decimal que posee el número. Por ejemplo, Yj

[i] representa el dígito decimal en la

posición j del i-ésimo término de la sucesión {Y[i]}.

Por otro lado, en lo que respecta a las arquitecturas detalladas en las figuras del presente capítulo, los almacenamientos y señales involucradas se modelan o describen

112

con rango descendente. Significa que para un registro o señal s que describe una variable v con formato Qn.p, los n dígitos de la parte entera de v se describen en sp+n-1··p

y los p dígitos de la parte fraccionaria de v se modelan en sp -1··0.

Además, en las figuras que describen circuitos, los valores que aparecen junto a la barra inclinada (símbolo / ) denotan el tamaño del bus. En cuanto a los rangos o valores que se encuentran entre corchetes asociados a un bus, describen el o los dígito/s seleccionado/s. Por otro lado, los tamaños se expresan en cantidad de dígitos BCD o dígitos binarios (bits). Lo mismo sucede con los dígitos seleccionados, éstos pueden ser BCD o binario.

5.2. Propuesta y Contribuciones

En este trabajo se propone la implementación eficiente en FPGA de Xilinx de la operación raíz cuadrada radix-10 en punto fijo. La propuesta implementa un método iterativo con recurrencia de dígitos basado en la técnica de restoring.

El principal aporte del método propuesto, se encuentra en el mecanismo de selección del dígito perteneciente al resultado en cada iteración. El cuál se efectúa mediante una división simple y posterior verificación de solo dos dígitos adicionales en caso que la restauración sea requerida.

Otra contribución se encuentra vinculada a la implementación eficiente en dispositivos de Xilinx. Para ello, se utilizaron las técnicas novedosas detalladas en el capítulo 3 en cuanto al uso eficiente de la lógica de propagación de acarreo en la suma binaria.

Debido a esto, los diseños propuestos instancian memorias LUTs y multiplexores muxcy, los cuáles son módulos indispensables en la implementación de la propagación de acarreo en dispositivos de Xilinx basados en LUTs de 6 entradas. Para que esta propuesta se pueda implementar en cualquier dispositivo de lógica programable (o tecnología ASIC) independientemente del fabricante, solo se requiere sustituir la instanciación de estos componentes por su descripción correspondiente en un lenguaje de descripción de hardware (VHDL en esta tesis).

Se realizaron comparaciones con las propuestas de los trabajos de [Erc09] y [Erc10]. Según el conocimiento del autor de esta tesis, estos son los trabajos de mayor relevancia existente en la literatura en cuanto a la implementación hardware basada en recurrencia de dígitos de la raíz cuadrada radix-10.

5.3. Método propuesto

El método propuesto en este trabajo para la implementación de la raíz cuadrada en radix-10 utiliza la técnica clásica de restoring. Esta técnica obtiene mediante recurrencia de dígitos los valores de dos sucesiones {Y

[i]} y {R[i]} (i=0,1, ...). En donde la sucesión

{Y[i]} se corresponde con los resultados parciales de la operación raíz cuadrada de un

valor v ( vy = ), y la sucesión {R[i]} se relaciona con el resto parcial (expresión 5.1) y

converge al valor 0:

113

2][][ )( ii YvR −= (5.1) donde v, R[i]

e Y[i] poseen formato Q0.p.

El objetivo del método es que en cada paso i se determina un dígito, Yi[i] (con

[ ] { }9,..,1,0∈i

iY ), del resultado final. De este modo, en cada paso Y[i] aumenta la exactitud

un dígito del resultado parcial raíz cuadrada de v.

[ ] ii

i

iiYYY

−− += 10)(]1[][ ; con { }pi ,..,2,1∈ (5.2) nótese que luego de k pasos (k≤p), Yj

[i] =Yj[l] : { }klij ,..,2,1,, ∈∀ .

En consecuencia, reemplazando (5.2) en (5.1) se obtiene:

( ) [ ]( ) [ ] ii

i

ii

i

iiiYYYYvR

−−−− +−−= 10102 ]1[2]1[][ (5.3)

significa que

[ ]( ) [ ] ii

i

ii

i

iii YYYRR −−−− +−= 10102 ]1[]1[][ (5.4) con { }pi ,..,2,1∈ , R[0]=v e Y

[0] =0.

Para que la selección del dígito Yi[i] sea más simple y directa, se trabaja con la

sucesión {W[i]} (i=0,1, ...), donde cada valor de la misma es un scaling de los valores de

{Y[i]}:

iiiRW 10][][ = (5.5)

donde W[i] posee formato Q1.p.

Entonces, sustituyendo (5.5) en (5.4):

[ ]( ) [ ]ii

ii

i

iiiYYYWW

−−− +−= 10210 ]1[]1[][ (5.6) donde en cada paso se determina Yi

[i], de modo que W[i] se acerque al valor cero. Para ello

[ ]( ) [ ]i

i

ii

i

iiYYYW

−−− +≈ 10210 ]1[]1[ (5.7)

La estrategia empleada para obtener Yi[i], consiste primero en obtener Yi

*[i] de la siguiente manera

[ ]

=

−

−

]1[

]1[*

2

10i

ii

iY

WY (5.8)

114

con [ ] { }9,..,1,0*∈

i

iY . Debido a que en la técnica restoring, los restos parciales son positivos, es decir W[i]≥0, en el caso que suceda lo siguiente

[ ]( ) [ ]ii

ii

i

ii YYYW **]1[]1[ 10210 −−− +< (5.9) se debe encontrar un número natural [ ] [ ]{ }i

i

iYh

*,..,1∈ , tal que se cumpla

[ ] [ ]( ) [ ] [ ])(10)(210 **]1[]1[ ii

i

iii

i

ii hYhYYW −−+≥ −−− y y

[ ] [ ]( ) [ ] [ ] )1(10)1(210 **]1[]1[ +−+−+< −−− ii

i

iii

i

iihYhYYW

(5.10)

en consecuencia Yi

[i]=Yi*[i]- h[i].

Para determinar Y1

[1] se utiliza la expresión (5.6) considerando W[0]=v e Y[0] =0

[ ]( ) [ ]11

111

]1[ 1010 YYvW −−= (5.11) por consiguiente para que el valor de W[1] sea lo más próximo al cero considérese

vY 10]1[1 = (5.12)

de este modo, en el método propuesto se toman los dos dígitos más significativos de v, para encontrar un valor de Y1

[1] que aproxime el cómputo de W [1] a cero

21]1[

1 .010 vvY = (5.13)

Obsérvese en la tabla 5.1 las operaciones involucradas en los diferentes pasos del

método propuesto para calcular la raíz cuadrada de 0.73753 con precisión p=5. Para ello, W[0]=v=0.73753 e Y[0]=0.

A continuación, se describe al algoritmo propuesto en este trabajo para implementar la raíz cuadrada radix-10 en punto fijo con precisión p.

Considere:

- p la precisión del argumento v y del resultado obtenido vy = .

- v en [0.1, 1) con formato Q0.p, donde v = 0.v1v2v3··vp-1vp

- y en (0.3, 1) con formato Q0.p, donde y = 0.y1y2y3··yp-1yp

Algoritmo 5.1 - Algoritmo por recurrencia de dígitos restoring para calcular y=√v en

punto fijo, con p dígitos de precisión

W

[0] = v; Y

[0]= 0;

Y1[1]

= integer(10×sqrt(0.v1v2)); W

[1] = 10×W

[0] - (Y

[1])2/10;

Y[1]

= Y1[1]

/10; for i= 2 to p loop

115

Yi*[i]

= (5×W[i-1]

)/Y[i-1]

; h=0; Yi

[i] = Y

i*[i]

-h ; while ((2×Y

[i-1]+Yi

[i]/10

i)×Yi

[i] >10×W

[i-1]) loop

h = h+1; Yi

[i] = Y

i*[i]

-h ; end loop;

W

[i] = 10×W

[i-1] - (2×Y

[i-1] +Yi

[i]/10

i)×Yi

[i];

Y[i] = Y

[i-1]+Yi

[i]/10

i

end loop y = Y

[p]

Tabla 5.1. Ejemplo de cálculo de 73753.0 con precisión p=5.

Paso Acciones Resultado

Ini W[0] = 0.73743 Y

[0] = 0 1 [ ] 873.0101

1 ==Y

W[1] = 7.3753-6.4 = 0.9753

Y[1] = 0.8

2 W[2] = 10W

[1]-(2Y[1] +10-2

Y2[2])Y2

[2] = 9.753-(1.6+10-2Y2

[2])Y2[2]

[ ] 66.1

753.92*2 =

=Y

W[2] = 9.753-(1.6+0.06)×6 = -0.207 <0 (restaura)

W[2] = 9.753-(1.6+0.05)×5 = 1.503≥ 0

Y2[2] = 5

Y[2] = 0.85

3 W[3] = 10W[2]-(2Y

[2] +10-3Y3

[3])Y3[3] = 15.03-(1.7+10-3

Y3[3])Y3

[3]

[ ] 87.1

03.153*3 =

=Y

W[3] = 15.03-(1.7+0.008)×8 = 1.366>0

Y3[3] = 8

Y[3] = 0.858

4 W[4] = 10W

[3]-(2Y[3] +10-4

Y4[4])Y4

[4] = 13.66-(1.716+10-4Y4

[4])Y4[4]

[ ] 7716.1

66.134*4 =

=Y

W[4] = 13.66-(1.716+0.0007)×7 = 1.6431>0

Y4[4] = 7

Y[4] = 0.8587

5 W[5] = 10W[4]-(2Y

[4] +10-5Y5

[5])Y5[5] = 16.431-(1.7174+10-5

Y5[5])Y5

[5]

[ ] 97174.1

431.165*5 =

=Y

W[5] = 16.431-(1.7174+0.00009)×9 = 1.6431>0

Y5[5] = 9

Y[5] = 0.85879

Apréciese en el algoritmo 5.1, que una vez que se encuentra el valor Yi*[i], se

realizan hasta 10 iteraciones para hallar el valor de h (correspondiente a h[i] en la

expresión 5.10). A continuación se demuestra que h[i] puede ser 0, 1 ó 2. Donde h

[i]

puede ser 0 ó 1 para el caso que i>2, o puede ser 0, 1 ó 2 en el caso que i=2.

116

Sea i con { }pi ,..,3,2∈ , la expresión 5.8 se puede postular de la siguiente manera:

[ ] rYYW i

i

ii += −− *]1[]1[ 210 (5.14)

donde r es el resto de la división determinada por la expresión 5.8.

En consecuencia, sustituyendo (5.14) en (5.6) y tomando Yi [i] =Yi

*[i], se obtiene:

[ ]( ) ii

i

iYrW

−−= 102*][ (5.15)

Según (5.15), cuando W [i] es negativo se cumple la expresión (5.9), significa que

se debe encontrar un valor h[i] de modo que cumpla con (5.10). En consecuencia,

tomando Yi [i] =Yi

*[i]-1 y sustituyendo (5.14) en (5.6), se obtiene:

[ ] [ ]( ) ii

i

iiYYrW

−− −−+= 10122*1][ (5.16)

Nótese que como el argumento v se encuentra en [0.1, 1), entonces Y

[i]≥0.3

{ }pi ,..,2,1∈∀ . De este modo, 2Y[i-1]≥0.6 { }pi ,..,3,2∈∀ . Además, [ ]( ) 6410

2* ≤−≤ i

iY

con { }pi ,..,3,2∈ .

Por todo lo expuesto, según expresión 5.16, W[i] es positivo a partir de la tercer iteración ( { }pi ,..,4,3∈ ). Por otro lado en el caso que i=2, puede que W

[i] obtenga valores negativos. Ésto puede suceder más precisamente, cuando Yi

*[2]=9 e Y[1]=0.3.

En el caso que i=2 y W[i] sea negativo según expresión 5.16, se debe tomar Yi [i]

=Yi*[i]-2. Por consiguiente sustituyendo (5.14) en (5.6), se obtiene:

[ ] [ ]( ) 222*2

1]2[ 1024 −−−+= YYrW (5.17)

como 4Y[1]≥1.2 y [ ]( ) 4910

22*2 ≤−≤ Y , entonces W

[i] de la expresión 5.17 es siempre positivo.

En consecuencia, conclúyase que el dígito seleccionado es Yi [i] =Yi

*[i]- h[i]. Donde h

[i] puede estar en {0,1} cuando { }pi ,..,3∈ , y h[i] puede estar en {0,1,2} cuando i=2.

El algoritmo 5.2 es similar al algoritmo 5.1, pero propone el cálculo optimizado de la selección de dígito Yi

[i], considerando los valores que puede tomar h[i] dependiendo de la iteración.

Algoritmo 5.2 - Algoritmo por recurrencia de dígitos restoring para calcular vy = en punto fijo, con p dígitos de precisión y cálculo optimizado de selección de dígito

W

[0] = v; Y

[0]= 0;

Y1[1]

= integer(10×sqrt(0.v1v2)); W

[1] = 10×W

[0] - (Y

[1])2/10;

Y[1]

= Y1[1]

/10;

117

Y2

*[2] = (5×W

[1])/Y

[1];

Y2[2]

= Y2*[2]

; if ((2×Y

[1]+Y2

[2]/10

2)×Y2

[2] >10×W

[1]) then

Y2[2]

= Y2*[2]

-1; if ((2×Y

[1]+Y2

[2]/10

2)×Y2

[2] >10×W

[1]) then

Y2[2]

= Y2*[2]

-2; end if; end if; W

[2] = 10×W

[1] - (2×Y

[1]+Y2

[2]/10

2)×Y2

[2];

Y[2]

= Y [1]

+Y2[2]

/102;

for i = 3 to p loop Yi

*[i] = (5×W

[i-1])/Y

[i-1];

Yi[i] = Yi

*[i];

if ((2×Y

[i-1]+Yi

[i]/10

i)×Yi

[i] >10×W

[i-1]) then

Yi[i]

= Y i*[i]

-1; end if;

W

[i] = 10×W

[i-1] - (2×Y

[i-1] +Yi

[i]/10

i)×Yi

[i];

Y[i] = Y

[i-1]+Yi

[i]/10

i

end loop y = Y

[p]

5.2. Arquitectura para calcular raíz cuadrada radix-10 punto fijo

En este apartado se detalla la arquitectura propuesta para implementar la raíz cuadrada radix-10 en punto fijo (figura 5.1). Este circuito implementa el algoritmo 5.2, donde la señal step se corresponde con la variable i. El registro reg_w se corresponde con W[i], y el registro reg_y se encuentra asociado a Y[i]. La señal step se genera por una Unidad de Control simple y toma valores que van desde 1 hasta p. Otras señales generadas por la Unidad de Control habilitan la carga en el registro reg_w y desplazamiento y carga del registro reg_y, éstas son en_w y en_y. La latencia de esta propuesta se encuentra directamente relacionada con la precisión deseada, significa que la arquitectura posee una latencia de p ciclos de reloj.

El módulo Add, realiza la suma entre operandos de p+1-dígitos en formato BCD. Este módulo implementa cualquiera de las soluciones propuestas en el capítulo 3. El componente Mult, es un multiplicador BCD que opera con un multiplicando de p+1 dígitos y un multiplicador de un dígito. Se utiliza el multiplicador eficiente propuesto en [Din10b] detallado en apartado 4.3.4.1. Por otro lado, el módulo Sub efectúa la resta entre operandos naturales de p+2-dígitos en formato BCD. Éste módulo implementa el restador eficiente Sub_Nat propuesto en el capítulo 3 (apartado 3.4), donde el puerto o indica overflow y se produce cuando el sustraendo es mayor al minuendo.

El módulo Lut_root se utiliza para obtener el primer dígito de la solución determinado por la expresión 5.13. La implementación de este módulo es una memoria

118

con todas las raíces precalculadas, accediendo a la misma a partir de los dos dígitos BCD más significativos de reg_w (reg_wp··p-1).

El componente div (figura 5.2), efectúa la división de la expresión (5.8). En la arquitectura propuesta, se efectúa el cociente entre los tres dígitos más significativos de 10reg_w y los dos más significativos de 2reg_y, es decir (10reg_w)p+1··p-1/(2reg_y)p··p-1.

p+1

reg_w reg_y

x10

i

en_w en_y

step

01

p+2

Lut_root

[p:p-1] 2

[p+1:p-1]

x2

3

1

2

p+1

[p:p-1]

1

-1 -2

x10-i

Add

p+1

ix10

-i

Add

p+1

ix10

-i

Add

p+1

Mult

p+1

p+2

Sub

Mult

p+1

p+2

Sub

Mult

p+1

p+2

Sub

0 10 1

rororo

0 1

p+2[p:0]

p+1

0 1

1

a bdiv

=1

Figura 5.1 - Circuito que calcula la raíz cuadrada radix-10 punto fijo.

Nota: tamaños, rangos y dígitos seleccionados asociados a buses describen dígitos

BCD.

La división propuesta está basada en el cálculo de todos los posibles productos

parciales correspondientes al divisor b

pj = b×j con { }9,..,2,1∈j (5.18)

119

Para determinar los productos pj, se propuso la utilización de 8 memorias con los productos precalculados de tres dígitos BCD almacenados. Nótese que como 2×Y

[i] (2×reg_y) se encuentra [0.1, 2), el dígito más significativo del puerto b (vinculado a 2×reg_y) puede ser 0 ó 1. Por consiguiente, con solo 5 bits se puede modelar b. Por lo anterior, cada una de las memorias posee 32 productos almacenados.

Figura 5.2 - Circuito que determina la división (div).

Nota: tamaños asociados a buses describen dígitos BCD.

Una vez que se obtienen los productos parciales se determina mediante el componente Cmp, cuáles productos son mayores al dividendo a. La señal lj indica si el dividendo a es menor que el correspondiente producto parcial

lj = 1 when (a<pj) else 0; con { }9,..,2,1∈j (5.19)

Por último, el Selector efectúa la selección del dígito correspondiente al cociente de la división, a/b, de la siguiente manera:

q = 0 when (l1 = 1) else 1 when (l2 = 1) else

2 when (l3 = 1) else

3 when (l4 = 1) else

4 when (l5 = 1) else

5 when (l6 = 1) else

6 when (l7 = 1) else

7 when (l8 = 1) else

8 when (l9 = 1) else 9

(5.20)

La figura 5.3 detalla la implementación del componente Cmp. Se utilizaron

eficientemente los recursos de la FPGA aprovechando la lógica de acarreo presente en estos dispositivos.

120

Cmp es un comparador de dos números en formato BCD de tres dígitos, el cuál genera el valor lógico uno (less=1) en el caso que a≤b. Se compone de tres módulos Cmp-i, donde cada uno realiza la comparación entre dos números en formato BCD ai<bi. Se basa en la implementación de la resta ai-bi, mediante la utilización eficiente de la lógica de cálculo de acarreo para determinar la comparación y efectuar las correspondientes peticiones en el caso que ai<bi, en donde

ci+1 = ci when (ai=bi) else 1 when (ai<bi) else 0;

(5.21)

con { }2,1,0∈i y c0=1.

Para ello, las señales psi[3..0] se utilizan para propagar el petición de la instancia anterior, y esto sucede cuando ai[j]=bi[j]

psi[j]= 1 when (ai[j]=bi[j] ) else 0; con { }2,1,0∈i y { }3,2,1,0∈j (5.22) Nótese que less=c4.

Figura 5.3- Circuito que implementa Cmp.

5.3. Resultados experimentales

Se implementó el diseño propuesto para el cálculo de la raíz cuadrada radix-10 punto fijo en dispositivos Virtex 5, 6 y 7 de Xilinx. La síntesis e implementación se realizaron con el XST [Xil13a] (Xilinx Synthesis Technology) y Xilinx ISE versión 14.3 [Xil13b]. Esto se llevó a cabo dejando los parámetros de síntesis por defecto. En las tablas 5.2 y 5.3 se observan los resultados de las implementaciones en Virtex 7 con speed grade 3. Las precisiones, p, utilizadas se corresponden al estándar IEEE 754-2008.

Para las operaciones de adición que intervienen en la arquitectura propuesta (figura 5.1) y para las sumas BCD involucradas en la multiplicación de los productos parciales pp

U y ppL de Mult, se consideraron las alternativas Adder-I, Adder-II y Adder-

121

III del capítulo 3. Obsérvese que las implementaciones que utilizan las técnicas basadas en [Din10a] presentan los mejores resultados en cuanto a tiempo de cómputo y consumo de área en términos de ocupación de LUTs. Las implementaciones propuestas poseen una latencia de p ciclos de reloj y tienen frecuencias de operación de: 102 MHz para p=7, 97 MHz para p=16, y 89 MHz con p=34.

Tabla 5.2. Tiempo de cálculo (ns) de raíz cuadrada punto fijo radix-10 en Virtex 7 con speed grade 3

p Adder-I Adder-II Adder-III

7 12.42 11.52 9.80 16 12.80 11.84 10.21 34 13.73 12.70 11.17

Tabla 5.3. Área (LUTs) de raíz cuadrada punto fijo radix-10 en Virtex 7 con speed

grade 3

p Adder-I Adder-II Adder-III

7 1372 1472 1241 16 2594 2810 2287 34 5105 5458 4408

Se comparó la solución propuesta en el presente trabajo, con los trabajos más

significativos según el criterio del autor de esta tesis, en cuanto a implementación hardware de la operación raíz cuadrada radix-10 en FPGA. Estos son [Erc09] [Erc10] pertenecientes a una serie de propuestas de Milos Ercegovac. No resultó necesario rediseñar e implementar nuevamente estos trabajos utilizando las técnicas novedosas de uso de lógica de acarreo binario pertenecientes a los dispositivos utilizados para aritmética radix-10 propuestas en esta tesis, debido a que los diseños planteados en los mencionados trabajos proponen una arquitectura en la que no se requiere el uso de esta lógica dedicada.

Debido a que en [Erc09] y [Erc10] se realizaron implementaciones sobre dispositivos Virtex 5 con speed grade 2 y Virtex 6 con speed grade 3 respectivamente, con la finalidad de poder efectuar las comparaciones de manera más objetiva, se realizaron las implementaciones de la solución propuesta en esta tesis sobre los mismos dispositivos y las mismas precisiones. En estas implementaciones se utilizaron para las operaciones de suma BCD involucradas, las soluciones propuestas basadas en [Din10a] (Adder-III).

En las tablas 5.4 y 5.5 se observan las comparaciones entre las diferentes propuestas. Respecto a las soluciones que se encuentran en [Erc09], las implementaciones de esta tesis poseen mejores tiempos de cómputo. Para p=7 se obtuvo una aceleración de 35%, en donde la misma disminuye a medida que aumenta la precisión hasta alcanzar el 13% para p=32. En cuanto al área, las soluciones de esta tesis poseen una penalización en área que van desde el 64% hasta el 83%.

En lo que respecta a las comparaciones con las propuestas de [Erc10], vale mencionar que en ese trabajo, para la implementación de la raíz cuadrada se utilizan las ideas expuestas en el trabajo que lo precede [Erc09], y que además combina las operaciones de división y raíz en el diseño e implementación. Debido a ésto, se incrementa significativamente respecto al trabajo previo la ocupación de LUTs. Las

122

implementaciones de esta tesis poseen mejores tiempos de cómputo respecto a [Erc10], con aceleraciones que se encuentran entre el 29% y 42%. En cuanto al área, se obtuvo menor ocupación de LUTs para p=7,8 ó 16 (entre -11% y -6%), con un incremento poco significativo para p=32 (2%).

Tabla 5.4. Tiempo de cálculo (ns) de raíz cuadrada punto fijo radix-10

p [Erc09] Esta tesis

Virtex 5 speed

grade 2

Acel. [Erc10] Esta tesis

Virtex 6 speed

grade 3

Acel.

7 18.94 13.97 1.35 14.53 10.17 1.42 8 18.73 14.01 1.33 14.53 10.23 1.42 16 18.73 14.90 1.25 15.29 10.68 1.43 32 18.65 16.43 1.13 15.13 11.69 1.29

Tabla 5.5. Área (LUTs) de raíz cuadrada punto fijo radix-10

p [Erc09] Esta tesis

Virtex 5 speed

grade 2

Penalización

[Erc10] Esta tesis

Virtex 6 speed

grade 3

Penalización

7 740 1282 1.73 1384 1241 0.89 8 844 1390 1.64 1479 1363 0.92

16 1322 2247 1.69 2392 2255 0.94 32 2263 4151 1.83 4066 4153 1.02

Para tener noción de cuán significativo es la ocupación de LUTs de las

implementaciones de estas propuestas en los dispositivos seleccionados, hay que verificar el tamaño de los mismos en cuanto a cantidad de LUTs de 6 entradas. En los dispositivos pertenecientes a la familia Virtex 5 [Xil15a], el más pequeño posee 12480 LUTs y el más grande 207360 LUTs. En cuanto a los dispositivos de la familia Virtex 6, el más pequeño posee 46560 LUTs y el más grande 474240 LUTs [Xil15b]. Por último, para aquellos pertenecientes a la familia Virtex 7, el más pequeño posee 204000 LUTs y el más grande más de un millón [Xil16d].

Por lo anterior, dependiendo del dispositivo escogido puede resultar conveniente prevalecer el tiempo de cómputo respecto a la ocupación de LUTs, en el momento de optar por alguna solución.

5.4. Raíz cuadrada radix-10 punto flotante

Si bien en esta tesis no se diseñó la arquitectura para llevar a cabo la raíz cuadrada DFP, en este apartado se efectúa un análisis de las operaciones involucradas para poder realizar esta operación.

Como sucede con la implementación hardware de todas las operaciones aritméticas punto flotante, para implementar un circuito que compute la raíz cuadrada DFP, el núcleo principal es la implementación de algoritmo que lleva a cabo la raíz cuadrada radix-10 punto fijo.

A continuación, se detallan los pasos requeridos para la implementación de raíz cuadrada DFP conforme al estándar IEEE 754-2008. Un valor DFP conforme al estándar (véase capítulo 2, sección 2.3), está conformado por el signo, la mantisa y el exponente. Para soportar este tipo de operandos, se debe realizar un tratamiento especial

123

del exponente y de la mantisa. El formato del operando v, es (-1)sx10q

xvm, donde s

corresponde al signo, vm a la mantisa y q al exponente. Nótese que vm no se encuentra normalizado y se interpreta como entero (véase tabla 2.4). Por consiguiente, se debe ajustar el exponente de modo que considere vm con el formato Q0.p. Para ello

v = vmx10q = 0.vm x10q+p

donde 0.vm posee formato Q0.p. Obsérvese que 0.vm se encuentra en [0, 1), debido a que puede poseer ceros iniciales luego del punto. En consecuencia, se deben eliminar estos ceros iniciales y realizar el correspondiente ajuste de exponente, 0.vm = vm'10-z, donde z es la cantidad de ceros iniciales. Nótese que vm' posee formato Q0.p y se encuentra en [0.1, 1). Entonces:

zpq

mvvy−+== 10' (5.23)

Para que el resultado y se encuentre conforme al estándar IEEE 754-2008,

considere y = ymx10t, donde el valor ym se corresponde a la mantisa, no se encuentra normalizado y se interpreta como entero.

Como 'mv se determina mediante la implementación del algoritmo punto fijo

5.2, éste posee formato Q0.p en [0.3, 1). Sea e=q+p-z, se identifican dos casos:

i) cuando e es par

'210 m

e

vy = (5.24)

para que ym se encuentre en formato Qp.0, se toma

p

mm vy 10'= (5.25)

reemplazando (5.25) en (5.24) se obtiene

pe

myy−

= 210 (5.26)

con pet −= 2 .

ii) cuando e es impar

'2 1010 m

e

vy = (5.27)

sea ....16227766.310 ==c , se toman los p dígitos más significativos de c de modo que se encuentre en formato Q1.p-1. En consecuencia

'210 m

e

vcy = (5.28)

124

el resultado de la operación 'mvc , posee formato Q1.p-1 y se encuentra en [1, 10 ).

Por consiguiente, para que ym se encuentre en Qp.0, se toma

1' 10 −= p

mm vcy (5.29)

reemplazando (5.29) en (5.28) se obtiene

1210 +−= pe

myy (5.30)

con 12 +−= pet .

5.5. Conclusiones del capítulo y trabajo futuro

En este trabajo se propone la implementación eficiente de la operación raíz cuadrada radix-10 en punto fijo sobre dispositivos basados en LUTs de 6 entradas de Xilinx. La solución propuesta implementa el método iterativo mediante recurrencia de dígitos basado en la técnica de restoring. Vale mencionar que los diseños e implementaciones que se encuentran en este capítulo se publicaron en [Vaz14].

Esta propuesta presenta como aporte principal, el mecanismo de selección del dígito perteneciente al resultado en cada iteración, el cuál posibilita la simplificación de la operación de restauración en el caso de requerirse. Se basa primero en encontrar un dígito mediante el cociente entre dos operandos de tamaño pequeño (dividendo de tres dígitos y divisor de dos dígitos). La implementación de la división realizada se basa en el uso de tablas. Si el dígito encontrado, h, no es el requerido y se necesita restaurar, se analizó y demostró que solo se necesita explorar dos números, h-1 y h-2, para seleccionar el dígito correcto.

La implementación se basa en la utilización de la lógica de propagación de acarreo de suma binaria que se encuentra en estos dispositivos. Se usaron las estrategias expuestas en el capítulo 3 para las operaciones de suma y resta de números naturales BCD que intervienen en el diseño. Además se usaron las ideas novedosas de [Din10b] para implementar el multiplicador BCD de (p+1)×1-dígitos (véase apartado 4.3.4.1). Otro componente diseñado para usar la lógica eficiente de acarreo, es el comparador de dos números BCD (Cmp) presente en el divisor.

Si bien esta propuesta no instancia los componentes dedicados que se encuentran en los dispositivos seleccionados, como es el caso de multiplicadores, o bloques de memoria RAM, etc, instancia los componentes genéricos LUT y muxcy utilizados en la implementación eficiente de la propagación de acarreo en la suma binaria. Esto lleva a que el diseño no sea genérico, solo puede ser aplicable a los dispositivos pertenecientes a las familias de dispositivos de Xilinx basados en LUTs de 6 entradas.

Para que la propuesta se pueda implementar en cualquier dispositivo de lógica programable (o tecnología ASIC) independientemente del fabricante, lo único que se

125

requiere es sustituir la instanciación de estos componentes por su correspondiente descripción en VHDL.

Las implementaciones se realizaron en dispositivos Virtex 7 de Xilinx con speed

grade 3, se consideraron las precisiones involucradas en el estándar, esto es p=7,16 ó 34. Considerando las mejores alternativas, es decir aquellas basadas en las ideas de [Din10a], se obtuvo que las velocidades de operación son: 102 MHz para p=7, 97 MHz para p=16, y 89 MHz con p=34. En donde la latencia del circuito es p ciclos de reloj.

Se realizaron comparaciones con las propuestas de los trabajos [Erc09] y [Erc10]. Para ello, se efectuaron implementaciones sobre los mismos dispositivos y utilizaron las mismas precisiones. Respecto a [Erc09], las soluciones propuestas en esta tesis obtienen aceleraciones que se encuentran entre el 13% y 35%, y penalizaciones en área que van desde 64% hasta el 83%. Considerando las implementaciones de [Erc10], las soluciones propuestas poseen aceleraciones entre 29% y 42%, con menor ocupación de LUTs para p=7,8 ó 16 (entre -11% y -6%), y un aumento de 2% de uso de LUTs para p=32.

Relacionado con el diseño e implementación de la raíz cuadrada radix-10 basada en recurrencia de dígitos se proponen las siguientes líneas de trabajo futuro:

- Con la finalidad de disminuir el consumo de área, se propone analizar y mejorar de ser posible, el diseño del módulo división div desarrollado en este trabajo.

- Profundizar el estudio de las técnicas de recurrencia de dígitos desarrolladas por Milos Ercegovac en [Erc09] y [Erc10], con el objeto de incrementar su eficiencia a partir del uso de los recursos dedicados para propagación de acarreo de suma binaria que se encuentran en los dispositivos.

- Explorar e implementar de manera eficiente en dispositivos de Xilinx, otros métodos de recurrencia de dígitos, tales caso de SRT, non-restoring, etc

- Realizar el diseño e implementación de la raíz cuadrada DFP conforme al estándar IEEE 754-2008. Considerando para ello, el tratamiento de excepciones y el manejo de diferentes técnicas de redondeo.

127

CAPÍTULO 6

Conclusiones

6.1. Resumen final

En esta tesis se realizaron contribuciones en el área aritmética decimal en FPGAs. Se presentan diversas estrategias, muchas de ellas novedosas, para la implementación de las operaciones suma, resta, suma/resta, logaritmo decimal y raíz cuadrada en punto fijo y logaritmo decimal en punto flotante. Los diseños se realizaron sobre dispositivos FPGAs de Xilinx con LUTs de 6 entradas. Algunas de las estrategias desarrolladas en este trabajo se publicaron en congresos y revistas internacionales, tales casos de [Vaz15] (con diseños del capítulo 3) y [Vaz15] (con diseños del capítulo 5). Un artículo con los aportes expuestos en el capítulo 4 respecto a la implementación del logaritmo decimal radix-10 en punto fijo y DFP conforme al estándar, se encuentra en evaluación en el momento de la redacción de esta memoria.

- M. Vázquez, E. Todorovich. FPGA-Specific Decimal Sign-magnitude Addition and Subtraction. International Journal and Electronics (Taylor and Francis), 103/7, pp: 1166-1185, Oct 2015, ISSN: 0020-7217, Indice de Impacto: JCR 2014=0.459, JCR 2015= 0.414, Digital Object Indentifier: 10.1080/00207217.2015.1089945. [Vaz15]

- M. Vázquez, M. Tosini. Design and Implementation of Decimal Fixed-Point Square Root in

LUT-6 FPGAs. IX Southern Programmable Logic Conference (SPL), ISBN: 978-1-4799-6846-6. pp. 1-6, 2014. [Vaz14]

- M. Vázquez, L. Leiva, G. Sutter. Radix-10 decimal logarithm by direct selection for 6-input

LUTs programmable devices. [En evaluación].

Debido a que todas las funciones aritméticas requieren de la operación suma, los dispositivos de Xilinx poseen lógica dedicada que permiten la implementación eficiente de la propagación de acarreo binario (carry-chain) en esta operación. Este trabajo propone implementar las operaciones aritméticas radix-10 de manera que utilicen estos recursos dedicados en forma eficiente. Una de las principales contribuciones, es el diseño eficiente de implementaciones de operaciones aritméticas radix-10, en dispositivos programables optimizado para diseño en radix-2, o eventualmente radix-2b.

Se realizaron aportes respecto a la implementación de las operaciones de suma y resta de números naturales, así como también suma/resta de números enteros. Para ello, se profundiza el trabajo realizado en [Vaz11], el cuál se basa en el cálculo de las funciones de generación y propagación de acarreo decimal, junto con el uso eficiente de los recursos dedicados para implementar eficientemente de la carry-chain radix-2. Además, se analizan y aplican las técnicas desarrolladas en [Din10a] para la suma decimal multioperando.

128

Para la suma BCD, se analizan y comparan las técnicas novedosas desarrolladas en [Vaz11] y [Din10a] para la propagación de acarreo en dispositivos basados en LUTs de 6 entradas. También, se analizan y comparan los sumadores/restadores de números en C10 presentes en [Vaz11], con el diseño de un sumador/restador C10 basado en las ideas expuestas en [Din10a]. Se obtiene que la elección de las diferentes estrategias depende de las restricciones o requerimientos de la aplicación, en cuanto a tiempo de cómputo u ocupación de LUTs.

Se realizó el diseño novedoso de la implementación de la resta BCD de números naturales, mediante el uso de la lógica empleada para la implementación de la propagación de peticiones de dígitos en la resta radix-2 que se encuentra en los dispositivos. En base al resultado permitido, se diseñaron dos tipos restadores de números naturales. Uno, solo permite que el resultado sea un número natural, es decir, para el caso que el resultado debiera ser negativo genera la señal overflow. El otro restador, permite que el resultado sea entero en SVA.

Se desarrollaron dos estrategias para la implementación de la suma/resta de números enteros decimales en SVA. Una se basa en sumadores/restadores en C10, la otra en un multiplexor que selecciona entre dos resultados que provienen de un sumador y un restador. Para cada una de estas estrategias, se diseñaron tres alternativas asociadas a las técnicas de diseño empleadas para la suma BCD propuestas en [Vaz11] y [Din10a]. Se obtuvo que la elección entre las diferentes alternativas depende de las restricciones o requerimientos de la aplicación.

En lo que respecta a lo operación de logaritmo decimal radix-10, se proponen diseños e implementaciones eficientes en dispositivos basados en LUTs de 6 entradas, tanto para punto fijo como para punto flotante conforme al estándar IEEE 754-2008. Para el logaritmo DFP, las soluciones soportan los formatos decimal32, decimal64 y decimal128.

La solución propuesta para resolver el cálculo del logaritmo, se basa en un método iterativo mediante recurrencia de dígitos. Presenta como novedad la selección directa del dígito de convergencia mediante el scaling de los valores de la sucesión auxiliar. Los valores de la sucesión auxiliar, se obtienen principalmente mediante una operación de multiplicación por un dígito decimal y una suma/resta. Para ello, basados en la certeza de la conveniencia de utilizar los recursos dedicados en la implementación de la carry-chain, se emplearon los sumadores/restadores desarrollados en esta tesis y las ideas expuestas en [Din10b] para la multiplicación decimal. Debido a esto, la ruta de datos de la implementación no utiliza lógica redundante carry-save, como sucede con los principales trabajos existentes en la bibliografía acerca de soluciones mediante recurrencia de dígitos.

Se efectuaron comparaciones con el principal trabajo existente en la bibliografía en cuanto a implementación hardware del logaritmo decimal DFP conforme al estándar [Che12]. Para ello, se hicieron modificaciones a la solución de [Che12], con el objeto de realizar comparaciones lo más objetivas posibles ya que éste se implementó en ASICs. En consecuencia, se modificaron algunos módulos para que sean más eficientes en dispositivos FPGAs de Xilinx con LUTs de 6 entradas. Se obtuvo que los diseños propuestos en esta tesis obtienen mejores tiempos de cómputo y menor ocupación de

129

LUTs que las soluciones de [Che12], para todas las precisiones soportadas por el estándar.

Para la operación raíz cuadrada radix-10 en punto fijo, se propone un método iterativo con recurrencia de dígitos basado en la técnica de restoring. La principal contribución de esta propuesta, se encuentra en el mecanismo de selección de dígito del resultado, el cuál permite que se simplifique la restauración en caso de ser necesario. Para seleccionar el dígito, primero se realiza una división entre dos operandos de tamaño pequeño, luego en el caso de requerir restauración, solo se necesitan explorar dos números. La implementación propuesta se basa en el uso eficiente de los recursos de propagación de acarreo presentes en el dispositivo.

Se realizaron comparaciones con los trabajos de mayor relevancia existentes en la bibliografía que proponen la implementación en FPGA de la operación raíz cuadrada radix-10: [Erc09] y [Erc10]. Debido a que estos trabajos se hicieron en los dispositivos Xilinx, con el objeto de efectuar comparaciones lo más objetivas posible, se implementaron las soluciones de esta tesis en los mismos dispositivos que se usaron en los mencionados trabajos. Se obtuvo que las soluciones expuestas aquí, poseen mejores tiempos de cálculo, pero mayor ocupación de LUTs.

Las implementaciones propuestas en esta tesis para todas las operaciones aritméticas, no utilizan los núcleos embebidos presentes en los dispositivos, tales caso de memorias, multiplicadores, etc. De todas maneras, se deben diseñar a nivel slice mediante la instanciación de LUTs y multiplexores dedicados para la carry-chain. Esto lleva a que los diseños no sean portables, incluso entre dispositivos de diferentes familias de FPGAs de un mismo fabricante. Para que las propuestas se puedan implementar en cualquier dispositivo de lógica programable (o tecnología ASIC) independientemente del fabricante, lo único que se debe hacer es reemplazar la instanciación de estos componentes por su correspondiente descripción genérica en algún lenguaje estándar de descripción de hardware.

Todas las ideas y técnicas expuestas en esta tesis, pueden considerarse una continuación de un trabajo precedente realizado por el autor [Vaz11]. Si bien ambos trabajos son independientes, pueden entenderse como dos etapas de un trabajo más abarcativo y completo cuya contribución principal es la misma, y consiste en el desarrollo de técnicas para la implementación eficiente de operaciones aritméticas radix-10 en dispositivos de Xilinx. Muchas de las soluciones presentes en la primera etapa también se publicaron en congresos y revistas internacionales: [Bio09a] [Bio09b] [Bio10] [Vaz09b] y [Sut09]. En consecuencia, el trabajo mas abarcativo comprende una producción de 8 artículos, 3 se corresponden con esta tesis (uno se encuentra en evaluación) y 5 con [Vaz11].

El propósito fundamental de esta tesis, es contribuir al desarrollo e implementación de soft cores y firm cores de unidades aritméticas DFP conforme al estándar IEEE 754-2008, sobre dispositivos programables FPGAs. Otro de los propósitos consiste en establecer estrategias para que los sintetizadores, más precisamente aquellos usados por Xilinx, puedan emplearlas al implementar operaciones aritméticas radix-10 en los dispositivos.

130

6.2. Investigación futura

Además de las líneas de trabajo futuro específicas en relación a las operaciones implementadas que se detallan en los capítulos correspondientes, en términos más generales como investigación futura se proponen diversos lineamientos.

6.2.1. Generalización para dispositivos basados en LUTs de n entradas

Basado en la experiencia de diseño optimizado de módulos que implementan operaciones aritmética radix-10 en dispositivos programables de Xilinx, cuyas arquitecturas se encuentran fuertemente basadas en el uso de elementos de memoria LUTs y recursos dedicados de la carry-chain, uno de los interrogantes que surgieron durante el desarrollo de este trabajo, es saber que sucede con los diseños realizados, si a raíz de una mejora de los procesos tecnológicos, en los dispositivos de Xilinx las LUTs poseen más entradas. Resulta interesante encontrar mecanismos genéricos para diseñar módulos aritméticos radix-10 (o eventualmente radix-B) en dispositivos basados en LUTs de n entradas.

En el presente trabajo, se observó que el uso eficiente de los recursos dedicados para la propagación de acarreo de la suma binaria que se encuentra en los dispositivos, es de vital importancia en el momento de implementar operaciones aritméticas independientemente del radix. Debido a que la operación suma se encuentra en la implementación de todas las operaciones aritméticas, surge interés en investigar acerca de la elaboración de estrategias para el diseño e implementación eficiente de la operación suma radix-B en dispositivos basados en LUTs de n entradas.

Para lo anterior, una posible solución consiste en utilizar una secuencia de sumadores completos de dígitos radix-B (figura 6.1). En donde cada sumador, implementa las funciones de propagación y generación de acarreo, para poder utilizar los recursos dedicados de la carry-chain. En consecuencia, para la suma radix-B, ri =xi + yi; con ri, xi e yi dígitos radix-B, la funciones de generación y propagación de acarreo se expresan de la siguiente manera:

if (xi+yi) > B then Gi =1 else Gi =0

if (xi+yi) = B-1 then Pi =1 else Pi=0

Figura 6.1 –Sumador radix-B de p dígitos.

La figura 6.2 muestra una implementación del sumador completo radix-B basada en el uso de la carry-chain, donde m es la cantidad de bits involucrados en la representación binaria de un dígito radix-B (m= B2log ). Obsérvese que el módulo

Add_mod_2m realiza la suma binaria entre las representaciones binarias de los

operandos radix-B. Por otro lado, el componente Correction efectúa la corrección del

131

resultado generado por Add_mod_2m, teniendo en cuenta si éste es mayor a B y además

considerando el acarreo que proviene del sumador anterior ci. Es importante destacar, que en el caso particular que la base sea potencia de dos, es decir B=2m, la corrección solo consiste en sumarle al resultado el acarreo de entrada ci.

xi yi

ci

Add_mod_2m

m

G-P radix-B

GiPi

1

0ci+1

m

m

Correction

m

ri

Figura 6.2 – Full Adder radix-B.

En este contexto, resulta de significativo interés estudiar posibles implementaciones de sumadores binarios módulo 2m (Add_mod_2

m) y módulos que determinan las funciones de G y P (G-P radix-B), considerando LUTs de n entradas. Para ello hay que analizar de manera genérica arquitecturas con diferentes relaciones entre n y m.

6.2.2. Formato BID (Binary Integer Decimal)

Los números DFP conforme al estándar IEEE 754-2088, también se pueden codificar en formato BID [Cor07]. Cuando se utiliza el formato BID, se procesa la mantisa como entero binario, en lugar de procesarla como una secuencia de números decimales en formato BCD. El primero en adoptar el formato BID fue Intel, con una librería matemática DFP desarrollada en software [Cor07]. En la bibliografía existen muy pocos trabajos que aborden la implementación hardware utilizando el formato BID [Gon13] [Tse09] [Tse11]. Más aún, según el conocimiento del autor, no existen trabajos significativos en lo respecta a implementaciones sobre FPGAs. Esto se debe probablemente, a que existe una percepción de que el formato BID es más apropiado tratarlo en software que en hardware.

El costo de realizar la implementación hardware de valores DFP utilizando el formato BID, recae principalmente: en la alineación de mantisas cuando las operaciones son suma y resta, requiriendo multiplicaciones por valores potencia de diez; y en las operaciones de redondeo, donde se requieren divisiones por potencias de diez.

Resulta desafiante poder investigar acerca del diseño e implementación en FPGAs, de operaciones aritméticas DFP con operandos que utilizan el formato BID. En primera instancia, porque es un tema que hasta el momento no se abordó en esta tecnología. En segunda lugar, debido a que para la alineación de mantisas y redondeo,

132

se requiere el uso de multiplicadores binarios, los cuáles se encuentran embebidos en la mayoría de los dispositivos de lógica programable de los principales fabricantes. Por último, se pueden integrar o combinar, las unidades aritméticas DFP basadas en el uso de BID, con las unidades aritméticas en punto flotante binario.

6.2.3. Unidades aritméticas DFP en lógica programable

En el presente trabajo se abordaron diferentes estrategias para la implementación eficiente de algunas operaciones aritméticas radix-10 en dispositivos programables de Xilinx. Se desarrollaron soluciones tanto en punto fijo, como en punto flotante conforme al estándar IEEE 754-2008. Si bien se exploraron muchas estrategias y se analizaron muchas soluciones, surge el interés de continuar con el desarrollo de cores de unidades aritméticas DFP.

Resulta auspicioso continuar este trabajo, investigando en el desarrollo de implementaciones en FPGAs de otras funciones transcendentales en radix-10. Además, profundizar diseños DFP para una mayor cantidad de operaciones aritméticas, ya que en esta tesis sólo se abordó el punto flotante en la operación logaritmo decimal.

Puede ser una alternativa atrayente adaptar, o analizar la posibilidad de aplicar, los diseños expuestos en este trabajo en los dispositivos de la otra compañía líder en el mercado en desarrollo y ventas de FPGAs: Intel-Altera. Si bien mucho de los diseños utilizan recursos dedicados como la carry-chain, surge cierto interés en adaptar estas estrategias en las arquitecturas de otros dispositivos.

Por último, otro de los temas sugestivos para abordar, es explorar en el desarrollo de coprocesadores de unidades aritméticas DFP basados en FPGAs, mediante la síntesis de alto nivel de soluciones software desarrolladas y testeadas con éxito. Para ello se puede, como un primer paso, realizar la síntesis de ciertas rutinas de la librería IBM C DecNumber [Cow10]. Si bien a priori, se puede afirmar que se obtienen soluciones mas costosas en cuanto a tiempo de cómputo y ocupación de LUTs, respecto a soluciones desarrolladas a medida a partir de descripciones con HDLs, resulta interesante poder validar y análizar esta afirmación.

133

Bibliografía

[ANS76] TC X3J1. ANSI X3.53-1976: American National Standard Programming Languages PL/I. New York: American National Standards Institute, Feb. 1976.

[ANS96] TC X3J18. ANSI X3.274-1996: American National Standard for Information Technology -

Programming Languages REXX. New York: American National Standards Institute, Feb. 1996.

[ANS02] JTC 1/SC 22/WG 4. ISO/IEC1995: Information technology – Programming languages –

COBOL. New York: American National Standards Institute, Dec. 2002.

[Alf05] Peter Alfke. Creative Uses of Block RAM. Xilinx – White Paper: Vrtex and Spartan FPGAs families, 2005.

[Alf97] P. Alfke and B. New Serial code conversion between BCD and binary. Xilinx application note XAPP 029, Oct. 1997.

[Ama12] A. Amarcai, O. Boncalo. FPGA Implementation of Very High Radix Square Root with

Prescaling. 19th IEEE International Conference on Electronics, Circuits and Systems, 2012.

[And79] J. L. Anderson. Binary or BCD Adder with Precorrected Result. U.S. Patent, October 1979. #4,172,288.

[Ant06] A. Vazquez, E. Antelo. Conditional Speculative Decimal Addition. Proc. Seventh Conf. Real Numbers and Computers (RNC 7), pp. 313-317, July 2006.

[Ant09] A. Vazquez and E. Antelo. A High-Performance Significand BCD Adder with IEEE 754-

2008 Decimal Rounding. 19th IEEE Symposium on Computer Arithmetic, ARITH 2009, pp. 135–144, June 2009.

[Ant12] Á. Vázquez, J. Villalba-Moreno, E. Antelo, E. Zapata. Redundant Floating-Point Decimal

CORDIC Algorithm. IEEE Transactions on Computers, Vol. 61, No. 11, 2012.

[Ash90] Peter Ashender. The VHDL CookBook (First Edition). University of Adelaide,1990.

[Ash08] Peter Ashender and Jim Lewis. VHDL-2008. Elsevier, 2008.

[Bab05] H. Hasan Babu and A. Chowdhury. Design of a Reversible Binary Coded Decimal Adder

by Using Reversible 4-bit Parallel Adder. Proceedings of the 18th International Conference on VLSI Design, pp. 255–260, 2005.

[Bae09] M. Baesler and T. Teufel. FPGA Implementation of a Decimal Floating-Point Accurate

Scalar Product Unit with a Parallel Fixed-Point Multiplier. International Conference on Reconfigurable Computing and FPGAs, pp. 6-11, Dec. 2009.

134

[Bae10] M. Baesler, M. Voigt, T. Teufel. An IEEE 754-2008 Decimal Parallel and Pipelined

FPGA Floating-Point Multiplier. International Conference on Field Programmable Logic and Applications (FPL), pp. 489-495, 2010.

[Bak73] P.W. Baker. Parallel Multiplicative Algorithms for Some Elementary Functions. IEEE Transaction on Computers, vol. 61, no. 5, pp. 322-325, March 1975.

[Ban85] J. Bannur, A. Varma.The VLSI Implementation of a Square Root Algorithm. 7th IEEE Symposium on Computer Arithmetic, 1985.

[Bat03] F. Batista. Decimal Data Type. Disponible en http://www.python.org/dev/peps/pep-0327/, 2003.

[Bay07] A. Bayrakci and A. Akass. Dreduced delay BCD adder. IEEE International Conf. on Application- specific Systems, Architectures and Processors, pp. 266-271, 2007.

[Ben77] M. Bennedek. Developing Large Binary to BCD Conversion Structures. IEEE Transactions on Computers, Vol. C-26, #7, pp. 688-700, Jul. 1977.

[Bha04] J. Bhasker. A SystemC Primer (2nd

Edition). Star Galaxy Publishing, 2004.

[Bio09a] G. Bioul, M. Vázquez, J-P. Deschamps, G. Sutter. Decimal Addition in FPGA.V Southern Programmable Logic Conference, IEEE, pp 101-108, Abril 2009.

[Bio09b] G. Bioul, M. Vázquez, J-P. Deschamps, G. Sutter. FPGA Implementations of BCD

addition. XV Workshop Iberchip, ISBN (completo): 978-987-9486-10-8, pp. 1-6, Marzo 2009.

[Bio10] G. Bioul, M.Vázquez, J-P. Deschamps, G. Sutter. High Speed FPGA 10’s Complement

Adders-Substractor. International Journal of Reconfigurable Computing (IJCR). Volumen 2010, 14 páginas. ISSN: 1687-7195, doi: 10.1155/2010/219764, 2010.

[Bis08] A.K. Biswas, M.M. Hasan, M. Hasan, A.R. Chowdhury and H-M-H- Badu. A Novel

Approach to Design BCD Adder and Carry Skip BCD Adder. 21st International Conference on VLSI Design, pp. 566–571, Jan. 2008.

[Bla92] M. Blair, S. Obenski, and P. Bridickas, Patriot Missile Defense: Software

Problem Led to System Failure at Dhahran, Saudi Arabia, Tech. Rep. GAO/IMTEC-92-26, United States General Accounting, Washington, D.C. 20548, February 1992. Diponible en http://www.fas.org/spp/starwars/gao/im92026.htm.

[Bru13] A. Vázquez, J. Bruguera. Iterative Algorithm and Architecture for Exponential, Logarithm,

Powering, and Root Extraction. IEEE Transaction on Computers, vol. 62, no. 9, pp. 1721-1731, Sep. 2013

[Bus01] Fadi Y. Busaba, Christopher A. Krygowski, Wen H. Li, Eric M. Schwarz, and Steven R. Carlough. The IBM z900 Decimal Arithmetic Unit. Asilomar Conference on Signals, Systems and Computers, Vol.2, pp.1335–1339, 2001.

[Car11] D. De Caro, N. Petra, A. Strollo. Efficient Logarithmic Converters for Digital Signal

Processing Applications. IEEE Transactions on Circuits and Systems II, vol. 58, no. 10, May. 2011.

[Cor07] M. Cornea, C. Anderson, J. Harrison, P.T.P. Tang, E. Schneider, and C. Tsen. A Software

Implementation of the IEEE 754R Decimal Floating-Point Arithmetic Using the Binary

Encoding Format. Proceedings of the 18th IEEE Symposium on Computer Arithmetic, pp. 29–37, Jun. 2007.

135

[Cor99] P. Corsonello, S. Perri. High performance square rooting circuit using hybrid radix-2

adders. IET Journals & Magazines, Electronics Letters, Vol. 35, No. 3, 1999.

[Cow02] Michael F. Cowlishaw. Densely Packed Decimal Encoding. IEE Proceedings – Computers and Digital Techniques, Vol. 149, #3, pp. 102–104, 2002.

[Cow03] Michael F. Cowlishaw. Decimal Floating_Point_ Algorism for Computers. IEEE Proceedings of the 16th Symposium on Computer Arithmetic, pp. 104–111, IEEE, June 2003.

[Cow09] M. Cowlishaw. General Decimal Arithmetic Specification. Disponible en http://seleotrove.com/decimal/, versión 1.7, 2009.

[Cow10] M. Cowlishaw. The decNumber Library. Disponible en http://speleotrove.com/decimal/decnumber.html, versión 3.68, 2010.

[Cor07] M. Cornea and J. Crawford. IEEE 754R Decimal Floating-Point Arith-metic: Reliable and

Efficient Implementation on Intel ArchitecturePlatforms. World Wide Web, Intel Technology Journal, February 2007.http://www.intel.com/technology/itj/2007/v11i1/s2-decimal/1-sidebar.htm.

[Cri04] P. Crismer. Eiffel Decimal Arithmetic Library. Disponible en https://www.gobosoft.com/eiffel/gobo/math/decimal/index.html, 2004.

[Cur07] D. Currie. Lua decNumber Library. Disponible en http://luaforge.net/projects/ldecnumber/, versión 2.1, 2007.

[Cha13] M. Chaudhary and P. Lee. Two-stage logarithmic converter with reduced memory

requirements. IET Computers & Digital Techniques, pp. 23-29, Jun. 2013.

[Cha15] M. Chaudhary and P. Lee. An Improved Two-Step Binary Logarithmic Converter for

FPGAs. IEEE Transactions on Circuits and Systems II, vol. 62, no. 5, May. 2015.

[Che08] D. Chen, Y. Choi, Li Chen, D.Teng, K. Wahid and S-B. Ko. A Novel Decimal-to-Decimal

Logarithmic Converter. IEEE International Symposium on Circuits and Systems, pp.688-691,May. 2008.

[Che09] D. Chen, Y. Zhang, Y. Choi, M.H. Lee, S-B. Ko. A 32-bit Decimal Floating-Point

Logarithmic Converter. 19th IEEE Symposium on Computer Arithmetic, pp. 195-203, Jun. 2009.

[Che11] D. Chen. Algorithms and Architectures for Decimal Transcendental Function

Computation. Phd dissertation, Dep. of Electrical and Computer Engineering, University of Saskatchewan, Canada, 2011.

[Che12] D. Chen, L. Han, Y. Choi and S-B. Ko. Improved Decimal Floating-Point Logarithmic

Converter Based on Selection by Rounding. IEEE Transaction on Computers, vol. 61, no. 5, pp. 607-621, May. 2012.

[Dad07] L. Dadda. Multioperand Parallel Decimal Adder: A Mixed Binary and BCD Approach. IEEE Transactions on Computers, Vol. 56, #10, pp. 1320–1328, October 2007.

[Des06] J.P. Deschamps, G. Bioul and G. Sutter. Synthesis of Arithmetic Circuits, - ASIC, FPGA,

Embedded Systems, John Wiley & Sons, New-York, Feb. 2006.

[Des12] J-P. Deschamps, G. Sutter. Guide to FPGA Implementation of Arithmetic Functions. Springer, 2012.

136

[Det06] J. Detrey, F. Dinechin. Parameterized floating-point logarithm and exponential functions

for FPGAs. Microprocessors and Microsystems: Embedded Hardware Design (MICPRO), Elsevier, pp. 537-545, Feb. 2006.

[Dil16] Paul Dillien. And the Winner of Best FPGA of 2016 is... Disponible en www.eetimes.com/author.asp?doc_id=1331443 , 2016.

[Din05] F. Dinechin and A. Tisserand. Multipartite Table Methods. IEEE Transaction on Computers, vol. 54, no. 3, pp. 319-330, March 2005.

[Din10a] A. Vazquez, F. de Dinechin. Multi-operand decimal tree adders for FPGAs. INRIA, Reseach Report, Sep. 2010.

[Din10b] A. Vazquez, F. de Dinechin. Efficient Implementation of Paralell BCD multiplication in

LUT-6 FPGAs. International Conference on Field-Programmable Technology (FPT), IEEE, pp 126-133, 2010.

[Din10c] F. Dinechin, M. Joldes, B. Pasca, G. Revy. Multiplicative square root algorithms for

FPGAs. International Conference on Field Programmable Logic and Applications, 2010.

[Dor14] M. Dorrigiv, G. Jaberipur. Low area/power decimal addition with carry-select correction

and carry-select sum-digits. Integration, theVLSI Journal, 47(4), pp. 443-451, Sep. 2014.

[Dua07] A. Y. Duale, M. H. Decker, H.Zipperer, M. Aharoni and T. Bohizic. Decimal Floating-

Point in Z9: An Implementationand Testing Perspective. IBM Journal of Research and Development, Vol.51, pp. 217-228, Jan. 2007.

[Erc03] M. Ercegovac, J-M. Muller. Digit-Recurrence Algorithms for Division and Square Root

with Limited Precision Primitives. 37th Asilomar Conference on Signals, Systems & Computers, IEEE, 2003.

[Erc09] M. Ercegovac, J-M. Muller. Design and FPGAs Implementation of Radix-10 Algorithm for

Square Root with Limited Precision Primitives. 43th Asilomar Conference on Signals, Systems & Computers, IEEE, 2009.

[Erc10] M. Ercegovac, J-M. Muller. Design and FPGAs Implementation of Radix-10 Combined

Division/Square Root Algorithm with Limited Precision Primitives. 44th Asilomar Conference on Signals, Systems & Computers, IEEE, 2010.

[Erc12] M. Ercegovac, J-M. Muller. Design and FPGAs Implementation of Radix-10 and Radix-16

Algorithm for Square Root with Limited Precision Primitives. 46th Asilomar Conference on Signals, Systems & Computers, IEEE, 2012.

[Eis07] L. Eisen, J.W.W. III, H-W. Tast, N. Mding, J. Leenstra, S. Mueller, C. Jacobi, J. Preiss, E. Schwarz and S. Carlough. IBM POWER6 Accelerators: VMX and DFU. IBM Journal of Research and Development, Vol. 51, pp. 663-684, Nov. 2007.

[Erl02] Mark A Erle, Michael J Schulte, and J G Linebarger. Potential Speedup with Decimal

Floating-Point Hardware. Conference Record of the Thirty Sixth Asilomar Conference on Signals, Systems and Computers, pp. 1073–1077, 2002.

[Erl09] M. A. Erle. Algorithms and Hardware Designs for Decimal Multiplication. Phd. dissertation, Dep. Electrical and Computer Eng, Lehigh University, 2009.

[Fan87] J. Fandriano. Algorithm for High Speed shared radix 4 division and radix 4 square-root. 8th IEEE Symposium on Computer Arithmetic, 1987.

[Fan89] J. Fandriano. Algorithm for High Speed shared radix 8 division and radix 8 square-root. 9th IEEE Symposium on Computer Arithmetic, 1987.

137

[Far09] A. Farmahini-Farahani, C. Tsen and K. Compton. FPGA Implementation of a 64-Bit BID-

based decimal floating-point adder/substractor. Inetrnational Conference on Field-Programmable Technology, pp. 518-521, Dec. 2009.

[Fla05] D. Flannery. The Square Root of Two. Springer Verlag, 2005.

[Flo91] L. P. Flora. Fast BCD/Binary Adder. U.S. Patent, April 1991. #5,007,010

[Fre03] M. Frerking. Digital Signal Processing Communications Systems. 9th Edition, Kluwer publisher, 2003.

[FSF08] Free SoftwareFoundation. CNU C Compliler (GCC) 4.2 release. Disponible en http://gcc.gnu.org/gcc-4.2, 2008.

[FSF17] Free SoftwareFoundation. CNU C Compliler (GCC) 4.3 release. Disponible en https://gcc.gnu.org/, 2017. https://gcc.gnu.org/

[Gao12] L. Gao, M. Zhu, J. He and W. Xiong. High Efficient Logarithm Convertor for Graphics

Physics Simulation. International Conference on Audio, Language and Image Processing (ICALIP), pp. 397-402, July 2012.

[Gau16] M. Gautschi, M. Schaffner, F. Gürkaynak, L. Benini. A 65nm CMOS 6.4-to-

29.2pJ/FLOP@0.8V Shared Logarithmic Floating Point Unit for Acceleration of

Nonlinear Function Kernerls in a Tightly Coupled Processor Cluster. IEEE International Solid-State Circuits Conference (ISSCC), pp. 82-83, Feb. 2016.

[Gok05] M. Gokhale, P. Graham. Reconfigurable Computing: Acceleration Computation with

Field-Programmable Gate Arrays. Springer, 2005.

[Gol96] H. Goldstine and A. Goldstine.The Electronic Numerical Integrator and Computer

(ENIAC). IEEE Annals of the History of Computing, Vol. 18, #1, pp. 10-16, 1996.

[Gon13] S. Gonzalez-Navarro, C. Tsen, M. Schulte. Binary integer decimal-based floating-point

multiplication. IEEE Transaction on Computing, 62(7), pp. 1460-1466, 2013.

[Gor09] S. Gorgin, G. Jaberipur. . Microelectronics Journal, 40(10), pp. 1471-1481, Oct. 2009.

[Gut10] R. Gutierrez, V. Torrez, J Valls. FPGA-implementation of atan(Y/X) based on logarithmic transformation and LUT-based techniques. Journal of Systems Architecture, Elsevier, vol. 56, no. 11, pp. 588-596, Ago. 2010.

[Gut11] R. Gutierrez and J. Valls. Low Cost Hardware Implementation of Logarithm

Approximation. IEEE Transaction on Very Large Scale Integration (VLSI) Systems, vol. 19, no. 12, pp. 2326-2330, Dec. 2009.

[Han11] L. Han, D. Chen, K. Wahid, S.-B. Ko. Nonspeculative decimal signed digit adder. IEEE International Symposium on Circuits and Systems (ISCAS), pp. 1053-1056, 2011.

[Han13] L. Han, S.-B. Ko. High-Speed Parallel Decimal Multiplication with Redundant Internal

Encodings. IEEE Transaction on Computers, 62(5), pp. 956-968, 2013.

[Hea21] T. Heath. A History of Greek Mathematics. Clarendon Press, Oxford, Vol. 2, 1921.

[Hea01] R. Head.Univac: a Philadelphia Story. IEEE Annals of the History of Computing, Vol. 23, #3, pp. 60-63, 2001.

138

[IBM03] M. Cowlishaw. Decimal Arithmetic for java.math JSR 13 Publix Review Draft. Disponible en http://speleotrove.com/decimal/decimalj/decimalj.html, 2003.

[IBM07a] IBM. IBM Enterprice PL/I V3.7. Disponible en http://www-01.ibm.com/common/ssi/rep_ca/6/897/ENUS207-266/index.html. Accedido en Octubre, 2007.

[IBM07b] IBM. IBM DB2 V9.5. Disponible en http://www-01.ibm.com/common/ssi/rep_ca/1/897/ENUS207-261/index.html. Accedido en junio, 2007.

[IBM07c] IBM. The DFPAL Library. Disponible en http://speleotrove.com/decimal/dfpal/index.html, 2007.

[IBM08] IBM. ESA/390 Principles of Operation. Disponible en http://publibfp.dhe.ibm.com/cgi-bin/bookmgr/BOOKS/dz9ar008/CCONTENTS, 2008.

[IBM15] IBM. IBM High Level Assembler (HLASM) and Toolkit Feature. Disponible en https://www-01.ibm.com/software/awdtools/hlasm/library.html, 2015.

[IBM17] IBM. IBM C and C++ Compilers. Disponible en http://www-01.ibm.com/software/awdtools/xlcpp/, 2017.

[IEEE85] Floating-Point Working Group. ANSI/IEEE Std 754-1985: IEEE Standard for Binary

Floating-Point Arithmetic. New York: The Institute of Electrical and Electronics Engineers, 1985.

[IEEE87] Floating-Point Working Group. ANSI/IEEE Std 854-1987: IEEE Standard for Radix-

Independent Floating-Point Arithmetic. New York: The Institute of Electrical and Electronics Engineers, 1987.

[IEEE08] IEEE Working Group of the Microprocessor Standards Subcommittee. IEEE Standard for

Floating-Point Arithmetic. New York: The Institute of Electrical and Electronics Engineers, 2008.

[Ifr00] G. Ifrah. A Universal History of Computing: From Prehistory to Computers. New York, John Wiley and Sons, Inc., 2000.

[Igu07] Y. Iguchi, T. Sasao, and M. Matsuura. On Designs of Radix Converters using Arithmetic

Decompositions – Binary to Decimal Converters-. 37th International Symposium on Multiple-Valued Logic, pp. 32, May 2007.

[Int01a] Intel. IA-32 Intel Architecture Software Developer’s Manual, Vol. 2: Instruction Set

Reference. Intel, 2001.

[Int01b] Intel-Altera. Excalibur ARM-based: Hardware Design Tutorial . Disponible en www.altera.com, 2001.

[Int15] Intel-Altera. ArriaV Hard Processor System Technical Reference Manual. Disponible en www.altera.com, 2015.

[Int17a] Intel-Altera. Intel FPGA and SOC. Solutions. Disponible en www.altera.com/solutions.html , 2017.

[Int17b] Intel-Altera. Intel FPGA Portfolio. Disponible en www.altera.com/products/intellectual-property/overview.html, 2017.

[Int17c] Intel-Altera. Intel Quartus Prime Standard Edition HandBook Volume 1,2. Disponible en www.altera.com, 2017.

139

[Int17d] Intel-Altera. Quick-Start for Intel Quartus Prime Pro Edition Software. Disponible en www.altera.com, 2017.

[ISO92] ISO/IEC JTC 1/SC 32. ISO/IEC 9075:1992: Information Technology – Database

Languages - SQL. Switzarland: International Organization for Standarization (ISO), Junio 1992.

[ISO01] ISO/IEC JTC 1/SC 22/WG 9. ISO/IEC 8652:1995: Ada Reference Manual: Language and

Standasrd Libraries. Switzarland: International Organization for Standarization, Jun. 2001.

[ISO03] JTC 1(ECMA TC 39/TG 2). ISO/IEC 23270: Information Tchnology - C# Language

Specification. Switzarland: International Organization for Standarization, primera edición. Apr. 2003.

[ISO15] ISO/IEC JTC 1/SC 22/WG 14. TR 24732: Extensions for the Programming Language C to

Sopport Decimal Folating Point Artihmetic. Disponible en http://www.open-std.org/Jtc1/sc22/wg14/www/docs/, 2015.

[ISO17] ISO/IEC JTC 1/SC 22/WG 21. TR 24733: C++ Decimal Folating Point Artihmetic

Extensions. Disponible en http://www.open-std.org/jtc1/sc22/wg21/docs/papers/, 2017.

[Jam09] R. James, K. Jacob and S. Sasi. Performance analysis of double digit decimal multiplier on

various FPGA logic families. 5th Southern Conference on Programmable Logic, pp. 165-170, April 2009.

[Jua12] T.-B. Juang, H.-H. Peng, H.-L. Kuo. Parallel and digit-serial implementations of area-

efficient 3-operand decimal adders. International SoC Design Conference, IEEE, 2013.

[Jun14] k. Jun, E. Swartzlander. Improved Non-restoring Square Root Algorithm with Dual Path

Calculation. 48th Asilomar Conference on Signals, Systems & Computers, IEEE, 2014.

[Kab94] H. Kabuo, T. Taniguchi, A. Miyoshi, H. Yamashita, M.Urano, H. Edamatsu, S. Kuninobu. Accurate Rounding Scheme for the Newton-Raphson Method Using Redundant Binary

Representation. IEEE Transaction on Computer, Vol. 43, No. 1, pp. 43-51, 1994.

[Kai70] M. V. Kailas. Another method of converting from hexadecimal to decimal. Communications of the ACM, Vol. 1, #3, pp. 193, ACM Press, Mar. 1970.

[Kan65] Herbert Kanner. Number Base Conversion in a Significant Digit Arithmetic. Journal of the ACM, Vol. 12, #2, pp. 242–246, ACM Press, April 1965.

[Kan96] G. Kane. PA-RISC 2.0 Architecture, ch. 7: Instruction Descriptions. Prentice Hall, 1996.

[Kap15] P. Kapgate and S. Gugulothu. Design and Implementation of Complex Operations using

Binary Logarithmic Number System. IEEE International Conference on Communications and Signal Processing (ICCSP), pp. 1374-1377, Apr. 2015.

[Ken04] R. Kenney and M. Schulte. Multioperand Decimal Addition. Proceedings of the IEEE Computer Society Annual Symposium on VLSI, pp. 251-253, Feb. 2004.

[Ken05] R. Kenney and M. Schulte. High-speed multioperand decimal adders. IEEE Transactions on Computers, Vol. 54 #8, pp. 953–963, August 2005.

[Kha13] K.M.N.H. Khan, Md. L. Ali, S. Islam. A New Technique for High Speed Decimal

Logarithm Computation of Decimal Floating-Point Number. Proceeding 14th International Conference on Computer and Information Technology (ICCIT 2011), Bangladesh, pp. 22-24, Dec. 2011.

140

[Kil07] S. Kilts. Advanced FPGA Design. Arquitecture, Implementation and Optimization. John Wiley & Sons, Inc., 2007.

[Knu86] D. Knuth. The IBM 650: An Apprecition from the Field. IEEE Annals of the History of Computing, Vol. 8, #1, pp. 50-55, 1986.

[Kog73] P.M. Kogge, H.S. Stone. A Parallel Algorithm for the Efficient Solution of a General Class

of Recurrence Equations. IEEE Trans. Computers, vol. C-22, no. 8, pp. 786-796, August 1973.

[Kos91] D. Koustopoulos. An Algorithm for the Computation of Binary Logarithms. IEEE Transaction on Computers, vol. 40, no. 11, pp. 1267-1270, Nov. 1991.

[Kos09] O. Kosheleva. Babylonian Method of Computing the Square Root: Justifications Based on

Fuzzy Techniques and on Computational Complexity. 28th North American Fuzzy Information Processing Society Annual Conference, IEEE, 2009.

[Kou13] I. Kouretas, Ch. Basetas and V. Paliouras. Low-Power Logarithmic Number System

Addition/Subtraction and Their Impact on Digital Filters. IEEE Transaction on Computers, vol. 62, no. 11, pp. 2196-2208, Nov. 2013.

[Kwo08] T-J. Kwon, J. Sondeen, J. Draper. Floating-Point Division and Square Root

Implementation using a Taylor-Series Expansion Algorithm. 15th IEEE International Conference on Electronics, Circuits and Systems, 2008.

[Lac08] S. Lachowicz, H-J. Pfleidewrer. Fast Evaluation of the Square Root and other Nonlinear

Functions in FPGA. 4th IEEE International Symposium on Electronic Design, Test & Applications, 2008.

[Lan95] T. Lang, P. Montuschi. Very-High Radix Combined Division and Square Root with

Prescaling and Selection by Rounding. Proceedings of the 12th Symposium on Computer Arithmetic, IEEE, 1995.

[Lan99] T. Lang, P. Montuschi. Very-High Radix Root with Prescaling and Rounding and a

Combined Division/Square Root Unit. IEEE Transactions on Computers, Vol. 48, No. 8, 1999.

[Li96] Y. Li, W. Chu. A New Non-Restoring Square Root Algorithm and Its VLSI

Implementations. Proceedings International Conference on Computer Design, VLSI Computers and Processors, IEEE, 1996.

[Li97a] Y. Li, W. Chu. Implementation of Single Precision Floating Point Square Root on FPGAs. 5th Symposium on Field-Programmable Custom Computing Machines, 1997.

[Li97b] Y. Li, W. Chu. Parallel Array Implementations of a Non-Restoring Square Root on

Algorithm. Proceedings International Conference on Computer Design VLSI in Computers and Processors, IEEE, 1997.

[Lih15] J. Yung Lih Low and Ch. Jong. Unified Mitchell-Based Approximation for Efficient

Logarithmic Conversion Circuit. IEEE Transaction on Computing, vol. 64, no. 6, pp. 1783-1797, June 2015.

[Liu16] Ch-W. Liu, Sh-H. Ou, K-Ch. Chang, T-Ch. Lin and S-K. Chen. A Low-Error, Cost-

Efficient Design Procedure for Evaluating Logarithms to Be Used in a Logarithmic

Arithmetic Processor. IEEE Transaction on Computers, vol. 65, no. 4, pp. 1158-1164, April 2016.

[Max04] Clive Maxfield. The Design Warrior’s Guide to FPGAs. Mentor Graphics and Xilinx, 2004.

141

[McQ93] S. McQuillan, J. McCanny, R. Hamill. New Algorithms and VLSI Architectures for SRT

Division and Square Root. Proceedings of IEEE 11th Symposium on Computer Arithmetic,1993.

[Mic11] Microsoft. Visual Basic. Disponible en http://msdn.microsoft.com/en-us/vbasic/default.aspx, versión 9.0. Accedido en junio, 2011.

[Mit62] John Mitchell. Computer Multiplication and Division Using Binary Logarithms. IRE Transaction on Electronic Computers, pp. 512-517, Ago. 1962.

[Mon03] P. Montuschi, L. Ciminiera. Reducing Iteration Time When Result Digit is Zero for Radix

2 SRT Division and Square Root with Redundant Remeinders. IEEE Transactions on Computers, 1993.

[Mor65] Moore GE. Cramming More Component onto Integrated Circuits. Electronics, pp 114-117, Abril, 1965.

[Mos07] J. Moskal, E. Oruklu, and J. Saniie. Design and Synthesis of a Carry-Free Signed-Digit

Decimal Adder. IEEE International Symposium on Circuits and Systems , pp. 1089–1092, May 2007.

[Mot92] Motorola. Motorola M6800 Family Programmers Reference Manual. Motorola,1992

[Nad08] F. Naderpour and A. Vafael. The Design of Reversible BCD Digit Adders: Decreasing the

Depth of Circuit. International Symposium on Communications and Information Technologies, pp. 310–314, Oct. 2008.

[Nat17] National Instruments. Introducción a la Tecnología FPGA: Los cinco beneficios

priincipales. Disponible en www.ni.com/white-paper/6984/es/ , 2017.

[New96] B. New, K. Pierce. Circuit for Fast Carry and Logic. U.S. Patent, Jan. 1996. 5,481,206.

[Nic71] J. D. Nicoud. Iterative Arrays for Radix Conversion. IEEE Transactions Computers, Vol. 20, #8, pp. 1479–1489, Dec. 1971.

[Pal03] Samir Palnitkar. Verilog HDL (2nd

. Edition). Sun Microsystems, Inc, 2003.

[Par00] B. Parhami. Computer Arithmetic. Algorithms and Hardware Designs. Oxford University Press, 2000.

[Par00] Behrooz Parhami. Computer Arithmetic: Algorithms and Hardware Designs. Oxford University Press, Inc., 2000.

[Pau09] S. Paul, N. Jayakumar and S. Khatri. A Fast Approach for Approximate, Efficient

Logarithm and Antilogarithm Computations. IEEE Transaction on Very Large Scale Integration (VLSI) Systems, vol. 17, no. 2, pp. 269-277, Feb. 2009.

[Pin02a] J-A Piñero, M.D. Ercegovac, J.D. Bruguera. High-Radix with Selection by Rounding. IEEE International Conference on Application-Specific Systems, Architectures, and Processors (ASAP), pp. 101-110, July 2002.

[Pin02b] J-A Piñero, M.D. Ercegovac, J.D. Bruguera. Analysis of the Tradeoffs for the

Implementation of a High-Radix Logarithm. IEEE International Conference on Computer Design: VLSI in Computers and Processors (ICCD), pp. 132-137, Sept. 2002.

[Piñ02c] J-A. Piñeiro, J. Bruguera. High-Speed Double-Precision Computation of Reciprocal,

Division, Square Root, and Inverse Square Root. IEEE Transactions on Computers, Vol. 51, No. 12, 2002.

142

[Pin04] J-A Piñero, M.D. Ercegovac, J.D. Bruguera. Algorithm and Architecture for Logarithm,

Exponential, and Powering Computation. IEEE Transaction on Computers, vol. 53, no. 9, pp. 1085-1096, Sep. 2004.

[Rah14] A. Rahman, Abdullah-Al-Kafi. New Efficient Hardware Design Methodology for Modified

Non-Restoring Square Root Algorithm .International Conference on Informatics, Electronics & Vision, IEEE, 2014.

[Ram72] C. Ramamoorthy, J. Goodman, K.H. Kim. Some Properties of Iterative Square-Rooting

Methods Using High-Speed Multiplication. IEEE Transactions on Computers, Vol. c-21, No. 8, 1972.

[Rap02] T. S. Rappapport. Wireless Communications Principles and Practice. Second Edition, Prentice Hall Communication, 2002.

[Reb09a] J. Rebacz, E. Oruklu, J. Saniie. Performance evaluation of multi-operand fast decimal

adders. 52nd IEEE International Midwest Symposium on Circuits and Systems, pp. 535–538, Aug. 2009.

[Reb09b] J. Rebacz, E. Oruklu, J. Saniie. High performance signed-digit decimal adders. IEEE International Conference on Electro/Information Technology, pp. 251–255, June 2009.

[Rich55] R. K. Richards. Arithmetic Operations in Digital Computers. New Jersey: D. Van Nostrand Company, Inc., 1955.

[Saj12] I. Sajid, M. Ahmed, S. Ziavras. Novel Pipelined Architecture for Efficient Evaluation of

the Square Root Using a Modified Non-Restoring Algorithm. Journal of System Processing System, Vol. 67, No 2, 2012.

[Sas05] T. Sasao. Radix Converters: Complexity and Implementation by LUT Cascades. 35th International Symposium on Multiple-Valued Logic, pp. 256–263, May 2005.

[Sch68] M. S. Schmookler. High Speed Binary to Decimal Conversion. IEEE Transactions on Computers, Vol. C-17, #5, pp. 506–508, 1968.

[Sch71] M. Schmookler and A. Weinberger. High speed decimal addition. IEEE Transactions on Computers, Vol. C-20 #8, pp. 862–867, August 1971.

[Sch99] M. Schulte, J. Stine. Approximating Elementary Functions with Symmetric Bipartite

Tables. IEEE Transaction on Computers, vol. 48, no. 8, pp. 842-847, Aug. 1999.

[Sch09] E. Schwarz, J.S. Kapernick, and M. Cowlishaw. Decimal Floating Point Support on the

IBM System z10 Processor. IBM Journal of Research and Development, Vol. 53, # 1/2, pp. 663-684, Nov. 2009.

[Shi88] B. Shirazi, D. Yun, and Ch. Zhang. VLSI designs for redundant binary-coded decimal

addition. IEEE Seventh Annual International Phoenix Conference on Computers and Communications, pp. 52–56, Mar. 1988.

[Shi89] B. Shirazi, D. Yun, and J. Zhang. RBCD:redundant binary coded decimal adder. IEE Proceedings in Computers and Digital Techniqques, vol. 136, #2, pp. 156-160, Mar. 1989

[Sim15] P.A. Simpson. FPGA Design. Best Prctices for Team-Based Reuse. Second Edition. Springer, Switzerland, 2015

[Skl01] B. Sklar. Digital Communications Fundamentals and Applications. Second Edition, Person Education, 2001.

143

[Sto01] T. Stouraitis and V. Palioras. Considering the alternatives in low power Design. IEEE Circuits Dev. Mag., vol. 17, no. 4, pp. 22-29, Jul. 2001.

[Sun17] Sun Microsystems. BigDecimal Java Class. Disponible en https://docs.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html. Accedido en junio, 2017.

[Sur13] S. Suresh, S. Beldianu, S. Ziavras. FPGA and ASIC Square Root Designs for High

Performance and Power Efficiency. IEEE 24th International Conference on Application-Specific Systems, Architectures and Processors, 2013.

[Sut09] G. Sutter, E. Todorovich, G. Bioul, M. Vázquez, J-P. Deschamps. FPGA Implementations

of BCD Multipliers. IX International Conference on Reconfigurable Computing and FPGAs, IEEE, pp. 36-41, Dic. 2009.

[Svo69] A. Sovoba. Decimal adder with signed digit arithmetic. IEEE Transactions on Computrers, vol. C-18, #3, pp. 212-215, Mar. 1969.

[Tak06] N. Takagi, K. Takagi. A VLSI Algorithm for Integer Square-Rooting. International Symposium on Intelligent Signal Processing and Communications, IEEE, 2006.

[Taj09] R. Tajallipour, K. Wahid. Error-free algorithm and architecture of radix-10 logarithmic

converter. Computers and Electrical Engineering, pp. 1066-1074, 2010

[Tha06a] H. Thapliyal, S. Kotiyal, and M. B. Srinivas. Novel BCD Adders and Their Reversible

Logic Implementation for IEEE 754r Format. Proceeding of the 19th International Conference on VLSI Design, pp. 387–392, 2006.

[Tha06b] H. Thapliyal and S. Gupta. Design of Novel Reversible Carry Look-Ahead BCD

Subtractor. Proceedings of the 9th International Conference on Information Technology, pp. 253–258, December 2006.

[Tha06c] H. Thapliyal and H. Arabnia. Modified Carry Look Ahead BCD Adder With CMOS and

Reversible Logic Implementation. Proceedings of the 2006 International Conference on Computer Design, pp. 64–69, Nov. 2006.

[Tha06d] A. Thakkar, A. Ejnioui. Design and Implementation of Double Precision Floating Point

Division and Square Root on FPGA. IEEE Aerospace Conference, 2006.

[Tho04] J. Thompson, N. Karra, and Michael J Schulte. A 64-bit Decimal Floating-Point Adder. Proceedings of the IEEE Computer Society Annual Symposium on VLSI, pp. 297–298, February 2004.

[Tse09] C.Tsen, Decimal Floating-Point Platform Support with the Binary-Integer Decimal

Encoding,” PhD dissertation, Univ. of Wisconsin, May 2009.

[Tse11] S. Tsen, S. Gonza´lez-Navarro, M.J. Schulte, and K. Compton. Hardware Designs for

Binary Integer Decimal-based Rounding. IEEE Trans. Computers, vol. 60, no. 5, pp. 614-627, May 2011.

[Tro07] S. Tropea. FPGA Implementation of Base-N Logarithm. 3rr Southern Conference on Programmable Logic (SPL), pp. 27-32, Feb. 2007

[Vaz09a] A.Vázquez. High Performance Decimal Floating-Point Units. Phd. dissertation, Universidad de Santiago de Compostela, 2009.

[Vaz09b] M. Vázquez, G. Sutter, G. Bioul, J-P. Deschamps. Decimal Adders/ Substractors in FPGA:

Efficient 6-input LUT Implementations. IX International Conference on Reconfigurable Computing and FPGAs, IEEE, pp. 42-47, Dic. 2009.

144

[Vaz11] Martín Vázquez. Tesis de Maestría de carrera Maestría en Ingeniería de Sistemas, Universidad Nacional del Centro de la Provincia de Buenos Aires, 2011.

[Vaz14] M. Vázquez, M.Tosini. Design and Implementation of Decimal Fixed-Point Square Root

in LUT-6 FPGAs. IX Southern Programmable Logic Conference (SPL), ISBN: 978-1-4799-6846-6. pp 1-6, 2014.

[Vaz15] M. Vázquez, E. Todorovich. FPGA-Specific Decimal Sign-magnitud Addition and

Subtraction. International Journal and Electronics (Taylor and Francis), 103/7, pp: 1166-1185, Oct 2015, ISSN: 0020-7217, Índice de Impacto: JCR 2014=0.459, JCR 2015= 0.414, Digital Object Indentifier: 10.1080/00207217.2015.1089945.

[Vee07] S. Veeramachaneni, M. Krishna, L. Avinash, S. Reddy P, and M Srinivas. Novel, High-

Speed 16-Digit BCD Adders Conforming to IEEE 754r Format. IEEE Computer Society Annual Symposium on VLSI, pp. 343–350, May. 2007.

[Vij12] K. Vijeyakumar, V. Sumathy, P. Vasakipriya, A. Dinesh Babu. FPGA Implementation of

Low Power High Speed Square Root Circuits. IEEE International Conference on Computational Intelligent and Computing Research, 2006.

[Wan03] X. Wang, B. Nelson. Tradeoffs of Designing Floating-Point Division and Square Root on

Virtex FPGAs. 11th IEEE Symposium on Field-Programmable Custom Computing Machines, 2003.

[Wan05] L-K. Wang, M. Schulte. Decimal Floating-Point Square Root Using Newton-Raphson

Iteration. IEEE International Conference on Application-Specific Systems, Architecture Processors, 2005.

[Wan07] L-K. Wang , M. J. Schulte. Decimal Floating-Point Adder and Multifunction Unit with

Injection-Based Rounding. Proceedings of the 18th IEEE Symposium on Computer Arithmetic, pp. 56–65, June 2007.

[Wan09a] L-K. Wang and M. Schulte. A Decimal Floating-Point Adder with Decoder Operands and

a Decimal Leading-Zero Anticipator.19th IEEE Symposium on Computer Arithmetic, pp.125–134, June 2009.

[Wan09b] L-K. Wang, M. Schulte, J. Thompson and N. Jairam. Hardware Designs for Decimal

Floating-Point Addition and Related Operations. IEEE Transactions on Computer, pp. 322–335, Mar. 2009.

[Wan13] Sh. Wang, Y. Shang, H. Ding, Ch. Wang and J. Hu. An FPGA Implementation of the

Natural Logarithm Based on CORDIC Algorithm. Research Journal of Applied Sciences, Engineering and Technology, pp. 119-122, 2013

[Xil00] Xilinx. Designs Tips for HDL Implementation of Arithmetic Functions. Disponible en www.xilinx.com, 2000.

[Xil04] Xilinx. Optimal Pipelining of I/O Ports of the Virtex-II Multiplier. Disponible en www.xilinx.com, 2004.

[Xil05a] Xilinx. Virtex-II Platform FPGAs: Complete Data Sheet. Disponible en www.xilinx.com, 2005.

[Xil05b] Xilinx. Spartan-3 FPGA Family : Complete Data Sheet. Disponible en www.xilinx.com, 2005.

[Xil05c] Xilinx. Virtex-4 Family Overview. Disponible en www.xilinx.com, 2005.

145

[Xil05d] Xilinx. Virtex-II Pro and Virtex-II Pro X Platform FPGAs: Complete Data Sheet. Disponible en www.xilinx.com, 2005.

[Xil06] Xilinx. Switching Power Supplies for Virtex-4 RocketIO MGTs. Disponible en www.xilinx.com, 2006.

[Xil08] Xilinx. XtremeDSP for Virtex-4 FPGAs - User Guide. Disponible en www.xilinx.com, 2008.

[Xil09] Xilinx. Virtex-5 FPGA Integrated Endpoint Block for PCI Express. Disponible en www.xilinx.com, 2009.

[Xil10a] Xilinx. PowerPC 405 Processor Block Reference Gude. Disponible en www.xilinx.com, 2010.

[Xil10b] Xilinx. Virtex 4 Family Overview. Disponible en www.xilinx.com, 2010.

[Xil11] Xilinx. Spartan-6 Family Overview. Disponible en www.xilinx.com, 2011.

[Xil13a] Xilinx. XST User Guide for Virtex-6, Spartan-6 and 7 Series Devices. Disponible en www.xilinx.com, 2013.

[Xil13b] Xilinx. ISE Design Suite 14: Release Notes, Installation and Licensing. Disponible en www.xilinx.com, 2013.

[Xil14] Xilinx. Implementation SMPTE SDI Interface with Virtex-7 GTH Transceivers. Disponible en www.xilinx.com, 2014.

[Xil15a] Xilinx. Virtex-5 Family Overview. Disponible en www.xilinx.com, 2015.

[Xil15b] Xilinx. Virtex-6 Family Overview. Disponible en www.xilinx.com, 2015.

[Xil16a] Xilinx. 7 Series FPGAs Memory Recourses. User Guide. Disponible en www.xilinx.com, 2016.

[Xil16b] Xilinx. Series FPGAs Memory Recourses. User Guide. Disponible en www.xilinx.com, 2016.

[Xil16c] Xilinx. 7 Series FPGAs and Zynq-7000 All Programmable SoC XADC Dual 12-bit 1

MSPS Analog-to-Digital Converter. User Guide. Disponible en www.xilinx.com, 2016.

[Xil16d] Xilinx. 7 Series FPGAs Configuration. User Guides. Disponible en www.xilinx.com, 2016.

[Xil17a] Xilinx. UltraScale Architecture DSP slice. User Guide. Disponible en www.xilinx.com, 2017.

[Xil17b] Xilinx. Zynq UltraScale + Device. Technical Reference Manual. Disponible en www.xilinx.com, 2017.

[Xil17c] Xilinx. Aplications. Industry Megatrends. Disponible en www.xilinx.com/applications/megatrends.html, 2017.

[Xil17d] Xilinx. 7 Series FPGAs Data Sheet: Overview. Disponible en www.xilinx.com, 2017.

[Xil17e] Xilinx. Zynq-7000 All Programmable SoC First Generation Architecture. Disponible en www.xilinx.com, 2017.

146

[Xil17f] Xilinx. 7 Series FPGA Clocking Resources: User Guide. Disponible en www.xilinx.com, 2017.

[Xil17g] Xilinx. Xilinx CORE Generator System. Disponible en www.xilinx.com/products/design-tools/coregen.html, 2017.

[Xil17h] Xilinx. Vivado Design Suite User Guide. Release Notes, Installation and Licensing. Disponible en www.xilinx.com, 2017.

[Xil17i] Xilinx. Xilinx SDx Development Environment. Release Notes, Installation and Licensing

Guides. Disponible en www.xilinx.com, 2017.

[Wen10] D. Wendel, R. Kallar, R. Cargoni, J. Clables, J. Friedrich, R. Frech, J. Kahle, B. Sinharoy, W. Starke, S. Taylor, S. Weitzel, S. G. Chu, S. Islam, V. Zyuban. The Implementation of

Power 7: Highly Parallel and Scalable Multi-Core High-End Server Processor. IEEE International Solid-State Circuits Conference Digest of Technical Reports, pp. 102-104, 2010.

[Wil07] Peter Wilson. Design Recipes for FPGAs. Elsevier, 2007.

[Yan12] B. Yang, D. Wang, L. Liu. Complex Division and Square Root Using CORDIC. 2nd International Conference on Consumer Electronics, Communications and Networks, IEEE, 2012.

[Yeh10] K. Yehia, H. Fahmy, M. Hassan. A redundant decimal floating-point adder. 44th. Asilomar Conference on Signals, Systems and Computers. IEEE, pp. 1144-1147, 2010

[Yix10] G. Yixiong, D. Yu, L. and Yang Jun. A Research and Design of Decimal Floating

Multiplier Based on FPGA. Third International Conference on Knowledge Discovery and Data Mining, pp. 314-319, Jan. 2010

[You06] Y. You, Y. Kim, and J. Choi. Dynamic decimal adder circuit design by using the carry

look ahead. IEEE Workshop on Design and Diagnostics of Electronic Circuits and Systems, pp. 242-244, April 2006.

[Zho14] R-G. Zhou, -Y-C. Li, M-Q. Zhang. Novel designs for fault tolerant reversible binary coded

decimal adders. International Journal of Electronics, 101(10), pp. 1-21, Dic. 2014.

[Zhu16] M. Zhu, Ch. Gu and L. Gao. An Optimized Logarithmic Converter with Equal Distribution

of Relative Error. IEEE Transaction on Circuits and Systems II, vol. 63, no. 9, pp. 848-852, 2016.