Automated bug detection for pointers and memory accesses in High-Level Synthesis compilers

Abstract

Abstract-Modern High-Level Synthesis (HLS) compilers aggressively optimize memory architectures. Bugs involving memory accesses are hard to detect, especially if they are inserted in the compilation process. We present an approach to isolate automatically memory bugs introduced by HLS tools, without user interaction, using only the original high-level specification. This is possible by tracing memory accesses in software (SW) and hardware (HW) executions on a given input dataset. The execution traces are compared performing a context-aware HW/SW address translation, leveraging alias-analysis, HLS memory allocation information and SW memory debugging practices. No restrictions are imposed on memory optimizations. We show results on the relevance of the problem, the coverage, the detected bugs. We also show that the approach can be adapted to different commercial and academic HLS tools.

Enabling Automated Bug Detection for IP-Based Designs Using High-Level Synthesis

“…This approach is orthogonal and entirely compatible to other works on Discrepancy Analysis, such as [11]. Consider the scenario shown in Fig.…”

Automated Bug Detection for High-level Synthesis of Multi-threaded Irregular Applications

“…Hence, what is called OpTrace in Reference [14] for a Basic Block is just a set of OpTraces as defined here for a single operation. Notice that the equality function can be as simple as bitwise equality for plain integer data, but it can be complicated in case of floating points or custom data formats, up to involving contextdependent address translation tables for pointers and addresses [15].…”

“…This holds both for control flow bugs and for faults involving single operations. For custom data types, the approach can use special comparison functions, for instance, considering Unit in Last Place for floating points or considering the HW/SW address mapping for pointers (see Reference [15]). The approach can also isolate bugs in libraries of external components used as elementary operators in HLS.…”

“…For benchmarks with larger memories and a higher number of shared variables the number of memory accesses and pointer operations is also higher. This triggers the address Discrepancy Analysis algorithm implemented by bambu and described in Reference [15]. This algorithm is more complicated, because it keeps track of context-dependent memory locations of stack-allocated variables in software to build tables that are queried by the Discrepancy Analysis to resolve matches and mismatches on pointer operations.…”