Avances en el uso eficiente de sistemas multi-softcores en FPGAs

• Autores: Claverino, Daniel Gonzalo
• Año de publicación: 2023
• Idioma: español castellano
• Tipo de recurso: tesis de grado
• Colaborador/a o director/a de tesis: González Márquez, David Alejandro; Mocskos, Esteban Eduardo
• Materia: FPGA; SMP; BRAM; SOFTCORE; MICROBLAZE; MEMORIA; CACHE; STACK; SPIN- LOCK; PERFORMANCE; FPGA; SMP; BRAM; SOFTCORE; MICROBLAZE; MEMORY; CACHE; STACK; SPIN-LOCK; PERFORMANCE
• Institución: Universidad Nacional de Buenos Aires. Facultad de Ciencias Exactas y Naturales

Desde hace a ̃nos, el avance tecnológico en la fabricación de circuitos integrados ha permitido implementar múltiples procesadores en una misma pastilla con una creciente cantidad de núcleos, memoria e, inclusive, contener unidades funcionales con distinto grado de especialización. Sin embargo, a la hora de resolver problemas específicos, los procesadores de propósito general pueden ser superados por aceleradores, que son sistemas especialmente diseñados. Los más comunes son los aceleradores de vídeo que permiten, por ejemplo, procesar imágenes o descomprimir un flujo (stream) de vídeo de forma muy eficiente. Las FPGAs (Field-Programmable Gate Array) surgen como plataformas que permiten implementar soluciones de hardware programable, es decir, hardware que puede ser modificado o rediseñado por el usuario sin necesidad de reemplazar el circuito integrado. Consisten en una grilla de celdas de distinta especialización que pueden conectarse de diversas formas, resultando en una plataforma con alta flexibilidad. Las FPGAs resultan un camino v ́alido para el diseño, prototipado y construcción de hardware y, en particular, aceleradores. Siempre dentro de sus limitaciones de recursos, permiten implementar hardware y se puede lograr un alto grado de paralelismo. Dado este nivel de flexibilidad, un componente que se implementa en FPGA recibe el nombre de softcore. Estos pueden ir desde una máquina de estados o un sumador, hasta procesadores multi-core con varios niveles de cache. El límite dependerá de la cantidad de celdas y las formas de conexión disponibles, que es fija para una FPGA dada. El presente trabajo busca avanzar en técnicas que permitan el uso eficiente de múltiples softcores dentro de una FPGA, proponiendo un framework que permitirá estudiar distintos sistemas de procesamiento. Haremos especial uso del MicroBlaze, uno de los softcores más utilizados, desarrollado por Xilinx y creado específicamente para su uso en FPGAs. Una de las principales limitaciones de los sistemas basados en softcores es el acceso a memoria. Partiendo de este punto y utilizando bloques RAM de FPGA (BRAM), se propone estudiar un conjunto de estrategias de uso de la memoria: usar el stack en BRAM, correr código del programa en BRAM, y correr código de funciones de sincronización en BRAM. Esto implica ejecutar programas cuyos accesos a memoria utilizan distintas memorias, cada una con características distintas (BRAM y Cache+DDR). Respecto a las tres formas de uso de BRAM propuestas, notamos que mover y correr código de funciones de sincronización en BRAM no genera mejoras significativas salvo en casos donde hay muchos llamados o varios procesadores en espera. Dependiendo del algoritmo y su implementación, usar el stack en BRAM puede ir desde tener poco efecto a tener un impacto significativo en el desempeño, por encima de mover las funciones de sincronización. Finalmente, mover y correr código del algoritmo en BRAM genera el mayor impacto positivo en el rendimiento. Este impacto puede verse reducido si hay partes del código de uso frecuente que no se han movido a BRAM y continúan en memoria principal. Tener control del hardware nos permite implementar soluciones que se ajusten al problema a resolver. Trabajar desde una capa de abstracción baja implica que los desarrolladores deben manejar detalles de muy bajo nivel, como los procesadores mismos, su interconexión, y la distribución de memoria utilizando distintos tipos de memoria.
For years, technological advances in the manufacture of integrated circuits have allowed the implementation of multiple processors on the same chip with an increasing number of cores, memory, and even functional units with different degrees of specialization. However, when it comes to solving specific problems, general-purpose processors can be outperformed by accelerators, which are specially designed-systems. The most common are video accelerators that allow, for example, to process images or decompress a video stream very efficiently. FPGAs (Field-Programmable Gate Array) are platforms allowing programmable hardware implementation. The user can modify or redesign this hardware while using the same chip. FPGAs are composed of a variety of specialized cells distributed on a grid. These cells can be connected in different ways, resulting in a highly flexible platform. FPGAs are a valid path for hardware design, prototyping, and implementation. It is possible to implement several hardware components within their fixed and limited resources. Their nature favors highly parallel components and efficient access to I/O external events. Accelerators are one such particular piece of hardware. Given this flexibility, a component implemented on an FPGA is called softcore. These can go from a state machine or an adder to a multi-core processor with multiple cache levels, but some restrictions still apply. The number of cells and available connections are fixed on an FPGA limiting what can be implemented. In this thesis, we aim to study efficient ways of running multiple softcores on an FPGA. We propose a framework that allows studying a wide range of processing systems, and we use it to implement one particular multi-core system. We use Xilinx’s MicroBlaze, one of the most widely used softcore and specifically created to be deployed on FPGAs. One limitation of softcore systems is memory access. Having this in mind, we use RAM Blocks (BRAM) to study different memory usage strategies: point the stack to BRAM, execute program code on BRAM, and execute synchronization code on BRAM. This implies running programs where memory accesses are done to different memory types, each with its characteristics (BRAM and Cache+DDR). Regarding the three proposed BRAM uses, we found moving and executing synchronization code on BRAM to yield no significant improvements except in heavy synchronization cases or where processors were competing too strongly with memory access. Depending on the algorithm and its implementation, stack on BRAM results ranged from no impact to a significant performance improvement, even over the prior case. Lastly, moving and executing program code on BRAM showed the most positive impact on the performance of the three strategies. The latter’s results were reduced when the program was not completely moved to BRAM and frequently executed code was still executed on other memory. Controlling the hardware lets us implement a specifically designed solution to a problem. Working on a low-abstraction layer implies developers need to handle low-level details, such as processors, the interconnection between them, and memory distribution using different memory types.
Fil: Claverino, Daniel Gonzalo. Universidad de Buenos Aires. Facultad de Ciencias Exactas y Naturales; Argentina.