ReuseTracker : Fast Yet Accurate Multicore Reuse Distance Analyzer

Abstract

One widely used metric that measures data locality is reuse distance —the number of unique memory locations that are accessed between two consecutive accesses to a particular memory location. State-of-the-art techniques that measure reuse distance in parallel applications rely on simulators or binary instrumentation tools that incur large performance and memory overheads. Moreover, the existing sampling-based tools are limited to measuring reuse distances of a single thread and discard interactions among threads in multi-threaded programs. In this work, we propose ReuseTracker —a fast and accurate reuse distance analyzer that leverages existing hardware features in commodity CPUs. ReuseTracker is designed for multi-threaded programs and takes cache-coherence effects into account. By utilizing hardware features like performance monitoring units and debug registers, ReuseTracker can accurately profile reuse distance in parallel applications with much lower overheads than existing tools. It introduces only 2.9× runtime and 2.8× memory overheads. Our tool achieves 92% accuracy when verified against a newly developed configurable benchmark that can generate a variety of different reuse distance patterns. We demonstrate the tool’s functionality with two use-case scenarios using PARSEC, Rodinia, and Synchrobench benchmark suites where ReuseTracker guides code refactoring in these benchmarks by detecting spatial reuses in shared caches that are also false sharing and successfully predicts whether some benchmarks in these suites can benefit from adjacent cache line prefetch optimization.

Precise event sampling‐based data locality tools for AMD multicore architectures

“…We evaluate the accuracy of ReuseTracker $$$ {}^{+} $$$ in capturing reuse distance pattern, and the sensitivity of its accuracy under different thread counts, sampling intervals, and debug register counts. To evaluate its accuracy, we run ReuseTracker $$$ {}^{+} $$$ on the RIBench benchmark 15 . We also evaluate its runtime and memory overheads on a number of PARSEC benchmarks.…”

“…One of the two tools is ComDetective that detects inter‐thread communication, while the second is ReuseTracker that profiles reuse distance in multi‐threaded applications. We developed their Intel‐based implementations in References 14 and 15, and both tools are publicly available in Reference 25. In this work, we develop their AMD counterparts, which requires non‐trivial effort due to the fundamental design differences of AMD IBS and Intel PEBS.…”

“…ReuseTracker , which was first proposed in Reference 15, leverages PMUs and debug registers to analyze reuse distance in multithreaded code. It utilizes PMUs to sample uses and debug registers to detect either reuses or invalidations.…”

“…To detect inter‐thread communications and measure data locality in multi‐threaded code with low overheads, we substantially extend ComDetective , 14 a tool that captures inter‐thread communications in the forms of communication matrices, and ReuseTracker , 15 another tool that measures reuse distance in multi‐threaded applications, to work in AMD machines. We introduced these tools in our previous works, 14,15 and developed them to interface with Intel PEBS in sampling memory accesses. In this work, we extend them to leverage Instruction Based Sampling (IBS) facility when running on AMD machines to sample memory loads and stores in detecting communications and measuring reuse distance.…”

“…In our experimental study, we firstly verify the accuracy of ComDetective $$$ {}^{+} $$$ and ReuseTracker $$$ {}^{+} $$$ by using the microbenchmarks introduced in 14 and in 15 on an AMD multicore. We also perform sensitivity analysis to evaluate the impacts of different thread counts, sampling intervals, and debug register counts on the accuracy of our tools.…”