[Paper Review] DINAMITE: A modern approach to memory performance profiling

Svetozar Miučin, Conor Brady+1 more|arXiv (Cornell University)|Jun 1, 2016

Parallel Computing and Optimization Techniques18 references3 citations

TL;DR

DINAMITE is a compiler-based dynamic instrumentation and stream-processing framework for high-fidelity memory performance profiling, leveraging LLVM for precise source-level tracing and Spark Streaming for real-time analysis of full memory access traces. It enables detailed, portable memory optimization with 15–20% performance gains in applications and 20x speedup in a key-value store by identifying cache bottlenecks and data layout issues.

ABSTRACT

Diagnosing and fixing performance problems on multicore machines with deep memory hierarchies is extremely challenging. Certain problems are best addressed when we can analyze the entire trace of program execution, e.g., every memory access. Unfortunately such detailed execution logs are very large and cannot be analyzed by direct inspection. We present DINAMITE: a toolkit for Dynamic INstrumentation and Analysis for MassIve Trace Exploration. DINAMITE is a collection of tools for end-to-end performance analysis: from the LLVM compiler pass that instruments the program to plug-and-play tools that use a modern data analytics engine Spark Streaming for trace introspection. Using DINAMITE we found opportunities to improve data layout in several applications that resulted in 15-20% performance improvements and found a shared-variable bottleneck in a popular key-value store, whose elimination improved performance by 20x.

Motivation & Objective

• To address the challenge of diagnosing memory performance bottlenecks in multicore systems with deep memory hierarchies.
• To overcome limitations of existing tools that lack portability, generality, or flexibility in analyzing detailed memory access patterns.
• To provide a scalable, extensible framework for end-to-end memory trace analysis with minimal runtime overhead.
• To enable advanced memory optimizations through precise, source-level trace introspection and streaming analytics.
• To support flexible, pluggable analysis of memory access patterns without hardware or OS-specific dependencies.

Proposed method

• Instrumenting programs at compile-time using an LLVM pass to insert fine-grained tracing code for every memory access.
• Capturing detailed trace data including source location, variable name, type, value, and access type in binary format with buffering for efficiency.
• Using Spark Streaming to process traces in real time, eliminating the need for large-scale trace storage.
• Enabling plug-in analysis tools via a modular architecture that supports custom analytics in Scala or other languages.
• Integrating a cache simulator into the pipeline to replicate hardware-level behavior and validate optimization strategies.
• Leveraging precise debug information from LLVM to maintain source-level fidelity in trace metadata.

Experimental results

Research questions

• RQ1 Can a compiler-based instrumentation framework achieve low runtime overhead while enabling full-precision memory trace collection?
• RQ2 Can real-time stream processing of memory traces replace traditional trace storage and enable scalable, interactive performance analysis?
• RQ3 To what extent can such a system identify and resolve complex memory bottlenecks like false sharing and poor data locality?
• RQ4 How does the flexibility of a pluggable analysis framework compare to monolithic, OS- or hardware-specific tools in identifying performance issues?
• RQ5 Can the framework be extended to support multi-level cache simulation and fine-grained access pattern analysis?

Key findings

• DINAMITE reduced the last-level cache miss rate of SPEC2006’s 429.mcf by 55% and improved performance by 12% using trace-based analysis.
• The framework achieved a 50% reduction in LLC miss rate and a 15% performance improvement in PARSEC’s fluidanimate application.
• By applying structure splitting via DINAMITE’s second tool, the LLC miss rate in 429.mcf dropped by 60%, reducing runtime by 20%.
• DINAMITE detected a shared-variable bottleneck in WiredTiger, a popular key-value store, whose fix led to a 20x performance improvement.
• Runtime slowdowns were comparable to state-of-the-art tools like Pin and Valgrind, despite instrumenting every memory access.
• The integration of Spark Streaming enabled on-the-fly analysis with minimal storage overhead, supporting scalable and interactive memory profiling.