UNIVERSIDAD PRIVADA “ANTENOR ORREGO”
FACULTAD DE INGENIERIA “PROCESAMIENTO “PROCESAMIENTO DIGITAL DE SEÑALES IMPLEMENTANDO HPRC”
TESIS PARA OPTAR OPTAR EL TITULO PROFESIONAL DE INGENIERO ELECTRÓNICO
TESISTAS: - BR. JORGE LUIS GONZÁLEZ REAÑO - BR. NELSON ENRIQUE YALTA SOPLIN ASESOR: - ING. KALUN JOSÉ LAU GAN TRUJILLO – TRUJILLO – PERU PERU 2009
TÍTULO: “PROCESAMIENTO PROCESAMIENTO DIGITAL DE SEÑALES IMPLEMENTANDO HPRC” AUTORES: Br. Jorge Luis González Reaño Br. Nelson Enrique Yalta Soplin APROBADO POR:
Ing. Oscar Morales Gonzaga PRESIDENTE
Ing. Marco Trujillo Silva SECRETARIO
Ing. Luis Gutiérrez Magan VOCAL
Ing. Kalun José Lau Gan ASESOR
III
DEDICATORIA
A Manuela y Alfonso. Jorge
Dedicado a un grupo de amigos importantes guiados por Carlos y Lissetti, que cambiaron mi vida, y que
pueden
generar
grandes
cambios en el Futuro. A mis Padres que me dan la fuerza y el apoyo. Y a una chavita muy especial por su amistad. Nelson
IV
AGRADECIMIENTOS
Agradezco a mis padres, a mi mamá Mila, a mi tía Pelu, Lore y Chris por caminar siempre conmigo; a todos mis familiares y amigos por el apoyo apoyo y las risas. Jorge
Agradecer a mi Abuelita Delicia D elicia por su apoyo incondicional en todo este tiempo, a mi familia, mis tíos, primos
y
acompañan
abuelitas y
que
siempre
me me
aconsejan. Nelson
V
INDICE GENERAL
1.
......................................................... ......................................... ......................................... ........................................ ............................ ........ 1 INTRODUCCION .....................................
1.1. 1.2.
........................................................... ........................................ ......................................... ...................................... .................. 3 ANTECEDENTES........................................ ........................................................... ......................... ...... 3 ANÁLISIS Y FORMULACIÓN DEL PROBLEMA ........................................
DE FPGA’S SOLAMENTE DE SOLAMENTE ...... 3 PRES PRESENCI ENCI A DE BENEF I CIOS SI SI MI LA RES AL U SO REDUCCION DE TI EM PO DE DI SEÑO EN COMPARACI COMPARACI ÓN A USAR USAR EXCLUSIVAMENTE EXCLUSIVAMENTE FPGA’ S S ....................................... .......................................................... ........................................ ......................................... ............................ ........ 4 1.2.3. DI SEÑO EM PLEANDO LEN GUAJE C ...................................... ......................................................... ...................................... ................... 4
1.2.1. 1.2.2.
1.3. 1.4.
........................................................... ........................................ ......................................... ........................................ ............................ ......... 5 HIPÓTESIS ....................................... ......................................................... ........................................ ......................................... ......................... ..... 5 OBJETIVOS DE LA TESIS ......................................
1.4.1. 1.4.2.
1.5. 2.
............................................................ ........................................ ........................................ ...................... .. 6 RESUMEN DESCRIPTIVO ........................................
FUNDAMENTO TEÓRICO ...................................... .......................................................... ........................................ ........................................ ................................ ............ 7 2.1.
3.
OBJETIVOS GENERALES ........................................ ........................................................... ........................................ .................................... ............... 5 OBJETIVOS ESPEC ESPECII FI COS ...................................... .......................................................... ........................................ ................................... ............... 5
............................................................ ........................................ ........................................ ................................... ............... 8 MARCO TEORICO ........................................
2.1.1. 2.1.1.1. 2.1.1.2.
.......................................................... ........................................ ........................................ ........................................ ................................ ............ 8 FPGA ...................................... .......................................................... ........................................ ........................................ ................................ ............ 8 ¿Qué es un FPGA? ...................................... Fabricantes FPGA ....................................... ........................................................... ........................................ ........................................ ................................ ............ 9
2.1.1.3.
Arquitectura general de un FPGA ........................................ ............................................................ ........................................ .......................... ...... 12
2.1.1.4.
Fortalezas y Debilidades de los FPGAs ..................................... ......................................................... ........................................ .................... 22
2.1.2. 2.1.2.1.
.......................................................... ........................................ ........................................ ........................................ .............................. .......... 26 HPRC ...................................... Computación Reconfigurable ........................................ ........................................................... ........................................ .................................. ............. 26
2.1.2.2.
......................................................... ........................................ ......................................... ....................... ... 29 Procesamiento Paralelo ......................................
2.1.2.3.
............................................................ ........................................ ........................................ ................................. ............. 36 Arquitectura RC ........................................
2.1.2.4.
¿Porqué usar Computación Reconfigurables para DSP? ...................................... ................................................... ............. 41
2.1.3. 2.1.4. 2.1.4.1. 2.1.4.2.
....................................... .......................................................... ........................................ ......................................... .................................... ................ 47 FI LTROS FI R ...................... ...................... 51 COM CO M PIL ADORES C PARA PARA ARQUIT ECTURAS RECONFI RECONFI GURABLES Plataformas FPGA ....................................... ........................................................... ........................................ ........................................ .............................. .......... 51 Programas de Síntesis ...................................... ......................................................... ........................................ ......................................... .......................... ...... 56
2.1.4.3.
De C a FPGA ..................................... ......................................................... ........................................ ......................................... ........................................ ................... 60
...................................................... ................ 62 METODOLOGIA PARA LA SOLUCION DEL PROBLEMA ......................................
3.1.
......................................................... ........................................ ................................. ............. 63 HERRAMIENTAS HERRAMIENTAS EMPLEADAS .....................................
3.1.1.
I M PUL SE C CoDeve CoDevelope loper r ....................................... ........................................................... ........................................ ..................................... ................. 63
3.1.2.
.......................................................... ........................................ ......................................... ........................................ ................... 66 XILI NX ISE ISE ......................................
3.1.3. 3.1.4.
MATLAB ........................................ ........................................................... ........................................ ......................................... ........................................ ....................... ... 67 DI GIL ENT SPARTAN SPARTAN 3E STARTER STARTER BOARD ...................................... ......................................................... .......................... ....... 68
3.2. 3.3. 3.4. 3.5. 3.6.
.......................................................... ........................................ ........................................ .................... 69 PROYECCIÓN DE COSTOS ...................................... .......................................................... ........................................ ........................... ...... 70 TECNICA DE DISEÑO TOP-DOWN ....................................... .......................................................... ........................................ ....................... ... 71 PROGRAMACION ESTRUCTURADA ...................................... ............................................................ ................................. ............. 73 DISEÑO DE UN FILTRO FIR EN FIR EN MATLAB ........................................ ........................................................... ........................................ ................................. ............. 78 FIR256 Y FIR_ACCELERATED .......................................
VI
4.
........................................................... ........................................ ........................................ ........................................ ............................ ........ 108 RESULTADOS .......................................
5.
DISCUSION: PRUEBA DE LA HIPOTESIS ....................................... ........................................................... ........................................ ...................... 121
6.
CONCLUSIONES...................................... .......................................................... ........................................ ......................................... ......................................... ........................ .... 125
7.
.......................................................... ........................................ ......................................... .................................. .............. 128 RECOMENDACIONES .......................................
8.
........................................................... ........................................ ................................ ........... 130 REFERENCIAS BIBLIOGRAFICAS ........................................
9.
......................................................... ........................................ ...................................... .................. 134 PAGINAS COMPLEMENTARIAS .....................................
............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 135 ANEXO 1 ........................................ ............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 136 ANEXO 2 ........................................ ............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 137 ANEXO 3 ........................................ ............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 138 ANEXO 4 ........................................ ............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 139 ANEXO 5 ........................................ ............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 140 ANEXO 6 ........................................ ............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 141 ANEXO 7 ........................................ ............................................................ ........................................ ........................................ ........................................ ........................................ ...................... 142 ANEXO 8 ........................................
VII
INDICES COMPLEMENTARIOS COMPLEMENTARIOS INDICE DE FIGURAS Figura 1 - Núcleo FPGA Altera ........................................................................................................ 11
Figura 2- Arquitectura general de un FPGA [5]................................................................................ 12 Figura 3 - Estructura de un bloque lógico [5]. ................................................................................. 13 Figura 4 - Estructura de una LUT de n entradas [5]. ............................. ............................ ............... 14 Figura 5 - Estructura de un CLB [5]. .......................... ............................ ............................ ............... 15 Figura 6 - Lógica de acarreo [5]. ...................................................................................................... 18 Figura 7 - Multiplicadores embebidos próximos a los bloques de RAM [5]. ......................... .......... 20 Figura 8 - Distribución de la señal de reloj dentro de un FPGA F PGA [5]. ............................................... ..21 Figura 9 - Multiple clock domains [5]. ............................................................................................. 22 Figura 10 – Arreglo Lógico Reconfigurable Splash 2[1]. .................................................................. 28 Figura 11 - Digital Equipment Corporation’s PAM Perle -0 [1]. .................. ........................... ........... 29 Figura 12 - Una Palabra P alabra de Instrucción VLIW [1]. [1 ]. ................................................... ......................... 30 Figura 13 - Co-procesador SSE [1]. .................................................................................................. 31 Figura 14 - Una Instrucción RC [1]. .................................................................................................. 32 Figura 15 - Process Level Parallelism [1]. [1 ]............................. ............................ ........................... ...... 33 Figura 16 - Thread Level Parallelism [1]........................................................................................... 33 Figura 17 - Client Server Model [1]. .......................... ............................ ............................ ............... 34 Figura 18 - Stream Comunication [1] ......................... ........................... ............................ ............... 35 Figura 19 - Adquisición Adquisici ón de la Data [1]. ........................... ............................ ............................ .......... 36 Figura 20 - Placa FPGA E/S Genérica [1]. ......................................................................................... 37 Figura 21 - Matriz FPGA F PGA masivamente paralela [1]. ................................. ............................. .......... 38 Figura 22 - Supercomputador Reconfigurable SRC [1]. ............................. ............................ .......... 39 Figura 23 - NAPA 1000 [1]. .............................................................................................................. 41 Figura 24 - Implementación de un FIR simple [2]. ............................................. ............................ ..42 Figura 25 - Implementación de un FIR altamente segmentado (4 Taps) [2]. ................................... 42 Figura 26 - Esquema del Buffer Lineal [6]. ................................................ ............................ ........... 50 Figura 27 - Movimiento de datos en un buffer circular [6]............................. ............................ .....50 Figura 28 - Soft processor proc essor dentro de un FPGA junto a otros IP (Intellectual Property) cores co res [12]. . 52 Figura 29 - Arquitectura DLX RISC de acuerdo al modelo de D.A.Patterson, J.L. Hennessy publicado en 1996 [13]. ................................................................................................................................... 53 Figura 30 - Usos de impulse C [10]. ................................................................................................. 64 Figura 31 - Flujo de una aplicación de proceso a proceso con acceso a memorias compartidas [3]. ........................................................................................................................................................ 65 Figura 32 - Logo del ISE Design Suite de Xilinx................................................................................. 67 Figura 33 - Herramienta BSB Wizard del Xilinx Platform Studio. ................................ ..................... 67 Figura 34 - Logo de Matlab......................... ............................ ........................... ............................ ..68 Figura 35 - Tarjeta Digilent Spartan 3E Starter Board Rev. D usada en la implementación. ............ 69 Figura 36 - Representacion de un diseño TOP-DOWN. ................................................................... 71 Figura 37 – Ejemplo de un Programación Estructurada .............. ........................... ......................... 71
VIII
Figura 38 - Esquema Filtro Fil tro FIR ......................... ............................ ............................ ........................ 73 Figura 39 - Señal de Entrada (double) ............................................................................................. 74 Figura 40 - Señal de Entrada (fixed point) ....................................................................................... 75 Figura 41 - Diagrama de Flujo Filtro FIR .......................................................................................... 76 Figura 42 - Señal de Salida y(n) (double) ......................................................................................... 77 Figura 43 - Señal de Salida y(n) (fixed point) ................................................................................... 77 Figura 44 - Respuesta en Frecuencia Filtro Fi ltro Fir ............................. ........................... ......................... 77 Figura 45 - Capas de representación en fixed fix ed point. [9] ............................ ............................ .......... 78 Figura 46 - Funcionamiento de FIR256 por bloques. ........................... ............................ ............... 79 Figura 47 - For para el llenado del array ‘coef’ ................................................................................ 80 Figura 48 - For para el llenado del array ‘firbuffer’ ......................................................................... 81 Figura 49 - Funcionamiento de FIR256 FIR 256 .......................... ............................ ............................ .......... 82 Figura 50 - Funcionamiento FIR_ACCELERATED FIR _ACCELERATED en bloques. .......................... ........................... ...... 83 Figura 51 - Macro fxmul32, usando la macro de Impulse C FXMUL16 d efinido FRACBITS=23 en FIR_ACCELERATED............................. ............................ ............................ ........................... ........... 84 Figura 52 - Implementacion de punteros para buffer circular ............................. .......................... ..85 Figura 53 - Consola de Mensajes.......................... ........................... ............................ .................... 86 Figura 54 - Menu Opciones de Impulse C Compiler ........................................................................ 87 Figura 55 - Menu Generación de HDL ...................... ............................ ............................ ............... 87 Figura 56 - Consola de Errores ........................................................................................................ 87 Figura 57 - Menu Exportación de d e HDL ........................... ............................ ............................ .......... 88 Figura 58 - Menu Abrir Proyecto Xilinx Platform Studio ................................................... ............... 88 Figura 59 - Menu Proyecto Nuevo empleando el Wizard .......................... ............................ .......... 89 Figura 60 - Menu Guardar, Xilinx Platform Studio ........................... ............................ .................... 89 Figura 61 - Bienvenida al Menu Constructor .......................... ........................... ............................ ..90 Figura 62 - Selección de la Tarjeta a emplear ......................... ............................ ........................... ..90 Figura 63 - Selección del Sistema de Procesamiento....................... ............................ .................... 91 Figura 64 - Configuración del Procesador........................................................................................ 91 Figura 65 - Configuración de los l os periféricos ............................................. ............................ ........... 92 Figura 66 - Configuración del puerto RS232 .................................................. ............................ ...... 92 Figura 67 - Configuración del módulo Timer ............................................ ............................ ........... 93 Figura 68 - Configuración de la Memoria M emoria Caché.......................... ........................... ......................... 93 Figura 69 - Configuración de la Aplicación ...................................................................................... 94 Figura 70 - Finalización de la Creación del Proyecto ............................ ............................ ............... 94 Figura 71 - Bus Interfaces .................................................. ............................ ............................ ...... 95 Figura 72 - Añadiendo una IP .......................................................................................................... 95 Figura 73 - Configurando la IP ......................................................................................................... 96 Figura 74 - Microblaze ............................ ............................ ........................... ............................ ...... 96 Figura 75 - Configuración del Microblaze ........................... ............................ ........................... ...... 97 Figura 76 - Configuración del fsl_filt_0 .......................... ............................ ............................ .......... 97 Figura 77 - Configuración de los Relojes............................ ............................ ........................... ...... 97 Figura 78 - Configuracion de la l a IP ......................... ........................... ............................ .................... 98 Figura 79 - Configuración del Reloj.................................................................................................. 98
IX
Figura 80 - Sumario de los Puertos ........................... ............................ ............................ ............... 99 Figura 81 - Configuración del fls_filt_0 .......................... ............................ ............................ .......... 99 Figura 82 - Ventana de Direcciones .......................... ............................ ............................ ............... 99 Figura 83 - Ventana de Mensajes de Consola ......................... ............................ ........................... 100 Figura 84 - Generacion del BitStream............................................................................................ 100 Figura 85 - Construcción de la Aplicación de Usuario... ............................. ............................ ........ 100 Figura 86 - Actualización del bistream. ......................................................................................... 101 Figura 87 - Agregar aplicación de software al proyecto. ........................................ ............. ........................... ....................... 101 Figura 88 - Insertar nombre a la aplicación de software. ..................... ............................ ............. 102 Figura 89 - Agregar source y header files. ..................................................................................... 102 Figura 90 - Archivos Source dentro de la carpeta code. ....................... ............................ ............. 103 Figura 91 - Archivos header dentro de la carpeta Code. ............................... ............................ ...103 Figura 92 - Construcción del proyecto de usuario. ......................... ............................ .................. 104 Figura 93 - Generación del linker script. script. ............................ ............................ ........................... ....104 Figura 94 - Ventana de opciones del Linker Script......................................................................... 104 Figura 95 - Segunda compilación del proyecto de usuario. .............................................. ............. 104 Figura 96 - Selección de la aplicación de arranque en BRAMs para microblaze. .......................... 105 Figura 97 - Tercera actualización del bitstream............................................................................. 105 Figura 98 - Iniciar la descarga del bitstream a la plataforma. ............................. .......................... 105 Figura 99 - Opciones JTAG. ......................... ............................ ........................... ............................ 106 Figura 100 - Configuración en hyperterminal para la comunicación con la plataforma. .............. 106 Figura 101 - Inicio de la consola XMD........................... ............................ ............................ ........ 106 Figura 102 - Diagrama de bloques del filtro FIR256 obtenido al simular en CoDeveloper mediante el Application Monitor. ................................................................................................................. 109 Figura 103 - Test consumer en funcionamiento funci onamiento del filtro FIR256. FIR25 6........................... ....................... 109 Figura 104 - Filter process en funcionamiento del filtro FIR256. FIR2 56. ............................ ....................... 110 Figura 105 - Test producer en funcionamiento del filtro FIR256. ................................ .................. 110 Figura 106 - DataflowGraph (DFG) del filtro fil tro FIR256. .............................................. ....................... 111 Figura 107 - Gráfica en MATLAB con acercamiento, donde están ploteados los valores obtenidos con CoDeveloper y los obtenidos al implementar un FIR en MATLAB. ............. ............................ 111 Figura 108 - Gráfica en MATLAB, donde están ploteados los valores obtenidos con CoDeveloper y los obtenidos al implementar un FIR en MATLAB. ............................... ... ............................ ............................ ............. 112 Figura 109 - Ventana V entana de Matlab con mensaje del Tiempo de Procesamiento .............................. ... ........................... 112 Figura 110 - Consola XMD al correr la aplicación apli cación del FIR creada para Microblaze. ....................... 113 Figura 111 - Registro log de la consola XMD al correr la apli cación del FIR creada para Microblaze. ...................................................................................................................................................... 118 Figura 112 - Ventana de Hyperterminal recibiendo datos del puerto RS232 DCE de la tarjeta Spartan. ......................................................................................................................................... 119 Figura 113 - Señal de Error ............................................................................................................ 119 Figura 114 - Mensaje de valor de Error ........................................... ........................... ................... 119 Figura 115 - Comparación de los Tiempos de Procesamiento ............................. .......................... 127 Figura 116 - Comparación de los Factores de Aceleración ...................................... ...................... 127
X
INDICE DE TABLAS
Tabla 1 - Comparativa Cualitativa de Tecnologías de Implementación DSP [2]............................... [2]........... .................... 44 Tabla 2 - C para compiladores compi ladores de Diseño VLSI desarrollados hasta el momento ........ .................... 58 Tabla 3 - Características de la Tarjeta Digilent Digi lent Spartan .................................................... ........................ ............................ ............... 69 Tabla 4 - Precios de herramientas a utilizar en un diseño. ...................................... ........................ 70 Tabla 5 - Comparación de Resultados ........................................................................................... 120
XI
RESUMEN
La presente investigación se realizo con el objetivo de estudiar y conocer el diseño implementando sistemas de procesamiento de señales HPRC usados para incrementar la velocidad del procesamiento y escalabilidad, manteniendo el bajo costo y alto desempeño puesto que al manipular señales representadas bajo secuencias secuencias de números computables, resulta complicado o demanda excesivo tiempo en diseño hacerlo en sistemas con funciones específicas. Correspondiendo a la primera parte de este trabajo el marco teórico de funcionamiento en sistemas HPRC y a la segunda parte la implementación de una aplicación base que demuestre los beneficios en forma observable.
Para lograr nuestro objetivo implementamos dos aplicaciones correspondientes a un filtro FIR, con la primera se logró aprender el funcionamiento y uso de las herramientas mediante simulación. La segunda aplicación estuvo basada en la primera, considerándose la misma aplicación pero acelerada la cual nos permitió obtener el factor de tiempos para realizar una comparación de desempeño. desempeño.
Partiendo de los resultados obtenidos en las dos aplicaciones, se llegó a la conclusión de que los sistemas propuestos satisfacen a las expectativas de los objetivos.
XII
ABSTRACT
The present investigation was conducted with the main purpose of study and bring forward the HPRC digital process design which is used to increase processing speed and scalability, maintaining the low cost and exposing high performance because it results very difficult to achieve or take excessive design time in specific functions systems when it have to manipulate long signals represented under computable number sequences. Corresponding to the first part of this work the theory about operation of HPRC systems and the second part is about implementing a basic application to observe and demonstrate HPRC benefits.
To achieve our goal we implemented two applications corresponding on a FIR filter structure where the first was used to learn and comprehend its operation thru simulation. The second application was based on the first, considered to be the same application but accelerated with which we obtained the accelerator factor of times to compare performance.
Based on results obtained from these two applications, we concluded that the proposed systems meet the proposed objectives expectations.
XIII
1. INTRODUCCION
El procesamiento digital de señales conocido como DSP 1 está actualmente involucrado involucrado en muchas áreas como son el campo biomédico, tratamiento de audio y video, seguridad militar, entre otros; siendo de notoria importancia al desarrollo tecnológico ligado a la ingeniería. El procesamiento digital está referido a la manipulación de señales representadas bajo secuencias secuencias de números computables, es decir que serán transformadas y operadas en un computador. Dispositivos desde procesadores dedicados al DSP, hasta llegar a los FPGA 2, que han ido apareciendo apareciendo y evolucionando a través del del tiempo, han sido usados para para lograr perfeccionar algoritmos y aplicaciones para DSP DSP donde cada vez se incrementa la cantidad de datos a operar y es necesaria la obtención de resultados en tiempo real; donde los FPGA han marcado una tendencia en el diseño de sistemas digitales por sus características características únicas de ser flexibles y reconfigurables. Los FPGA desde su aparición hace más de dos décadas han revolucionado el procesamiento digital digital de señales así como lo hicieron los PDSP 3 en su momento. El hecho hecho de ser un dispositivo reprogramable permite ser sometido a cambios a medida que el diseño avanza; siendo un elemento beneficioso para el desarrollador quien realiza modificaciones sobre el lenguaje especial usado. Asimismo durante la etapa de desarrollo del sistema se pueden usar múltiples herramientas para verificación y simulación de los módulos implementados. Donde, son las herramientas de software y los lenguajes de programación piezas fundamentales; siempre se ha tratado de llegar a la convergencia convergencia entre software y hardware para optimizar los diseños, apuntando a sistemas que presenten un paralelismo funcional tanto a nivel de procesadores como a nivel de ejecución directa de instrucciones por medio de hardware, en este caso caso en FPGA‟s. FPGA‟s. Ante todas las características ventajosas que presenta el uso de FPGA‟s y la necesidad de plataformas de grandes prestaciones, estos están siendo usados en computadores reconfigurables de alto desempeño o HPRC 4, que logran cubrir las altas necesidades. necesidades.
1 2 3 4
DSP: Digital Signal Processing FPGA: Field Programmable Gate Array PDSP: Programmable Digital Signal Pr ocessor HPRC: High Performance Reconfigurable Computing
2
Para lograr asentar el conocimiento sobre HPRC, se necesita hacer un trabajo y desarrollo sobre un conocimiento básico. Siendo la base en el DSP el uso de filtros, apuntar a lograr implementar filtros digitales como son los FIR 5 demostraría el conveniente uso de estos sistemas previamente descritos.
1.1. ANTECEDENTES Habiendo realizado una pesquisa bibliográfica en la Biblioteca Central y Especializada de Ingeniería de la Universidad Privada Antenor Orrego, no se ha encontrado trabajos relacionados con el tema de investigación a realizar.
1.2. ANÁLISIS Y FORMULACIÓN DEL PROBLEMA La tendencia actual de operar grandes cantidades de datos a casi tiempo real, hace necesario el uso de nueva herramientas en el diseño como son los sistemas basados en HPRC. Donde estos sistemas, presentan las siguientes características relevantes:
Menor tiempo de diseño en comparación a usar exclusivamente exclusivamente FPGA's.
Permite el diseño usando Lenguaje C.
1.2.1. PRESENCIA DE BENEFICIOS SIMILARES AL USO DE FPGA’S SOLAMENTE
Los FPGA son dispositivos de semiconductores programables que son basados en una matriz de bloques lógicos configurables o CLB 6 [15], y presentan las siguientes ventajas para el diseño [8]:
Rápido tiempo-a-mercado. No presenta un NRE NRE7 por adelantado.
5 FIR: Finite Impulse Response 6 CLB: Configurable Logic Block
3
Ciclo de diseño más simple.
Ciclo de proyecto más predecible.
Reprogramabilidad en campo.
1.2.2. REDUCCION
DE
TIEMPO
DE
DISEÑO
EN
COMPARACIÓN A USAR EXCLUSIVAMENTE FPGA’S Para la programación se utiliza utili za un lenguaje especial llamado HDL 8 o lenguaje de Descripción de Hardware, un FPGA siendo un dispositivo lógico programable o PDL9 usa un HDL habiendo dos corrientes grandes de HDL: VHDL 10 y Verilog. Hacer uso de HDL representa un tarea tediosa y larga para los desarrolladores que no conocen sobre descripción de hardware pero dominan lenguajes como C o Java, puesto que el HDL nunca fue diseñado diseñado para describir algoritmos, la solución ante esto fue hacer uso de compiladores que trasladen algoritmos de punto fijo y flotante a un lenguaje de alto nivel o HLL 11 directamente a un circuito expresado en HDL. Algunas de estas soluciones son Impulse C, Mitrion C, SRC Carte y Handel C [7].
1.2.3. DISEÑO EMPLEANDO LENGUAJE C Los HPRC son sistemas de computación paralelos que contienen múltiples microprocesadores y múltiples FPGAs. En diseños actuales, el FPGA es usado como coprocesador que está dispuesto a ejecutar pequeñas porciones de la aplicación que toman mucho tiempo [7]. Los sistemas HPRC usan las herramientas y compiladores de lenguajes como C hacia dispositivos FPGA, logrando disminuir el tiempo ti empo de diseño y obtener sistemas de óptimo desempeño.
7 8 9 10 11
NRE: Non recurring expenses HDL: Hardware D escription Languange PDL: Programmable Logic Device VHDL: Very High Speed Integrated Int egrated Circuit Hardware Description Languange HLL: High Level Language
4
El procesamiento digital de señales de datos es muy complicado de realizar en sistemas muy costoso o con funciones especificas, o sistemas que demandan tiempo excesivo en su diseño. Además de los problemas generados por el excesivo tiempo de procesamiento de los mismos. Por tal motivo se propone un sistema que ayude a disminuir el tiempo de procesamiento sin necesidad de invertir demasiado tiempo o sean costosos en su diseño.
1.3. HIPÓTESIS
[H1]: Un sistema diseñado con HPRC optimizará el tiempo de procesamiento y permitirá a los diseñadores diseñadores la escalabilidad escalabilidad del sistema, sistema,
1.4. OBJETIVOS DE LA TESIS 1.4.1. OBJETIVO GENERAL Proponer un sistema de procesamiento digital de señales de datos, a través de la implementación un filtro FIR, que permita incrementar la velocidad del procesamiento, escalabilidad, de bajo bajo costo y alto desempeño.
1.4.2. OBJETIVOS ESPECIFICOS - Estudiar las tecnologías referentes a HPRC. - Analizar los tiempos de procesamientos de los algoritmos implementados
en un sistema HPRC, para diferentes cantidades y tipos de datos - Analizar los gastos realizados para la implementación del diseño. - Analizar el desempeño y la eficiencia de los algoritmos implementados en
un sistema HPRC. - Implementar un filtro FIR en un sistema HPRC, que demuestre nuestros
resultados. - Análisis de los resultados r esultados obtenidos después de las pruebas pertinentes.
5
1.5. RESUMEN DESCRIPTIVO El presente trabajo de investigación, el cual se ha dividido en 9 capítulos, los que se describen a continuación:
Capítulo 1: Se presenta lo que es, es, una breve breve introducción al tema, continuando con los antecedentes, el análisis y formulación del problema, presentando sus causas y efectos; seguimos con presentación de las hipótesis, el objetivo general y los objetivos específicos; finalizando con este resumen r esumen descriptivo.
Capítulo 2: Presentamos el Fundamento Teórico, el cual consta de Marco Teórico, en el cual damos a conocer acerca del HPRC, las ventajas de implementación, los Filtros FIR y
las Plataformas
de
Compilación; lo que nos ayudará a comprender mejor el tema.
Capítulo 3: Metodología para la solución solución del problema, aquí damos a conocer los pasos de implementación de un Filtro FIR en MATLAB, y la implementación del Filtro FIR Accelerator dentro del FPGA.
Capítulo 4: Aquí mostramos los resultados de nuestras simulaciones, acompañados de sus respectivas gráficas y diagramas de bloques.
Capítulo 5: Discusión, donde damos a conocer nuestra prueba de hipótesis. Capítulo 6: Presentamos nuestras conclusiones. Capítulo 7: Damos a conocer nuestras recomendaciones. recomendaciones. Capítulo 8: Presentamos una lista de la bibliografía utilizada. Capítulo 9: Páginas complementarias, donde alcanzamos algunos documentos que serán de mucha utilidad.
6
2. FUNDAMENTO TEÓRICO
2.1. MARCO TEORICO 2.1.1. FPGA 2.1.1.1. ¿Qué es un FPGA? Los FPGAs o Arreglos de Compuertas Programables de Campo , son chips de silicios ubicados en el nivel más alto dentro de la actual microelectrónica. Emplea bloques lógicos pre construidos que se encuentran dispuestos de tal manera que no necesitan ningún tablero o cautín para configurarlos o programarlos. Sólo deberá desarrollar tareas de computación digital en software y compilarlas en un archivo de configuración o una escritura de bits que contenga información de cómo deben conectarse los componentes. Sin embargo, el aumento de herramientas de diseño de alto nivel está cambiando las reglas de programación de FPGAs, con nuevas tecnologías que convierten los diagramas a bloques gráficos, o hasta el código ANSI12 C, a circuitos de hardware digital [11]. El desarrollo de proyectos llevados a cabo con implementación de FPGAs dentro de las industrias, se han visto impulsadas por las mejoras que ofrecen los FPGAs ante los demás dispositivos programables, entre ellas incremento de las velocidades de procesamiento y fiabilidad del producto final, y esto sin requerir de incrementos desmesurados de la inversión en el proyecto. La gran diferencia entre procesadores y FPGAs es el modo de procesamiento de las operaciones dentro de ellas, mientras que en un procesador las sentencias sentencias se ejecutan secuencialmente; secuencialmente; los FPGAs FPGAs desarrollan de modo paralelo, ejecutándose una tarea independiente programada dentro del FPGA de otra, sin necesidad de competir por los mismos recursos, y sin afectar a otros bloques. Como resultado, el rendimiento de una parte de la aplicación no se ve afectado cuando se agregan otros procesos. 12 ANSI: American National Standards Institute
8
2.1.1.2. Fabricantes FPGA Tras su aparición de los FPGA en los años 80, estos dispositivos son populares por su capacidad de hardware reconfigurable y flexibilidad. Los FPGAs son el resultado de la convergencia de dos tecnologías diferentes, los PLDs, y los ASICs 13, pero los FPGAs no aparecerían hasta que los innovadores de Xilinx a mediados de los 80 combinaran las dos tecnologías con un mecanismo de interconexión que pudiese programarse utilizando fusibles, antifusibles o celdas RAM 14. El resultado fue un circuito con capacidad y aplicación mayor a los PLD, aunque con puntuales diferencias, que delatan antepasados antepasados diferentes. diferentes. A principios de 2007, 2007, el mercado de los FPGA se ha colocado en un estado donde hay dos productores de FPGA de propósito general que están a la cabeza del mismo, y un conjunto de otros competidores quienes se diferencian por ofrecer dispositivos de capacidades únicas.
Xilinx uno de los grandes líderes y los pioneros en la fabricación de FPGAs. Fundada por Ross Freeman (el inventor de las FPGA), Bernie Vonderscmitt (pionero del concepto de compañía fabless) y Jim Barnett en 1984 y con base en Silicon Valley. Al año siguiente desarrollaron su primera FPGA, el modelo XC2064. Hoy en día, la base reside en San José, California, mientras que en Europa se hallan en Dublín, Irlanda y en Asia en Singapur. Xilinx desarrolla FPGAs y CPLDs15 que son usados en numerosas aplicaciones, como telecomunicaciones, automoción, productos de consumo, industria militar y otros campos. Las familias de dispositivos de Xilinx son: glue logic (CoolRunner y CoolRunner II), bajo coste (Spartan) y alto rendimiento (Virtex). Las familias Virtex-II Pro, Virtex-4 y Virtex-5 son particularmente interesantes para los diseñadores de system-on-achip (SoC) porque pueden incluir dos núcleos del IBM PowerPC 405.
13 ASIC: Application-specific integrated circuit 14 RAM: Random Access Memory 15 CPLD: Complex Programmable Logic Device
9
IP Cores) en lenguajes HDL para Xilinx también crea núcleos IP 16 ( IP
permitir a los diseñadores reducir los tiempos de desarrollo. Estos núcleos van desde funciones simples como contadores a sistemas complejos como microcontroladores, un ejemplo de esto último es el microprocesador Microblaze.
Altera Corporation, miembro del grupo NASDAQ-100y del S&P 500, es uno de los pioneros de la lógica programable, siguiendo líderes notables anteriores como Signetics y MMI 17 en la producción de PLDs. Altera desarrolla algunas características que están orientadas hacia capacidad de sistemas en chips programables (SOPC 18). Algunos de los ejemplos más recientes incluyen memoria embebida, procesadores embebidos, embebidos, y transceptores de de alta velocidad. El éxito en lanzamientos de productos de 130nm y 90nm son buenos casos de estudio. Los procesadores soft-core Nios II y Nios de Altera y los dispositivos HardCopy II y HardCopy están extendiendo el alcance de Altera en el mercado, y coloca a esta empresa en el mundo de los procesadores embebidos y ASICs estructuradas respectivamente. respectivamente. Altera ofrece también el software Quartus II, dirigido al diseño y simulación de circuitos lógicos. Aunque su software soporta extensivamente VHDL y Verilog como principales lenguajes, Altera es el desarrollador de lenguaje de descripción de hardware conocido como AHDL. Entre su familia de FPGAs de alto rendimiento tenemos la serie Stratix, anunciado en el 2002 y con posteriores series GX, II, II GX y II en el 2006. 2006. En su familia de productos de FPGAs de de bajo coste tenemos la serie Cyclone también anunciado en el 2002, con sus posteriores series II II y III y Arria GX anunciada el 2007
16 IP: Intellectual Property 17 MMI: Monolithic Memories Inc 18 SOPC: System on a Programmable Chip
10
Figura 1 - Núcleo FPGA Altera
Lattice Semiconductor lanzó al mercado dispositivos FPGA con tecnología de 90nm. En adición, Lattice es un proveedor líder en tecnología no volátil, FPGA basadas en tecnología Flash, con productos de 90nm y 130nm. Los principales productos Lattice Semiconductor Semicond uctor son FPGAs volátiles volátil es LatticeECP2 LatticeEC P2
y FPGAs
LatticeXP2 con módulos Flash incluidos.
Actel tiene FPGAs basados en tecnología Flash reprogramable. También ofrece FPGAs que incluyen mezcladores de señales basados en Flash. Adicionalmente, fabrica FPGAs de alta fiabilidad para los mercados militares y aeroespaciales. Que tienen menos densidad que sus homólogos de Altera y Xilinx. Los modernos dispositivos Actel incluyen Familias basadas en Flash ProASIC 3 y Igloo, FPGAs RTAX basadas en antifusibles tolerantes a la y FPGAs antifusibles de propósito general Axcelerator. Axcelerator.
QuickLogic tiene productos basados en antifusibles (programables una sola vez).
Atmel es uno de los fabricantes cuyos productos son reconfigurables (el Xilinx XC62xx fue uno de estos, pero no están siendo fabricados actualmente), se centra principalmente en microcontroladores, no en la lógica programable. Sin embargo, tienen una familia FPSLIC 19 que
19 FPSLIC: Field Programmable System Level Integrated Circuit
11
combina el núcleo MCU 20 AVR con estructura FPGA, todo en el mismo encapsulado. encapsulado.
Achronix Semiconductor tienen en desarrollo FPGAs muy veloces. Salieron al mercado a comienzos de 2007, FPGAs con velocidades cercanas a los 2GHz.
MathStar, Inc. ofrecen FPGA que ellos llaman FPOA (Arreglo de objetos de matriz programable).
2.1.1.3. Arquitectura general de un FPGA Un FPGA consiste en arreglos de varios bloques programables (bloques lógicos) los cuales están interconectados entre sí mediante canales de conexión verticales y horizontales [5], tal como muestra la Figura 2. En general, un FPGA posee una estructura altamente regular.
Figura 2- Arquitectura general de un FPGA [5].
20 MCU: Microcontroller Unit
12
Los bloques lógicos de la periferia de esta estructura se conectan a celdas de entrada/salida de forma tal de lograr una comunicación con el exterior del circuito.
Bloques lógicos El bloque lógico consta de una parte combinacional que permite implementar funciones lógicas booleanas más una parte secuencial formada por flip-flops, que permite sincronizar la salida con una señal de reloj externa, lo cual es útil para realizar circuitos secuenciales y permite implementar registros. registros. La estructura de un bloque lógico varía de un fabricante a otro. Sin embargo, la parte combinacional se basa principalmente en una Look-Up Table (LUT).
Una LUT es un componente de memoria que almacena una tabla de verdad. Las direcciones de la memoria son las entradas de la función lógica a implementar, y en cada celda de dicha memoria se almacena el resultado de la combinación correspondiente de las entradas. En una LUT de n x 1 es posible implementar cualquier función lógica de n entradas. En la Figura 3 se muestra la estructura básica de un bloque lógico. lógico. En la misma se observa observa que el multiplexor puede ser configurado para aceptar la salida de la LUT o aceptar una entrada del bloque lógico. A su vez, en la Figura 4 se muestra la estructura de una LUT.
Figura 3 - Estructura de un bloque lógico [5].
13
Figura 4 - Estructura de una LUT de n entradas [5].
Si se desea implementar funciones lógicas de más de n entradas se deben interconectar más de una LUT para lograrlo. Resulta conveniente cuando se realizan circuitos combinacionales de varias entradas, separarlos en etapas por medio de registros, de forma tal de no aumentar el tiempo de propagación de las señales al utilizar varias LUT en cascada. A su vez, si se desea implementar registros o circuitos secuenciales, se deberá utilizar en general los flip-flops de más de un bloque lógico. La combinación de distintos bloques lógicos se realiza a través de los bloques de interconexión.
CLBs vs LABs
Los distintos fabricantes de FPGAs llaman de diferentes formas a los componentes lógicos de un FPGA. El elemento básico de los FPGAs de Xilinx es la celda lógica (LC, Logic Cell ). ).
Una celda lógica contiene una LUT, un multiplexor, lógica de acarreo, un registro y lógica de configuración. Este registro puede funcionar como como flip-flop D o como cerrojo cerrojo ( latch).
14
La polaridad del flanco de reloj puede ser configurada (ascendente o descendente) como así también la polaridad de las señales de clock enable, set y reset . A su vez las celdas lógicas están agrupadas en un slice. Un bloque lógico configurable configurable (CLB, (CLB, Configurable Logic Block ) se encuentra conformado por dos slices. La estructura de un CLB se observa en la Figura 5.
Figura 5 - Estructura de un CLB [ 5].
Altera, por su parte, llama a un elemento básico Logic Element (LE) [5]. Un LAB ( Logic Array Block ) se encuentra
conformado por un conjunto de ocho a diez LEs. Un LE difiere en su estructura interna de una LC. Sin embargo, las funcionalidades de ambos bloques son similares.
Bloques entrada/salida La función de un bloque de entrada/salida es permitir el paso de una señal hacia dentro o hacia el exterior del dispositivo. Por este
15
motivo, dependiendo de la interfaz eléctrica, el mismo debe contar con recursos tales como:
Salidas configurables como Tri-State u Open-Collector.
Entradas
con
posibilidad
de
pull-up
o
pull-down
programables.
Registros de salida.
Registros de entrada.
Además, debido a que hoy en día los FPGA funcionan a altas velocidades de operación y que los mismos tienen desde cientos hasta miles de terminales de conexión, los bloques de entrada/salida deben ser capaces de proveer una adecuada terminación en cuanto a términos de impedancia se refiere, de forma tal de evitar reflexiones de las señales. Esto que en el pasado se lograba conectando un resistor cercano al terminal del dispositivo, en la actualidad debe ser implementado dentro del propio FPGA debido a la gran cantidad de terminales que estos dispositivos poseen.
Recursos de interconexión Para utilizar las celdas lógicas disponibles, debe disponerse de una red de interconexión flexible. Sin embargo, debe considerarse considerarse que cuanto mayor flexibilidad tenga la red de interconexión mayor será el consumo de potencia y menor la velocidad de operación del dispositivo. En general, las conexiones internas entre elementos de un FPGA pueden realizarse realizarse de tres formas:
Líneas directas . Tienen lugar entre bloques adyacentes
16
Conexiones de propósito general . Se realizan a través de una matriz de interconexión cuando se desean conectar dos bloques no adyacentes. Su misión es conectar canales verticales y horizontales que permiten llegar al punto final de la conexión. Cuanto más larga es la línea de ruteo, mayores serán los retrasos introducidos tanto por la propia longitud de la línea como por los elementos de interconexión utilizados a lo largo de la misma.
Líneas largas . Estas conexiones se utilizan cuando una señal debe recorrer una gran longitud, por ejemplo en la implementación de un bus interno, de forma tal de evitar que la misma atraviese elementos de interconexión evitando de esta forma retrasos introducidos por los mismos.
Líneas rápidas . Cuando los bloques lógicos contienen más de una LUT, las líneas rápidas son las encargadas de realizar las conexiones entre las distintas LUTs. LUTs.
Recursos Recursos internos de los FPGA actuales Los FPGA actuales cuentan con muchos recursos de propósito
específico. En esta sección solo se presentarían algunos de los más importantes.
RAM distribuida
Las LUTs basadas en celdas de SRAM 21 brindan distintas posibilidades. En adición al rol primario de conformar una LUT, en algunos dispositivos se permite utilizar estas celdas como memoria RAM o como registros de desplazamiento.
21 SRAM: Static Random Access Memory
17
Una LUT de 4 entradas puede ser utilizada para formar una memoria RAM de 16 x 1 bits. A su vez, las 16 celdas de memoria pueden ser interconectadas en forma de cadena formando un registro de desplazamiento.
Cadenas de acarreo rápidas
Una característica de los FPGAs actuales es que incluyen lógica y elementos de interconexión útiles para implementar cadenas de acarreo rápidas ( fast carry chains) cuya función es la de propagar de forma rápida señales de acarreo entre dos elementos lógicos. Una cadena de acarreo genera el acarreo de salida a partir de las entradas de la LUT y el acarreo de entrada. Las cadenas de acarreo permiten realizar de forma eficiente sumadores, multiplicadores, contadores y comparadores de gran velocidad.
Figura 6 - Lógica de acarreo [5].
RAM embebida
Muchas aplicaciones requieren el uso de memoria, de forma tal que una gran cantidad de dispositivos FPGA incluyen bloques de memoria RAM además de la RAM distribuida en las LUTs. LUTs.
18
Dependiendo de la arquitectura del dispositivo, estos bloques de memoria pueden estar ubicados en la periferia del dispositivo, dispersos sobre la superficie del mismo o ubicados en columnas. Dependiendo de la aplicación, estos bloques de memoria pueden ser configurados de diversas maneras, formando memorias de un solo puerto ( single-port RAMs), memorias de doble puerto ( dual-port RAMs), memorias FIFO ( first-in firstout ), ),
etc. Poseen además un sistema de enrutamiento dedicado
que provee una eficiente comunicación entre estos bloques de memoria y los bloques lógicos.
Multiplicadores
Algunas funciones lógicas tales como suma y multiplicación son inherentemente lentas si se realizan interconectando un gran número de bloques lógicos. Para aplicaciones de procesamiento digital de señales (DSP), donde los algoritmos generalmente se basan en sumas y multiplicaciones (denominadas operación MAC, Multiply and Accumulate),
el hecho de que los FPGAs cuenten con una
cantidad de multiplicadores embebidos los hace ideales para ser utilizados. Generalmente, los multiplicadores se encuentran cercanos a los bloques de memoria RAM dentro del dispositivo, ya que los mismos son utilizados para procesar datos alojados en dichos bloques.
19
Figura 7 - Multiplicadores embebidos embebidos próximos a los bloques de RAM RAM [5].
Ciertos dispositivos, como por ejemplo los correspondientes a la familia Spartan-IIIA DSP de Xilinx, integran bloques dedicados a funciones DSP incluyendo registros, multiplicadores y sumadores.
Clock trees y clock manager
Todos los elementos secuenciales dentro de un FPGA, tales como los flip-flops presentes en los bloques lógicos, deben ser sincronizados por una señal de reloj. Para lograr tal sincronismo, la señal de reloj debe llegar a todos los elementos secuenciales del FPGA en fase, de manera tal que en un instante de tiempo t iempo no se produzcan transiciones sólo en algunos elementos mientras que en otros no (clock skew). Por lo tanto, la señal de reloj es distribuida distri buida dentro del FPGA en forma de árbol (clock tree).
20
La Figura 8 muestra la estructura de este árbol. Se observa que a todos los flip-flops llegan a un flanco de reloj aproximadamente en el mismo instante de tiempo. En los FPGAs, en vez de que la señal de reloj externa se conecte al clock tree, generalmente se conecta a un clock manager, el cual genera diferentes señales de reloj. Estas señales generadas por el clock manager sirven para distintos propósitos. Uno es el de atacar distintos clock tres, de forma tal que el FPGA cuente con más de un árbol con el fin de que ninguno sea muy extenso, asegurando siempre el sincronismo entre los elementos secuenciales.
Figura 8 - Distribución de la señal de reloj dentro de un FPGA [5].
A su vez, también estas señales de reloj pueden ser utilizadas para manejar dispositivos dispositivos externos al FPGA. Otra utilidad que surge de tener distintas señales de reloj que manejan distintos ´arboles, es poder tener dentro del FPGA distintos sectores que funcionen con velocidades de operación diferentes o con distintas fases de reloj ( multiple clock domains ).
21
Figura 9 - Multiple clock domains [5].
2.1.1.4. Fortalezas y Debilidades de los FPGAs Al momento de implementar un algoritmo o un a aplicación, un desarrollador tiene la oportunidad de escoger entre los múltiples dispositivos disponibles que se tiene en el mercado: FPGA, ASIC o un microprocesador. Sin embargo cada una cuenta ventajas y desventajas que a continuación se numerarán:
a) Tiempo de salida al Mercado Como gran fortaleza, los FPGAs cuentan con salida al mercado como ventaja ante los ASIC, ya que para estos hay que hacer un proceso de (1) diseño, (2) verificación, (3) fabricación, (4) empaquetamiento, y (5) prueba del dispositivo antes de sacar el producto al mercado. Además, el desarrollo de software requiere acceder al dispositivo ASIC (o una emulación del caso) antes de que pueda ser verificado y completado. Los FPGAs han sido ya fabricados, empacados, y probados por el vendedor, como dispositivos estándares disponibles inmediatamente, reduciendo reduciendo el tiempo de salida al mercado en por lo menos cuatro meses. Dos puntos importantes difíciles de cuantificar pero no menos importantes que las demás son: (1) re-fabricaciones (rediseños) causado por errores en el diseño o cambios de última hora a
22
especificar, debido a un cambio en un estándar en evolución, por ejemplo, y (2) programas de desarrollo de software que dependen del acceso a la ASIC. Ambos de estas situaciones modifican el cronograma de producción del producto, un rediseño fácilmente puede emplear un máximo de cuatro meses, y el anticipado acceso acceso al hardware pueden acelerar el desarrollo de software y de depuración, en especial para el software integrado que se comunica directamente con el dispositivo. En vista de estas consideraciones, una estimación conservadora de ventaja del tiempo de salida al mercado de los FPGAs en relación con ASICs es de 6 a 12 meses. Como esta reducción es significativa; en los mercados de consumo electrónico, muchos productos sólo tienen un ciclo de vida de 24 meses.
b) Costo Por dispositivo, Los FPGAs pueden ser mucho menos costosos que ASICs, especialmente en volúmenes más bajos, ya que los costes no recurrentes de la fabricación de FPGA son asumidos por muchos usuarios. Sin embargo, debido a su reprogramabilidad, los FPGAs requieren mucha más área de silicio para aplicar una funcionalidad equivalente. Así, en volumen más alto posible en la electrónica de consumo, el costo del dispositivo FPGA finalmente superará el coste de dispositivo de ASIC.
c) Tiempo de Desarrollo Implementar aplicaciones en FPGA es similar a diseñar dispositivos o hardware: las aplicaciones se describen en Verilog o VHDL, simuladas para determinar la exactitud, y sintetizados mediante herramientas de síntesis lógica comerciales. Herramientas
23
comerciales disponibles que sintetizan los programas escritos en lenguajes de comportamiento secuencial como C a FPGAs. Sin embargo, en la mayoría de los casos, altos rendimientos y mayor densidades se logran utilizando HDL, ya que permiten al usuario directamente describir y explotar el paralelismo intrínseco disponibles en una aplicación. La explotación del paralelismo de una aplicación es la mejor forma de lograr un alto desempeño del FPGA. Sin embargo, el diseño de las implementaciones de aplicaciones altamente paralelas en HDLs requiere un significante esfuerzo de desarrollo ante el de desarrollo de software con lenguajes de programación convencionales secuencial como Java o C++.
d) Consumo de Potencia Los FPGAs FPGAs consumen más energía que los ASICs ASICs simplemente simple mente porque la programación requiere muchos más transistores, en relación rel ación con un circuito integrado personalizado (IC). Los FPGAs pueden consumir más o menos energía tanto como un microprocesador o procesador de señal señal digital (DSP), dependiendo dependiendo de la aplicación. aplicación.
e) Depuración y Verificación Los FPGAs son desarrollados con técnicas y herramientas de diseño de hardware estándar. Codificado en VHDL o Verilog y sintetizado, los diseños FPGA pueden ser depurados en simuladores tanto como un típico diseños ASIC. Sin embargo, muchos diseñadores verifican sus diseños directamente, descargándolos en un FPGA y probándolos en un un sistema. Con este enfoque, la aplicación puede ser probada en velocidad (un millón de veces más rápido que la simulación) en el entorno operativo real, donde es expuesto a las condiciones del mundo real. Si
24
a fondo, esta prueba proporciona una mayor forma de la verificación funcional en relación con la simulación. Sin embargo, la depuración de aplicaciones en un FPGA puede más ser difícil porque las herramientas del vendedor vendedor proporcionan menos observabilidad y controlabilidad en relación, por ejemplo, a un simulador de lenguaje de descripción de hardware (HDL).
f) FPGA y Microprocesadores Cada
aplicación
tiene
requerimientos
específicos,
estos
requerimientos se analizan cuidadosamente para determinar si es posible que la aplicación requiera de un microprocesador o un DSP. Para el caso de aplicaciones con FPGA, el desarrollo de códigos es complicado en lo que respecta a ASIC, ya que programar en C o en JAVA es menos complicado que programar en VERILOG o VHDL, de igual manera no existen en el mercado muchas herramientas disponibles para VERILOG o VHDL como la disponibilidad de herramientas para C o JAVA. Los microprocesadores son también en general mucho menos costosos que FPGAs. Si el microprocesador puede cumplir con los requisitos de la aplicación (rendimiento, potencia, etc), es casi siempre la mejor opción. En general, general, los FPGAs son muy adecuados para aplicaciones que requieren de un muy alto desempeño y reprogramabilidad, para los componentes de la interfaz que se comunican con muchos dispositivos y para sistemas de hardware implementados en volúmenes que hacen que sus costos a escala sean viable.
25
2.1.2. HPRC 2.1.2.1. Computación Reconfigurable La Computación Reconfigurable (RC), tuvo un gran avance con el desarrollo de los FPGA durante finales de los 80's, características de estos dispositivos llamaron la atención a desarrolladores de DSP y sobre todo a la comunidad de la supercomputación. Hoy en día, las velocidades obtenidas bajo ejecución directa en hardware se encuentran en una tasa entre 10x -100x a comparación de tareas ejecutadas bajo un procesador como algoritmo de software [1]. Al ser reconfigurable un FPGA se personaliza a nivel de compuertas para cumplir la función de un algoritmo específico cubriendo solo los tamaños, tipos y las unidades aritméticas usadas; donde es posible configurar la interconexión entre operaciones. En cambio en un microprocesador eso no es posible, el procesador se limita a efectuar las operaciones y soportar los tipos de datos a operar. El problema se originaba al tener que describir algoritmos complejos al FPGA, por lo que otros dispositivos como los ASIC's tenían ventaja en la flexibilidad de su software. Una de las primeras ideas desarrolladas, bajo el nombre de “computación distribuida” fue el computador computador Fixed-Plus-Variable Fixed -Plus-Variable (F+V) desarrollada por Estrin y la Universidad de California a mitad de los 60's. El F+V poseía muchas limitaciones, por ser un procesador estándar que dominaba otras variables, y donde el conexionado era manual cableado.
26
Fue a finales de los 80's que los productos de empresas como Altera y Xilinx tuvieron gran salida al mercado. Investigadores americanos del IDA 22 Supercomputing Research Center (SRC, renombrado Center for Computing Sciences en 1994) y franceses del DEC 23 Paris Research Lab (cerrado después que la Digital Equipment Equipment Corporation fuese vendida) vendida) idearon un supercomputador que posea hardware reconfigurable reconfigurable para poder ser cambiado de acuerdo a la aplicación y que su desempeño sea el doble que los procesadores con con un set de instrucciones. instrucciones. En 1989 SRC construyo un arreglo sistólico llamado Splash 1 y tres años después construyo Splash 2, los cuales lograban superar el desempeño de un supercomputador Cray 2. Splash 1 contenía 32 FPGAs Xilinx 3090 series conectados en un array lineal. Los chips de FPGA adyacentes compartían un buffer de memoria. El computador reconfigurable era conectado a una workstation Sun mediante interconexión VME 24. Splash podía realizar una comparación de la secuencia de ADN25 a 45X (1990‟s (1990‟s). ). Splash 2, redujo el número de FPGAs a 16 Xilinx 4010 4010 series que que poseían 1 1/2 veces la lógica de Splash 1. Para mejorar la flexibilidad en interconexión se aumentaron las interconexiones lineales con un crossbar, permitiendo a los FPGA FPGA comunicarse directamente directamente entre sí. sí.
22 23 24 25
IDA: Institute for D efense Analyses DEC: Digital Equipment Corporation VME: VERSAmodule Eurocard ADN: Ácido Desoxirribonucleico
27
Figura 10 – Arreglo Lógico Reconfigurable Splash 2[1].
DEC desarrollo el proyecto PAM (Programable Active Memories) con la tarjeta Perle-0 la cual tenía 25 dispositivos Xilinx XC3090 en un arreglo de 5x5 los cuales estaban conectados a 4 rápidas memorias estáticas RAM (SRAM) de 64k x 64 bits las cuales eran controladas por dos XC3090 adicionales. Luego Luego Perle-0 fue potenciada usando XC4000. La tarjeta Perle-0 Perle -0 se convirtió en una de las tarjetas más populares para la investigación.
28
Figura 11 - Digital Equipment Corporation’s PAM Perle-0 [1].
2.1.2.2. Procesamiento Paralelo En la computación reconfigurable se maneja el paralelismo a nivel de instrucción y a nivel de tarea.
Paralelismo a nivel de instrucciones Es el nivel más bajo de la granularidad, y es explotado en la micro arquitectura de procesadores superescalares, los cuales poseen múltiples instrucciones en progreso durante varios estados de operación, por lo que puede completar más de una en un solo ciclo de reloj. Los procesadores Very Long Instruccion Word (VLIW) ofrecen otro método para la operación paralela fine-grained, ya que posee múltiples unidades de operación en paralelo. Usando una palabra de instrucción de varios campos como se observa en la Figura 12, posee dos para operaciones enteras, dos para operaciones en punto flotante, dos para operaciones de memoria y un branch.
29
Figura 12 - Una Palabra de Instrucción VLIW [1].
En un procesador superescalar, el compilador genera un stream de instrucciones secuencial, secuencial, y el procesador lo paraleliza mientras esta en operación. A diferencia de un procesador VLIW que ejecuta la palabra de instrucción generada por el compilador, requiriendo que el compilador programe las tareas al tiempo de compilación. El paralelismo con co-procesador es logrado usando un solo stream de instrucciones. Una instrucción paralela personalizada es ejecutada por el co-procesador. Ejemplos de co-procesadores incluyen las unidades MMX 26/SSE27 o unidades vector. Las instrucciones para el co-procesador son integradas en el set de instrucciones del procesador. El co-procesador comparte archivos de registro y otros estados internos con las otras unidades aritméticas, como las unidades de punto flotante, como se muestra en la Figura 13. El paralelismo a nivel de instrucciones es de gran importancia en los sistemas RC 28. En contraste con los procesadores convencionales en los cuales la unidad de instrucción es optimizada para un gran clase de aplicaciones, es posible (y necesario) en sistemas RC adaptar el paralelismo a nivel de instrucción únicamente para cada aplicación específica. En un procesador VLIW el formato de instrucción es
26 MMX: Multi Media eXtensions 27 SSE: Streaming SIMD Extensions 28 RC: Reconfigurable Computing
30
determinado por el número y tipo de unidades de función paralelas. En un FPGA estas unidades son construidas a partir de bloques lógicos configurables. El numero, ancho ancho y tipo son son arbitrarios, y pueden ser ser optimizados hacia la aplicación al momento de compilar. Si se puede hacer reconfiguración parcial dinámica, el diseño de las unidades de función debe ser modificado al momento de la l a ejecución.
Figura 13 - Co-procesador SSE [1].
Así pues, una "instrucción" según la interpretación del sistema reconfigurable es una colección arbitraria de circuitos lógicos relacionados, en los cuales el número y tipo de unidades aritméticas es optimizado para cada aplicación. En la Figura 14 se ilustra el flujo de datos dentro de una instrucción RC compuesta de 11 niveles de operación. En cada nivel, múltiples operaciones ocurren en paralelo. Por ejemplo, el primer nivel contiene seis multiplicadores. Si la instrucción por sí misma es parte del flujo de operación del pipeline, por cada ciclo de reloj, habrá 23 operaciones aritméticas ocurriendo en paralelo. La aplicación específica siendo mapeada a la lógica reconfigurable determina los tamaños y tipos de datos de operación. Una instrucción para un
31
computador reconfigurable es análoga a una subrutina entera de un procesador convencional. convencional.
Figura 14 - Una Instrucción RC [1].
Paralelismo a nivel de tareas El paralelismo a nivel de tareas tiene dos categorías resaltantes. La relación entre tareas puede ser peer-to-peer o cliente/servidor. En un sistema paralelo peer-to-peer la actividad puede ser a nivel de proceso a nivel del hilo más fino de la granularidad. En sistema de nivel de proceso peer-to-peer, ilustrados en la Figura 15, cada proceso tiene su espacio de dirección dirección separado. separado. De manera que que al comunicar estado, el proceso debe enviar un mensaje y el proceso(os) destino debe explícitamente recibir el mensaje. Diferentes tipos de protocolos de mensajería son usados. Los mensajes debe ser bufferizados, asíncronos y de alta latencia, como con el Message Passing Interface (MPI). Se puede utilizar un protocolo streaming de baja latencia de streaming, con colas, búferes FIFO, o comunicación semi-sincrónica "bit valida" semi-sincrónica. Finalmente, los mensajes deben ser streams perfectamente sincronizados, en los cuales los retardos son determinados al momento de la compilación Y son pre-compilados dentro de los procesos sincronizados del reloj. El último protocolo es típico e los algoritmos DSP.
32
Figura 15 - Process Level Parallelism [1].
A nivel de hilos de procesamiento paralelo peer-to-peer (Figura 16), los hilos comparten un espacio de dirección, y pueden
comunicarse a través de memoria compartida o de mensajes. Los mecanismos de señalización y sincronización para procesamiento basado en hilos incluyen secciones críticas y exclusión mutua, o barreras.
Figura 16 - Thread Level Parallelism [1].
En un modelo paralelo cliente/servidor, el cliente puede requerir espacio del servidor, o el cliente puede requerir trabajo del servidor. Originalmente (mostrado a la izquierda de la Figura 17), la fuente de cómputo es centralizada en el servidor, a diferencia del último (mostrado a la derecha). Donde los clientes realizan tareas intensas de cómputo y el servidor solo sirve como repositorio para la descripción de tareas.
33
Figura 17 - Client Server Model [1].
La lógica reconfigurable tiene un rol también en estas actividades paralelas de larga granularidad. En procesamiento procesamiento peer-to-peer, los procesos de hardware se comunican con procesos de software. Este escenario es particularmente común en procesamiento embebido, donde el hardware puede manipular la adquisición de datos y el procesamiento front-end, fr ont-end, mientras que el software realiza análisis de datos y toma de decisiones. Unas de las formas más comunes de comunicación hardware-asoftware son a través de buffers de memoria o con un stream de comunicación, el cual se observa en la Figura 18. En este ejemplo, dos procesos de hardware (Procesos 1 y 2) se comunican vía un stream hardware-a-hardware, los Procesos 2 y 3 se comunican vía un stream hardware-a-software, hardware-a-software, y los Procesos 3 y 4 se comunican vía un stream software-a-hardware. Los sistemas RC tienden más a ser estáticos, canales de comunicación de aplicación-especifica más que a streams dinámicos como se propone en procesadores dedicados de stream como el Imagine. Esto es debido a que los caminos de comunicación de streams determinados son mucho más eficientemente mapeados al FPGA.
34
Figura 18 - Stream Comunication [1]
35
Dentro
del
procesamiento
cliente/servidor
el
computo
reconfigurable también posee un rol importante. Los nodos RC pueden desempeñar trabajos data/compute, por ejemplo para criptografía, bioinformatica o aplicaciones de seguridad de redes. Los nodos RC también sirven como nodos de adquisición de datos, como se muestra en la Figura 19. Bajo este escenario, múltiples fuentes de data alimentan a los nodos de lógica reconfigurable que pre-procesan la data y proveen esta a distintos nodos de la red.
Figura 19 - Adquisición de la Data [1].
2.1.2.3. Arquitectura RC Los Procesadores paralelos basados en FPGAs aparecieron por primera vez en la década de 1990 y han seguido prosperando [1]. Los Sistemas de Computación Reconfigurable pueden agruparse agruparse en cuatro categorías:
Acelerador de Bus E/S
Matriz FPGA masivamente paralela
Supercómputo Reconfigurable
Co-procesador Lógico Reconfigurable
36
a) Acelerador de Bus E/S El acelerador de BUS E/S mostrada en la Figura 20 contiene una interconexión entre FPGA, módulos de SRAM y/o DRAM 29 on-board, interfaces (serial) de alta velocidad para dispositivos externos, y una interfaz para el bus de E/S del ordenador host. Fue el primer equipo reconfigurable a comienzos comienzos del los años 90. Las posibilidades de interconexión entre FPGAs varían dependiendo de la cantidad de FPGAs que se dispongan. En caso de contar con pocas FPGAs, pero suficientes pines FPGA, se puede contar con una interconexión todos a todos, de lo contrario se puede emplear una interconexión de anillo de tal manera que cada uno este interconectado con su vecino izquierdo y derecho. Las tarjetas aceleradoras aceleradoras FPGA FPGA normalmente contienen memoria de buffer en la placa en forma de SRAM y/o DRAM. A diferencia de las estrechas y profundas memorias caché jerárquica utilizada en microprocesadores, los procesadores FPGA pueden explotar mejor el acceso amplio a los bancos de memoria. De hecho, no es raro para las placas FPGA contener 5-10 bancos de SRAM, permitiendo, por ejemplo, 64 * 10 = 640 bits de acceso a memoria concurrente cada ciclo de reloj.
Figura 20 - Placa FPGA E/S Genérica [1].
Dado que el ancho de banda entre el procesador host y tarjeta E/S es de alta latencia y bajo ancho de banda, el uso de un sub-sistema de
29 DRAM: Dynamic Random Access Memory
37
memoria integrada permite a las tareas intensivas de computo – y de datos – en las FPGAs tener una acceso directo y dependiendo de la aplicación a las arreglos de datos.
b) Matriz FPGA masivamente masivamente paralela La segunda arquitectura basada en FPGA generaliza la placa aceleradora FPGA reuniendo una colección muy grande de placas FPGA como un único recurso computacional, como se muestra en la Figura 21.
Esta arquitectura es particularmente útil para la emulación de la lógica o computo a una gran escala. La matriz de FPGA masivamente paralela requiere una interconexión de alto rendimiento para que la comunicación entre las placas FPGA pueda asemejarse al ancho de banda entre FPGAs FPGAs en la misma placa. placa.
Figura 21 - Matriz FPGA masivamente paralela [1].
38
c) Supercómputo Supercómputo Reconfigurable Reconfigurable En la supercomputación reconfigurable, las placas FPGA son incluidas como nodos de aceleración en un grupo (cluster) de alto rendimiento [2]. Esta tarjeta tiene como característica la comunicación con procesadores convencionales, así como con otras FPGAs a través de una red de interconexión de gran ancho de banda. Esto le permite que la velocidad de transmisión con el host sea más rápido (una latencia de microsegundos) con un gran ancho de banda, permitiéndole compartir su estado con el host más fácilmente. Este sistema está dispuesto de manera que se tengan muchas placas interconectadas de tal manera que pueda resolver problemas de grandes supercómputos sin limitaciones existentes. Las primeras supercomputadoras reconfigurable de esta forma fueron desarrolladas por SRC Computers, Inc.
Figura 22 - Supercomputado Supercomputadorr Reconfigurable SRC [1].
d) Co-procesador Lógico Reconfigurable El co-procesador lógico reconfigurable es la unión final de microprocesador tradicional con la lógica reconfigurable. Al igual que con procesadores en paralelo, sólo vale la pena migrar funcionalmente
39
al hardware si el tiempo de ejecución de hardware junto con el tiempo de la migración a hardware es significativamente menor que el tiempo para calcular la función función en el software: software:
Al permitir que el procesador y la lógica reconfigurable compartan el estado de bajo nivel, el componente
de la
desigualdad se puede reducir considerablemente, permitiendo una menor granularidad de las tareas, de manera rentable, asignado a hardware. También hace posible reconfigurar de forma dinámica la lógica durante la ejecución, similar al cambio de contexto en los procesadores convencionales. convencionales. La idea i dea de la dramática reducción de la latencia y aumento del ancho de banda entre el microprocesador y la lógica reconfigurable mediante la combinación de los dos en una sola entidad se ha repetido desde los primeros días de la computación reconfigurable. El primer IC co-procesador reconfigurable que se fabricó fue el chip NAPA 1000 por la National Semiconductor. Este chip utilizó un núcleo RISC 30 de 50 MHz 32-bit, junto con la matriz lógica reconfigurable CLAY de la National. El procesador RISC, el chip de memoria local, un controlador de reconfiguración, un controlador de red de interconexión, y la matriz lógica reconfigurable compartían un bus común básico (Figura 23). La matriz lógica reconfigurable tuvo acceso directo a la memoria local y dedicada. El Cómputo de la matriz lógica fue optimizado para un datapath de 32 bit lineal y segmentado. Las columnas de 32-bit podían ser reconfigurados dinámicamente dinámicamente durante la l a operación.
30 RISC: Reduced Instruction Set Computer
40
Figura 23 - NAPA 1000 [1].
2.1.2.4. ¿Porqué usar Computación Reconfigurables para DSP?
-
Adecuado para DSP La implementación de DSP empleando RC es muy adecuada indican numerosos estudios, debido al paralelismo del RC que puede ser explotados por aplicaciones DSP. Las más comunes aplicaciones a implementar son un Filtro FIR con la siguiente ecuación:
Teniendo como representación grafica al diagrama de flujo de la figura
23,
el
cual
desarrollaría
computacionalmente
N
multiplicaciones y N-1 adiciones secuencialmente. En un hardware de computo reconfigurable, los filtros FIR pueden ser implementados usando segmentación de tal manera que se desarrollan N multiplicaciones y N-1 adiciones en cada ciclo con resultados en cada ciclo. La Fig. 24 nos muestra un equivalente al filtro FIR que ha sido
41
altamente segmentado. Sin embargo, las aplicaciones DSP, por mayoría no implementan un solo filtro, sino llegan a necesitar de multiples Filtros FIR implemetados, además de conversores analógicos digitales, tranformadas, etc.
Figura 24 - Implementación de un FIR simple [2].
Figura 25 - Implementación de un FIR altamente segmentado (4 Taps) [2].
Los factores que influyen al DSP el uso de cómputo reconfigurable son:
El ancho de palabra de aplicaciones DSP empleados por conversores A/D, comúnmente de 8 a 12 bits, los cuales pueden ser procesados por microprocesadores; sin embargo, muchas veces no es suficiente, debido a que la precisión de la palabra es muy baja para algunas aplicaciones. En caso de querer ampliar el ancho, se vería limitado ya que el procesador no podría procesar tantos datos, pero un dispositivo RC con procesamiento paralelo si es capaz.
42
La suministración de ancho de banda de memoria, la cual es mayor y flexible además de la suministración de puertos SRAM externos, permitiendo la capacidad de procesar múltiples bloques en simultáneo, a comparación con un microprocesador, microprocesador, que solo solo puede procesar entre dos variables de entrada y una de salida por sentencia.
El ancho de banda de las Entradas/Salidas, las cuales, a través de un microprocesador deben recuperar la información, tomándoles mayor tiempo antes del procesamiento de la información. Sin embargo un hardware reconfigurable maneja directamente los puertos, reduciendo el tiempo y requerimientos requerimientos de procesamiento; sin contar con la flexibilidad de personalizar las E/S y la escalabilidad del ancho de banda E/S En síntesis, El DSP y la computación reconfigurable reconfigurable puede ser ser
buena pareja, debido al paralelismo disponible y la eficiencia de las implementaciones personalizables de computación reconfigurable. Aunque muchas dispositivos de computó reconfigurables sólo operan en decenas a unos pocos cientos de megahercios, dado el potencial de explotación del paralelismo, no debería sorprender que las implementaciones de aplicaciones de computó reconfigurable DSP puedan superar a los microprocesadores y procesadores de señales digitales programable (PDSP) a pesar de operar en 1/10 veces o menos de la frecuencia del reloj.
-
Comparación en Tecnologías de Implementación DSP Al momento de elegir un tipo de hardware empleado para DSP se tiene que tener en cuenta la aplicación a realizar ya que cada uno de estos tiene un lugar de aplicación, que comúnmente no es compartido.
43
) a d n a B e
jo
jo
jo
ot
o
B
B
B
A
l
ot A
ot A
l
ot A
d
oj ot
M
B
A
S/
a
a
d E
l
a
h c n A( ) a d n a iar B e
oj
o
B
o
oi oj d
a
d
a
m e M
l
e B M
h c n A( d a idl
oi
ot
ot A
A
e
oi
oi
i l
bi
l
x
l
el
a
F ot
ai c ot
n
l d
A-
M
B
d
d
oj
l
et
e
e
A
o
io a
M
P
e M
r oi
o
oi
P
d e
ip ot
M-
oj
AB
d
Ma
C jo
o
l e
oj
h s
ot d
B
oi a
jo
a
C
e
a M
B
B
o ñ e a D
et jo
jo
S B
B
is m l si e d
d l
e
e A
M
e s
io ot
d a
l ot
io
a
M
d o C o ot
ñ e p oj
oj
e B
B
a
m s
l oi ot
AA d
d l
a e
e
M
oi e M
D r n
e al
d
r o lo
G ot
g
w
CI
s
or
A
S
c
c o p
or P
M
or or
a u
ar o
e P
er
g
i
e
r
a
n
s c
m
b
t
a n
el
or
d o
a m
e
g
T
b o
d aí
le
ar
l e
P ci
n
dr c
H
fi
a e
o
P S D
R
Tabla 1 - Comparativa Cualitativa de Tecnologías de Im plementación DSP [2].
44
Entre las tecnologías de implementación contamos con:
Procesadores de propósito general (GPP), de rendimiento relativamente bajo debido a los cuellos de botella de su arquitectura Von-Neumann (memoria de datos e instrucciones instrucciones compartida). Su bajo costo de adquisición, debido a su producción en masa, y su programabilidad y reprogramabilidad son su mayor atractivo. La flexibilidad provista por su programabilidad y la programación de alto nivel facilitan su uso para el manejo de diversas tareas. Sus desventajas son la considerable cantidad de energía para su funcionamiento y el throughput relativamente bajo proporcionado por el sistema. Además de su ancho de banda de memoria y ancho de banda de E/S es relativamente bajo. Su uso en aplicaciones DSP es en sistemas ya disponibles, como en una PC de escritorio, con bajas prestaciones.
Los Microcontroladores, un pariente cercano a la GPPs, son efectivamente microprocesadores de más bajos rendimiento que se utilizan más para aplicaciones de control en lugar de procesamiento de datos. Con frecuencia tienen soporte de hardware para hacer hacer E/S y, a veces instrucciones especiales especiales para el ejercicio de las funciones DSP. En su mayor parte, sus fortalezas y debilidades son similares a los de GPPs, excepto por lo general requieren menos energía y ofrecen menos m enos rendimiento.
Los Procesadores de Señales Digitales Programables (PDSPs) son dispositivos generados a partir de los GPPs, sin embargo tienen grandes cambios y mejoras como el empleo de la arquitectura HARVARD (Memoria de datos e instrucciones separadas), llegando a ser más populares que sus predecesores. Los PDSPs tienen mayor rendimiento que los GPPs y los microcontroladores de baja potencia, según lo observado en la Tabla 1, sin embargo
45
su programabilidad es relativamente difícil comparada con las otras dos, dificultad presentada por la forma de programación de las características especiales de la arquitectura a emplear, si se quiere llegar a un rendimiento máximo. Los PDSPs son encontrados en múltiples aplicaciones debido a su rendimiento y características de energía, como en reproductores de música digital y CD, módems convencionales y DSL 31, entre otros. Pero también se cuenta con PDSPs de mayor calidad que son disponibles a expensas de un mayor costo e incremento de la energía suministrada.
Los ASIC posiblemente sean los dispositivos más idóneos para aplicaciones DPS, debido a su rendimiento, potencia y ancho de banda de memoria y E/S. Sin embargo su adquisición se dificulta por motivo del costo de adquisición, costo generado por la creación de la misma; misma; el tiempo de diseño, diseño, fabricación y validez que emplea, entre meses a un año; y la falta de flexibilidad. Una vez implementada una aplicación en un ASIC esta no puede cambiarse, generando problemas en el rediseño. Las ASICs se encuentra presente en aplicaciones de alto procesamiento, como codecs MPEG para celulares; o aplicaciones críticas, donde el rendimiento y otras limitaciones son de suma importancia, como en aplicaciones militares.
Los FPGAs FPGAs (sistemas reconfigurables) cuentan con ventajas y desventajas al momento de emplearlos en una aplicación DSP. Si es cierto que su hardware reconfigurable proporciona rendimiento rendimiento y flexibilidad, rendimiento mejor que el de un PDSP, su costo de desarrollo se encuentra entre sobre el de PDSP y ASIC, bordeando los US $ 10.000 por FPGA. Requiere tanta energía como los ASIC incluso como los PDSP, suponiendo que este
31 DSL: Digital Subscriber Line
46
último tiene un alto rendimiento. Los FPGAs proporcionan una gran flexibilidad ya que pueden adaptarse con eficiencia a una gran variedad de nuevas aplicaciones; además, el FPGA provee mayor memoria, interface, y otras características personalizables significativas en comparación con otras tecnologías. Actualmente, el campo de aplicación de los FPGAs son aplicaciones de alto rendimiento, donde su producción sea de gran volumen y no exista restricción de energía. En un diseño donde la reprogramabilidad y flexibilidad son necesarios, la solución apropiada será un hardware reconfigurable o FPGA.
2.1.3. FILTROS FIR 2.1.3.1. Teoría básica Filtros FIR Un filtro FIR con longitud M , entrada x(n) y salida y(n) se describe por la ecuación de diferencias [6]:
(1)
donde { } son los coeficientes del filtro. Esta estructura es comúnmente comúnmente conocida como promedio móvil. Alternativamente, es posible representar la secuencia de salida como la convolución de la respuesta a impulso del sistema h(n) con la entrada.
(2)
47
donde x(n) representa la entrada muestreada,
representa la respuesta a
impulso ideal del filtro, e y(n) es la salida filtrada. Es claro que las ecuaciones (1) y (2) son iguales en su forma y, por lo tanto, se puede decir que
, k = 0, 1, 2,..., M -1. -1.
En general, la respuesta a impulso
=
para un filtro ideal es infinita en
duración y debe ser truncada en algún punto para su manejo en sistemas reales. Para producir un filtro FIR de largo M es necesario truncarla en n = M – 1. Este truncamiento es equivalente a la multiplicación de la respuesta a impulso ideal del filtro con una ventana rectangular, definida como:
(3)
Con ello se puede rescribir la ecuación (2) de la siguiente forma:
(4)
Esta truncación de los coeficientes afecta la respuesta del filtro, apareciendo oscilaciones en las bandas de paso y supresión, además de una disminución en la pendiente de caída del filtro. Estas características pueden alterarse utilizando otro tipo de ventanas y entre las más comunes se pueden mencionar las siguientes:
Blackman
( ( ) ( ( )
(5)
Hamming
( ( )
(6)
Aplicando la transformada Z a (4) es posible observar algunas características interesantes de los filtros FIR:
48
*+ { } *+ (7) ∑ *+
De (7) se puede ver que un filtro FIR de orden M posee M-1 polos en cero, es decir M-1 retardos, por lo que es siempre estable, y su característica de filtrado está dada sólo por la ubicación de sus ceros.
2.1.3.2. Buffer Lineal y Circular De la ecuación (4) es posible identificar tanto entradas x(k) como coeficientes b(k). Para calcular la salida del filtro es necesario mantener en memoria un buffer con los datos de las entradas pasadas (también llamadas “delay line”) además de la muestra actual. Existen dos formas de implementar un buffer para almacenar los l os datos pasados.
Buffer Lineal: Este tipo de buffer contempla el uso de un puntero que siempre apunta al comienzo del arreglo que actúa como buffer. Con este tipo de arreglo es necesario realizar corrimientos sucesivos de todos los datos almacenados de modo que el más antiguo “caiga” d el buffer y el más nuevo quede en la l a primera posición. El inconveniente que se presenta en esta implementación es que el costo en tiempo de ejecución de mover grandes cantidades de datos es alto. En la Figura 26 se observa un esquema de la implementación.
49
Figura 26 - Esquema del Buffer Lineal [6].
Buffer Circular : El direccionamiento por buffer circular se basa en la manipulación de un puntero, el cual es incrementado en cada ciclo. Por este método es posible realizar los cálculos de forma más eficiente. Cada nueva muestra que debe ser almacenada es ubicada en la posición de memoria utilizada por el dato más viejo, y que ya no es necesario para el cálculo de la salida del filtro, reutilizando de esta forma la memoria. Cuando el puntero alcanza el final del buffer debe ser actualizado para que salte al comienzo del buffer. Este hecho da nombre a este tipo de buffer ya que el final del arreglo parece quedar junto al comienzo del mismo en una forma circular. Algunos Algunos DSPs implementan los buffer circulares por hardware, lo cual permite conservar memoria y minimizar la sobrecarga del software. Es necesario darse cuenta de que este tipo de implementación requiere del manejo apropiado del puntero tanto de buffer de datos como de coeficientes (Figura 27)
Figura 27 - Movimiento de datos en un buffer circular [6].
50
2.1.4. COMPILADORES C PARA ARQUITECTURAS RECONFIGURABLES 2.1.4.1. Plataformas FPGA “Plataforma” se define como la configuración verificada de software y/o hardware que puede ser usada como la base para una o más especificaciones específicas. Una plataforma puede estar conformada por un sólo FPGA o algún otro tipo de dispositivo programable, una tarjeta llena de múltiples FPGA, o incluso un sistema de desarrollo como una PC de escritorio o un workstation que emule el comportamiento de un FPGA. Una plataforma siempre de contener un elemento de hardware programable, como un FPGA, y debe ser capaz de implementar todo o parte del algoritmo de software [12]. Dentro de una plataforma se consideran elementos determinantes al comportamiento de diseño como son procesadores embedded dentro del FPGA, lo cual permite correr sistemas operativos como son el Micro Linux (uClinux), Nucleus, ThreadX, etc.. Estos son procesadores “soft”, los cuales son IP cores (Intellectual Property) puesto que son implementaciones de microprocesadores a partir del ordenamiento de compuertas de las que dispone el tejido reconfigurable. El diseño usando plataformas con núcleos soft, permite implementar los llamados system-on-chip (SoC). Núcleos conocidos son los Nios de Altera, Microblaze de Xilinx, Leon3 Leon3 de Aeroflex Gaisler A, entre otros.
51
Figura 28 - Soft processor dentro de un FPGA junto a otros IP (Intellectual Property) cores [12].
También existen plataformas con procesadores “hard”, es decir, procesadores físicos en las plataformas como son la Xilinx Virtex-4 FX y Virtex-5 FXT que poseen núcleos PowerPC y la Atmel FPSLIC que trae un AVR. Al usar plataformas con un procesador soft, implica i mplica que el CPU realizará reali zará el control de trabajo del circuito y cálculos sobre todo de verificación, mientras que el resto del FPGA se encargará de operar el paralelismo y la comunicación de interfaces. - MICROBLAZE Es un núcleo propietario de 32 bits producido por Xilinx que corresponde a la arquitectura RISC DLX, existen versiones clones de ésta con la intención de proveer una librería de código abierto, estas son aeMB y OpenFire.
52
Figura 29 - Arquitectura DLX RISC de acuerdo al modelo de D.A.Patterson, J.L. Hennessy publicado en 1996 [13].
Microblaze utiliza un bus primario de I/O llamado CoreConnect PLB32 Bus, para acceso al a memoria local BRAM 33 implementa un bus LMB34, en cuanto a la aceleración por hardware como co procesador, la manipulación de instrucciones personalizadas personalizadas y conexiones se realiza mediante FSL 35. Siendo sus ventajas fundamentales la configurabilidad y programabilidad permite configurar el tamaño de caché, interfaces de bus, la profundidad del pipeline (puede ser 3-stage, el cual sacrifica velocidad de reloj por capacidad lógica y se implementa sobre familias como las Spartan, o 5-stage, este último permite lograr mayores velocidad de reloj y se implementa en familias de FPGA's como el Virtex-5 donde se logran velocidades máximas de hasta 210 Mhz), el MMU 36 (con el cual puede manipular kernels como el de Linux y al no usarlo, puede correr sistemas operativos de protección
32 33 34 35 36
PBL: Processor Local Bus BRAM: Block RAM LMB: Local Memory Bus FSL: Fast Simple Link MMU: Memory Management Unit
53
limitada y de un modelo de memoria virtual como son el uCLinux y el FreeRTOS 37). Sus principales características son [14]:
Unidad de Gestión de Memoria (MMU)
Completa MMU con memoria virtual soportada por Linux 2.6
Modo MPU38 para protección de regiones en aplicaciones RTOS seguras.
Unidad de Punto Flotante
Compatible con IEEE 754
Precisión Simple
Soporte de Excepciones de Hardware
Acceso no alineado
Instrucción ilegal
Error de bus de datos
Error de Instrucción de Bus
Divisiones entre cero
Cache de Datos e Instrucciones
Uso de bloques RAM integrados primitivos
Tamaño configurable de 2kB - 64kB
Microcache configurable (empleando RAM distribuido) de tamaño de 64B – 64B – 1024B 1024B
Escritura mapeada directa a través de operación
37 RTOS: Real Time Operating System 38 MPU: Múltiple Process Unit
54
Desplazador
1 ciclo de operación
Hardware Divisor de Enteros
32 ciclos de operación
Hardware Multiplicador Multiplicador
1 ciclo de operación.
Operación MUL64
Extensión de conjunto de instrucciones
Instrucción de Comparación de Patrones
Set y Clear en Registros de Maquinas de estado
Acceso Atómico
Adaptación de Múltiples Buses dependiendo de las diferentes necesidades necesidades de rendimiento
Bus de Memoria Local (LMB) para acceso rápido a memoria local
Interface de enlace de Cache punto a punto Xilinx para conexiones directas entre la cache y la memoria externa
Bus de Procesador Local (PLB46) para conectar múltiples periféricos directamente directamente al MicroBlaze
Hasta 16 Enlaces Rápidos Simplex (FSL), enlaces de Co procesador para aceleración de de hardware
Señalización de Interrupción Interrupción
Por Flanco o nivel
Activo en alto o bajo
55
Lógica de Depuración
Soporte de Núcleo de depuración vía control JTAG 39
Hasta 8 puntos de análisis en hardware
Puerto de Rastreo Integrado
2.1.4.2. Programas de Síntesis Existen múltiples herramientas basadas en lenguaje C y también en Java, empleadas para sintetizar circuitos provenientes de un HLL hacia una plataforma basada en FPGA. Los algoritmos de operación en punto fijo o flotante son traducidos por las herramientas del compilador hacia lenguaje HDL para poder ser montados en la plataforma; previamente probados, simulados, verificados y acelerados. Si bien el lenguaje base del compilador es C, puede tomar las siguientes formas en el entorno usado [7]:
Que el lenguaje sea de base secuencial, con construcciones para manipular anchos de bits, describiendo paralelismo explícito, y que conecte piezas de hardware. Los entornos de programación que realizan esto son Handel C de Celoxica, Impulse C, y el compilador MAP C del Carte SRC.
Que el lenguaje creado sea para descripción algorítmica, lo cual simplifica el trabajo del compilador, pero requiere que los programadores reestructuren la descripción algorítmica como también reescriban en una nueva sintaxis. Este es el caso del flujo de datos del lenguaje en Mitrion C y SHard.
Que se represente en una interfaz gráfica. Las herramientas gráficas proveen una vista en diagrama de bloques ordenados de forma jerárquica que permite al diseñador rápidamente construir circuitos.
39 JTAG: Joint Test Action Group
56
Dos herramientas que usan esta representación son System Generator de Xilinx y Viva de Starbridge. Programas como Impulse C, Handel C y DIME-C, tienen un impacto positivo en el mercado, el uso para aplicaciones aplicaciones y mejoras constantes constantes de estos lo demuestran. Sin embargo, estos programas usan un dialecto no-ANSI, utilizan un dialecto propietario. Ante la necesidad de lograr una estandarización y extensión del código C, aparecen propuestas abiertas como lo son Trident y el estándar IEEE System-C. La siguiente tabla muestra los programas de síntesis más desarrollados [4]:
57
Compilador HardwareC
Características
Transmogrifier C
SystemC
Impulse C
C2Verilog
Mitrion C
Handel C
Spec C
Napa C
Catapult C
DIME-C
Mapeo de la especificación de hardware a nivel de comportamiento hacia la descripción de nivel de transferencia de registros. Enfoque en procesos concurrentes, paso de mensajes, instanciamiento explícito de procedimientos, y muestras Un compilador para un lenguaje simple simp le de descripción de hardware. Toma un programa escrito en un subset restringido del lenguaje de programación C,y produce, un netlist para un circuito secuencial que implementa el programa. Extensión open-source de C++ para modelamiento HW/SW. Orientado para la industria de verificación a nivel de sistemas. Usa librerías de clase C++ y un kernel de simulación para crear diseños de comportamiento y RTL. Soporta descomposición jerárquica de un sistema hacia módulos. Facilita la conectividad estructural entre módulos usando puertos. Especializado en operaciones de modelamiento secuencial. Compatible con System C y facilita interprocesos de sincronización y comunicación. Convierte algoritmos C en Verilog. Resultados de síntesis lógica mejorados. Gran control sobre los procesos de compilación de C hacia código HDL. Buena compatibilidad e interfaz con otros diseños de automatización a nivel de sistemas (SLDA System Level Design Automation), verificación funcional, y herramientas de síntesis en flujo de diseño. Usa conceptos de procesadores soft-core. Trabajar en la capa de abstracción entre código C y FPGA. Hace uso de APIs de mapeo. Produce interms de salida de núcleos IP VHDL para la arquitectura FPGA seleccionada. Conocido por el desarrollo de aplicaciones precisas en los ciclos. La frecuencia de reloj es limitada por la operación más lenta. El compilador especializado en análisis eficiente, optimización de código. Provisión para obtener interms de salida de VHDL, Verilog, SystemC, EDIF. Extensión de ANSI – C. Soporta diseños de comportamiento y estructurales jerárquicos de sistemas embedded. Enfocado en la síntesis y verificación. Usado ampliamente para diseño a nivel de sistemas y modelamiento de arquitecturas. Lenguaje/compilador orientado para RISC de procesadores FPGA híbridos. Usa técnicas de síntesis de datapath. Interms de salida en VHDL, VHDL estructural y Verilog estructural. Herramienta de síntesis algorítmica para la generación RTL. Salidas RTL a partir de una entrada de programa en C++ pura. Interms de salida de las netlists RTL en VHDL, Verilog, y System C. Herramientas de prototipo FPGA. Poca precisión en ciclos. Diseños de rendimiento de altas velocidad de reloj. El compilador soporta optimizaciones de pipeline o paralelas.
Tabla 2 - C para compiladores de Diseño VLSI desarrollados hasta el momento
58
En la tabla anterior, se observa los compiladores en lenguaje C hasta ahora desarrollados. Dentro de estos tenemos el Transmogrifier C , desarrollado por la Universidad de Toronto, Canada. El compilador genera una netlist para un circuito secuencial que implementa el programa. Los netlist son empleados para programar un FPGA Xilinx Xilinx serie XC4000. XC4000.
Mitrion C, de la Mitrionics, que ha desarrollado un SDK 40 que habilita al software escrito, empleando un lenguaje de asignación único, ha ser compilado y ejecutado en computadores basadas en FPGA. El compilador Impulse C, de la Impulse Accelerated Tecnologies, que presenta una solución para generar código C a FPGA, el cual permite al diseñador compilar Lenguaje C directamente en lógica optimizada lista para ser empleada con los FPGAs más populares del mercado, Xilinx y Altera.
Catapult C, de la Mentor Graphics, se cuenta como una herramienta de síntesis de alto nivel para ASIC y FPGA, aportando al diseño de hardware de equipos inalámbricos y de procesamiento de imágenes y video, con librerías de algoritmos de modelación, diseño, y verificación de problemas, en las aéreas de SDTV 41 y HDTV42, Compresión y Descompresión; y filtraje de señales de video y también en procesamiento de imágenes medicas, y procesamiento de de imágenes de radar.
DIME-C es un compilador de C a VHDL de la compañía Nallatech, que aparte de trabajar con sus propias tarjetas DIMEtalk V3, tiene soporte so porte para las FPGA de Xilinx Virtex 4 y 5. Es empleado para diseñar y optimizar algoritmos. Soporta un grupo grupo de gramatica ANSI-C, ANSI-C, sin punteros, además de
40 SDK: Software Development Kit 41 SDTV: Standard Definition Television 42 HDTV: High Definition Television Television
59
soportar punto simple y punto flotante; y la optimización y paralelismacion del código cuando es posible. Por otro lado, la SCR Computers ha desarrollado un compilador “Carte” que toma un existente lenguaje de alto nivel como C o FORTRAN, FORTRAN, y con pocas modificaciones, los compila para su ejecución en el FPGA y el microprocesador. Carte extrae el máximo paralelismo del código y genera lógica de hardware segmentada.
2.1.4.3. De C a FPGA
El uso de compiladores C y lenguajes similares se dará siempre y cuando el código fuente utilizado cumpla con los estándares ISO; en su uso de señuelos, comentarios y pragmas. Dentro de las razones y beneficios de usar código C conocidas se presenta:
Hay más programadores de C que diseñadores di señadores de hardware, y escribir algoritmos en C es comúnmente más rápido que en HDL.
Existe una gran referencia de código para aplicaciones embebidas, por lo menos con la referencia escrita en C.
Trabajar con una sola descripción del programa entero facilita al diseñador o al compilador de explorar rápidamente los balances de diferentes particiones de hardware/software. También, permite que ambas versiones de hardware (HW) y software software (SW) sean creadas de de manera que el sistema operativo elija en el funcionamiento cual es mejor.
Los diseñadores pueden empezar con la compilación automática, y luego centrar sus esfuerzos en la mejora de una combinación de bucles, mientras otros se benefician del compilador en su aumento de velocidad en el código restante. Además, con el apoyo del compilador el esfuerzo que se requiere en diseño se reduce en muchos casos simplemente a la reestructuración del código o incluir directivas simples en la forma de comentarios o sintaxis # pragma.
60
El código puede ser fácilmente testeado en un microprocesador para corregir errores.
El código C original se puede particionar entre la unidad central de proceso y dispositivos reconfigurables, incluyendo procedimientos, bucles compuestos, bucles internos, y bloques.
La partición entre HW y SW basa en las capacidades de los dispositivos reconfigurables y los procesadores a usar para la implementación.
61
3. METODOLOGIA PARA LA SOLUCION DEL PROBLEMA
3.1. HERRAMIENTAS EMPLEADAS 3.1.1. IMPULSE C CoDeveloper Impulse C es un conjunto de rutinas C y que poseen librerías de extensión ANSI, que son compatibles con el estándar y al mismo tiempo con un modelo de programación paralela, en el caso de Impulse C el modelo paralelo en el que se basa es CSP 43. El entorno de Impulse C, librerías, y documentación es desarrollado por la empresa Impulse Accelerated Technologies. Su funcionamiento está centrado en la descripción de múltiples unidades de procesamiento llamadas procesos; y el soporte de streams, señales y memorias mediante funciones y tipos de datos correspondientes. Así, poder agrupar los procesos en una sola aplicación paralela que pueda funcionar completa sobre una plataforma en hardware; y esta esta aplicación corriendo en hardware al mismo tiempo tiempo sea capaz de comunicarse con procesos de software residente en un microprocesador embedded o en un entorno de simulación mediante los streams, señales y memorias. Esto permite desarrollar aplicaciones de tres tipos con las herramientas de co-simulación hardware/software y las de optimización C-toRTL44 del entorno de Impulse C como se muestra en la Figura 30: (1) traducir un módulo descrito en C hacia HDL, (2) acelerar aplicaciones de un soft-processor y (3) acelerar aplicaciones de un procesador externo; todas estas alojadas en un FPGA.
43 CSP: Communicating Sequential Processes 44 RTL: Resistor-transistor logic
63
Figura 30 - Usos de impulse C [10].
Impulse C posee una gran versatilidad y buen soporte para el desarrollo de aplicaciones. El compilador soporta el uso de scheduling, loop pipelining, y unrolling; como también el uso de sintaxis #pragma que permiten realizar optimizaciones personalizadas. Permite la simulación/emulación de escritorio, lo cual es beneficioso para el desarrollador, y trabaja con compiladores como el gcc y el Visual Studio. También posee librerías específicas para el soporte de plataformas FPGA de Xilinx Xili nx y documentación sobre Microblaze y Power-PC; así como, de Altera y los soft processors Nios I y II. Por esto Impulse C es usado en aplicaciones como procesamiento de imágenes y sistemas embedded (compresión de datos, seguridad de comunicación, diagnóstico médico y forense por imágenes, robótica y visión de máquina) y en computación de alto performance (bioinformática, criptografía, análisis de tráfico y filtrado de redes). - EL MODELO CSP Y EL MODELO DE PROGRAMACIÓN DE
IMPULSE El modelo Communicating Sequential Processes conocido como CSP por sus siglas en inglés, fue descrito por Sir Anthony Hoare en 1978 y publicado en 1985. Este modelo describe la interacción entre componentes llamados procesos, cada proceso corresponde a un programa tradicional de software el cual se comunica mediante canales de datos llamados streams.
64
Cada programa opera independientemente en su hardware, parecido al comportamiento de una máquina von Neumman; mientras que el funcionamiento del programa como un todo depende del movimiento de datos entre los canales de cada programa, considerando que estos tienen inmediato a los recursos de memoria interno. i nterno. Como modelo ideal, este no debería presentar retardos en el intercambio de datos. Resalta el concepto del acceso a la memoria local, el cual debe más rápido que a los nodos externo. Este concepto se llama locality, y es una noción importante en los l os sistemas de alto
desempeño. desempeño.
El modelo de programación de Impulse C es de comunicación de procesos secuenciales orientado aplicaciones mixtas de hardware/software basadas en streams. Los procesos son sincronizados independientemente, independientemente, aceptan diversos tipos de datos realizando cálculos específicos y asignados, generando salidas deseadas. Estos procesos no son llamados (called) como subrutinas, sino que al contrario, siempre están activos respondiendo a las señales de entrada que se les presenten; implementando paralelismo aplicado. aplicado.
Figura 31 - Flujo de una aplicación de proceso a proceso con acceso a memorias compartidas [3].
De acuerdo al modelo CSP, las aplicaciones en Impulse C poseen las siguientes características [3]:
65
La aplicación posee altos rangos de datos, de y hacia las fuentes de datos, y entre los elementos de procesamiento. procesamiento.
Los tamaños de los paquetes de datos son fijas, con una relativamente pequeña carga en los streams.
Múltiples cálculos relacionados pero independientes están obligados a realizarse en el mismo stream de datos.
La data consiste en valores de precisión baja o fija, típicamente enteros de ancho fijo o valores fraccionales en punto fijo (fixed point).
Existen referencias hacia las memorias locales o compartidas, las cuales deben ser usadas para almacenamiento de arrays de datos, coeficientes, y otras constantes, y para almacenar resultados de cómputos.
Múltiples procesos independientes están primordialmente comunicados a través de la data que está pasando, con una sincronización ocasional requerida vía mensajes.
Mediante una comunicación correcta entre procesos, se obtendrá un diseño ágil y optimizado en operación. Siendo los streams el medio perfecto para los desarrolladores de lograr sincronismo entre procesos y memorias.
3.1.2. XILINX ISE
66
La herramienta Xilinx ISE permite realizar diseños en plataformas que incorporan dispositivos reprogramables como los FPGA‟s de la familia Spartan y otros productos de Xilinx. Viene en tres ediciones llamadas Logic Edition, Embedded Edition y DSP Edition; así como las tres ediciones están contenidas en todo el paquete System Edition.
Figura 32 - Logo del ISE Design Suite de Xilinx.
Se llegó a emplear la l a edición Xilinx ISE 11.1 actualizada con el SP3, disponibles
en
la
página
web
del
fabricante:
http://www.xilinx.com/support/download/index.htm.. http://www.xilinx.com/support/download/index.htm
Figura 33 - Herramienta BSB Wizard del Xilinx Platform Studio.
3.1.3. MATLAB
67
MATLAB (abreviatura de MATrix LABoratory, "laboratorio de matrices") es un software matemático que ofrece un entorno de desarrollo integrado (IDE) con un lenguaje de programación propio (lenguaje M). Está disponible para las plataformas Unix, Windows y Apple Mac OS X. Entre sus prestaciones básicas se hallan: la manipulación de matrices, la representación de datos y funciones, la implementación de algoritmos, la creación de interfaces de usuario (GUI) y la comunicación con programas en otros lenguajes y con otros dispositivos hardware. El paquete MATLAB dispone de dos herramientas adicionales que expanden sus prestaciones, a saber, Simulink (plataforma (plataforma de simulación multidominio) y GUIDE (editor de interfaces de usuario - GUI). Además, se pueden ampliar las capacidades de MATLAB con las cajas de herramientas (toolboxes); y las de Simulink con los paquetes de bloques (blocksets). Es un software muy usado en universidades y centros de investigación y desarrollo. En los últimos años ha aumentado el número de prestaciones, como la de programar programar directamente procesadores procesadores digitales de señal o crear código VHDL. Para la implementación del filtro FIR se empleo la versión 2008, versión de prueba de 30 días suministrada en la pagina web de la Empresa Mathworks.
Figura 34 - Logo de Matlab
3.1.4. DIGILENT SPARTAN 3E STARTER BOARD
68
Figura 35 - Tarjeta Digilent Spartan 3E Starter Board Rev. D usada en la implementación.
La tarjeta posee las siguientes características e incorpora los siguientes dispositivos.
FPGA Conectores
Xilinx XC3S500E de 500K compuertas
Programación
IC’s
Memoria
Conector 100-pin Hirose FX2 Pmod de 6-pines DB15HD VGA PS/2 keyboard 2 DB9 RS-232 connectors (1 DTE , 1 DCE) RJ-45 Ethernet Header de 16-pines para módulos LCD opcionales SMA para entradas de reloj r eloj de alta velocidad JTAG via el puerto USB2 de la tarjeta; JTAG JTAG & SPI Flash con cable paralelo o USB JTAG; varias opciones de configuración. Linear Technologies Power Supplies Texas Instruments TPS75003 Triple-Supply Power Management IC SMSC LAN83C185 Ethernet PHY Memoria de 32MB Micron DDR SDRAM S DRAM 16MB Numonyx StrataFlash 2MB ST Microelectronics Serial Flash Xilinx XCF04 Platform Flash para almacenar la configuración del FPGA
Tabla 3 - Características de la Tarjeta Digilent Spartan
3.2. PROYECCIÓN DE COSTOS
69
HERRAMIENTA TARJETA SPARTAN 3E STARTER BOARD LICENCIA NODE-LOCKED XILINX ISE EMBEDDED EDITION LICENCIA PERPETUAL IMPULSE CODEVELOPER TOTAL
PRECIO (US $) 190 595 10500
11285
Tabla 4 - Precios de herramientas a utilizar en un diseño.
La tarjeta Digilent Spartan 3E fue una donación como desarrollador hacia el Ing. Kalún Lau Gan al ser parte del Xilinx University Program. Mientras que la licencia usada en el Xilinx ISE fue la del trial de 30 días. La licencia del Impulse CoDeveloper fue una donación de tres meses de un miembro del staff de Impulse.
3.3. TECNICA DE DISEÑO TOP-DOWN La programación es sin duda una actividad compleja, pues en ella se combinan muchos procesos procesos mentales [16]. También conocida como como de arriba-abajo, consiste consiste en establecer una serie de niveles de mayor a menor complejidad (arriba-abajo) que den solución al problema. Se establece una relación entre las etapas de la estructuración de forma que una etapa jerárquica y su inmediato inferior se relacionen rel acionen mediante entradas y salidas de información. Este diseño se caracteriza por una serie de descomposiciones descomposiciones sucesivas del problema inicial, que recibe el refinamiento progresivo del repertorio de instrucciones que van a formar parte del programa. La utilización de la técnica de diseño Top-Down tiene los siguientes objetivos básicos:
Simplificación del problema y de los subprogramas de cada descomposición. descomposición.
Las diferentes partes del problema pueden ser programadas de modo independiente e incluso por diferentes personas.
70
El programa final queda estructurado en forma de bloque o módulos lo que hace más sencilla su lectura y mantenimiento.
Figura 36 - Representacion de un diseño TOP-DOWN.
3.4. PROGRAMACION ESTRUCTURADA ESTRUCTURADA La programación estructurada (PE) es una forma de escribir programas de ordenador (programación de computadora) de forma clara. Para ello utiliza únicamente tres estructuras: secuencia, selección e iteración; siendo innecesar i nnecesario io el uso de la instrucción o instrucciones de transferencia incondicional (GOTO, EXIT FUNCTION, EXIT SUB o múltiples RETURN).
Figura 37 – Ejemplo de un Programación Estructurada
Un programa estructurado se compone de funciones, segmentos, módulos y/o subrutinas, cada una con una sola entrada y una sola salida. Cada uno de estos
71
módulos (aún en el mismo programa completo), se denomina programa apropiado cuando, además de estar compuesto solamente por las tres estructuras básicas, tiene sólo una entrada y una salida y en ejecución no tiene partes por las cuales nunca pasa ni tiene ciclos infinitos. La PE tiene un teorema estructural o teorema fundamental, el cual afirma que cualquier programa, no importa el tipo de trabajo que ejecute, puede ser elaborado utilizando únicamente las tres estructuras básicas (secuencia, selección, iteración).
Ventajas de la programación estructurada
Los programas son más fáciles de entender, ya que pueden ser leídos de forma secuencial, sin necesidad de hacer seguimiento a saltos de línea (GOTO) dentro de los bloques de código para entender la lógica.
La estructura del programa es clara, puesto que las instrucciones están más ligadas o relacionadas entre sí.
Reducción del esfuerzo en las pruebas. El seguimiento de los fallos o errores del programa ("debugging") se facilita debido a la estructura más visible, por lo que los errores se pueden detectar y corregir más fácilmente.
Reducción de los costos de mantenimiento de los programas.
Programas más sencillos y más rápidos (ya que es más fácil su optimización).
Los bloques de código son auto explicativos, lo que facilita la documentación.
Los GOTO se reservan para construir las instrucciones básicas. Aunque no se usan de forma directa, por estar prohibida su utilización, están incluidas implícitamente en las instrucciones de selección e iteración.
Un programa escrito de acuerdo a estos principios no solamente tendrá una mejor estructura sino también una excelente presentación.
La programación estructurada ofrece estos beneficios, pero no se la debe considerar como una panacea ya que el desarrollo de programas es, principalmente, una una tarea de dedicación, dedicación, esfuerzo esfuerzo y creatividad.
Inconvenientes de la programación estructurada
72
El principal inconveniente de este método de programación es que se obtiene un único bloque de programa, que cuando se hace demasiado grande puede resultar problemático su manejo; esto se resuelve empleando la programación modular, definiendo módulos interdependientes programados programados y compilados por separado (en realidad esto no es necesario, pero es recomendable para su mantenimiento y funcionalidad). En realidad, cuando se programa hoy en día se suelen utilizar, tanto las técnicas de programación estructurada como las de programación modular, de forma conjunta y por lo tanto es posible que cuando uno haga referencia a la programación estructurada esté considerando también
las técnicas de
modularización. Un método un poco más sofisticado es la programación por capas, en la que los módulos tienen una estructura jerárquica en la que se pueden definir funciones dentro de funciones o de procedimientos. procedimientos.
3.5. DISEÑO DE UN FILTRO FIR EN MATLAB El propósito del experimento es la implementación del Filtro FIR para su posterior análisis. El filtro está basado en el sgte. esquema:
Figura 38 - Esquema Filtro FIR
73
Para la experimentación con el filtro, fil tro, empleamos como señal de entrada una señal cuadrada implementamos en el MATLAB con el nombre de senial_entrada (ANEXO 1), con frecuencia fundamental de 100hz una amplitud de 2 unidades pico a pico, con un periodo de 0.02segundos y una frecuencia de muestreo de 48Khz, obtenido de la sgte manera:
Donde
= 2.5
Fo= frecuencia fundamental f undamental
Figura 39 - Señal de Entrada (double)
La señal previa implementada se encuentra en valores double, sin embargo para nuestro análisis también empleamos el uso de valores fixed-point. fixed -point.
74
Figura 40 - Señal de Entrada (fixed point)
Para el diseño del FIR empleamos la función fir1, que diseña los filtros FIR por método de ventana. La función es llamada introduciendo, en el ambiente de trabajo de MATLAB, la siguiente instrucción: i nstrucción: B = fir1(N, Wn), Donde el vector B, de longitud N+1, contendrá los coeficientes de un filtro digital FIR pasabajas de orden N. La frecuencia de corte Wn debe estar entre 0 < Wn < 1.0, donde 1.0 corresponde a la mitad de la frecuencia de muestreo. El filtro resultante es real y tiene fase lineal, es decir, tiene simetría par en sus coeficientes obedeciendo obedeciendo la relación:
, en donde k = 1, 2, …,N+1
Para nuestro diseño empleamos un FIR pasabajos, de orden 256, teniendo en cuenta que cuanto mayor es la orden del filtro obtendremos un mejor filtrado en la
75
señal, pero el tiempo de procesamiento también aumenta siendo una desventaja para aplicaciones en tiempo real. Determinamos Wn, Wn, la frecuencia frecuencia de corte normalizada, normalizada, a través de la sgte sgte división: fc/fn, donde fn es la frecuencia de muestreo entre 2 y fc la frecuencia de corte del filtro que deseamos implementar. implementar. Ya que el la frecuencia de corte de nuestro filtro a diseñar es de 150hz, y la frecuencia de muestreo es de 48k, obtenemos un valor de Wn = 0.0063. Una vez que hemos obtenido estos valores, pasamos a la implementación de la ecuación del filtro FIR en MATLAB MATLA B con el nombre de “filtro_senial” (ANEXO 2) , el cual es dado por:
El programa del filtro fi ltro obedece al siguiente diagrama de flujo: INICIO
Señal Entrada -> x(n) fir1 ->coeficientes h(n)
Tiempo1 = cputime N=256 n= 0 i=0
SI
n=lenght(x)?
NO SI i=N?
i=1 n=n+1
NO
Y(n)=y(n)+(x(n-i)*h(i)) i=i+1
tiempo2=cputime-tiempo1 Display “tiempo2 “tiempo 2” Plot “y(n) “y(n)”” Plot “Respuesta en Frecuencia”
FIN
Figura 41 - Diagrama de Flujo Filtro FIR
76
Obteniendo el sgte resultado:
Figura 42 - Señal de Salida y(n) (double)
Figura 43 - Señal de Salida y(n) (fixed point)
Figura 44 - Respuesta en Frecuencia Filtro Fir
77
3.6.
FIR256 Y FIR_ACCELERATED FIR_ACCELERATED
En la implementación usamos como base los ejemplos “FIR filter example” explicado en el libro “Practical FPGA Programming In C” de David Pellerin y Scott Thibault citado en las referencias bibliográficas [3], [3] , y “Complex FIR Filter example” creado por Bruce Bruce Karsten [ 9] de Xilinx. Ambos ejemplos pueden conseguirse contactándose contactándose con el soporte al usuario de Impulse a la dirección electrónica
[email protected] [email protected].. Los coeficientes obtenidos en el diseño del filtro FIR en MATLAB fueron usados en la implementación de dos filtros C fixed point: “FIR256” y “FIRACCELERATED”, así como la misma señal de entrada para realizar pruebas y corroborar resultados. El uso de algoritmos con operaciones en fixed point se debe principalmente al menor consumo de capacidades computacionales tanto en hardware como en tiempo a comparación de algoritmos en floating point. La notación usada corresponde a 1 bit de signo, 8 bits enteros y 23 bits fraccionales; conocida como 1s8.23 y descrita en la siguiente figura:
Figura 45 - Capas de representación en fixed point. [9]
78
FIR256 Este algoritmo corresponde a un filtro FIR de orden 256 en fixed point donde la operación de multiplicación es realizada en un buffer circular con desplazamiento de muestra, el cual fue implementado con el propósito de observar el funcionamiento de un FIR mediante simulación en Impulse CoDeveloper en una computadora desktop y comparar los resultados al filtrar con los obtenidos en MATLAB. Sw 1
Coefficients.dat
roduc
Filter_in.dat
consume
stre stream am read read
2
coef
4
firbuffe
FIR
Figura 46 - Funcionamiento de FIR256 FIR256 por bloques.
La carga de valores de coeficientes se realiza a partir del archivo Coefficients.dat donde se encuentran los valores en fixed point obtenidos en MATLAB. Estos valores pasan del SW al HW mediante un stream de lectura a llenar el array de coeficientes „coef‟, considerando a la entidad de HW en modo lectura y al SW como un productor. Luego se llena el array „firbuffer‟ con los valores en fixed point de la misma señal de entrada empleada en MATLAB provenientes del archivo Filter_in.dat por el mismo stream. Una vez llenos los lo s arrays estos pasan a operarse en la estructura FIR y el resultado es enviado mediante un stream de escritura hacia la estructura consumidora de SW y finalmente se expulsan hacia un archivo llamado Filter_out.dat mediante otro stream de escritura.
79
INICIO
int tap; int TAPS=256; co_int32 nSample; co_int32 coef[tap];
tap
no
sí coef[tap]=nSample; ta ++
FIN Figura 47 - For para el llenado del array ‘coef’
El llenado del array „coef‟ es completo, mientras que el de „firbuffer‟ es con un espacio para una muestra, la cual se toma al momento que inicia la estructura FIR. En ambos se hace uso de una variable llamada „nSample‟ que está asignada al stream de lectura, las dos se llenan por el uso de un comando cíclico y están dispuestas en el algoritmo una a continuación de otra por lo que no es necesario instanciar las variables nuevamente nuevamente para el llenado l lenado de „firbuffer‟. Una vez operados los valores pasan a una variable llamada „nFiltered‟ relacionada al stream de escritura utilizado para la salida y luego se realiza el desplazamiento “hacia atrás” de las muestras para darle lugar a una muestra posterior.
80
INICIO
int tap; int TAPS=256; co_int32 nSample; co_int32 firbuffer[TAPS];
tap=1;
tap
no
sí firbuffer[tap-1]=nSample; ta ++;
FIN Figura 48 - For para el llenado del array ‘firbuffer’
81
INICIO
int tap; int TAPS=256; co_int32 nSample; co_int32 firbuffer; co_int32 accum; co_int32 nFiltered;
firbuffer[TAPS-1]=nSample; accum=0x00000000; no
tap
accum+=FXMUL32(firbuffer[tap],coef[tap],23);
nFiltered=accum; tap=1;
tap
no
sí firbuffer[tap-1]=firbuffer[tap]
FIN Figura 49 - F uncionamiento de FIR256
82
FIR_ACCELERATED Es un filtro FIR circular a partir de un soft processor Microblaze, este implementa dos relojes „TimeHa‟ y „TimeSa‟ para medir el tiempo de operación en software y hardware y contrastarlos. El objetivo es apreciar la aceleración en hardware de procesos siendo este caso la operación de un mismo filtro FIR en fixed point dentro del uBlaze como en el hardware mediante la obtención de un factor de aceleración. XC3S500E SW uBlaze TimeHA TimeSA
fxmul32 call_accelerator HW FIR
Figura 50 - Funcionamiento FIR_ACCELERATED FIR_ACCELERATED en bloques.
El factor de aceleración obedece a la ecuación:
, donde:
y es el reloj para medir el tiempo de
operación en el procesador uBlaze. y es el reloj para medir el tiempo de
operación en hardware.
FinishIF_TS: es el tiempo final de operación del timer. StartIF_TS: es el tiempo inicial de operación del timer.
83
TIMER_FREQ_MILLI: TIMER_FREQ_MILLI: es la frecuencia en HZ del CPU entre 1000. Así mismo, se implementó una macro llamada „fxmul32‟ la cual permite realizar la multiplicación de 32 bits requerida por el filtro porque la macro „FXMUL32‟ utiliza en su definición un tipo de 64 bits. Esta macro implementada se ajusta a las características del procesador Microblaze el cual es de arquitectura de 32 bits.
INICIO
int16 a1,ah,b1,bh; int16 r1,r2,r3;
a1=a . 0xFF; ah=(a>>16).0xFF; b1=b.0xff; bh=(b>>16).0xFF;
r1=FXMUL16(ah,bh,FRACBITS-16); r2=FXMUL16(ah,b1,FRACBITS-16); r3=FXMUL16(a1,bh,FRACBITS-16);
return (((int16)r1 << 16) + (int16)r2 + (int16)r3);
FIN Figura 51 - Macro fxmul32, usando la macro de Impulse C FXMUL16 definido FRACBITS=23 en FIR_ACCELERATED.
84
El buffer circular fue implementado a base de punteros. Si tenemos un array de coeficientes llamado coef_values donde sus valores son {b0,b1,b2,…,b255} estos pasarán a un buffer para coeficientes llamado coef_mem donde al ingresar se posicionan: b0
coef_mem[0],coef_values[0] b1
b0
coef_mem[1] b2
b1
b0
coef_mem[2] b255 b254 b253
…
…
b3
b2
b1
b0
coef_mem[255], coef_values[255] Figura 52 - Implementacion de punteros para buffer circular
Es el mismo caso para el buffer de valores a filtrar. Al tener en un array llamado „filter_values‟ de tamaño N los valores serán señalados por el puntero „pvalues‟, estos pasaran a un buffer „filter_mem‟ de tamaño de los TAPS TAPS para coeficientes señalado por po r el puntero „pmem‟, en este caso 256, hasta hasta llenarlo, luego el puntero „pmem‟ señalará filter_mem[0] y volverá a llenarse con la última posición conocida de „filter_values‟ más 1 ; para la primera ronda sería pvalues=255+1. pvalues=255+1. Es decir se están señalando señalando las posiciones de un array, no las posiciones de memoria. Cuando se invoca al método call_accelerator para operar en hardware se realiza el mismo llenado de buffer con otros nombres en los arrays arrays y punteros. Es básicamente básicamente el el principio de funcionamiento funcionamiento de FIR256, el método „call_acelerator‟ hace la función de productor y consumidor siendo aquí donde se le pasan los datos al hardware para operar y donde se
85
reciben los resultados de operación para comprobar el buen funcionamiento f uncionamiento del filtro en hardware.
FIR_ACCELERATED FIR_ACCELERATED HACIA LA TARJETA SPARTAN 3E STARTER Una vez terminado el código se pasó a la compilación mediante la herramienta Impulse C Co Developer, de forma que se pueden descartar errores en la sintaxis de código y referencias, así como la creación de un ejecutable usado para la simulación. Para esto se hace click en Project>>Build Software Simulation Executable Executable Observamos que la consola no arrojó errores al compilar.
Figura 53 - Consola de Mensajes
Se especificó el soporte a la plataforma (Xilinx Microblaze FSL). Click en Project>>Options. Y en el cuadro de diálogo se seleccionó la plataforma y habilitamos los dual clocks que nos permitieron la correcta incorporación de nuestro hardware generado hacia la tarjeta posteriormente. Luego se dio click en Aceptar.
86
Figura 54 - Menu Opciones de Impulse C Compiler
Se generó el HDL para la plataforma. Para esto se dio click sobre Project>>Generate Project>>Generate HDL
Figura 55 - Menu Generación de HDL
Se obtuvo en consola un resultado sin ningún ningún error.
Figura 56 - Consola de Errores
87
Luego se exportó el Hardware generado hacia una carpeta EDK, la cual está contenida dentro de la carpeta donde se alojarán todos los archivos de nuestro proyecto. Se dió click sobre Project>>Export Project>>Export Generated Hardware (HDL). Se hizo lo mismo para el software Project>> Export Generated Software.
Figura 57 - Menu Exportación de HDL
Se procedió a realizar el diseño para el FPGA con la herramienta Xilinx Ise 11.1 SP3 EDK Platform Studio. Al abrirla se inició un proyecto con el Base System Builder wizard el cual es una herramienta que facilita el diseño de sistemas mediante una interfaz paso a paso.
Figura 58 - Menu Abrir Proyecto Xilinx Platform Studio
Se ubicó la ruta del proyecto en la misma carpeta EDK donde se generó el software y el hardware en Impulse CoDeveloper para evitar problemas en búsqueda y relación de archivos. archivos.
88
Figura 59 - Menu Proyecto Nuevo empleando el Wizard
Figura 60 - Menu Guardar, Xilinx Platform Studio
En la siguiente pantalla del wizard elegimos crear un nuevo diseño. Click sobre Next.
89
Figura 61 - Bienvenida al Menu Constructor
Elegimos las características de nuestra tarjeta Xilinx Spartan 3E Starter Board Revision D y continuamos.
Figura 62 - Selección de la Tarjeta a emplear
90
Se eligió un sistema de un solo procesador, porque solo queríamos un Microblaze corriendo para producir un sistema de co procesador único como se había referido en el algoritmo en Impulse CoDeveloper.
Figura 63 - Selección del Sistema de Procesamiento
Mantuvimos las frecuencias de los relojes ambas en 50 Mhz tanto la del sistema como la de referencia y la memoria memori a en 8KB. Puesto que el oscilador que trae la tarjeta es de esa frecuencia.
Figura 64 - C onfiguración del Procesador
91
Removimos todos los periféricos que no usamos, solo dejamos el puerto RS232 DCE, agregamos un Timer. Quedando la lista de componentes como se observa en la imagen 65.
Figura 65 - C onfiguración de los periféricos
Se usó la siguiente configuración del puerto RS232.
Figura 66 - C onfiguración del puerto RS232
Se usó la siguiente configuración del timer, a dos timers presente para poder referenciar los relojes de sistema y de aplicación. apli cación.
92
Figura 67 - C onfiguración del módulo Timer
Habilitamos la caché de instrucciones y de datos. Ambas en 2K.
Figura 68 - Configuración de la Memoria Caché
Se mantuvo la configuración de la sección Application, en esta sección del wizard referencian a las aplicaciones de prueba de hardware y memoria, para corroborar el correcto estado y funcionamiento de estas, al igual que se hace en otros dispositivos electrónicos antes de empezar a operar.
93
Figura 69 - Configuración de la Aplicación
Observamos el sumario de la implementación que hemos realizado y se finalizó el wizard.
Figura 70 - Finalización de la Creación del Proyecto
94
Una vez en el entorno del Platform Studio. Agregamos el IP Core correspondiente al hardware creado y definido en Impulse CoDeveloper que en nuestro caso es un FIR acelerado para funcionamiento junto a un co procesador mediante el bus FSL. Para eso click sobre IP Catalog>>Project Local Pcores>>USER y ubicamos fsl_filt. Luego anticlick sobre él y le damos click a Add IP.
Figura 71 - Bus Interfaces
Luego agregamos dos buses FSL que permitirán a fsl_filt comunicarse con el procesador Microblaze. Microblaze. Con un click sobre Bus and Bridge y luego anticlick sobre Add IP (este paso lo hacemos dos veces para obtener los dos buses deseados).
Figura 72 - Añadiendo una IP
95
Configuramos el procesador para que acepte los dos buses FSL. Dimos anticlick sobre microblaze_0 y click sobre configure IP. Al aparecer la ventana de diálogo de configuración en la pestaña Buses agregamos los 2 links FSL.
Figura 73 - Configurando la IP
Figura 74 - Microblaze
Luego se procedió a realizar esta conexión donde se conectan la aplicación del filtro con el procesador Microblaze mediante su interface de bus de salida MFSL0 con el de entrada de la aplicación SFSL0 y el de entrada SFSL0 de
96
Microblaze con el de salida de la aplicación MSFL1. Así obteniendo un bus bidireccional para el intercambio de datos. microblaze_0 MFSL0 con fsl_v20_0 fsl_filt_0 SFSL0 con fsl_v20_0 microblaze_0 SFSL1 con fsl_v20_1 fsl_filt_0 MFSL1 con fsl_v20_1
Figura 75 - Configuración del Microblaze
Figura 76 - Configuración del fsl_filt_0
Configuramos los relojes en >>Ports. FSL_Clk en 50 MHz y el SYS_Rst hacia net_gnd en ambos buses FSL asignando de esta forma el mismo reloj al que opera el procesador Microblaze.
Figura 77 - Configuración Configuración de los Relojes
97
Configuramos un reloj adicional el cual definimos su existencia al habilitar el dual
clock
en
el
Impulse
CoDeveloper.
Dimos
anticlick
sobre
clock_generator_0 y luego click sobre Configure IP. Necesitamos agregar un reloj a 25 MHz la mitad de la frecuencia del reloj de sistema. Para esto en la pestaña System de la ventana emergente seleccionamos en Slow 25.000000 y luego damos click sobre Validate Clocks
Figura 78 - Configuracion de la IP
Figura 79 - Configuración del Reloj
En la pestaña Ports Overview pudimos ver la aparición de un CLKOUT3 a 25 MHz. Cerramos la ventana con un click en Ok.
98
Figura 80 - Sumario de los Puertos
Configuramos los relojes de fsl_filt_0 asignando el nuevo clock creado con el cual funcionará. Para co_clk le asignamos el reloj de 25 MHz y a FSL_Rst lo enviamos a net_gnd.
Figura 81 - Configuración del fls_filt_0
Luego en la pestaña Addresses, click sobre Generate Addresses. Y observamos en consola el mensaje de generación exitosa.
Figura 82 - Ventana de Direcciones
99
Figura 83 - Ventana de Mensajes de Consola
Generamos el Bitstream, se dio click en >>Hardware>>Generate Bitstream. El proceso tomó unos unos minutos en completarse.
Figura 84 - Generacion del BitStream
Luego se dio click en >>Software>>Build >>Software>>Build All User Applications.
Figura 85 - Construcción de la Aplicación de Usuario
100
Actualizamos el bitstream con los cambios al compilar el software. Click sobre >>Device Configuration>> Update Bitstream.
Figura 86 - Actualización del bistream.
Agregamos nuestra aplicación en software. Doble click sobre Add Software Application Project.
Figura 87 - Agregar aplicación de software al proyecto.
En la ventana que apareció escribimos el nombre de nuestra aplicación. Click sobre OK.
101
Figura 88 - Insertar nombre a la aplicación de software.
Agregamos los archivos generados por Impulse en una carpeta llamada Code. Los agregamos a Sources y Header. Para eso se dio doble click sobre Sources lo cual abrió una ventana para encontrar los archivos. Se seleccionaron (todos) los archivos respectivos a cada caso y se les dio click en Abrir.
Figura 89 - Agregar source y header files.
102
Figura 90 - Archivos S ource dentro de la carpeta code.
Figura 91 - Archivos header dentro de la carpeta Code.
Se compiló el proyecto, para esto dimos click en Build Project.
103
Figura 92 - Construcción del proyecto proyecto de usuario.
Una vez compilado se genero el Linker Script, para asignar secciones de memoria. Dimos anticlick al proyecto y luego click sobre Generate Linker Script.
Figura 93 - Generación del linker script.
Se realizaron los siguientes cambios y dimos click a Ok.
Figura 94 - Ventana de opciones del Linker Script.
Compilamos de nuevo el proyecto, para esto dimos click en Build Project.
Figura 95 - Segunda compilación del proyecto de usuario.
104
Cambiamos la aplicación de inicio en las BRAMs. Dimos anticlick sobre Default:microblaze_0_bootloop Default:microblaze_0_bootloop y luego click sobre Mark to Initialize BRAMs.
Figura 96 - Selección de la aplicación aplicación de arranque en BRAMs BRAMs para microblaze.
Actualizamos el bitstream con los cambios. Click sobre >>Device Configuration>> Update Bitstream.
Figura 97 - Tercera actualización del bitstream.
Conectamos la tarjeta por el puerto RS232_DCE y el cable USB para poder programarla y luego la encendimos. Para bajar el proyecto a la tarjeta dimos click en >>Device Configuration>>Download Configuration>>Download Bitstream.
Figura 98 - Iniciar la descarga del bitstream a la plataforma.
Apareció el cuadro de diálogo Debug Configuration. En la pestaña JTAG Properties verificamos que se encuentre en tipo Auto.
105
Figura 99 - Opciones JTAG.
Iniciamos una sesión en Hyperterminal.
Figura 100 - Configuración en hyperterminal para para la comunicación con la plataforma.
Lanzamos la consola XMD. Para eso hicimos click >>Debug>>Launch >>Debug>>Launch XMD.
Figura 101 - Inicio de la consola XMD.
106
Una vez en consola tipeamos los comandos para empezar a correr el proyecto en la tarjeta.
dow FIR_ACCELERATED/executab FIR_ACCELERATED/executable.elf le.elf con
107
4. RESULTADOS
Al correr la simulación en CoDeveloper de la aplicación FIR256 se puede realizar una monitorización del proceso simulado con una herramienta llamada Application monitor, esta aplicación muestra las entidades que componen a la aplicación, siendo observables incluso en plena simulación. Al abrir el monitor observamos el diagrama de bloques esperado como muestra la Figura 102, muy similar al mostrado en la descripción de la aplicación en la Figura 46 anteriormente. Tres entidades claramente definidas: producer_process, producer_process, filter_process y consumer_process, consumer_process, que corresponden al productor de valores, al filtro en sí y al consumidor de valores respectivamente.
Figura 102 - Diagrama de bloques del filtro FIR256 obtenido al simular en CoDeveloper mediante el Application Monitor.
Figura 103 - Test consumer en funcionamiento del filtro FIR256.
Al seleccionar cada una de las entidades, se vio a la entidad en bloque conectada mediante streams hacia otras entidades, mientras que la consola mostró valores de intercambio y resultados de operaciones que los manipulaban como podemos apreciar en las Figura 103, Figura 104 y Figura 105.
109
Figura 104 - Filter process en funcionamiento del filtro FIR256.
Figura 105 - Test producer en funcionamiento del filtro FIR256.
Al finalizar la simulación, en la herramienta Stage Master Explorer navegamos en el DFG de la aplicación como apreciamos en la Figura 106, siendo esta una herramienta útil para el planeamiento de optimización de la aplicación puesto que se puede observar observar los bloques de funciones funciones anidadas anidadas y nodos de intercambio.
110
Figura 106 - DataflowGraph (DFG) del filtro FIR256.
Terminada la simulación, tomamos los valores de la señal filtrada y los introdujimos al MATLAB para compararlos con la señal filtrada inicialmente en MATLAB. El ploteo arrojó señales “idénticas” que se superponían como muestra la Figura 108. Sin embargo al hacer un zoom de acercamiento notamos una desviación pequeña como muestra la Figura 107. Entonces calculamos la tasa de error porcentual mediante el algoritmo descrito en el ANEXO 4 cuyo valor resultante está en la Figura 114 y la función correspondiente la ploteamos en la Figura 113.
Figura 107 - Gr áfica en MATLAB con acercamiento, donde están ploteados los valores obtenidos con CoDeveloper y los obtenidos al implementar un FIR en MATLAB.
111
Figura 108 - Gráfica en MATLAB, donde están ploteados los valores obtenidos con CoDeveloper y los obtenidos al implementar un FIR en MATLAB.
Una vez terminadas las pruebas con la aplicación FIR256 pasamos a realizar la implementación con FIR_ACCELERATED para obtener un factor de aceleración. Para tener un punto de comparación calculamos los tiempos de procesamiento en la computadora desktop tanto del FIR en floating point como en fixed point y los mostramos en segundos, Figura 109. Completada la implementación hacia la tarjeta, empezamos a correr el Microblaze junto a nuestra versión acelerada del FIR. Por lo que vimos en la consola XMD como arranca en la plataforma como mostramos en la Figura 110, y guardamos el logfile del funcionamiento en plataforma según está en la Figura 111.
Figura 109 - Ventana de Matlab con mensaje del Tiempo de Procesamiento
112
Figura 110 - Consola XMD al correr la a plicación del FIR creada para Microblaze.
Xilinx Microprocessor Debugger (XMD) Engine Xilinx EDK 11.3 Build EDK_LS3.57 Copyright (c) (c) 1995-2009 Xilinx, Inc.
All rights reserved.
Release 11.3 - psf2Edward EDK_LS3.57 (nt) Copyright (c) (c) 1995-2009 Xilinx, Inc.
All rights reserved.
Checking platform configuration ... IPNAME:plb_v46 INSTANCE:mb_plb C:\Impulse\CoDeveloper3\Examples\Embedded\ComplexFIR_MicroBlaze\EDK\system.mhs line 66 - 2 master(s) : 3 slave(s) IPNAME:lmb_v10 INSTANCE:ilmb C:\Impulse\CoDeveloper3\Examples\Embedded\ComplexFIR_MicroBlaze\EDK\system.mhs line 73 - 1 master(s) : 1 slave(s) IPNAME:lmb_v10 INSTANCE:dlmb C:\Impulse\CoDeveloper3\Examples\Embedded\ComplexFIR_MicroBlaze\EDK\system.mhs line 80 - 1 master(s) : 1 slave(s) IPNAME:fsl_v20 INSTANCE:fsl_v20_0 C:\Impulse\CoDeveloper3\Examples\Embedded\ComplexFIR_MicroBlaze\EDK\system.mhs line 237 - 1 master(s) : 1 slave(s) IPNAME:fsl_v20 INSTANCE:fsl_v20_1 C:\Impulse\CoDeveloper3\Examples\Embedded\ComplexFIR_MicroBlaze\EDK\system.mhs line 244 - 1 master(s) : 1 slave(s)
113
Checking port drivers... WARNING:EDK:2098 - PORT:IWAIT CONNECTOR:ilmb_LMB_Wait c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\microblaze_v7_20_c\data\mic
roblaze_v2_1_0.mpd line 234 - No driver found. Port will be driven to GND! WARNING:EDK:2098 - PORT:DWAIT CONNECTOR:dlmb_LMB_Wait c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\microblaze_v7_20_c\data\mic
roblaze_v2_1_0.mpd line 270 - No driver found. Port will be driven to GND! WARNING:EDK:2098 - PORT:bscan_tdo1 CONNECTOR:bscan_tdo1 c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
.mpd line 230 - No driver found. Port will be driven to GND! WARNING:EDK:2099 - PORT:I_ADDRTAG CONNECTOR:ilmb_M_ADDRTAG c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\microblaze_v7_20_c\data\mic
roblaze_v2_1_0.mpd line 232 - floating connection! WARNING:EDK:2099 - PORT:D_ADDRTAG CONNECTOR:dlmb_M_ADDRTAG c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\microblaze_v7_20_c\data\mic
roblaze_v2_1_0.mpd line 273 - floating connection! WARNING:EDK:2099 - PORT:FSL0_M_CLK CONNECTOR:fsl_v20_0_FSL_M_Clk c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\microblaze_v7_20_c\data\mic
roblaze_v2_1_0.mpd line 375 - floating connection! WARNING:EDK:2099 - PORT:FSL1_S_CLK CONNECTOR:fsl_v20_1_FSL_S_Clk c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\microblaze_v7_20_c\data\mic
roblaze_v2_1_0.mpd line 380 - floating connection! WARNING:EDK:2099 - PORT:bscan_tdi CONNECTOR:bscan_tdi c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
.mpd line 223 - floating connection! WARNING:EDK:2099 - PORT:bscan_reset CONNECTOR:bscan_reset c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
114
.mpd line 224 - floating connection! WARNING:EDK:2099 - PORT:bscan_shift CONNECTOR:bscan_shift c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
.mpd line 225 - floating connection! WARNING:EDK:2099 - PORT:bscan_update CONNECTOR:bscan_update c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
.mpd line 226 - floating connection! WARNING:EDK:2099 - PORT:bscan_capture CONNECTOR:bscan_capture c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
.mpd line 227 - floating connection! WARNING:EDK:2099 - PORT:bscan_sel1 CONNECTOR:bscan_sel1 c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
.mpd line 228 - floating connection! WARNING:EDK:2099 - PORT:bscan_drck1 CONNECTOR:bscan_drck1 c:\Xilinx\11.1\EDK\hw\XilinxProcessorIPLib\pcores\mdm_v1_00_f\data\mdm_v2_1_0
.mpd line 229 - floating connection! WARNING:EDK:2099 - PORT:FSL0_S_Clk CONNECTOR:fsl_v20_0_FSL_S_Clk C:\Impulse\CoDeveloper3\Examples\Embedded\ComplexFIR_MicroBlaze\EDK\pcores\fs
l_filt_v1_00_a\data\fsl_filt_v2_1_0.mpd l_filt_v1_00_a\data\fsl_filt_v2 _1_0.mpd line 13 - floating connection! WARNING:EDK:2099 - PORT:FSL1_M_Clk CONNECTOR:fsl_v20_1_FSL_M_Clk C:\Impulse\CoDeveloper3\Examples\Embedded\ComplexFIR_MicroBlaze\EDK\pcores\fs
l_filt_v1_00_a\data\fsl_filt_v2_1_0.mpd l_filt_v1_00_a\data\fsl_filt_v2_ 1_0.mpd line 18 - floating connection!
Performing Clock DRCs...
Performing Reset DRCs...
115
Overriding system level properties...
Running system level update procedures...
Running UPDATE Tcl procedures for OPTION SYSLEVEL_UPDATE_PROC...
Running system level DRCs...
Performing System level DRCs on properties...
Running DRC Tcl procedures for OPTION SYSLEVEL_DRC_PROC...
XMD% Info:AutoDetecting cable. Please wait. Info:Connecting to cable (Usb Port - USB21). Info:Checking cable driver. Info: Driver file xusb_emb.sys found. Info: Driver version: src=1029, dest=1029. Info: Driver windrvr6.sys version = 8.1.1.0.Info: WinDriver v8.11 Jungo (c) 1997 - 2006 Build Date: Oct 16 2006 X86 32bit SYS 12:35:07, version = 811. Info: Cable PID = 0008. Info: Max current requested during enumeration is 74 mA. Info:Type = 0x0004. Info: Cable Type = 3, Revision = 0. Info: Setting cable speed to 6 MHz. Info:Cable connection established. Info:Firmware version = 1303. Info:File version of c:/Xilinx/11.1/ISE/data/xusb_xlp.hex = 1303. Info:Firmware hex file version = 1303. Info:PLD file version = 0012h. Info: PLD version = 0012h. Info:Type = 0x0004. Info: ESN device is not available for this cable.
JTAG chain configuration
116
-------------------------------------------------Device
ID Code
IR Length
Part Name
1
01c22093
6
XC3S500E
2
f5046093
8
XCF04S
3
06e5e093
8
XC2C64A
MicroBlaze Processor Configuration : ------------------------------------Version............................7.20.c Optimization.......................Area Interconnect.......................PLBv46 MMU Type......................... Type...........................No_MMU ..No_MMU No of PC Breakpoints...............1 No of Read Addr/Data Watchpoints...0 No of Write Addr/Data Watchpoints..0 Instruction Cache Support..........on Instruction Cache Base Address.....0x44000000 Instruction Cache High Address.....0x47ffffff Data Cache Support.................on Data Cache Base Address............0x44000000 Data Cache High Address............0x47fffff Address............0x47ffffff f Exceptions FPU
Support................off
Support.......................off
Hard Divider Support...............off Hard Multiplier Support............on - (Mul32) Barrel Shifter Support.............off MSR clr/set Instruction Support....on Compare Instruction Support........on Number of FSL ports................2 Extended FSL Support...............off Data Cache Write-back Support......off
Connected to "mb" target. id = 0 Starting GDB server for "mb" target (id = 0) at TCP port no 1234 XMD% dow ComplexFIR/executable.elf
117
System Reset .... DONE Downloading Program -- ComplexFIR/executable.elf section, .vectors.reset: 0x00000000-0x00000007 section, .vectors.sw_exception: 0x00000008-0x0000000f section, .vectors.interrupt: 0x00000010-0x00000017 section, .vectors.hw_exception: 0x00000020-0x00000027 section, .text: 0x44000000-0x44003c0b section, .init: 0x44003c0c-0x44003c2f section, .fini: 0x44003c30-0x44003c4b section, .rodata: 0x44003c4c-0x440053f1 section, .data: 0x440053f4-0x44005923 section, .ctors: 0x44005924-0x4400592b section, .dtors: 0x4400592c-0x44005933 section, .eh_frame: 0x44005934-0x44005937 section, .jcr: 0x44005938-0x4400593b section, .sbss: 0x4400593c-0x4400593f section, .bss: 0x44005940-0x4400780b section, .heap: 0x4400780c-0x4404780f section, .stack: 0x44047810-0x4408780f Setting PC with Program Start Address 0x00000000
XMD% con 0x44000000 Info:Processor started. Type "stop" to stop processor
RUNNING> XMD%
Figura 111 - Registro log de la consola XMD al correr la aplicación del FIR creada para Microblaze.
Observamos un correcto funcionamiento de nuestra aplicación junto al Microblaze y pudimos obtener el factor de aceleración que tratábamos t ratábamos de medir como se observa en la Figura 112. Este resultado apareció en una ventana hyperterminal, puesto que la comunicación se realizó vía puerto serial entre la plataforma y la computadora desktop.
118
Figura 112 - Ventana de Hyperterminal recibiendo datos del puerto RS232 DCE de la tarjeta S partan.
Figura 113 - Señal de Error
Figura 114 - Mensaje de valor de Error
119
Finalmente ordenamos nuestros resultados de tiempos en una tabla para su posterior análisis, Tabla 5. FIR FIR_ACCELERATED SÓLO SOFTWARE FIR_ACCELERATED ACELERADO MATLAB FLOATING POINT MATLAB FIXED POINT
TIEMPO 0.116s 0.003 s 0.03125 s 129.4063 s
FACTOR ACELERACIÓN 38x ----------------------------
Tabla 5 - Comparación de Resultados
120
5. DISCUSION: PRUEBA DE LA HIPOTESIS
El proceso de diseño resultó muy natural y sencillo al sólo tener que describir qué iba a hacer exactamente el algoritmo, ahorrando mucho tiempo en el planeamiento a diferencia del diseño modular por VHDL en el cual tendríamos que haber planeado desde la cantidad de módulos idénticos hasta la correcta interconexión entre ellos. La ventaja radicó al usar Impulse CoDeveloper, fue la capacidad del compilador para traducir en forma correcta el nivel de descripción descripción que maneja maneja el lenguaje C para para bajarlo hacia el el nivel eléctrico que que soportan los dispositivos programables y el descarte de errores al compilar el algoritmo hacia un ejecutable para poder simularlo. A pesar que existen múltiples compiladores de C hacia FPGA, aún no se encuentra completamente estandarizado. estandarizado. Esto puede significar un gran problema a futuro, fut uro, a pesar que todos los fabricantes de compiladores ofrezcan soporte a los fabricantes de dispositivos, migrar de un compilador a otro sería incómodo para el desarrollador, quien tendría que adecuarse a las sentencias propietarias para cada caso y las estructuras algorítmicas de cada uno. Siendo una tendencia casi nueva, ya se empezaron a desarrollar compiladores open source para estandarizar como lo son System C y Trident. Tri dent.
Es más fácil utilizar C y compiladores de C hacia FPGA para el diseño que utilizar netamente HDL, sin embargo existe una relación de complementación entre ambos, C y VHDL juntos permiten realizar diseños en corto tiempo y también describir módulos y hacer mejoras, es similar a la relación que mantienen los lenguajes como C y C++ con el lenguaje ensamblador. A futuro inmediato los diseños se harán a partir de algoritmos y las descripciones de ciertos puertos y módulos de entrada salida pueden ser en VHDL para agilizar el diseño. Siendo la descripción de algoritmos tan sencilla, el desarrollador tiene la capacidad de implementar muchas aplicaciones IP para sus necesidades y adecuando cada una según los requerimientos del proyecto. Lo cual es una ventaja significativa porque no tendrá que comprar IP cores de tareas que antes eran difíciles de implementar sólo con HDL, ahorrando a la larga grandes cantidades de dinero por diseño de un sistema.
122
Considerado el ESL el siguiente paso en descripción de circuitos, el cual está sobre RTL; los compiladores han dado un gran aporte a la comunidad de desarrolladores por la rápida evolución de herramientas y documentación. Así como el soporte hacia el usuario que ofrecen estas nuevas e innovadoras empresas. Al empezar a diseñar un filtro tomamos el principio de operación matemática de un FIR circular y lo traducimos en un algoritmo que posteriormente fue simulado y ejecutado tanto en MATLAB como con el CoDeveloper. Como apreciamos en las Figura 107 y Figura 108, comprobamos la similitud de resultados obtenidos en fixed point mediante FIR256 y
los obtenidos al implementar un FIR en MATLAB, donde al calcular la desviación obtenemos la tasa de error de 0.6873%. Como se presenta en las Figura 103 a la Figura 105, al simular nuestra aplicación apreciamos la operación de métodos como entidades independientes la cuales realizan una comunicación de datos entre sí. Mientras se van obteniendo los resultados, estos interactúan entre las entidades como si éstas existieran físicamente cuando realidad sólo son descripciones de un algoritmo. La Figura 90, corresponde al Data Flow Graph de nuestra aplicación FIR256, esto quiere decir que la estructura del compilador le otorga al usuario la libertad de trabajar con la l a optimización de su código. Para esto el diseñador debe entender el funcionamiento de instrucciones de un compilador C hacia FPGA y como se forman los bloques de instrucciones, empezando a introducir sentencias como #pragma para cambiar y agilizar la interacción de datos datos entre nodos y bloques. Cuando diseñamos la aplicación FIR_ACCELERATED mantuvimos el concepto de funcionamiento de FIR256, para obtener una prueba real de la aceleración y performance de un sistema trabajando con un co-procesador. Como se observa en la Figura 112, obtuvimos un factor de aceleración de 38X, es decir al correr el filtro en hardware resulta 38 veces más rápido que correrlo en un procesador Microblaze descrito en software. Los resultados de las Figura 106 a la Figura 108, están orientados a demostrar la facilidad de diseño y correcta operación al implementar algoritmos de en compilador de C hacia FPGA. Mientras que los resultados de la Figura 112 y Figura 114, tienen el propósito de demostrar la aceleración en hardware y el desempeño de un sistema HPRC.
123
Los resultados expuestos en la Tabla 5 indican resultados esperados tras la implementación de la aplicación FIR_ACCELERATED. FIR_ACCELERATED. Pero parecieran contradictorios al compararse los tiempos de operación en MATLAB que se presentan en dicha tabla. A pesar, que la aplicación en la plataforma es más rápida que la ejecución del filtro en la computadora desktop lo cual es un resultado esperado, los tiempos de operación del mismo filtro en fixed point es mayor al de floating point a pesar de haber corrido en la misma computadora desktop. Siendo el propósito de usar fixed point la disminución de carga computacional, computacional, resultó extraño esto al no presentarse el caso inverso, in verso, donde el filtro FIR en fixed point fuera ligeramente más rápido que el fixed point. Esto es debido a que MATLAB utiliza la librería BLAS o Basic Linear Algebra Subroutines para realizar sus operaciones en floating point la cual cual va optimizada para para los procesadores Intel o AMD, AMD, mientras que para operar en fixed point emula un procesador fixed point y es allí donde realiza las operaciones lo cual hace lento el proceso.
124
6. CONCLUSIONES
Tras analizar los resultados concluimos lo siguiente:
En el presente trabajo se estudio acerca e las tecnologías HPRC las cuales derivan de los tres tipos fundamentales de operación en la aplicación: hardware modular descrito, soft processor junto a módulos aceleradores de hardware, hard processor junto a módulos aceleradores de hardware; y logramos trabajar de forma exitosa con una plataforma de soft processor.
En el presente trabajo se demostró que con procesamiento HPRC obtuvimos mejores tasas de performance. Siendo el diseño de un hard processor junto a módulos de hardware aceleradores el que menores tiempos de operación de una misma aplicación deberá obtener, comparado al de soft processor usado en este trabajo y al de módulo acelerador; así como un correcto planeamiento para evitar desbordamientos desbordamientos en el uso de macros en fixed point agilizará aplicaciones antes descritas en floating point al disminuirse la carga computacional.
La implementación del diseño del presente trabajo tuvo un costo teórico de $11285, sin embargo el precio se redujo a $0, por el préstamo de la tarjeta tarj eta que nos hizo nuestro asesor, así como las l as licencias de los productos facilitadas por las empresas, mostrándonos su apoyo incondicional y constante ante el desarrollo de nuestro sistema.
Se implementó exitosamente un filtro FIR circular acelerado, que se describe en el presente trabajo, en fixed point de orden 256 obteniendo un factor de aceleración de 38x contra la operación en un soft processor.
126
0.14
0.129x10 3 0.116 MATLAB FIXED POINT
0.12 0.1
FIR_ACCELERATED SÓLO SOFTWARE
0.08
MATLAB FLOATING POINT
0.06
0.03125
0.04
0.003
0.02
FIR_ACCELERATED ACELERADO
0 Tiempos de Procesamiento
Figura 115 - Comparación de los Tiempos de Procesamiento
38x 40 FIR_ACCELERATED SÓLO SOFTWARE FIR_ACCELERATED ACELERADO
35 30 25 20
MATLAB FLOATING POINT MATLAB FIXED POINT
15
--
10 5 0
FACTOR ACELERACIÓN
Figura 116 - Comparación de los Factores de Aceleración
Los resultados obtenidos del presente trabajo confirman la hipótesis planteada al inicio de la investigación y cumplen con todos los objetivos propuestos al inicio de la misma.
127
7. RECOMENDACIONES
Implementar diseños con entradas de datos a través de módulos físicos, donde se aprecie el buen trabajo de HDL con el del resultado de algún compilador. Pudiendo mejorar aplicaciones como FIR_ACCELERATED, y adecuarlo a recibir datos de una fuente externa.
Realizar pruebas con un procesador externo de más capacidad. Esto incrementaría notablemente el desempeño de alguna aplicación como FIR_ACCELERATED, aunque esto implique inversión en cuanto a hardware para lograr comunicar un procesador externo con un FPGA. FPGA.
Orientar el diseño a aplicaciones trasladando algoritmos, como son cómputo de grandes datos en el caso de encriptación, seguridad, trabajo por imágenes, etc. El desarrollador tiene la libertad de trabajar con las aplicaciones que encuentre más provechosas y entretenidas.
A pesar que el cálculo en fixed point facilita y alivia la carga computacional, siempre tener en cuenta el no desbordar registros o variables al operar, sino producirían resultados resultados erróneos o inexactos. inexactos.
Realizar actividades en la Escuela Profesional de Ingeniería Electrónica para conseguir hardware adecuado y financiar la investigación y diseño de sistemas HPRC, así como capacitar a los docentes del área de Procesamiento Proce samiento de Señales para que puedan dirigir proyectos y desarrollos con herramientas para HPRC.
129
8. REFERENCIAS BIBLIOGRAFICAS
[1] GOKHALE, Maya y GRAHAM Paul S. Reconfigurable Computing – Accelerating Reconfigurable Computation with Field-Programmable Gate Arrays: An Introduction to Reconfigurable Computing, Reconfigurable Computing Systems, Signal Processing Applications .
Netherlands: Netherlands: Springer, Springer, 2005, p. 1 – 1 – 10, 10, 37 – 37 – 49, 49, 87 – 87 – 117. 117. [2] HAUCK, Scott y DEHON, André. Reconfigurable Computing – The – The Theory and Practice of FPGA-Based Computing: Compute Models and System Architectures, Implementing Applications with FPGAs.
United States: Morgan Kaufmann Publishers, 2008, p. 107 –
125, 439 – 439 – 441. 441. [3] PELLERIN, David y THIBAULT Scott. Practical FPGA Programming in C: The FPGA as a Computing Platform, A Programming Model for FPGA-Based Applications ,
Massachusetts: Prentice Hall PTR, 2005, p 30 – 30 – 35, 35, 78-89. [4] KAMAT Rajanish K., SHINDE Santhosh A., SHELAKE Vinod G. Unleash the System On Chip using FPGAs and Handel C: Springer Science+Business Media B.V. 2009, pag 30. [5] ALPAGO, Octavio H. y SAGRERAS, Miguel A. “Lógica Programable: FPGA”, documento de trabajo, Facultad de Ingeniería – UBA, – UBA, Buenos Aires, Diciembre de 2007. [6] RIVERA A. Marco E. “Filtros Digitales – Filtros FIR e IIR”, documento de trabajo, Departamento de Electrónica, Valparaíso, Marzo 2009.
131
[7] BUELL, Duncan, EL-GHAZAWI, Tarek, GAJ, Kris y KINDRATENKO, Volodymyr. High Performance Reconfigurable Computing. Computer, 40: 23-27, marzo 2007. ISSN 0018-9162. [8] Xilinx, “FPGA vs. ASIC, en Xilinx Xi linx””, en Xilinx, Abril del 2007, http://www.xillinx.com/company/gettingstarted/fpgavsasic.htm#pcs , consultada el 26 de mayo 2008. [9] Tutorial 2: Complex FIR on EDK ED K 10.1i, en Impulse Accelerated Technologies, Technologies, http://www.impulseaccelerated.com/Tutor http://www.impulseaccel erated.com/Tutorials/Xilinx/S3ADSP ials/Xilinx/S3ADSP1800/Tutorial_ComplexF 1800/Tutorial_ComplexFII R_MB_SP3ADSP1800_EDK101.pdf ,, consultada el 21 de Septiembre del 2009. R_MB_SP3ADSP1800_EDK101.pdf
[10] Impulse Accelerated Technologeis, “Accelerating HPC and HPEC Applications Using Impulse C”, en ImpulseC, Octubre 2008, http://rssi.ncsa.illinois.edu/docs/industry/Impulse_presentation.pdf , consultada el 21 de Septiembre del 2009. [11] Una Introducción a la Tecnología FPGA: Los Cinco Beneficios Principales, en National Instruments,
Diciembre
del
2008,
http://zone.ni.com/devzone/cda/tut/p/id/8259 ,
consultada 17 de octubre 2009. [12] Application note: Fixed-Point Arithmetic Arithmetic in Impulse C, en
Impulse Accelerated
Technologies, http://www.impulseacce http://www.impulseaccelerated.com/su lerated.com/support_appnotes.htm pport_appnotes.htm,, consultada el 22 de Agosto del 2009.
132
[13] Computer Engineering, en University of Oulu, www.ee.oulu.fi/research/tklab/courses/.../DLXarkkitehtuuri.pdf ,, consultada el 24 de www.ee.oulu.fi/research/tklab/courses/.../DLXarkkitehtuuri.pdf Septiempre del 2009. [14] Microblaze Soft Processor Core, en Xilinx, http://www.xilinx.com/tools/microblaze.htm , consultada el 25 de Agosto del 2009. [15] Xilinx, “Getting Started with FPGAs”, en Xilinx, Abril del 2007, http://www.xillinx.com/company/gettingstarted/index.htm , consultada 26 de mayo 2008 . [16] GONZÁLEZ CORNEJO, José Enrique. “ Programación con Diseño modular o TopDown”, en DocIRS, Abril 2009, http://www.docirs.cl/programacion_topdown.htm , consultada el 18 de octubre 2009.
133
9. PAGINAS COMPLEMENTARIAS
ANEXO 1 senial_entrada.m clear variables Fs=48000; % Frecuencia de Muestreo tMax=0.02; % Tiempo límite del muestreo fo=100; % Frecuencia fundamental de la señal de entrada a=2.5; t=(0:1/Fs:tMax); % tiempo analógico muestreado x=zeros(1,length(t)); % señal de Entrada
for i=1:length(t) x(i)=a; end for i=1:2:200 x=x+((2*a)/(i*pi))*sin(2*pi*fo*i*t); % Generación de la Señal de Entrada end
figure(1) plot (t,x) figure(2) % fi(Data, Signed, Longitud de la Palabra, Longitud de La Fracción) t1=fi(t, 1, 16, 10); % tiempo en punto fijo x1=fi(x, 1, 16, 10); % señal de entrada en punto fijo stem(t1,x1)
135
ANEXO 2 filtro_senial N=256; % Longitud del vector de coeficiente FN=Fs/2; % fc=fo*1.5; % Frecuencia de Corte Wn=(fc/FN); % Frecuencia normalizada de corte Tipo='low' Tipo='low'; ; % Tipo de Filtro y=zeros(1,length(t)); % Señal de Salida y1=fi(y, 1, 16, 10); %Señal de Salida en Punto fijo T=(1:length(t)); % Tiempo discreto h=fir1(N,Wn,Tipo); % Coeficientes del FIR h1=fi(h, 1, 16, 10); %Coeficient %Coeficiente e FIR en punto fijo tiempo1=cputime; for n=1:length(x) for i=1:N if n-i==0 break end y(n)=y(n)+(x(n-i)*h(i)); %Filtro FIR double end end tiempo2=cputime-tiempo1; %en segundos disp(['Tiempo disp(['Tiempo de Procesamiento del FIR double' double',num2str(tiempo2), ,num2str(tiempo2), ' segundos']) segundos' ]) tiempo1=cputime; for n=1:length(x) for i=1:N if n-i==0 break end y1(n)=y1(n)+(x1(n-i)*h1(i)); %Filtro FIR en Punto Fijo end end tiempo2=cputime-tiempo1; %en segundos disp(['Tiempo disp(['Tiempo de Procesamiento del FIR fixed-point' fixed-point',num2str(tiempo2), ,num2str(tiempo2), ' segundos']) segundos' ]) figure(3) plot(T,y,'.-b' plot(T,y, '.-b') ) legend('double' legend( 'double') ) xlabel('n xlabel( 'n (samples)'); (samples)'); ylabel('amplitude' ylabel('amplitude') ) figure(4) plot(T,y1,'.-r' plot(T,y1, '.-r') ) legend('fixed-point' legend( 'fixed-point') ) xlabel('n xlabel( 'n (samples)'); (samples)'); ylabel('amplitude' ylabel('amplitude') ) figure(5) [H,f] = freqz(h,1,200,Fs); semilogx(f,20*log10(abs(H))); % Respuesta en Frecuencia
136
ANEXO 3 cambiando_valores
ans_fpga_fi=zeros(1,n); for i=1:n a=fi(0,1,32,23); a.hex=ans_fpga_raw{1,i}; ans_fpga_fi(i)=a; end
137
ANEXO 4 determinando_error error = y-ans_fpga_fi; media = mean (error); maximo =max(error); minimo = min(error); desviacion = std(error); e_porciento = desviacion*100; disp(['El disp(['El error % de la señal es de: ' ,num2str( e_porciento) ,'%' ,'%']) ])
138
ANEXO 5
139
ANEXO 6
140
ANEXO 7
141
ANEXO 8
142
