Heap Partitioning and Parallelisation

Abstract

A crucial task in HLS of source code written in programming languages such as C/C++ is the extraction of parallelism from a sequential program description while preserving the program semantics. Additionally, parallelisation requires the memory system to match the computational parallelism. A fundamental difference of custom hardware implementations compared to microprocessors is the application-specific memory architecture. Instead of a monolithic memory space, the application data can be distributed over many small blocks of on-chip memory leading to a high aggregate memory bandwidth. Consequently, multiple computational units can be fed in parallel, which results in a very efficient parallelisation if expensive dynamic interconnects between any memory and any piece of computation can be eliminated, i.e. if the parallelism is communication-free. Automatic parallelisation for HLS compilers therefore requires a memory access and dependence analysis so as to detect parallelisation opportunities and partition the memory space accordingly. The objective in this chapter is to implement a static program analysis and automated code transformations that enable automatic parallelisation and distribution of data over separate blocks of on-chip memory. Our program analysis and code transformations explicitly target programs that use pointers to heap-allocated data and dynamic memory allocation, a powerful and widely used feature of high-level programming languages such as C/C++. Automated program transformations that break the monolithic heap memory space into several portions (heaplets) and parallelise pointer-manipulating programs are beyond the scope of most current HLS techniques as we demonstrate in Chap. 2 and discuss in Chap. 3. This gap is mainly due to the difficulty of disambiguating pointer aliases and breaking the monolithic heap memory (implicit in the programming model) into small fragments. This thesis makes a step towards closing this gap and presents in this chapter a static analysis for pointer-manipulating programs which determines dependencies between loop iterations accessing heap memory and splits dynamic data structures into disjoint, independent regions. Our tool connects to the LLVM compiler infrastructure. The dependence/disjointness information provided by the