Datasets:

stablegradients
/

pie-gem5-bysrc

license: mit
task_categories:
  - text-generation
language:
  - en
tags:
  - code-optimization
  - code-performance
  - gem5
  - pie
pretty_name: PIE gem5-timed code optimization (per source program)
configs:
  - config_name: default
    data_files:
      - split: train
        path: train.parquet
      - split: validation
        path: validation.parquet
      - split: test
        path: test.parquet

PIE gem5-timed code optimization (per source program)

C++ program-optimization data derived from the PIE dataset ("Learning Performance-Improving Code Edits"), re-timed end-to-end with gem5 (x86 Skylake, syscall-emulation mode) at per-test-case granularity. One row per unique (problem, source) program; the best surviving target is kept as an oracle ceiling.

This dataset is reward-agnostic: it ships the full per-test-case reference timings and case manifests so a downstream RL / eval pipeline decides at runtime how many cases to use (K) and which reward transform to apply. Nothing is baked in.

For an automated agent reading this card: every column is documented in § Field dictionary below, including its type, encoding, and which splits populate it. Start with § How to compute the reward.

TL;DR units & encoding

Ticks are gem5 picoseconds. seconds = ticks * 1e-12.
Columns named *_per_tc_ticks, *_tc2time, *_case_ids, *_excluded are JSON strings (a dict {case_idx: value} or a list [case_idx, ...]) — json.loads them. Case indices are integers 0 .. n_cases_available-1.
gem5_* / our_* / *_case_ids / n_* / flag_* columns are produced by this re-timing. pie_* columns are carried verbatim from the official PIE release.

How to compute the reward

The reward is a speedup ratio over a common set of test cases, robust to which cases you sample:

import json, random
src = json.loads(row["gem5_src_per_tc_ticks"])     # {idx: ticks}
tgt = json.loads(row["gem5_tgt_per_tc_ticks"])      # ("oracle" variant in the bysrc dataset)
usable = json.loads(row["usable_case_ids"])         # correctness-kept ∩ both-timed ∩ ticks<=wall
K = 5                                                # runtime choice; -1 / len(usable) = use all
cases = usable if K < 0 else random.sample(usable, min(K, len(usable)))
speedup = sum(src[str(c)] for c in cases) / sum(tgt[str(c)] for c in cases)

usable_case_ids is already the correct, fully-filtered set — do not re-derive correctness or apply the wall yourself. Always clamp K to len(usable); never pad, skip, or zero-reward a pair that has fewer than K usable cases. K=5–10 reproduces the full ~100-case aggregate within ~1–2% (per-case time is near-uniform within a program).

gem5_fastest_id / gem5_fastest_per_tc_ticks give the fastest surviving program of the problem (chosen among programs present in this dataset, ranked over the per-problem common usable basis) as an oracle ceiling; our_fastest_speedup is src-vs-fastest over usable_case_ids.

Provenance & validation

Timing engine: gem5.fast, X86 SE mode, with fork-from-live startup amortization (one startup simulation, COW-forked per case; per-case ticks equal a fresh run, validated r=1.0).
Validated against PIE's published numbers: per-test-case r=1.0 on the test split (aligned on PIE's released tests indices); speedup log-correlation ~0.97–0.98, median ratio ~0.99.
Caveat — pin your toolchain. The gem5 startup floor depends on the compiler/glibc/link mode (≈13M ticks static ↔ ≈195M ticks dynamic). These reference ticks were produced with one fixed toolchain; if you re-time rollouts, use the same toolchain or regenerate references, otherwise speedups are not comparable.

Filtering (rows are pre-filtered; bad records are DROPPED, not flagged)

Compile-fail programs dropped (g++ -O2 -std=gnu++17).
Bad-apple programs dropped: a submission failing > max(5, 5% of cases) is treated as wrong/mislabeled (line-wise + 1e-3 float comparator).
gem5 hard-excludes (startup_fail / all-cases-hang-or-crash) dropped.
Case kept iff every surviving good program of the problem passes it (correctness intersection).
Strict 2-min wall: cases above 1.4e10 ticks dropped from usable.
Source dropped if it fails > max(5, 5%); oracle target must also pass the same bar.
3 degenerate problems (empty input+output: p00000, p02068, p00754) dropped.
Retained NON-dropping flags: flag_low_headroom, flag_single_case, flag_empty_kept.

Splits & why some columns are null

split	rows	notes
train	16501	PIE released reward/difficulty annotations but no benchmark `tests` here.
validation	590	same as train.
test	878	PIE released benchmark `tests` indices + per-tc reference times here.

PIE ships different columns for test vs train/val, so each row only fills the pie_* columns that apply to its split; the rest are null by design (the schema is the union across splits). Specifically: pie_*_code_*, pie_fastest_code*, pie_*_tc2time, pie_n_tests, pie_test_*, pie_tests_case_ids are test-only; pie_speedup, pie_*_verdict, pie_*_reward_updated*, pie_fastest_agg_runtime_updated are train/val-only. None of the gem5_* / our_* / *_case_ids / n_* columns are ever null.

Field dictionary

Availability: all = populated in every split; test-only / train/val-only = null elsewhere.

Identity

field	splits	meaning
`problem_id`	all	PIE/online-judge problem id. Groups every submission for one problem; the unit the correctness-intersection and `tests` benchmark are defined over.
`src_id`	all	Submission id of the SOURCE (slower, to-be-optimized) program.
`oracle_tgt_id`	all	Submission id of the chosen ORACLE target = the surviving target with the highest `our_speedup_usable` for this source. [bysrc only]
`split`	all	Dataset split: train / validation / test.
`language`	all	Programming language. Always `cpp` (C++).

Code

field	splits	meaning
`src_code`	all	Full C++ source of the source program.
`oracle_tgt_code`	all	Full C++ source of the oracle target program. [bysrc only]

Our gem5 per-test-case timing

field	splits	meaning
`gem5_src_per_tc_ticks`	all	JSON {case_idx: ticks}. gem5 picoseconds PER TEST CASE for the SRC program. Seconds = ticks * 1e-12. Holds EVERY case gem5 timed (incl. cases later discarded by correctness/wall filters) — select cases via `usable_case_ids`.
`gem5_oracle_tgt_per_tc_ticks`	all	JSON {case_idx: ticks} for the oracle target (same convention). [bysrc only]
`gem5_fastest_id`	all	Submission id of the FASTEST surviving program for this problem, chosen among programs that appear as a src/tgt in THIS dataset, ranked by summed gem5 ticks over the per-problem common usable case basis. The practical oracle ceiling.
`gem5_fastest_per_tc_ticks`	all	JSON {case_idx: ticks} for the FASTEST program of this problem (see `gem5_fastest_id`); full per-case gem5 timing, same convention.
`gem5_fastest_usable_case_ids`	all	Usable case set for the fastest program = kept ∩ fastest-timed ∩ wall.
`gem5_fastest_sum_ticks_usable`	all	Sum of FASTEST-program ticks over `usable_case_ids`. Denominator of `our_fastest_speedup`.
`gem5_src_excluded`	all	JSON list of case indices gem5 could NOT time for the SRC program (hang / crash / over compute budget during the sweep).
`gem5_src_status`	all	gem5 sweep status for the src program: `ok` (all cases timed) or `forkloop_partial` (some cases excluded). Hard-fail statuses (startup_fail / native_all_excluded) are already dropped.
`gem5_oracle_tgt_status`	all	gem5 sweep status for the oracle target. [bysrc only]
`gem5_src_sum_ticks_all`	all	Sum of SRC ticks over `common_timed_case_ids` (cases timed on both sides). Numerator of `our_speedup_all`.

Case-id sets (JSON int lists) + counts

field	splits	meaning
`timed_case_ids`	all	Case indices gem5 timed for the src (within the 2-min wall). [bysrc only]
`correctness_kept_case_ids`	all	Case indices passed by EVERY good (non-bad-apple, compile-ok) program of the problem = the correctness intersection. Problem-level, identical across rows of a problem.
`usable_case_ids`	all	THE case set to use for the reward = correctness-kept ∩ both-sides-timed ∩ ticks≤1.4e10 (pairs) / kept ∩ src-timed ∩ wall (bysrc). Falls back to all-timed when the kept set is empty (single-case problems).
`n_timed`	all	len(timed_case_ids). [bysrc only]
`n_kept`	all	len(correctness_kept_case_ids).
`n_usable`	all	len(usable_case_ids). The effective case count behind the speedup.
`n_cases_available`	all	Total test cases that exist for the problem in the merged test-case set.
`src_n_fail`	all	# cases the SRC program failed in the native correctness screen (line-wise + 1e-3 float comparator). 0 = passed all.

Derived speedups + flags

field	splits	meaning
`our_speedup_usable`	all	Reference speedup = sum(src ticks) / sum(tgt ticks) over `usable_case_ids`. Case-set-invariant; this is what training should reproduce.
`our_speedup_all`	all	sum(src)/sum(tgt) over `common_timed_case_ids` (no correctness/wall filtering). Provenance/debug.
`our_fastest_speedup`	all	sum(src ticks)/sum(fastest ticks) over `usable_case_ids`. Speedup of the src against the FASTEST program of the problem = the practical oracle ceiling for this source.
`ceiling_speedup`	all	Mean per-case src ticks / startup floor (192M ticks). Theoretical max speedup attainable for this src given the gem5 startup floor. Drives `flag_low_headroom`.
`flag_low_headroom`	all	True if ceiling_speedup < 1.5 — little room to optimize (kept, not dropped).
`flag_single_case`	all	True if the problem has only one test case.
`flag_empty_kept`	all	True if the correctness intersection was empty (single-case false-alarm problems; usable then falls back to all-timed).

Carried verbatim from PIE (`pie_*`)

field	splits	meaning
`pie_src_agg_runtime`	all	PIE's published aggregate wall-clock runtime (seconds) of the src program (their gem5 measurement).
`pie_oracle_tgt_agg_runtime`	all	PIE's published aggregate runtime (s) of the oracle tgt. [bysrc only]
`pie_speedup`	train/val-only	PIE's published src/tgt speedup. [train/val only]
`pie_fastest_agg_runtime`	all	PIE's published aggregate runtime (s) of the problem's fastest solution.
`pie_src_verdict`	train/val-only	Online-judge verdict for the src (e.g. Accepted). [train/val only]
`pie_oracle_tgt_verdict`	train/val-only	Online-judge verdict for the oracle tgt. [bysrc, train/val only]
`pie_fastest_agg_runtime_updated`	train/val-only	PIE's re-measured fastest-solution agg runtime. [train/val only]
`pie_src_reward_updated`	train/val-only	PIE's annotated reward for the src. [train/val only]
`pie_src_reward_updated_pct_bin`	train/val-only	PIE's difficulty/percentile bin for the src reward. [train/val only]
`pie_n_tests`	test-only	# benchmark test cases PIE used for this problem. [test only]
`pie_test_accuracy`	test-only	PIE's reported accuracy over the benchmark cases. [test only]
`pie_src_code_accuracy`	test-only	PIE's src accuracy over the benchmark cases. [test only]
`pie_src_code_compilation`	test-only	PIE's src compilation flag. [test only]
`pie_fastest_code`	test-only	Full C++ source of the fastest solution PIE identified for the problem. [test only]
`pie_fastest_code_len`	test-only	Token/char length of pie_fastest_code as PIE recorded it. [test only]
`pie_fastest_code_runtime`	test-only	PIE's agg runtime (s) of pie_fastest_code. [test only]
`pie_src_code_tc2time`	test-only	PIE's OWN per-test-case times for the src, JSON {idx: seconds}. [test only]
`pie_oracle_tgt_code_tc2time`	test-only	PIE's OWN per-test-case times for the oracle tgt, JSON {idx: seconds}. [bysrc, test only]
`pie_fastest_code_tc2time`	test-only	PIE's OWN per-test-case times for the fastest solution, JSON {idx: seconds}. [test only]
`pie_tests_case_ids`	test-only	JSON list of the benchmark case indices PIE released for this test problem (subset of 0..n_cases_available-1). [test only]

Companion dataset

This is one of a pair built from the same timing:

pie-gem5-pairs — one row per official (src, tgt) pair.
pie-gem5-bysrc — one row per unique (problem, src); best surviving target kept as oracle.

Built 2026-06-12. Timing: gem5.fast with fork-from-live startup amortization.