tiered-mem-traces

60 memory access traces for tiered-memory simulation, covering all 16 benchmark suites of the CMU-SAFARI/DAMOV suite, plus 1 LLM-inference trace collected from llama2.c (under llama_inference/, Git LFS — see § LLM-inference trace). Each trace preserves load/store/modify classification from Valgrind's lackey tool.

Format

Each trace is a gzipped text file with one memory operation per line:

S 1fff000198,8
S 1fff000190,8
S 1fff000188,8
L 04038e06,1
M 04038e10,4

• L = load, S = store, M = modify (read-modify-write)
• <hex_addr>,<size> = byte address and access size
• Instruction fetches are excluded; only data accesses are recorded

Total: 97 MB compressed (~4 GB uncompressed).

Traces (60 total, by suite)

Trace	Description	Access Pattern	Size
bwa (genomics)
bwa.AlignLite	BWA-MEM short-read alignment via FM-index lookup	scattered reads into a hot index region	817K
chai (heterogeneous)
chai.BFS	frontier-driven graph BFS over a CSR graph	scattered adjacency reads, drifting hot frontier	1.1M
chai.BS.BEZIER_KERNEL	2D Bezier surface evaluation	structured streaming with small reused control set	1.1M
chai.CEDD.Gaussian	5x5 Gaussian-blur image convolution	stencil streaming, near-perfect spatial locality	1.3M
chai.CEDD.Sobel	3x3 Sobel edge-detection	stencil streaming	1.3M
chai.HSTI	input-side histogram increment	stream-read + scattered hot-write into bins	782K
chai.OOPPAD.OOPPAD	out-of-place 2D padding (border insertion)	streaming with reflected-border copy	1.3M
chai.SC.SC	stream compaction = filter + prefix-sum + scatter	two streaming passes + scattered scatter	753K
darknet (ML)
darknet.conv	im2col-style 2D convolution layer	weight streaming + activation reuse	1.1M
gase (genomics)
gase.Align	banded Smith-Waterman DP cell update	streaming along the band, three-row reuse	4.1M
hardware_effects (microbench)
hardware_effects.bandwidth	page-stride memory walk	scattered, anti-prefetcher pattern	2.5M
hardware_effects.false_sharing	single-threaded RMW alternating two cache-line slots	high temporal locality, RMW writes	259K
hashjoin (database)
hashjoin.MPSM	massively-parallel sort-merge join	two-stream merge with run-length copies	2.8M
hashjoin.NPO.HashJoin	no-partition open-addressed hash join (build + probe)	sequential probe + hot hash-table writes	1.1M
hashjoin.NPO_st	single-thread no-partition variant of NPO	sequential probe + scattered hash-table reads	2.8M
hashjoin.PRO	partitioned radix-style hash join	phase change between partition-build and probe	1.5M
hpcc (HPC)
hpcc.RandomAccess	GUPS-style xor-shift updates to random table slots	uniform-random scattered RMW	2.5M
hpcg (HPC)
hpcg.CG	conjugate-gradient inner loop on a 7-pt sparse stencil	SpMV scattered reads + vector streaming reductions	2.2M
hpcg.MG	3-level multigrid V-cycle (smooth + restrict + prolong)	stencil sweep at multiple resolutions	408K
hpcg.SpMV	sparse matrix-vector multiply on a 27-pt stencil	row-streaming + scattered neighbor reads	1.2M
ligra (graph)
ligra.BC	betweenness centrality via Brandes-style two-pass BFS	frontier sweep + dependency back-propagation	2.7M
ligra.BellmanFord	single-source shortest paths via repeated edge relaxation	edge-stream sweep with dist updates per round	3.1M
ligra.BFS	frontier-driven BFS	per-level frontier sweep, drifting hot set	1.9M
ligra.Components	connected-components via min-label propagation	full edge-stream sweep per round, label updates	2.4M
ligra.KCore	k-core decomposition by iterative low-degree peeling	vertex-array sweep with neighbor degree updates	2.0M
ligra.MIS	maximal independent set via Luby-style randomized priority	neighbor-priority compare + alive removal	1.9M
ligra.PageRank	PageRank: full-vertex sweep with adjacency-list reads	per-iter full-vertex stream + scattered neighbor writes	2.0M
ligra.Triangle	triangle counting via per-edge neighbor-set intersection	nested adjacency-list scans, heavy reads	520K
parboil (HPC)
parboil.histo	image histogram with ~16k bins	streaming read + scattered bin RMW	884K
parboil.mri-q	MRI Q-matrix construction (per-voxel trig accumulation)	double-loop over voxels x k-points, streaming	1.5M
parboil.sgemm	naive single-precision dense matmul	triple-loop with strided B access	1.1M
parboil.spmv	sparse matrix-vector multiply (random sparsity)	row-stream + irregular column reads	815K
parsec (multimedia)
parsec.Streamcluster	k-means-style center-distance scan	stream over points + sequential per-DIM	1.1M
phoenix (mapreduce)
phoenix.histogram	256-bin histogram over a streaming byte input	streaming read + dense hot-write into 256 bins	863K
phoenix.kmeans	k-means iterations: assign + center update	phase change between assign and reduce	963K
phoenix.lr	linear-regression gradient descent	streaming over (x, y) pairs	956K
phoenix.matrix-mult	MapReduce-flavored dense matmul	row-by-row mapper-style sweep	1.4M
phoenix.reverseindex	build a doc->terms reverse index	scattered hash-style writes + linked-list traversals	744K
phoenix.WordCount	MapReduce word count via open-addressed hash table	streaming over words + scattered hash probes	823K
polybench (HPC)
polybench.3mm	three sequential dense matmuls (E=AB; F=CD; G=EF)	tiled streaming with phase change between matmuls	1.6M
polybench.atax	y = A^T * (A x) (transpose + matrix-vector twice)	two streaming sweeps over A with vector reads	897K
polybench.bicg	biconjugate-gradient kernel: q=Ap; s=A^T r	single sweep over A with two simultaneous reductions	854K
polybench.doitgen	3D tensor reduction	structured streaming with reduction	1.2M
polybench.gemm	naive dense matmul C = A * B + C	triple-loop with strided B access	1.4M
polybench.syr2k	symmetric rank-2 update C = AB^T + BA^T + C	triple-loop with shared inner-K accumulation	1.6M
rodinia (heterogeneous)
rodinia.bfs	BFS on a regular 4-connected 2D grid	regular per-level frontier sweep	1.7M
rodinia.cfd	Euler-equation flux update on an unstructured mesh	edge-stream with scatter to two endpoints	3.9M
rodinia.hotspot	2D thermal-stencil sweep with two-array swap	5-pt stencil, two-array swap per iter	1.4M
rodinia.lavamd	short-range MD pairwise force calc with cutoff	O(N^2) pairwise with cutoff rejection	1.4M
rodinia.lud	right-looking LU decomposition without pivoting	triangular sweep with shrinking trailing block	1.6M
rodinia.srad	speckle-reducing anisotropic-diffusion image filter	two-pass per-pixel stencil	1.8M
splash2 (HPC)
splash2.FFT	1D FFT (bit-reversal + butterfly stages)	bit-reversal scatter + log(N) butterfly passes	2.2M
splash2.FMM	O(N^2) particle pairwise interactions	O(N^2) double-loop with sqrt per pair	966K
splash2.OCEAN	2D 5-pt stencil sweep with two interleaved grids	stencil streaming with three-grid update	1.9M
splash2.RADIOSITY	hierarchical 2D iterative form-factor refinement	KxK gather kernel applied per cell	1.3M
splash2.RAYTRACE	ray casting through a small scene of spheres	per-pixel scene scan, frequent shared-data reads	895K
stream (microbench)
stream.Add	c[i] = a[i] + b[i]	perfectly sequential streaming, no reuse	3.5M
stream.Copy	c[i] = a[i]	perfectly sequential streaming, no reuse	3.5M
stream.Scale	b[i] = scalar * c[i]	perfectly sequential streaming, no reuse	3.5M
stream.Triad	a[i] = b[i] + scalar * c[i]	perfectly sequential streaming, no reuse	3.5M

LLM-inference trace

One extra trace lives under llama_inference/ and is stored via Git LFS (the file is ~323 MB compressed). It is not part of the 60-trace DAMOV set above — different workload class, different scale.

Trace	Description	Access pattern	Size
llama_inference/llama2c_stories15M_n3	karpathy/llama2.c inference, TinyStories-15M architecture (dim=288, hidden=768, 6 layers, vocab=32000), n=3 forward passes (BOS prefill + 2 generated tokens, seed=42), random N(0, 0.02) weights — memory pattern is determined by tensor shapes and access order, not weight values, so it is structurally identical to a real TinyStories-15M checkpoint	continuous hot scratchpad (RunState) + linear weight-tensor sweeps + KV-cache growth per generated token	323M

Collection scale: 144,868,169 data accesses, 15,709 unique 4 KiB pages (61.4 MiB footprint), captured under valgrind --tool=lackey --trace-mem=yes with instruction fetches filtered out. Loads 85.8 %, stores 13.7 %, modifies 0.4 %.

Access pattern (annotated)

The y-axis is the actual virtual address (stack at 131 GiB excluded — 3 pages absorbing 13.9 % of all accesses). Region boundaries are ground truth from /proc/self/maps plus an instrumented run.c that printed every weight / RunState / KV pointer under valgrind. Three forward passes are visible as three structurally identical segments (dotted vertical guides at ~46 M / ~84 M / ~122 M accesses):

• 64–66 MiB — HEAP / RunState scratchpad. A continuous horizontal band touched throughout every pass. Holds x, xb, xb2, q, att, logits and other activation buffers. ~11 pages absorb ~50 % of the full trace's traffic; even with stack excluded, ~63 pages cover 50 % of the remaining accesses.
• 75–110 MiB — wcls / token_embedding classifier sweep. The large diagonal climbing once per pass is the final logits = matmul(x, wcls) projection against the 32,000-entry vocabulary (wcls is shared with token_embedding_table). A 36.6 MiB linear scan at the end of every forward pass.
• 110–134 MiB — per-layer weight matmuls. The "rainfall" pattern is six layers' worth of wq, wk, wv, wo, w1, w2, w3 sweeps. Each cold weight page is touched once per forward pass.
• 133–137 MiB — KV cache. key_cache + value_cache (3.4 MiB total). Pass 1 is pure stores; passes 2 and 3 have growing reads as the attention softmax iterates over an increasing number of KV slots.
• 131 GiB — stack (filtered in the figure). 3 pages, 13.9 % of all accesses; valgrind redirects the user stack to the top of its managed address space.

The combination of a tiny continuously-hot scratchpad and a large once-per-pass cold-weight sweep is the canonical heavy-tailed access pattern of LLM inference: cache-policy choice barely matters at small cache sizes because the hot set fits in any cache and the cold weight scan is unaffected by eviction order.

Reproducing

The collection pipeline (random-weight model.bin generator, valgrind lackey wrapper, analyzer, plotter) lives in the arcsim repo: scripts/llama_traces/. See scripts/llama_traces/README.md for the full repro recipe and scripts/llama_traces/REPORT_stories15M.md for the original characterization run.

How Traces Were Collected

Each trace comes from a small self-contained C facsimile that reproduces the kernel's memory access pattern at smaller-than-production scale. The pipeline:

DAMOV recipe -> C facsimile (gcc -O0)
             -> valgrind --tool=lackey --trace-mem=yes
             -> awk filter (L/S/M lines only)
             -> gzip -6
             -> *.bytes.trace.gz

These are pre-cache traces (Valgrind sees every load/store including stack traffic). Working sets are small (all 60 traces have U <= 3091 4-KiB pages). The qualitative access pattern shape (skew, reuse-distance distribution, hot-set drift, spatial locality class) is preserved from the original DAMOV kernels, but absolute access counts differ from production-scale runs.

13 long-running workloads were SIGKILL-capped at ~25 min wall time once the trace had grown to 25-200M accesses.

Suite Coverage

Suite	DAMOV Functions	Traces Here
bwa	2	1
chai	19	7
darknet	4	1
gase	2	1
hardware_effects	4	2
hashjoin	12	4
hpcc	2	1
hpcg	5	3
ligra	39	8
parboil	7	4
parsec	5	1
phoenix	5	6
polybench	8	6
rodinia	11	6
splash2	14	5
stream	4	4
Total	143	60

Attribution

These traces are derived from the DAMOV benchmark suite by Oliveira et al. (CMU-SAFARI). The kernels were re-implemented at small scale as self-contained C facsimiles; the intent and naming of each trace follows the original DAMOV classification.

Geraldo F. Oliveira, Juan Gomez-Luna, Lois Orosa, Saugata Ghose, Nandita Vijaykumar, Ivan Fernandez, Mohammad Sadrosadati, Onur Mutlu. "DAMOV: A New Methodology and Benchmark Suite for Evaluating Data Movement Bottlenecks." IEEE Access, 2021. arXiv:2105.03725

https://github.com/CMU-SAFARI/DAMOV

DAMOV aggregates kernels from BWA, Chai, Darknet, GASE, Hardware-Effects, HPC-Challenge, HPCG, Hashjoin, Ligra, PARSEC, Parboil, PolyBench, Phoenix, Rodinia, SPLASH-2, and STREAM -- each licensed and credited by its upstream authors.