deepanjalimishra99/new-crono-traces

hpca2027-traces-deepanjali: CRONO SimPoint traces on SNAP graphs

DynamoRIO SimPoint traces for the CRONO shared-memory graph benchmark suite, collected on real SNAP datasets (plus CRONO's built-in synthetic graph generator for the two algorithms not suited to a 875K-node graph) and converted into the same layout used by the existing Scarab traces under /dev/shm/baseline/simpoint_traces (fingerprint/, simpoints/, traces_simp/{bin,trace}, trace_clustering_info.json).

Trace generation date: 2026-07-25

The original task scope was BFS/DFS/PageRank on web-Google and SSSP on ego-Facebook (the first 4 rows below). Scope was then explicitly expanded to cover the rest of the CRONO suite (the remaining rows); see the "tsp_synth (excluded)" note below for the one app that could not be collected.

Workloads

Workload dir	Application	Dataset	Graph	Algorithm	Threads	# SimPoints
bfs_web-google/	bfs	web-Google (SNAP)	875,713 nodes / 5,105,039 edges (directed web graph)	Breadth-First Search (vertex-coloring based, parallel)	8	4
dfs_web-google/	dfs	web-Google (SNAP)	875,713 nodes / 5,105,039 edges (directed web graph)	Depth-First Search (parallel, partitioned stack traversal)	8	4
pagerank_web-google/	pagerank	web-Google (SNAP)	875,713 nodes / 5,105,039 edges (directed web graph)	PageRank (lock-free, iterative power method)	8	4
sssp_ego-facebook/	sssp	ego-Facebook / facebook_combined (SNAP)	4,039 nodes / 88,234 edges (undirected social graph)	Single-Source Shortest Path (parallel Yen-optimized Dijkstra sweep)	8	3
community_web_google/	community_lock	web-Google (SNAP)	875,713 nodes / 5,105,039 edges	Community Detection (lock-based, approximate Louvain, 3 iterations)	8	4
connected_components_web_google/	connected_components_lock	web-Google (SNAP)	875,713 nodes / 5,105,039 edges	Connected Components (lock-based, parallel label propagation)	8	4
triangle_counting_web_google/	triangle_counting_lock	web-Google (SNAP)	875,713 nodes / 5,105,039 edges	Triangle Counting (lock-based, parallel)	8	4
bc_synth/	bc	CRONO synthetic generator (N=8192, DEG=16)	8,192 vertices / ~131,072 edges	Betweenness Centrality (partitioned, parallel Brandes-style)	8	3
apsp_synth/	apsp	CRONO synthetic generator (N=8192, DEG=16)	8,192 vertices / ~131,072 edges	All-Pairs Shortest Path (parallel)	8	3
tsp_synth (excluded)	tsp	CRONO synthetic generator	--	Traveling Salesman Problem	--	0

bc and apsp use CRONO's built-in synthetic random-graph generator (not a file-based SNAP dataset) because both are dense-graph algorithms (Brandes-style betweenness centrality is O(V·(V+E)) per source; all-pairs shortest path is O(V·(V+E)) or worse per source) that are not practical to profile end-to-end on an 875K-node graph within a bounded collection window; this mirrors how these two apps were previously exercised in this environment (bc_synth/apsp_synth under /dev/shm/baseline/crono_collect/).

tsp could not be collected: its whole-program BBV fingerprint pass reliably crashes the third-party DynamoRIO fingerprint client with ASSERT FAILURE: fingerprint_src/fpg.cpp:716: !for_trace. That assertion encodes an assumption that a basic block reached via DynamoRIO's trace-formation path (for_trace) is always one DynamoRIO has already seen "as-built" -- CRONO's tsp.cc does enough recursive backtracking branch-and-bound search to produce a basic block that violates that assumption, independent of the number of cities tried (verified at 8/14/18/20/22/24 cities, all either finished too fast to profile meaningfully or hit this same assertion). This is a bug/limitation in the fingerprint tool itself, not in CRONO or in this collection's pipeline, and wasn't fixable within the available time; tsp is therefore excluded from this release.

Every collected SimPoint trace contains at least 30,000,000 committed instructions (actual: 120-180,000,000 each -- 2 to 5 warmup chunks + 1 measured chunk of 30,000,000 instructions each), well above the task's 30M minimum.

Per-workload detail

bfs_web-google (BFS on web-Google)

Correction (2026-07-26): the original bfs_web-google release below never actually reached BFS's do_work traversal kernel. An independent source-level audit (tracing ideal-fusion candidate PCs back to their originating code) found that all 4 of the original SimPoints -- despite collectively spanning 100% of the fingerprinted run's weight -- resolved entirely to main()'s setup code, never to do_work, bfs.cc's actual pthreads coloring-BFS kernel. The mechanism: CRONO's file-reading mode hardcodes N = 2,097,152 (2^21) vertex slots as an upper bound, independent of the real graph's size (web-Google has ~875,713 vertices); main allocates a separate 64-byte-aligned buffer per vertex slot, twice, for all 2.1M slots -- over 4.19 million individual posix_memalign calls, immediately followed by a 33.5M-entry array init and a byte-at-a-time file parse -- before pthread_createing a single do_work thread. This setup phase turned out to span on the order of ten billion instructions (measured directly, see below), several times longer than the ~2.3 billion instructions the original fingerprint pass (bounded by FINGERPRINT_TIMEOUT_SEC=60) ever got through, so every segment SimPoint's clustering had to choose from was still inside setup.

Fix. Added a skip_instrs client option to the fingerprint tool (fingerprint_src/fpg.cpp): discards the first N dynamic instructions (across all threads, protected by the existing count_lock mutex) before any segment/BBV data is recorded, so SimPoint's clustering only ever sees the phase after the skip (plumbed through run_simpoint_trace.py as a SKIP_INSTRS env var, applied both to the fingerprint pass and to translating each selected segment's absolute -trace_after_instrs offset for cluster tracing). The skip point itself was measured empirically rather than guessed: a throwaway copy of bfs.cc was patched to call exit(0) on entry to do_work, built, and run natively (no DynamoRIO) -- it reached that point and exited in 1.75 seconds, confirming the setup-to-do_work transition is fast in wall-clock terms despite being instruction-dense. Under DynamoRIO fingerprinting, the same instrumented binary reached ~11.1-11.3 billion instructions before an unrelated DynamoRIO internal crash (likely triggered by the pthread_create/exit() interaction, not a measurement of do_work itself); that count was used as SKIP_INSTRS=10,900,000,000 for the real (unmodified) binary.

• SimPoints (segment id, weight, instructions, active worker threads) -- all verified inside do_work via the tid≠pid worker-thread check (segment 18's single active thread is still valid do_work evidence, matching the same pattern documented for sssp_ego-facebook below):
  • segment 0, weight 0.0290, 30,000,000 instructions -- 8 active worker threads
  • segment 2, weight 0.0869, 180,000,000 instructions -- 8 active worker threads
  • segment 18, weight 0.8552, 180,000,000 instructions -- 1 active worker thread (dominant)
  • segment 1, weight 0.0290, 60,000,000 instructions -- 8 active worker threads
• Weights sum to 1.0 (normalized).
• Application/dataset/graph/algorithm: see table above.

dfs_web-google (DFS on web-Google)

• SimPoints (segment id, weight, instructions):
  • segment 29, weight 0.1316, 180,000,000 instructions
  • segment 33, weight 0.1579, 180,000,000 instructions
  • segment 57, weight 0.1974, 180,000,000 instructions
  • segment 8, weight 0.5132, 180,000,000 instructions
• Weights sum to 1.0 (normalized).

pagerank_web-google (PageRank on web-Google)

• SimPoints (segment id, weight, instructions):
  • segment 38, weight 0.1183, 180,000,000 instructions
  • segment 6, weight 0.1445, 180,000,000 instructions
  • segment 25, weight 0.0657, 180,000,000 instructions
  • segment 76, weight 0.6715, 180,000,000 instructions
• Weights sum to 1.0 (normalized).

sssp_ego-facebook (SSSP on ego-Facebook)

• SimPoints (segment id, weight, instructions):
  • segment 21, weight 0.3947, 180,000,000 instructions -- 1 active worker thread
  • segment 0, weight 0.0065, 180,000,000 instructions -- 1 active worker thread (this is the earliest segment in the profiled run; it still shows worker-thread activity, i.e. by the end of the first 30M-instruction window the program has already moved past single-threaded graph parsing into do_work())
  • segment 155, weight 0.5989, 180,000,000 instructions -- 8 active worker threads (the dominant, fully-parallel SSSP relaxation phase)
• Weights sum to 1.0 (normalized).
• Note on collection: concurrent per-cluster DynamoRIO captures of this workload intermittently lost a cluster's modules.log/encodings.bin during conversion (raw trace data was captured fine, but ~half the concurrently-launched capture processes failed to produce readable module metadata). Tracing SSSP's clusters sequentially instead of concurrently (SEQUENTIAL_CLUSTER_TRACING=1, a small additive option added to run_simpoint_trace.py for this collection) resolved it completely -- all 3 selected clusters produced valid traces on that run.

community_web_google (Community Detection on web-Google)

• SimPoints (segment id, weight, instructions, active worker threads):
  • segment 0, weight 0.0153, 150,000,000 instructions -- 1 worker thread
  • segment 18, weight 0.2600, 180,000,000 instructions -- 1 worker thread
  • segment 42, weight 0.6023, 180,000,000 instructions -- 1 worker thread (dominant)
  • segment 4, weight 0.1224, 180,000,000 instructions -- 1 worker thread
• Weights sum to 1.0 (normalized). Collected sequentially (SEQUENTIAL_CLUSTER_TRACING=1).

connected_components_web_google (Connected Components on web-Google)

• SimPoints (segment id, weight, instructions, active worker threads):
  • segment 0, weight 0.0153, 150,000,000 instructions -- 1 worker thread
  • segment 18, weight 0.2595, 180,000,000 instructions -- 1 worker thread
  • segment 42, weight 0.6032, 180,000,000 instructions -- 1 worker thread (dominant)
  • segment 4, weight 0.1221, 180,000,000 instructions -- 1 worker thread
• Weights sum to 1.0 (normalized). Collected sequentially (SEQUENTIAL_CLUSTER_TRACING=1).

triangle_counting_web_google (Triangle Counting on web-Google)

• SimPoints (segment id, weight, instructions, active worker threads):
  • segment 0, weight 0.0153, 150,000,000 instructions -- 1 worker thread
  • segment 18, weight 0.2599, 180,000,000 instructions -- 1 worker thread
  • segment 42, weight 0.6024, 180,000,000 instructions -- 1 worker thread (dominant)
  • segment 4, weight 0.1223, 180,000,000 instructions -- 1 worker thread
• Weights sum to 1.0 (normalized). Collected sequentially (SEQUENTIAL_CLUSTER_TRACING=1).
• Note: community/connected_components/triangle_counting independently converged on the same segment ids (0, 18, 4, 42) and near-identical weights. This was verified to not be a copy/reuse bug -- each workload's fingerprint/bbfp.* file has distinct content (different md5 hashes) -- and is a coincidence of running structurally similar single-threaded-parse + single-dominant-parallel-phase kernels over the same graph under the same 60s fingerprint bound, which SimPoint's k-means clustering resolves similarly across all three.

bc_synth (Betweenness Centrality, synthetic graph)

• SimPoints (segment id, weight, instructions, active worker threads):
  • segment 1, weight 0.3333, 150,000,000 instructions -- 8 worker threads
  • segment 2, weight 0.3333, 180,000,000 instructions -- 8 worker threads
  • segment 0, weight 0.3333, 120,000,000 instructions -- 8 worker threads
• Weights sum to 1.0 (normalized). Collected sequentially (SEQUENTIAL_CLUSTER_TRACING=1). Only 3 total segments were profiled in the 60s fingerprint window (the whole synthetic workload is fast), so all 3 became separate, equally-weighted SimPoints.

apsp_synth (All-Pairs Shortest Path, synthetic graph)

• SimPoints (segment id, weight, instructions, active worker threads):
  • segment 1, weight 0.3333, 150,000,000 instructions -- 8 worker threads
  • segment 2, weight 0.3333, 180,000,000 instructions -- 8 worker threads
  • segment 0, weight 0.3333, 120,000,000 instructions -- 8 worker threads
• Weights sum to 1.0 (normalized). Collected sequentially (SEQUENTIAL_CLUSTER_TRACING=1). Same as bc_synth: only 3 total segments were profiled, all equally weighted.

How the "do-work" (steady-state graph-processing) phase was verified

This was the most important verification step, so it's explained in detail.

Every CRONO application (bfs.cc, dfs.cc, pagerank.cc, sssp.cc) follows the same structure: it opens and parses the input graph file single-threaded (a fopen()/getc() loop building the adjacency structure), and only calls pthread_create() to launch the parallel do_work() kernel (BFS/DFS traversal, PageRank iteration, SSSP relaxation) afterwards. This was confirmed by reading the source of all four apps (fopen() occurs around line 150-275, pthread_create()/do_work() around line 320-410 in each file).

On Linux, the main thread's tid always equals the process's pid; only threads created via pthread_create() get a distinct tid. This gives a mechanical, checkable test: for each selected SimPoint, inspect the raw per-thread DynamoRIO capture files under traces_simp/<segment>/raw/window.*/drmemtrace.<exe>.<pid>.<tid>.raw.lz4. If any such file has tid != pid, a pthread_create()d worker thread was active during that traced window — proof the segment falls inside the parallel do_work compute phase, not the single-threaded setup/parsing phase (this holds even if only one worker thread happened to be captured as "dominant" in that window; sibling workers can be briefly idle/blocked at a barrier without invalidating the signal, since only do_work() ever spawns non-main threads).

Applying this check to every SimPoint in this release: all of them across all 9 workloads (4 BFS + 4 DFS + 4 PageRank + 3 SSSP + 4 community + 4 connected_components + 4 triangle_counting + 3 bc + 3 apsp = 33 SimPoint traces total) have an active thread with tid != pid — i.e. the parallel do-work / graph-processing phase is represented in every single SimPoint trace in this bundle, not just startup/parsing. SSSP's dominant segment (155, weight 0.599) and every bc_synth/apsp_synth segment show all 8 worker threads simultaneously active, the clearest possible evidence of the fully-parallel phase; the web-Google-based community/connected_components/triangle_counting segments each show 1 dominant active worker thread per segment (their code is more serialized around shared locks/critical sections than SSSP's or bc's/apsp's per-thread-partitioned work, but the active thread is still, by construction, a pthread_create()d worker, never the parsing-phase main thread).

Additionally, per app: bfs/dfs/pagerank each had a full BBV fingerprint spanning 77 segments (30M instructions each = ~2.3B total instructions profiled) and sssp spanned 68+ segments before the profiling window closed. The SimPoint clusters selected span segment ids from early (1, 6, 8, 12, and SSSP's segment 0) to late (57, 60, 76, and SSSP's segment 155) in each timeline — i.e. SimPoint's own phase-clustering, run across the whole profiled execution, independently picked representative windows spread across both the (comparatively small, single-threaded) parsing phase and the (dominant, multi-threaded) compute phase, exactly as the task expects ("acceptable for one SimPoint to land during initialization... but the do-work phase must also be traced"). Notably, even SSSP's earliest segment (0) already shows worker-thread activity by the end of its 30M-instruction window, since graph parsing on this small dataset finishes well before 30M instructions.

Reproducing these traces

All commands below assume:

• scarab-infra checked out at /users/deepmish/scarab-infra (this repo includes small, additive patches used for this collection, all backwards compatible / opt-in via env vars:
  • common/scripts/run_simpoint_trace.py: FINGERPRINT_TIMEOUT_SEC env-var bound on the whole-program BBV fingerprint pass; minimize_simpoint_traces() now handles multi-threaded per-cluster captures (picks the largest per-thread trace file instead of requiring exactly one) and skips clusters whose DynamoRIO capture failed instead of aborting the whole run; SEQUENTIAL_CLUSTER_TRACING=1 traces clusters one at a time instead of concurrently (needed for sssp, see below).
  • common/scripts/replace_oversized_simpoints.py: fixed a duplicate-CSV-header edge case in the fingerprint's .inscount file, and made its instruction-count threshold (OVERSIZED_SIMPOINT_THRESHOLD) configurable -- the default 15M is stale for a 30M+ segment size (every segment is "oversized" by that standard) and was actively swapping SimPoint's chosen representative segment for a different one for no benefit.
• CRONO checked out at /users/deepmish/crono_collect/CRONO with datasets/web-Google.txt and datasets/facebook_combined.txt downloaded from SNAP.
• The allbench_traces docker image already built (contains DynamoRIO, the SimPoint 3.2 clustering tool, and the BBV fingerprint client).

CRONO's binaries must be rebuilt inside the tracing container (its glibc is older than the host's, so host-compiled binaries fail with GLIBC_2.34 not found); note also that DFS's own README.md documents an outdated argv order -- the real binary takes ./dfs <0|1> <threads> <file> just like the other three apps, not ./dfs <threads> <file>.

# One-time: build each app inside the container (example for bfs; same pattern for dfs/pagerank/sssp)
docker run --rm -v /users/deepmish/crono_collect:/tmp_home/application allbench_traces:<tag> \
  bash -c 'cp -r /tmp_home/application/CRONO/apps/bfs /tmp/bfs && cd /tmp/bfs && \
           g++ -g --std=c++0x -O3 -Wall bfs.cc -o bfs -lpthread -lrt'

# Then, per workload, run the mode-1 (cluster_then_trace) SimPoint pipeline:
docker run --privileged \
  -e SIMPOINT_SEG_SIZE=30000000 -e FINGERPRINT_TIMEOUT_SEC=60 \
  --mount type=bind,source=/dev/shm/baseline/crono_trace_root,target=/home/$USER \
  --mount type=bind,source=/users/deepmish/crono_collect,target=/tmp_home/application \
  allbench_traces:<tag> ... \
  python3 /usr/local/bin/run_simpoint_trace.py \
    --workload bfs_web_google --suite crono --simpoint_mode 1 \
    --simpoint_home /home/$USER/simpoint_flow/crono_snap \
    --bincmd "/tmp/bfs/bfs 1 8 /tmp_home/application/datasets/web-Google.txt" \
    -userk 5

Exact bincmd used for each workload in this release (the community/connected_components/ triangle_counting apps #include "../../common/*.h", so their source needs to be laid out as apps/<name>/ next to a common/ sibling directory when copied into the container -- see run_crono_trace.sh in this collection's tooling):

bfs:                   /tmp_home/crono_src/bfs/bfs 1 8 /tmp_home/application/datasets/web-Google.txt
dfs:                   /tmp_home/crono_src/dfs/dfs 1 8 /tmp_home/application/datasets/web-Google.txt
pagerank:              /tmp_home/crono_src/pagerank/pagerank 1 8 /tmp_home/application/datasets/web-Google.txt
sssp:                  /tmp_home/crono_src/sssp/sssp 1 8 /tmp_home/application/datasets/facebook_combined.txt
community:             /tmp_home/crono_src/apps/community/community_lock 1 8 3 /tmp_home/application/datasets/web-Google.txt
connected_components:  /tmp_home/crono_src/apps/connected_components/connected_components_lock 1 8 /tmp_home/application/datasets/web-Google.txt
triangle_counting:     /tmp_home/crono_src/apps/triangle_counting/triangle_counting_lock 1 8 /tmp_home/application/datasets/web-Google.txt
bc:                    /tmp_home/crono_src/apps/bc/bc 8 8192 16
apsp:                  /tmp_home/crono_src/apps/apsp/apsp 8 8192 16

FINGERPRINT_TIMEOUT_SEC=60 bounds the whole-program BBV fingerprint pass: bfs's and sssp's termination checks depend on reaching a specific (in bfs's case, possibly unreachable from the source vertex on a directed web graph) vertex id, and fall back to a much larger worst-case loop bound otherwise -- letting that run to completion would mostly capture degenerate repeated-scan behavior rather than additional representative phases, and could run for a very long time. -userk 5 caps the number of SimPoint clusters selected.

For sssp and, preemptively, all 5 additionally-collected apps (community, connected_components, triangle_counting, bc, apsp), also set SEQUENTIAL_CLUSTER_TRACING=1 (and OVERSIZED_SIMPOINT_THRESHOLD=35000000 to disable the stale replacement heuristic): tracing clusters concurrently intermittently lost a cluster's modules.log/encodings.bin during conversion for sssp (see the sssp_ego-facebook section above) -- sequential tracing is slower (clusters traced one at a time instead of in parallel) but was used for all 5 additional apps as a safety measure once the concurrency issue was understood, since none of them had been validated as safe under concurrent tracing.

After tracing, the working simpoint_flow/crono_snap/<workload>/ directory (fingerprint/, simpoints/, traces_simp/) was converted into this bundle's <workload>/ layout by copying fingerprint/, simpoints/, and traces_simp/{bin,trace} directly, and regenerating trace_clustering_info.json (mode 1 doesn't write one itself).

Validation performed

Before this bundle was assembled, every SimPoint trace was checked for:

• Completion: simpoints/opt.p.lpt0.99 and a non-empty traces_simp/trace/ exist (the underlying run_simpoint_trace.py process can exit 0 even after an internal failure, so exit code alone was not trusted).
• ≥30M committed instructions: computed by counting chunk.* entries inside each traces_simp/trace/<segment>.zip (each chunk = 30,000,000 instructions); all segments in this release have 6 chunks = 180,000,000 instructions.
• Zip integrity: every traces_simp/trace/*.zip passed zipfile.testzip() (no corrupt members).
• Metadata completeness: fingerprint/, simpoints/, traces_simp/bin/modules.log, traces_simp/bin/<binary>, and trace_clustering_info.json are present for every workload.
• Do-work phase representation: see the dedicated section above.

No incomplete or corrupted trace is included in this release. Earlier collection attempts for sssp_ego-facebook under concurrent cluster tracing did drop clusters whose DynamoRIO conversion failed rather than silently including them; the final sssp_ego-facebook in this bundle used sequential cluster tracing instead and has all 3 selected clusters present.

---

Part 2: Databases, agentic workloads, and software-engineering-agent benchmarks

Trace generation date: 2026-07-26

Scope expanded again to cover: open-source database engines (RocksDB, DuckDB, LevelDB; ClickHouse attempted but excluded, see below), agentic/tool-use workloads (a Toolformer-style tool-use loop, a Haystack-style BM25 RAG pipeline), and four "coding agent" benchmark representatives (AppWorld, SWE-bench, CORE-bench, Terminal-Bench). Same pipeline, same directory layout, same metadata format as Part 1 above; every SimPoint segment still targets at least 100,000,000 committed instructions (this part's requirement, stricter than Part 1's 30M) with SimPoint clustering capped at -userk 5.

For every workload below, the untraced prep step installs/builds the software and loads or downloads its dataset; the traced bincmd only runs query/retrieval/tool-execution/test work against that already-prepared state. This prep/trace separation is the primary evidence that no collected instruction comes from startup, package installation, or dataset loading.

Workloads

Workload dir	Application	Dataset/task	Threads	# SimPoints	Instructions/SimPoint
rocksdb_ycsb/	RocksDB db_bench (built from source, v9.7.3)	Synthetic YCSB-style KV (2M keys, 1KB values); readrandom,updaterandom	8	5	400-600M
leveldb_ycsb/	LevelDB db_bench (built from source)	Synthetic YCSB-style KV (2M keys, 1KB values); readrandom,readwhilewriting	8	4	300-400M
duckdb_tpch/	DuckDB CLI v1.1.3	TPC-H SF=1, all 22 standard queries x20, taskset -c 0-3	4	4	600M each
haystack_rag/	rank_bm25 (same core algorithm as Haystack's BM25Retriever)	20 Newsgroups corpus (9,000 docs), 60 held-out queries, 8 rounds	1	4	600M each
toolformer_agent/	Toolformer-style rule-based tool-use agent	101 synthetic tasks x4 tools (calculator/calendar/BM25 search/textstats), 6 rounds	1	4	600M each
swebench_sympy/	SWE-bench_Lite instance sympy__sympy-12481	sympy gold patch + test patch applied, own test suite x15000	1	1	100M
appworld_*/	AppWorld task execution	see per-workload section below	--	--	--
corebench_*/	CORE-Bench capsule-5975162 (ExPSO)	see per-workload section below	--	--	--
terminalbench_*/	Terminal-Bench task build-cython-ext (pyknotid)	see per-workload section below	--	--	--
clickhouse (excluded)	ClickHouse	--	--	0	--

Per-workload detail

rocksdb_ycsb (RocksDB db_bench)

• Why built from source instead of the distro package: the Ubuntu rocksdb-tools package (v6.11.4, from 2020) crash-loops under 8-thread readrandom,updaterandom and repeatedly shells out to its addr2line-based stack-trace handler (38 dash + 19 addr2line child processes observed in a single traced segment), corrupting that segment's DynamoRIO capture. RocksDB v9.7.3 built from the official upstream repo (DEBUG_LEVEL=0 PORTABLE=1 make db_bench) does not exhibit this.
• Prep (untraced): build db_bench from source; fillrandom pre-load of 2M keys (single-threaded).
• Traced bincmd: db_bench --benchmarks=readrandom,updaterandom --db=/data/db --use_existing_db=1 --num=2000000 --reads=500000 --value_size=1024 --threads=8 --stats_dump_period_sec=0
• Do-work verification: prep/trace separation (dataset pre-loaded, untraced) + tid≠pid worker-thread evidence (8-threaded benchmark).
• SimPoints (segment, weight, instructions): 19/0.0925/400M, 0/0.0463/600M, 10/0.0463/600M, 15/0.3985/400M, 4/0.4164/600M. Weights sum to 1.0.

leveldb_ycsb (LevelDB db_bench)

• Prep (untraced): build LevelDB's own db_bench from source (cmake, with LEVELDB_BUILD_TESTS=ON -- needed transitively for gmock, which db_bench.cc requires even when benchmarks-only); fillrandom pre-load of 2M keys (single-threaded).
• Traced bincmd: db_bench --benchmarks=readrandom,readwhilewriting --db=/data/db --use_existing_db=1 --num=2000000 --reads=500000 --value_size=1024 --threads=8
• Do-work verification: prep/trace separation + tid≠pid worker-thread evidence.
• SimPoints: 25/0.2460/400M, 4/0.1722/300M, 8/0.1881/400M, 26/0.3936/400M. Weights sum to 1.0.

duckdb_tpch (DuckDB TPC-H)

• Thread-explosion fix: DuckDB's default thread pool is one thread per CPU core (48 on this host); that many concurrently-active threads overwhelmed DynamoRIO's per-thread raw capture during cluster tracing (most per-thread files truncated, corrupting every simpoint). A PRAGMA threads=4; prepended to the query script was insufficient (DuckDB spawns its default pool at connection time, before the PRAGMA executes). Wrapping the traced bincmd in taskset -c 0-3 (OS-level CPU-affinity limiting, applied before DuckDB starts) fixed it completely -- confirmed via each captured segment containing exactly one duckdb process with 4 raw per-thread files, not dozens of truncated ones.
• Pipeline fix required: taskset execve()s into duckdb, and DynamoRIO starts a new output directory at that exec transition, leaving two dr_folders per segment (taskset's near-empty one, duckdb's real one) where run_simpoint_trace.py expected exactly one -- it exited(1) silently (no console error, only a JSON field) on every segment. Patched run_simpoint_trace.py to pick the largest dr_folder by on-disk size instead of requiring exactly one, matching the pattern already used for multi-file bbfp/trace.zip selection.
• Prep (untraced): install DuckDB CLI v1.1.3; CALL dbgen(sf=1); extract all 22 standard TPC-H queries via tpch_queries(), repeated 20x into one script.
• Traced bincmd: taskset -c 0-3 duckdb /data/tpch.duckdb < /data/queries.sql
• SimPoints: 2/0.1452/600M, 22/0.4481/600M, 33/0.1452/600M, 8/0.2614/600M. Weights sum to 1.0.

haystack_rag (BM25 retrieval)

• Substitution note: haystack-ai fails to install on this container's Python 3.8 (jiter has no compatible wheel); farm-haystack[inference] fails via a transitive posthog dependency using dict[str, X] syntax requiring Python 3.9+. Substituted rank_bm25 -- the same core BM25 scoring algorithm Haystack's own BM25Retriever uses -- as a documented, honest stand-in.
• numpy/BLAS thread-explosion fix: numpy's default BLAS backend spawns one thread per CPU core on import, same corruption pattern as DuckDB above. Fixed by setting OMP_NUM_THREADS=1, OPENBLAS_NUM_THREADS=1, MKL_NUM_THREADS=1 before the numpy-backed import, at the top of the traced script.
• Prep (untraced): build a 9,000-document corpus from 20 Newsgroups (sklearn.datasets, train split, docs >200 chars), tokenize, derive 60 queries from the held-out test split.
• Traced bincmd: python3 haystack_workload.py /data -- builds the BM25 index once, then 8 rounds x 60 queries, each followed by top-10 ranking + snippet extraction.
• SimPoints: 21/0.0393/600M, 1/0.1178/600M, 4/0.3141/600M, 13/0.5289/600M. Weights sum to 1.0.

toolformer_agent (Toolformer-style tool-use agent)

• Same numpy/BLAS thread-explosion fix as haystack_rag (the search tool reuses BM25).
• Prep (untraced): synthesize 101 tasks (20 calculator, 20 calendar, 40 search across 10 topics, 21 textstats), build the shared 20-Newsgroups corpus for the search tool.
• Traced bincmd: python3 toolformer_workload.py /data -- rule-based plan() (keyword classifier, a local/CPU-only stand-in for an LLM's tool-choice step) selects among 4 tools (calculator/calendar/BM25 search/textstats), executes, formats a response; 6 rounds x 101 tasks.
• SimPoints: 21/0.0368/600M, 9/0.2943/600M, 14/0.5586/600M, 1/0.1104/600M. Weights sum to 1.0.

swebench_sympy (SWE-bench_Lite: sympy__sympy-12481)

• Reproduces the SWE-bench_Lite instance's own checkout/patch/install sequence natively (no per-instance Docker image, no LLM): clone sympy at base_commit c807dfe, git apply the gold patch (the actual bug fix, restricting Permutation's duplicate-element check) and the test patch (the corresponding new/changed assertions in test_permutations.py), pip install -e ..
• Traced bincmd: python3 swebench_workload.py /data/repo 15000 -- imports the patched test module directly and calls all 9 of its test_* functions (covering this instance's single FAIL_TO_PASS test, test_args, and all 7 PASS_TO_PASS tests in the same file) 15,000 times.
• Fingerprint tooling incompatibility discovered: the patched libfpg.so fingerprint client used throughout this collection (the DR_ASSERT(!for_trace) removal that was needed to fix RocksDB, see fingerprint_src/fpg.cpp) causes a fast, silent crash specifically on sympy's import-time code (huge metaclass/class-body machinery generates an unusually large number of distinct basic blocks); this reproduced with both the release and a python3.8-dbg interpreter, independent of -max_bb_instrs. The stock (unpatched) libfpg.so fingerprints sympy successfully. Because the two fingerprint-client variants are needed for different workloads in this same collection (RocksDB needs the patch; sympy needs the stock client), this workload was collected via a separate launcher script that skips the patch-copy step, otherwise identical.
• Only 1 SimPoint (vs. the usual up to 5): sympy's own test suite executes very fast per round, and the resulting fingerprinted run was short enough that SimPoint's clustering converged on a single representative segment (the very first 100M-instruction window, weight 1.0). It still meets the ≥100M-instruction-per-SimPoint requirement.
• Source-construct traceability: this workload's Python interpreter (system Python 3.8) is stripped (no debug symbols) -- PC resolution for interpreter-internal code is not possible from this bundle alone. To compensate, the bundle's source_context/ directory contains the exact gold patch, test patch, and the two post-patch source files (permutations_patched.py, test_permutations_patched.py) actually exercised by the traced bincmd, so the dominant application-level code paths can still be correlated manually against the trace.

ClickHouse (excluded from this release)

Attempted with the OLAP-style benchmark methodology common in the ClickHouse community (clickbench-style repeated analytical queries against a pre-loaded table), but hit three distinct, unrelated DynamoRIO/SimPoint tooling failures in sequence:

1. The same DR_ASSERT(!for_trace) fingerprint-client assertion hit by RocksDB (fixed by the fpg.cpp patch used throughout this collection) also fires on ClickHouse's binary, for the same reason (heavier indirect/virtual-dispatch control flow than the assertion assumes).
2. After that fix, cluster tracing hit a different, deeper DynamoRIO limitation: instru_offline.cpp:567: instr_count < uint64_t(1) << 12 -- a hard-coded 4096-instruction basic-block cap inside drcachesim itself (not just the fingerprint client), most likely triggered by ClickHouse's heavily inlined/unrolled vectorized query-execution code. Lowering -max_bb_instrs to 512 made this worse (the fingerprint pass then crashed almost instantly, capturing only ~2.9M instructions); reverting to the default 4095 got further (356 total fingerprint segments) before hitting failure 3.
3. With 356 segments of real fingerprint data available, SimPoint's own clustering step still returned a degenerate result ("the best clustering was run 0 (k = 0)") -- no representative segments selected at all, despite ample candidate data.

Given three separate, deep tooling incompatibilities (not a workload-configuration or methodology issue) and the time already spent chasing them, ClickHouse was excluded from this release rather than continuing to debug DynamoRIO/SimPoint internals indefinitely.

Debug-symbol / source-construct traceability

A downstream goal of this collection is to trace ideal-fusion candidate PCs (pairs of fusible loads identified by Scarab's ideal-fusion-pass1/pass2, see scarab/src/ideal-fusion/) back to the source-code construct that produced them (struct fields, arrays, pointer chasing, CSR traversal, allocator metadata, STL/container internals, etc.). This requires the traced binary to carry debug symbols; it was not applied retroactively to Part 1 or the RocksDB/LevelDB/ DuckDB/Haystack/ToolFormer workloads already collected before this requirement was raised -- only to the four benchmark-agent workloads below.

Workload	Interpreter/binary used	Debug-info status
AppWorld	python-build-standalone CPython 3.11.11 (install_only build)	Full DWARF debug info, not stripped -- verified via file/nm before use, no change needed.
CORE-bench (ExPSO)	System Python 3.8 debug build (python3.8-dbg / python3.8d)	Full DWARF debug info for the interpreter; numpy's PyPI wheel is not stripped (retains its symbol table for function-level attribution) but lacks full DWARF line info -- rebuilding numpy from source for line-level info was judged not worth the added build time for this collection.
Terminal-Bench (pyknotid)	System Python 3.8 (regular, stripped) + our own Cython extensions built with CFLAGS="-g -O2"	The workload's own compiled code (chelpers, ccomplexity, cinvariants -- where the actual knot-invariant computation happens) has full debug info; the surrounding CPython interpreter does not.
SWE-bench (sympy)	System Python 3.8 (regular, stripped)	No debug info -- the patched libfpg.so fingerprint client (needed elsewhere in this collection) crashes on python3.8-dbg and on sympy's own import-time code independent of interpreter debug-build status (see the swebench_sympy section above); the workload's actual source code (gold patch, test patch, patched files) is bundled instead under source_context/ for manual correlation.

python3.8-dbg's debug build (python3.8d) was verified to load and correctly execute numpy (import numpy; numpy.array([1,2,3]).sum()) before being adopted -- Ubuntu's debug build is ABI-compatible with regular release-linked C-extension wheels, unlike a from-source --with-pydebug build.