182 research outputs found
Video Processing Acceleration using Reconfigurable Logic and Graphics Processors
A vexing question is `which architecture will prevail as the core feature of the next state of
the art video processing system?' This thesis examines the substitutive and collaborative
use of the two alternatives of the reconfigurable logic and graphics processor architectures.
A structured approach to executing architecture comparison is presented - this includes a
proposed `Three Axes of Algorithm Characterisation' scheme and a formulation of perfor-
mance drivers. The approach is an appealing platform for clearly defining the problem,
assumptions and results of a comparison. In this work it is used to resolve the advanta-
geous factors of the graphics processor and reconfigurable logic for video processing, and
the conditions determining which one is superior. The comparison results prompt the
exploration of the customisable options for the graphics processor architecture. To clearly
define the architectural design space, the graphics processor is first identifed as part of
a wider scope of homogeneous multi-processing element (HoMPE) architectures. A novel
exploration tool is described which is suited to the investigation of the customisable op-
tions of HoMPE architectures. The tool adopts a systematic exploration approach and a
high-level parameterisable system model, and is used to explore pre- and post-fabrication
customisable options for the graphics processor. A positive result of the exploration is the
proposal of a reconfigurable engine for data access (REDA) to optimise graphics processor
performance for video processing-specific memory access patterns. REDA demonstrates
the viability of the use of reconfigurable logic as collaborative `glue logic' in the graphics
processor architecture
Weighing up the new kid on the block: Impressions of using Vitis for HPC software development
The use of reconfigurable computing, and FPGAs in particular, has strong
potential in the field of High Performance Computing (HPC). However the
traditionally high barrier to entry when it comes to programming this
technology has, until now, precluded widespread adoption. To popularise
reconfigurable computing with communities such as HPC, Xilinx have recently
released the first version of Vitis, a platform aimed at making the programming
of FPGAs much more a question of software development rather than hardware
design. However a key question is how well this technology fulfils the aim, and
whether the tooling is mature enough such that software developers using FPGAs
to accelerate their codes is now a more realistic proposition, or whether it
simply increases the convenience for existing experts. To examine this question
we use the Himeno benchmark as a vehicle for exploring the Vitis platform for
building, executing and optimising HPC codes, describing the different steps
and potential pitfalls of the technology. The outcome of this exploration is a
demonstration that, whilst Vitis is an excellent step forwards and
significantly lowers the barrier to entry in developing codes for FPGAs, it is
not a silver bullet and an underlying understanding of dataflow style
algorithmic design and appreciation of the architecture is still key to
obtaining good performance on reconfigurable architectures.Comment: Pre-print of Weighing up the new kid on the block: Impressions of
using Vitis for HPC software development, paper in 30th International
Conference on Field Programmable Logic and Application
Reconfigurable computing for large-scale graph traversal algorithms
This thesis proposes a reconfigurable computing approach for supporting parallel processing in large-scale graph traversal algorithms. Our approach is based on a reconfigurable hardware architecture which exploits the capabilities of both FPGAs (Field-Programmable Gate Arrays) and a multi-bank parallel memory subsystem.
The proposed methodology to accelerate graph traversal algorithms has been applied to three case studies, revealing that application-specific hardware customisations can benefit performance. A summary of our four contributions is as follows.
First, a reconfigurable computing approach to accelerate large-scale graph traversal algorithms. We propose a reconfigurable hardware architecture which decouples computation and communication while keeping multiple memory requests in flight at any given time, taking advantage of the high bandwidth of multi-bank memory subsystems.
Second, a demonstration of the effectiveness of our approach through two case studies: the breadth-first search algorithm, and a graphlet counting algorithm from bioinformatics. Both case studies involve graph traversal, but each of them adopts a different graph data representation.
Third, a method for using on-chip memory resources in FPGAs to reduce off-chip memory accesses for accelerating graph traversal algorithms, through a case-study of the All-Pairs Shortest-Paths algorithm. This case study has been applied to process human brain network data.
Fourth, an evaluation of an approach based on instruction-set extension for FPGA design against many-core GPUs (Graphics Processing Units), based on a set of benchmarks with different memory access characteristics. It is shown that while GPUs excel at streaming applications, the proposed approach can outperform GPUs in applications with poor locality characteristics, such as graph traversal problems.Open Acces
Exploring the acceleration of Nekbone on reconfigurable architectures
Hardware technological advances are struggling to match scientific ambition,
and a key question is how we can use the transistors that we already have more
effectively. This is especially true for HPC, where the tendency is often to
throw computation at a problem whereas codes themselves are commonly bound,
at-least to some extent, by other factors. By redesigning an algorithm and
moving from a Von Neumann to dataflow style, then potentially there is more
opportunity to address these bottlenecks on reconfigurable architectures,
compared to more general-purpose architectures.
In this paper we explore the porting of Nekbone's AX kernel, a widely popular
HPC mini-app, to FPGAs using High Level Synthesis via Vitis. Whilst computation
is an important part of this code, it is also memory bound on CPUs, and a key
question is whether one can ameliorate this by leveraging FPGAs. We first
explore optimisation strategies for obtaining good performance, with over a
4000 times runtime difference between the first and final version of our kernel
on FPGAs. Subsequently, performance and power efficiency of our approach on an
Alveo U280 are compared against a 24 core Xeon Platinum CPU and NVIDIA V100
GPU, with the FPGA outperforming the CPU by around four times, achieving almost
three quarters the GPU performance, and significantly more power efficient than
both. The result of this work is a comparison and set of techniques that both
apply to Nekbone on FPGAs specifically and are also of interest more widely in
accelerating HPC codes on reconfigurable architectures.Comment: Pre-print of paper accepted to IEEE/ACM International Workshop on
Heterogeneous High-performance Reconfigurable Computing (H2RC
Type-driven automated program transformations and cost modelling for optimising streaming programs on FPGAs
In this paper we present a novel approach to program optimisation based on compiler-based type-driven program transformations and a fast and accurate cost/performance model for the target architecture. We target streaming programs for the problem domain of scientific computing, such as numerical weather prediction. We present our theoretical framework for type-driven program transformation, our target high-level language and intermediate representation languages and the cost model and demonstrate the effectiveness of our approach by comparison with a commercial toolchain
Automatic pipelining and vectorization of scientific code for FPGAs
There is a large body of legacy scientific code in use today that could benefit from execution on accelerator devices like GPUs and FPGAs. Manual translation of such legacy code into device-specific parallel code requires significant manual effort and is a major obstacle to wider FPGA adoption. We are developing an automated optimizing compiler TyTra to overcome this obstacle. The TyTra flow aims to compile legacy Fortran code automatically for FPGA-based acceleration, while applying suitable optimizations. We present the flow with a focus on two key optimizations, automatic pipelining and vectorization. Our compiler frontend extracts patterns from legacy Fortran code that can be pipelined and vectorized. The backend first creates fine and coarse-grained pipelines and then automatically vectorizes both the memory access and the datapath based on a cost model, generating an OpenCL-HDL hybrid working solution for FPGA targets on the Amazon cloud. Our results show up to 4.2× performance improvement over baseline OpenCL code
Toolflows for Mapping Convolutional Neural Networks on FPGAs: A Survey and Future Directions
In the past decade, Convolutional Neural Networks (CNNs) have demonstrated
state-of-the-art performance in various Artificial Intelligence tasks. To
accelerate the experimentation and development of CNNs, several software
frameworks have been released, primarily targeting power-hungry CPUs and GPUs.
In this context, reconfigurable hardware in the form of FPGAs constitutes a
potential alternative platform that can be integrated in the existing deep
learning ecosystem to provide a tunable balance between performance, power
consumption and programmability. In this paper, a survey of the existing
CNN-to-FPGA toolflows is presented, comprising a comparative study of their key
characteristics which include the supported applications, architectural
choices, design space exploration methods and achieved performance. Moreover,
major challenges and objectives introduced by the latest trends in CNN
algorithmic research are identified and presented. Finally, a uniform
evaluation methodology is proposed, aiming at the comprehensive, complete and
in-depth evaluation of CNN-to-FPGA toolflows.Comment: Accepted for publication at the ACM Computing Surveys (CSUR) journal,
201
Optimising runtime reconfigurable designs for high performance applications
This thesis proposes novel optimisations for high performance runtime reconfigurable designs.
For a reconfigurable design,
the proposed approach investigates idle resources introduced by static design approaches,
and exploits runtime reconfiguration to eliminate the inefficient resources.
The approach covers the circuit level, the function level, and the system level.
At the circuit level, a method is proposed for tuning reconfigurable designs with two analytical models:
a resource model for computational and memory resources and memory bandwidth,
and a performance model for estimating execution time.
This method is applied to tuning implementations of finite-difference algorithms,
optimising arithmetic operators and memory bandwidth based on algorithmic parameters,
and eliminating idle resources by runtime reconfiguration.
At the function level, a method is proposed to automatically identify and exploit runtime
reconfiguration opportunities while optimising resource utilisation.
The method is based on Reconfiguration Data Flow Graph,
a new hierarchical graph structure enabling runtime reconfigurable designs to be synthesised in three steps:
function analysis, configuration organisation, and runtime solution generation.
At the system level, a method is proposed for optimising reconfigurable designs by dynamically adapting the designs to available runtime resources in a reconfigurable system. This method includes two steps: compile-time optimisation and runtime scaling, which enable efficient workload distribution, asynchronous communication scheduling, and domain-specific optimisations. It can be used in developing effective servers for high performance applications.Open Acces
Tools for efficient Deep Learning
In the era of Deep Learning (DL), there is a fast-growing demand for building and deploying Deep Neural Networks (DNNs) on various platforms. This thesis proposes five tools to address the challenges for designing DNNs that are efficient in time, in resources and in power consumption.
We first present Aegis and SPGC to address the challenges in improving the memory efficiency of DL training and inference. Aegis makes mixed precision training (MPT) stabler by layer-wise gradient scaling. Empirical experiments show that Aegis can improve MPT accuracy by at most 4\%. SPGC focuses on structured pruning: replacing standard convolution with group convolution (GConv) to avoid irregular sparsity. SPGC formulates GConv pruning as a channel permutation problem and proposes a novel heuristic polynomial-time algorithm. Common DNNs pruned by SPGC have maximally 1\% higher accuracy than prior work.
This thesis also addresses the challenges lying in the gap between DNN descriptions and executables by Polygeist for software and POLSCA for hardware. Many novel techniques, e.g. statement splitting and memory partitioning, are explored and used to expand polyhedral optimisation. Polygeist can speed up software execution in sequential and parallel by 2.53 and 9.47 times on Polybench/C. POLSCA achieves 1.5 times speedup over hardware designs directly generated from high-level synthesis on Polybench/C.
Moreover, this thesis presents Deacon, a framework that generates FPGA-based DNN accelerators of streaming architectures with advanced pipelining techniques to address the challenges from heterogeneous convolution and residual connections. Deacon provides fine-grained pipelining, graph-level optimisation, and heuristic exploration by graph colouring. Compared with prior designs, Deacon shows resource/power consumption efficiency improvement of 1.2x/3.5x for MobileNets and 1.0x/2.8x for SqueezeNets.
All these tools are open source, some of which have already gained public engagement. We believe they can make efficient deep learning applications easier to build and deploy.Open Acces
- …