Implementação em hardware reconfigurável de operadores matriciais para solução numérica de sistemas lineares

Tese (mestrado)—Universidade de Brasília, Faculdade de Tecnologia, Departamento de Engenharia Mecânica, 2014.Este trabalho apresenta um estudo da implementação de operadores matriciais para solução numérica de sistemas lineares em FPGAs (Field Programmable Gate Arrays). As arquiteturas foram baseadas nos métodos diretos QR, de Schur, assim como na Eliminação Gaussiana. Os métodos foram desenvolvidos usando topologias orientadas a controle e fluxo de dados com representação aritmética de ponto flutuante, permitindo explorar o paralelismo intrínseco dos diferentes algoritmos para solução de sistemas lineares. Desta forma, mantendo o controle da propagação do erro e ganhos de desempenho em termos do tempo de execução, visando a sua aplicabilidade em problemas inversos. As arquiteturas foram desenvolvidas para obter a inversa de uma matriz assim como a solução de um sistema de equações lineares, baseados no método de eliminação Gaussiana (ou sua variante Gauss-Jordan). Além disso, neste trabalho foi proposta e implementada uma nova arquitetura baseada no método de Schur formada pelos seguintes circuitos: QRD-MGS (QR Decomposition via Modified Gram-Schmidt), MMM (Multiplicação Matriz-Matriz) e MDTM (Multiplicação-Diagonal-Transposta-Matriz). Adicionalmente, estudos de consumo de recursos para diferentes tamanhos de matrizes assim como uma análise da propagação do erro foram realizados no intuito de verificar a aplicabilidade dos algoritmos em arquiteturas reconfiguráveis. Neste trabalho, o modulo de Eliminação Gaussiana desenvolvido foi usado para apoiar os cálculos de uma rede neuronal do tipo GMDH na predição da estrutura 3D de uma proteína. Finalmente, foram implementadas duas metodologias, Fusão de Datapath para manter o controle da propaga ção de erro usando apenas uma representação com precisão simples e a Verificação/Validação para realizar uma padronização na validação dessas implementações.This work presents a study on the implementation of matrix operators for the numerical solution of linear systems on FPGAs (Field Programmable Gate Arrays). The architectures were based on direct methods such as QR, Schur as well as the Gaussian elimination. The methods were developed using topologies oriented to both control and to data-flow with a floating point arithmetic representation, exploring the intrinsic parallelism of different algorithms for solving linear systems. Thus, the developed architectures have been achieved maintaining both the control of the error propagation and performance gains in terms of runtime, seeking their applicability in inverse problems. The architectures have been developed to deal with the inverse of a matrix as well as for solving a system of linear equations based on the Gaussian elimination method (or its Gauss-Jordan variant). Additionally, this work has proposed and implemented a novel architecture based on the Schur method composed of the following circuits: QRD-MGS (QR Decomposition via Modi_ed Gram-Schmidt), MMM (Matrix-Matrix Multiplication) and MDTM (Matrix-Diagonal-Transpose-Multiplication). Furthermore, this work presents studies of the resource use for different sizes of matrices as well as the error propagation analysis in order to verify the applicability of the algorithms on reconfigurable hardware. Additionally, the Gaussian elimination module developed in this work was used to support the calculations of a GMDH neural network on an application to predict the 3D structure of a protein. Finally, two methodologies were implemented, the Datapath Fusion to maintain the control of the error propagation using only one representation with single precision and the Verification/Validation to create a benchmark to validate the results of the hardware implementations

Implementação em FPGA de uma biblioteca parametrizável para inversão de matrizes baseada no algoritmo Gauss-Jordan, usando representação em ponto flutuante

Dissertação (mestrado)—Universidade de Brasília, Faculdade de Tecnologia, Departamento de Engenharia Mecânica, 2010.As operações computacionais em que se desenvolvem cálculos matriciais são à base, ou melhor, o coração de muitos algoritmos computacionais científicos, por exemplo: processamento de sinais,visão computacional, robótica, entre outros. Esse tipo de algoritmos em que desenvolvem-se cálculos matriciais terminam sendo tarefas computacionalmente custosas, e suas implementações em hardware exigem grandes esforços e tempo. Existe então uma crescente demanda por arquiteturas que permitam cálculos matriciais, proporcionando soluções rápidas e eficientes para este tipo de problema. Este trabalho apresenta diferentes arquiteturas computacionais para inverter matrizes em hardware reconfigurável, FPGA: (a) sequencial, (b) pipeline e (c) Paralelo. Estas arquiteturas usam uma representação de ponto flutuante tanto em precisão simples (32 bits) quanto precisão dupla (64 bits), visando o uso em implementações de baixo consumo de recursos lógicos, na qual a unidade principal é o componente de processamento para redução Gauss-Jordan. Esse componente consiste de outras pequenas unidades organizadas de tal forma que mantêm a precisão dos resultados sem a necessidade de internamente normalizar e de-normalizar os dados em ponto flutuante. No intuito de gerar arquiteturas de baixo custo, este trabalho propõe o estudo de diferentes formas de abordar o problema, descrevendo em código VHDL estas arquiteturas em que os tamanhos de matrizes são definidos pelos usuários. Os resultados de erro e de tempo de execução das arquiteturas desenvolvidas foram comparados contra o MatLab, que faz uma simulação comportamental do código VHDL gerado através do ambiente de simulação ModelSim. A implementação das operações e da própria unidade procura explorar os recursos disponíveis na FPGA Virtex-5. O desempenho e o consumo de recursos são apresentados, comparando as diferentes arquiteturas desenvolvidas entre si e entre outras arquiteturas propostas encontradas em publicações anteriores. Além disso, é mostrado o decremento no desempenho a medida que o tamanho da matriz aumenta. ______________________________________________________________________________ ABSTRACTComputer operations demanding matrix calculations are at the heart of many scientific computing algorithms such as: signal processing, computer vision, robotics, among others. Because these algorithms perform matrix calculations, they are often computationally expensive, and their hardware implementations require much effort and time. So there is a growing demand for architectures that perform matrix calculations, fast and efficiently. This work presents different computer architectures for matrix inversion in FPGA reconfigurable hardware: (a) sequential, (b) pipeline and (c) Parallel. These architectures use a floating point representation in both single-precision (32 bit) and double precision (64 bits), suitable for use in low cost implementations, and where main component is Gauss-Jordan reduction. This component consists of other small units arranged in such a way that maintains the accuracy of results without the need of internally normalizing and de-normalizing the floating point data. In order to generate low-cost architectures, this work proposes to study different ways of approaching the problem in VHDL code, and allowing that sizes of matrices be defined by users. All architectures were simulated using MatLab, with a behavioral simulation of VHDL code generated by ModelSim simulation environment. As a result of comparing the error obtained by the architecture, with the inversion performed using MatLab as static estimator. The implementation of operations and the unit seeks to explore the resources available in Virtex-5 FPGA. The performance and resource consumption are presented, comparing the different architectures developed between themselves and with others proposed in previous publications. In addition, it is shown the influence of the array size in the performance

Minimal digital chaotic system

Over the past few decades, many works have been devoted to designing simple chaotic systems based on analog electronic circuits. However, the same attention is not observed in digital chaotic systems. This paper presents a design of a digital chaotic system using a digit complement. This special case of fixed-point number representation allows us to reduce the silicon area and the number of logic elements to perform the arithmetic operations. The design presents a configurable number of bits, and it is based on the logistic map. The proposed circuit has been implemented on a reconfigurable hardware, FPGA Cyclone V, showing that the number of logic elements has been significantly reduced compared to other works in the literature