A Framework to Support Run-Time Adaptation in Reconfigurable Multi-Accelerator Systems

Rodríguez Medina, Alfonso (2020). A Framework to Support Run-Time Adaptation in Reconfigurable Multi-Accelerator Systems. Thesis (Doctoral), E.T.S.I. Industriales (UPM). https://doi.org/10.20868/UPM.thesis.65388.

Description

Title: A Framework to Support Run-Time Adaptation in Reconfigurable Multi-Accelerator Systems
Author/s:
  • Rodríguez Medina, Alfonso
Contributor/s:
  • Torre Arnanz, Eduardo de la
Item Type: Thesis (Doctoral)
Date: 2020
Subjects:
Faculty: E.T.S.I. Industriales (UPM)
Department: Automática, Ingeniería Eléctrica y Electrónica e Informática Industrial
Creative Commons Licenses: Recognition - No derivative works - Non commercial

Full text

[img]
Preview
PDF - Requires a PDF viewer, such as GSview, Xpdf or Adobe Acrobat Reader
Download (24MB) | Preview

Abstract

Los sistemas embebidos de altas prestaciones han experimentado notables cambios tanto en la complejidad de las aplicaciones como en los requisitos de los propios sistemas. Para no quedarse atrás, las plataformas de cómputo tradicionales se han visto forzadas a evolucionar para poder adaptarse a estos nuevos escenarios. Así, a día de hoy es bastante habitual encontrar plataformas de cómputo paralelo (p.ej. CPUs multi-core, GPUs de propósito general, o FPGAs) en muchas soluciones embebidas de altas prestaciones. No obstante, y aunque el rendimiento sigue siendo uno de los factores decisivos de cara a elegir una plataforma u otra, el término “embebido” impone restricciones adicionales como la eficiencia energética o la tolerancia a fallos. En este contexto, se ha demostrado que el uso de dispositivos de lógica programable o FPGAs es altamente beneficioso, ya que juntan lo mejor del hardware (rendimiento, eficiencia energética) y del software (programabilidad, flexibilidad en la ejecución) gracias a sus capacidades de reconfiguración dinámica. Sin embargo, y a pesar de sus buenas prestaciones, las FPGAs siguen siendo poco accesibles para el público general. De hecho, estos dispositivos exigen conocer con gran detalle la tecnología subyacente tanto para implementar algoritmos como para gestionarlos durante su ejecución. De cara a eliminar estas limitaciones, es un requisito indispensable que los sistemas de cómputo paralelo basado en FPGA cuenten con tres elementos fundamentales: arquitecturas de cómputo capaces de crear una infraestructura eficiente de aceleración, herramientas de soporte en tiempo de diseño con métodos de generación de aceleradores desde descripciones de alto nivel y mecanismos automatizados de implementación de sistemas reconfigurables, y herramientas de soporte en tiempo de ejecución para abstraer procesos complejos como la gestión de la propia reconfiguración hardware y de la ejecución de múltiples aceleradores en paralelo. El framework que se propone en esta Tesis integra estos tres componentes en una solución única. El elemento central del framework es ARTICo3, una arquitectura hardware reconfigurable con múltiples aceleradores inspirada en las GPUs de propósito general y en los modelos de abstracción definidos en la especificación OpenCL. ARTICo3 usa reconfiguración dinámica y parcial (DPR) para desplegar paralelismo a nivel de tarea (cargando aceleradores con distinta funcionalidad) y de datos (cargando varias copias del mismo acelerador). Además, su datapath configurable puede ser modificado en tiempo de ejecución para alcanzar un compromiso entre rendimiento, eficiencia energética, y nivel de tolerancia a fallos. De hecho, tres modos de funcionamiento distintos pueden ser seleccionados cuando hay más de una copia del mismo acelerador en la FPGA: paralelo (cada acelerador recibe distintos datos de entrada y los procesa con un enfoque similar a SIMD), redundante (cada acelerador pertenece a un grupo TMR/DMR, recibe los mismos datos de entrada, y devuelve sus resultados a través de una unidad de votado), y reducción (parecido a paralelo, pero con una operación final de reducción antes de escribir los datos en la memoria principal). Para simplificar su programación, ARTICo3 virtualiza sus aceleradores usando mapas de memoria, y proporciona un conjunto reducido de registros de configuración. Por último, la arquitectura cuenta con una infraestructura de monitorización para poder extraer información relevante durante la ejecución de los aceleradores (p.ej. latencia, número de errores por región reconfigurable). En paralelo a la arquitectura, el framework propuesto en esta Tesis incluye una herramienta para la generación automática de sistemas reconfigurables con múltiples aceleradores. Para simplificar el proceso de implementación de este tipo de sistemas, la herramienta soporta dos niveles de abstracción distintos para especificar la funcionalidad de los aceleradores: descripciones RTL de bajo nivel en VHDL/Verilog (para diseñadores con cierto conocimiento previo de diseño hardware), y descripciones algorítmicas de alto nivel en C/C++ (para usuarios sin experiencia previa en diseño hardware), que son implementadas usando un motor HLS comercial de manera automática y transparente. Los aceleradores ARTICo3 se generan mediante la instanciación de la lógica del usuario en un contenedor estándar. Dicho módulo incluye bancos configurables de memoria y registros, y una interfaz simplificada y fija para facilitar la integración con el resto del sistema. La herramienta ha sido implementada de manera modular, por lo que su funcionalidad puede ser fácilmente extendida mediante la creación de distintas plantillas de usuario. El último componente del framework es una biblioteca de gestión de la ejecución que se basa en un modelo de paralellismo a nivel de datos similar al usado en OpenCL. Esta biblioteca es accesible desde las aplicaciones software del usuario gracias a una API que contiene las funciones necesarias para reconfigurar la FPGA y gestionar la ejecución de los aceleradores, cuya planificación se realiza de manera transparente usando un modelo de memoria compatible con DMA y un esquema de ejecución escalable. Como añadido, el framework incluye un modelo simplificado de la ejecución de los aceleradores que permite realizar estimaciones del rendimiento y el consumo energético durante el funcionamiento normal del sistema. Para la validación del framework se han considerado tres escenarios distintos: usar aceleradores ad hoc descritos en VHDL, usar aceleradores ad hoc descritos en C, y usar un benchmark HLS con varias aplicaciones estándar. En el primer escenario, los distintos perfiles de ejecución de los aceleradores ARTICo3 han sido analizados, mostrando las diferencias entre aquellos limitados en memoria (el tiempo de transferencia de datos es mayor que el de procesamiento) y aquellos limitados en cómputo (el tiempo de procesamiento es mayor que el de transferencia de datos). En el segundo escenario se ha podido comprobar que las soluciones basadas en ARTICo3 son mejores que sus alternativas software para ciertos algoritmos, llegando a obtener aceleraciones del orden de 14£ y ratios de eficiencia energética en torno a 10£. Por último, la evaluación basada en benchmarks ha servido para identificar qué tipo de aplicaciones obtiene los mejores resultados cuando éstas son implementadas usando las propuestas de esta Tesis. Para ello, los distintos patrones de cómputo/comunicaciones han sido asociados a perfiles de ejecución limitados en memoria y en cómputo. Tras la integración de los tres componentes previamente descritos, el framework permite implementar sistemas reconfigurables con múltiples aceleradores de manera accesible y transparente para muchos desarrolladores software. Sin embargo, también impone un único modelo de programación. Este modelo con paralelismo explícito a nivel de datos puede no ser el más adecuado en algunas aplicaciones, como se ha podido ver tras la validación basada en benchmarks. Además, limitar el lenguaje de especificación de alto nivel de los aceleradores a C/C++ va en contra de muchas corrientes actuales, en las que se busca incrementar el nivel de abstracción. Por ello, los modelos de programación y ejecución de ARTICo3 han sido extendidos para soportar la ejecución multihilo en hardware o en software por un lado, y el uso de especificaciones de alto nivel basadas en modelos de flujo de datos por otro. La ejecución multihilo tanto en hardware como en software se ha conseguido mediante la integración directa con ReconOS, otro entorno de diseño y gestión de sistemas reconfigurables con múltiples aceleradores que incluye las extensiones necesarias a nivel arquitectural y de sistema operativo para permitir que los aceleradores se comporten como hilos software. Además, se ha implementado un sistema evolutivo basado en estructuras sistólicas, que permiten la adaptación a nivel de circuito mediante procesos de aprendizaje por imitación. Esta combinación genera un enfoque de reconfiguración multinivel, que combina DPR a nivel de región reconfigurable (grano grueso) con DPR a nivel de LUTs (grano fino). Por otro lado, las extensiones orientadas a modelos de flujo de datos han sido introducidas mediante la integración directa con MDC, una herramienta capaz de generar aceleradores con sustratos CGR usando especificaciones escritas en CAPH. Esto permite un enfoque de reconfiguración híbrido en el se combina DPR (cambios funcionales completos, pero lentos) con CGR basada en registros de configuración (cambios paramétricos, pero muy rápidos). La integración de ARTICo3 con MDC habilita un mecanismo de generación de estructuras hardware muy optimizadas en las que se fomenta la reutilización de recursos lógicos, ya que MDC es capaz de identificar y unir unidades funcionales compartidas en la estructura interna de los aceleradores. La última parte de este documento cubre la evaluación de las propuestas de la Tesis en una aplicación real para sistemas embebidos de altas prestaciones: el procesamiento de imágenes hiperespectrales a bordo. Las aplicaciones de sensado remoto que utilizan sensores hiperespectrales para la adquisición de imágenes generan grandes cantidades de datos que deben ser procesados para extraer la información que contienen. En este sentido, pueden darse dos posibles escenarios: que los datos sean adquiridos, comprimidos, y enviados a la Tierra para ser procesados, o que los datos sean directamente procesados a bordo. En esta Tesis se propone una implementación adaptativa de un algoritmo de compresión sin pérdidas basado en el estándar CCSDS 123. Dicha implementación usa un algoritmo de particionado de las imágenes de entrada para explotar el máximo paralelismo a nivel de datos posible. Los resultados obtenidos demuestran que la solución propuesta es competitiva con otras alternativas disponibles en la literatura. En esta Tesis también se ha cubierto el segundo escenario (procesamiento directamente a bordo, sin compresión), proponiendo una implementación adaptativa de una cadena de desmezclado espectral. Dicha implementación usa un algoritmo de particionado y reducción para explotar el paralelismo a nivel de datos, proporcionando una solución escalable en un contexto con múltiples FPGAs. Las principales contribuciones de esta Tesis son las siguientes: - [Arquitectura] Una arquitectura de procesamiento hardware para sistemas embebidos de altas prestaciones capaz de establecer compromisos, en tiempo de ejecución, entre rendimiento, eficiencia energética, y tolerancia a fallos. - [Diseño]Una metodología automatizada de generación de sistemas reconfigurables con múltiples aceleradores desde descripciones RTL de bajo nivel o usando procesos HLS desde descripciones algorítmicas de alto nivel. - [Ejecución]Una biblioteca para gestionar, de manera transparente, la reconfiguración y la gestión del cómputo en entornos con múltiples aceleradores. - [Validación] Una estrategia de caracterización y validación del framework propuesto basada en benchmarks HLS. - [Ejecución] Un enfoque multiparadigma para programar sistemas reconfigurables con múltiples aceleradores combinando ejecución paralela a nivel de datos con ejecución multihilo en hardware y software. - [Diseño] Una flujo integrado de diseño para generar, de manera automática, sistemas reconfigurables con múltiples aceleradores desde especificaciones basadas en modelos de flujo de datos. - [Aplicación] Una implementación adaptativa de un algoritmo de compresión hiperespectral basado en el estándar CCSDS 123. - [Aplicación] Una implementación adaptativa de un algoritmo de desmezclado hiperespectral con múltiples dispositivos de tipo FPGA. Este documento está organizado en 5 capítulos. El primero discute la motivación detrás del trabajo realizado, fijando los objetivos principales y proporcionando el marco tecnológico necesario. En el segundo capítulo, los tres componentes principales del framework (la arquitectura hardware, la herramienta de diseño automatizado y la biblioteca de gestión) son descritos en detalle y validados usando diseños ad hoc y benchmarks. Las extensiones multihilo y basadas en modelos de flujo de datos se cubren en el tercer capítulo, mientras que la evaluación de ARTICo3 en aplicaciones de procesado de imágenes hiperespectrales se presenta en el cuarto. Por último, el quinto capítulo cierra esta Tesis discutiendo las conclusiones, resumiendo las principales contribuciones, presentando una evaluación cuantitativa del impacto del trabajo realizado, y proponiendo líneas futuras de investigación. ----------ABSTRACT---------- High-performance embedded computing systems have experienced a surge in both application complexity and overall system requirements. In order to keep pace with these fast changes, traditional computing platforms and paradigms have been also forced to evolve and adapt themselves to unprecedented scenarios. As a consequence, it is fairly common nowadays to see parallel computing platforms (e.g., multi-core CPUs, general-purpose GPUs, or FPGAs) at the core of high-performance embedded computing solutions. However, and even though execution performance still plays an important role in the platform selection process, additional criteria, such as energy efficiency or fault tolerance, need to be taken into account as well. In this context, the use of run-time reconfigurable SRAM-based FPGAs as standalone processing elements has already proven to be the best option in multiple application scenarios, since they provide the best of both hardware (computing performance, energy efficiency) and software (programmability, execution flexibility) worlds. However, the use of these devices presents several problems, the most relevant one still being their lack of accessibility for the general public. In most cases, developers are expected to have extensive low-level knowledge of the underlying technology, either to describe and implement their algorithms, or to execute and manage the generated hardware accelerators. In order to overcome these issues, it is mandatory for reconfigurable FPGA-based parallel computing frameworks to provide three key components: computing architectures to create a proper acceleration infrastructure, design-time support tools to enable high-level entry points for accelerator description and automated system implementation, and run-time support mechanisms to hide low-level reconfiguration and execution management details. The framework proposed in this Thesis is an integrated solution that covers all three components. The framework is built around the ARTICo3 architecture, a hardware-based reconfigurable multi-accelerator infrastructure inspired by general-purpose GPUs and OpenCL abstractions. As such, it is capable of using DPR to exploit both task- (load different application-specific hardware accelerators) and data-level (load multiple copies of the same application-specific hardware accelerator) parallelism. In addition, it features a configurable datapath that can be dynamically modified during application execution to enable run-time tradeoffs between computing performance, energy efficiency, and fault tolerance. In this regard, the architecture supports three operation modes when multiple copies of the same application-specific hardware accelerator are present on the FPGA fabric: parallel (each accelerator gets different input data and executes in SIMD-like fashion), redundant (each accelerator belongs to a TMR/DMR group, receives the same input data, and sends its results back through a configurable voter unit to enforce fault tolerance), and reduction-oriented (similar to parallel, but with a final reduction operation before writing results back to main memory). To simplify its programming, ARTICo3 uses a memory-mapped virtualization of the hardware accelerators, and provides a register-based interface for configuration purposes. The ARTICo3 architecture also features an embedded monitoring infrastructure to keep track of relevant execution metrics (e.g., accelerator latency, number of faults per reconfigurable slot). The ARTICo3 framework also comes with a toolchain to automatically generate reconfigurable multi-accelerator systems with DPR-compatible floorplannings. In order to further simplify FPGA-based system implementation, two different entry points for hardware accelerator specification are supported: low-level RTL descriptions in VHDL/Verilog (for users with certain knowledge in hardware design) and high-level algorithmic descriptions in C/C++ (for users with no previous experience on hardware design), which are then implemented using a commercial HLS engine under the hood. Independently of the selected entry point, accelerators are integrated in the main ARTICo3 infrastructure by instantiating the input user logic in a standard wrapper, which features configurable memory and register banks, and a fixed interface to simplify the implementation of the static and reconfigurable partitions on the FPGA. The toolchain is implemented in a modular way, enabling users to extend its functionality by creating custom templates for multi-accelerator system deployment. The last component of the ARTICo3 framework is a runtime library that enables a data-parallel execution model similar to the one present in the OpenCL specification. This library is accessible from user applications through a lightweight API that hides low-level reconfiguration and accelerator management details. In fact, accelerator scheduling is transparently performed using a DMA-friendly memory model and a scalable execution scheme. In parallel, the framework includes a lightweight model for hardware accelerator execution that can be used to perform run-time estimations of execution performance and power consumption. In order to validate the proposed framework, three different approaches have been considered: using optimized custom VHDL-based hardware accelerators, using optimized custom HLS-based hardware accelerators, and using standard HLS-based benchmarks. In the first scenario, the different execution profiles in ARTICo3 have been assessed, showing the different behavior of memory-bounded applications (data transfers are larger than computing time) and computing-bounded applications (computing time is larger than data transfers). In the second scenario, it is shown that ARTICo3-based hardware acceleration does indeed outperform alternative highperformance embedded computing platforms, showing speedups of up to 14£ and energy efficiency ratios of up to 10£ when compared with a software-based implementation of the same algorithm. Finally, the benchmark evaluation has been used to identify which type of application can truly benefit from using the framework proposed in this Thesis, associating different computation/communication patterns to memory- and computing-bounded execution profiles. Although the baseline ARTICo3 framework provides an accessible and transparent way for software programmers to implement reconfigurable multi-accelerator systems, it constrains them to use a single programming model. However, and as the benchmark-based validation has confirmed, the native data-parallel programming model of the ARTICo3 framework may not render proper acceleration values in certain application scenarios. Using plain C/C++ code for accelerator specification might be also a limitation, especially when considering that current programming trends tend to raise the level of abstraction. As a consequence, the ARTICo3 programming and execution models have been extended with transparent hardware/software multithreading capabilities and dataflow-based accelerator specification support. Hardware/software multithreading has been enabled by a direct integration with ReconOS, another hardware-oriented framework for reconfigurable multi-accelerator systems that provides the required architectural and OS-level extensions to allow hardware accelerators to behave as regular software threads. Additionally, an evolvable SA system has been implemented as an ARTICo3 accelerator to support circuit adaptation using learn-by-imitation procedures. This approach enables a multi-grain reconfiguration approach, combining the coarse-grained DPR used in ARTICo3 slots with a fine-grained DPR mechanism to change functional units at LUT level. Dataflow-based extensions have been enabled by a direct integration with MDC, a tool to generate hardware accelerators with embedded CGR substrates using modelbased specifications written in CAPH. This enables a hybrid reconfiguration approach that combines DPR (to perform slow but complete functional changes) with registerbased CGR (to performfast but parametric-only modifications in the accelerator logic). In addition, the integrated MDC-ARTICo3 toolchain allows designers to generate highly-optimized structures that heavily enforce resource reuse, since MDC identifies and merges common functional units in the internal accelerator datapath. Finally, the ARTICo3 framework has been evaluated under a real-world application scenario for high-performance embedded computing: on-board hyperspectral data processing. Remote sensing applications that rely on hyperspectral imaging sensors produce large amounts of data that need to be further processed to extract relevant information. In this regard, there are two alternatives: on the one hand, data can be acquired, compressed on board, and sent to on-Earth processing facilities; on the other hand, data can be directly processed on board. In this Thesis, a run-time adaptive implementation of a lossless hyperspectral data compressor based on the CCSDS 123 standard has been proposed. A novel hardware-friendly data partitioning algorithm compatible with the standard has been applied to properly exploit datalevel parallelism. Experimental results show comparable performance an energy efficiency levels with alternative solutions available in the literature. The second scenario (i.e., on-board data processingwithout compression) has been also addressed in this Thesis, proposing a run-time adaptive implementation of a linear unmixing chain for hyperspectral images. This particular implementation relies on a novel hardware-friendly data partitioning and reduction algorithm to ensure proper datalevel parallelism and execution scalability, which has been addressed in both singleand multi-FPGA (using a small Ethernet-based computing cluster) contexts. Themain contributions of this Thesis can be classified and summarized as follows: - [Architecture] A hardware-based processing architecture for adaptive highperformance embedded computing based on run-time tradeoffs between computing performance, energy efficiency, and fault tolerance. - [Design] An automated design methodology to generate custom reconfigurable multi-accelerator systems from either low-level RTL descriptions or high-level algorithmic descriptions and HLS. - [Runtime] A runtime library to transparently manage FPGA reconfiguration and computation offloading in multi-accelerator scenarios. - [Validation] A Dwarf-based characterization and validation strategy for the ARTICo3 framework based on HLS benchmarks. - [Runtime] A multi-paradigm programming approach for reconfigurable multiaccelerator systems that combines SIMD-like data-parallel execution with transparent hardware/softwaremultithreading. - [Design] An integrated toolchain to automatically generate reconfigurablemultiaccelerator systems fromhigh-level dataflow descriptions. - [Application] A run-time adaptive FPGA implementation of a low-complexity on-board CCSDS 123 lossless multispectral and hyperspectral compressor with selectable performance and energy efficiency levels. - [Application] A run-time adaptive and multi-FPGA implementation of a lowcomplexity on-board linear hyperspectral unmixing chain with selectable performance and energy efficiency levels. This Thesis is organized in 5 chapters. Chapter 1 discusses the motivation behind the developed work, establishes the main goals to be achieved, and presents a brief overview of the technology background (reconfigurable computing and parallel computing). In Chapter 2, the three main components of the ARTICo3 framework (hardware-based computing architecture, automated toolchain, and runtime library) are presented and validated using custom designs (i.e., in-house VHDL and HLSbased accelerators) and an HLS benchmark suite. The reference abstractions provided by the ARTICo3 framework are extended in Chapter 3 to also support transparent hardware/software multithreading using ReconOS and dataflow-oriented accelerator specification using MDC. Chapter 4 showcases the ARTICo3 framework in two state of-the-art high-performance embedded computing applications: hyperspectral data compression and hyperspectral linear unmixing. Finally, Chapter 5 closes the Thesis, discussing the conclusions drawn from the developed work, summarizing its main contributions, analyzing its impact with quantitative measurements such as its related publications, and presenting the future lines of work.

Funding Projects

TypeCodeAcronymLeaderTitle
Government of SpainFPU13/06007UnspecifiedUnspecifiedFormación de Profesorado Universitario

More information

Item ID: 65388
DC Identifier: https://oa.upm.es/65388/
OAI Identifier: oai:oa.upm.es:65388
DOI: 10.20868/UPM.thesis.65388
Deposited by: Archivo Digital UPM 2
Deposited on: 12 Nov 2020 10:18
Last Modified: 12 May 2021 22:30
  • Logo InvestigaM (UPM)
  • Logo GEOUP4
  • Logo Open Access
  • Open Access
  • Logo Sherpa/Romeo
    Check whether the anglo-saxon journal in which you have published an article allows you to also publish it under open access.
  • Logo Dulcinea
    Check whether the spanish journal in which you have published an article allows you to also publish it under open access.
  • Logo de Recolecta
  • Logo del Observatorio I+D+i UPM
  • Logo de OpenCourseWare UPM