From badf9830d4ac081fa2bd479fdcd583bd6a79d0ea Mon Sep 17 00:00:00 2001 From: c71n93 Date: Fri, 22 May 2026 17:08:31 +0300 Subject: [PATCH 1/8] Add infrastructure for reproducers --- .gitignore | 7 + README.md | 8 + build.gradle | 7 + reproducer/README.md | 63 ++ .../baseline/UseStringBuilderConcatCase.java | 27 + .../variant/UseStringBuilderConcatCase.java | 27 + .../UseArraysStreamPrimitiveCase.java | 28 + .../variant/UseArraysStreamPrimitiveCase.java | 26 + .../baseline/MakeMethodFieldFinalCase.java | 48 ++ .../variant/MakeMethodFieldFinalCase.java | 48 ++ .../UseArraysStreamInlineBudgetCase.java | 50 ++ .../UseArraysStreamInlineBudgetCase.java | 50 ++ .../LoopComputationsStreamBoxedCase.java | 37 ++ .../LoopComputationsStreamBoxedCase.java | 36 ++ reproducer/run.py | 567 ++++++++++++++++++ reproducer/test_run.py | 79 +++ .../comparator/reproducer/ComparePairs.java | 101 ++++ .../reproducer/ComparePairsOptions.java | 85 +++ .../reproducer/ComparisonManifest.java | 146 +++++ .../comparator/reproducer/ManifestEntry.java | 144 +++++ .../comparator/reproducer/ManifestPair.java | 39 ++ .../comparator/reproducer/package-info.java | 4 + .../reproducer/ComparePairsOptionsTest.java | 26 + .../reproducer/ComparisonManifestTest.java | 46 ++ .../comparator/reproducer/package-info.java | 4 + 25 files changed, 1703 insertions(+) create mode 100644 reproducer/README.md create mode 100644 reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java create mode 100644 reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java create mode 100644 reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java create mode 100644 reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java create mode 100644 reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java create mode 100644 reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java create mode 100644 reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java create mode 100644 reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java create mode 100644 reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java create mode 100644 reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java create mode 100644 reproducer/run.py create mode 100644 reproducer/test_run.py create mode 100644 src/main/java/comparator/reproducer/ComparePairs.java create mode 100644 src/main/java/comparator/reproducer/ComparePairsOptions.java create mode 100644 src/main/java/comparator/reproducer/ComparisonManifest.java create mode 100644 src/main/java/comparator/reproducer/ManifestEntry.java create mode 100644 src/main/java/comparator/reproducer/ManifestPair.java create mode 100644 src/main/java/comparator/reproducer/package-info.java create mode 100644 src/test/java/comparator/reproducer/ComparePairsOptionsTest.java create mode 100644 src/test/java/comparator/reproducer/ComparisonManifestTest.java create mode 100644 src/test/java/comparator/reproducer/package-info.java diff --git a/.gitignore b/.gitignore index 81f716f..89e8d69 100644 --- a/.gitignore +++ b/.gitignore @@ -45,3 +45,10 @@ AGENTS.md ### Examples ### examples/*/*.class + +### Reproducer ### +reproducer/runs/ + +### Python ### +__pycache__/ +*.pyc diff --git a/README.md b/README.md index 50dc5ef..1e30a44 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,14 @@ CSV rows also include `JIT log file` and `JMH result file` path columns. - The target method should preferably return a value. `void` methods are more likely to be removed by JIT optimization as dead code. - The target method should preferably execute at least `1000` instructions. Around `50-100` instructions may come from non-optimized JMH wrapper overhead (`Method.invoke()`). By default this optimization should work and overhead will be around `10-20` instructions. +## Reproducer + +The `reproducer/` directory contains a runner for curated baseline/variant cases. +It compiles each case, runs Comparator repeatedly, preserves raw JIT/JMH artifacts, +and writes per-case aggregate CSV files. + +See [reproducer/README.md](reproducer/README.md) for usage. + ## API usage ### Run an analysis diff --git a/build.gradle b/build.gradle index 17b20b3..1fee707 100644 --- a/build.gradle +++ b/build.gradle @@ -48,3 +48,10 @@ jacocoTestReport { application { mainClass = 'comparator.Main' } + +tasks.register('printRuntimeClasspath') { + dependsOn classes + doLast { + println sourceSets.main.runtimeClasspath.asPath + } +} diff --git a/reproducer/README.md b/reproducer/README.md new file mode 100644 index 0000000..a1c1cc8 --- /dev/null +++ b/reproducer/README.md @@ -0,0 +1,63 @@ +# Reproducer + +The reproducer runs curated JIT instability cases from `reproducer/cases`. +Each case contains a `baseline` Java source and an equivalent `variant` Java source. + +It can: + +- discover valid baseline/variant pairs; +- compile each pair into isolated class directories; +- run Comparator on each pair through JMH; +- collect JIT logs, JMH JSON results, and perf-backed metrics; +- repeat whole-case executions with `--runs`; +- write per-run CSV files and per-case aggregate CSV files. + +## Requirements + +- Linux with working `perf`; +- JDK with `java` and `javac` on `PATH`; +- Gradle wrapper from this repository. + +The runner checks `perf --version` and `perf stat -e instructions -- sleep 0.1` +before starting expensive work. + +## Usage + +Run all cases once: + +```bash +python3 reproducer/run.py --runs 1 +``` + +Run selected cases by prefix: + +```bash +python3 reproducer/run.py --runs 3 --include-cases case01,case03 +``` + +Useful options: + +- `--runs N` - required number of whole-case repeats; +- `--include-cases case01,case03` - comma-separated case-id prefixes; +- `--session-id NAME` - fixed output session name; +- `--cases-root PATH` - custom cases directory; +- `--runs-root PATH` - custom output directory. + +## Output + +Each run creates a session under `reproducer/runs/` and updates +`reproducer/runs/latest` when symlinks are supported. + +Important files: + +- `metadata.json` - tools, environment, selected cases, Gradle classpath output; +- `index.csv` - one row per case run; +- `cases//runs/run-001/status.json` - run status or captured failure; +- `cases//runs/run-001/logs/*.log` - stdout and stderr for `javac` and Comparator commands; +- `cases//runs/run-001/comparisons.csv` - raw Comparator CSV; +- `cases//runs/run-001/artifacts/*` - JIT logs and JMH results; +- `cases//all_runs.csv` - concatenated rows across runs; +- `cases//summary.csv` - count, mean, stdev, min, and max per role. + +The MVP intentionally does not generate graphs or normalized percent-difference +reports. diff --git a/reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java b/reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java new file mode 100644 index 0000000..b3a2f47 --- /dev/null +++ b/reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java @@ -0,0 +1,27 @@ +/* + * Mechanism: use-string-builder. + * Aggregate provenance: FuzzInput09_PushDownAndConcat/1-use-string-builder. + * Hypothesis: replacing repeated string concatenation with an explicit + * StringBuilder changes the optimized code shape enough that HotSpot does + * not converge to the same machine code. + * Expected symptom: strong allocation drop and supporting counter drift. + * Loop note: the outer run() loop is intentionally large enough to keep the + * coarse comparator run comfortably above ~10 us/op. + */ +public class UseStringBuilderConcatCase { + private static int render(int seed) { + String text = ""; + for (int i = 0; i < 48; i++) { + text += seed + i; + } + return text.length(); + } + + public static int run() { + int res = 0; + for (int i = 0; i < 800; i++) { + res += render(i); + } + return res; + } +} diff --git a/reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java b/reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java new file mode 100644 index 0000000..c569625 --- /dev/null +++ b/reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java @@ -0,0 +1,27 @@ +/* + * Mechanism: use-string-builder. + * Aggregate provenance: FuzzInput09_PushDownAndConcat/1-use-string-builder. + * Hypothesis: replacing repeated string concatenation with an explicit + * StringBuilder changes the optimized code shape enough that HotSpot does + * not converge to the same machine code. + * Expected symptom: strong allocation drop and supporting counter drift. + * Loop note: the outer run() loop is intentionally large enough to keep the + * coarse comparator run comfortably above ~10 us/op. + */ +public class UseStringBuilderConcatCase { + private static int render(int seed) { + StringBuilder text = new StringBuilder(); + for (int i = 0; i < 48; i++) { + text.append(seed + i); + } + return text.length(); + } + + public static int run() { + int res = 0; + for (int i = 0; i < 800; i++) { + res += render(i); + } + return res; + } +} diff --git a/reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java b/reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java new file mode 100644 index 0000000..ad67cd4 --- /dev/null +++ b/reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java @@ -0,0 +1,28 @@ +/* + * Mechanism: use-arrays-stream. + * Aggregate provenance: FuzzInput02_ArraysStreamAndBoxing/1-use-arrays-stream-3. + * Hypothesis: switching from a boxed List stream to a primitive IntStream + * changes the stream pipeline enough to perturb JIT counters. + * Expected symptom: visible instruction/load/store drift, not just JMH noise. + * Loop note: the outer run() loop is intentionally large enough to keep the + * coarse comparator run comfortably above ~10 us/op. + */ +import java.util.Arrays; + +public class UseArraysStreamPrimitiveCase { + private static int sumEven(int seed) { + return Arrays.asList(seed, seed + 1, seed + 2, seed + 3, seed + 4, seed + 5) + .stream() + .mapToInt(Integer::intValue) + .filter(value -> (value & 1) == 0) + .sum(); + } + + public static int run() { + int res = 0; + for (int i = 0; i < 12_000; i++) { + res += sumEven(i); + } + return res; + } +} diff --git a/reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java b/reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java new file mode 100644 index 0000000..f6cc986 --- /dev/null +++ b/reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java @@ -0,0 +1,26 @@ +/* + * Mechanism: use-arrays-stream. + * Aggregate provenance: FuzzInput02_ArraysStreamAndBoxing/1-use-arrays-stream-3. + * Hypothesis: switching from a boxed List stream to a primitive IntStream + * changes the stream pipeline enough to perturb JIT counters. + * Expected symptom: visible instruction/load/store drift, not just JMH noise. + * Loop note: the outer run() loop is intentionally large enough to keep the + * coarse comparator run comfortably above ~10 us/op. + */ +import java.util.Arrays; + +public class UseArraysStreamPrimitiveCase { + private static int sumEven(int seed) { + return Arrays.stream(new int[] {seed, seed + 1, seed + 2, seed + 3, seed + 4, seed + 5}) + .filter(value -> (value & 1) == 0) + .sum(); + } + + public static int run() { + int res = 0; + for (int i = 0; i < 12_000; i++) { + res += sumEven(i); + } + return res; + } +} diff --git a/reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java b/reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java new file mode 100644 index 0000000..69166c9 --- /dev/null +++ b/reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java @@ -0,0 +1,48 @@ +/* + * Mechanism: make-fields-and-variables-final. + * Aggregate provenance: FuzzInput04_FieldMethod/1-make-fields-and-variables-final. + * Hypothesis: making the reflective Method field final lets the JIT treat the + * reference as stable and simplifies the reflective call path. + * Expected symptom: strong counter reduction and smaller generated code. + * Loop note: the outer run() loop is intentionally large enough to keep the + * coarse comparator run comfortably above ~10 us/op. + */ +import java.lang.reflect.Method; + +public class MakeMethodFieldFinalCase { + private static Method METHOD = getSum0Method(); + + private static Method getSum0Method() { + try { + Method method = MakeMethodFieldFinalCase.class.getDeclaredMethod( + "sum0", + int.class, + int.class + ); + method.setAccessible(true); + return method; + } catch (ReflectiveOperationException e) { + throw new RuntimeException("Failed to initialize METHOD", e); + } + } + + private static int sum0(int a, int b) { + return a + b; + } + + public static int sum(int a, int b) { + try { + return (Integer) METHOD.invoke(null, a, b); + } catch (ReflectiveOperationException e) { + throw new RuntimeException("Failed to invoke METHOD", e); + } + } + + public static int run() { + int res = 0; + for (int i = 0; i < 900; i++) { + res = sum(res, i); + } + return res; + } +} diff --git a/reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java b/reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java new file mode 100644 index 0000000..a2be046 --- /dev/null +++ b/reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java @@ -0,0 +1,48 @@ +/* + * Mechanism: make-fields-and-variables-final. + * Aggregate provenance: FuzzInput04_FieldMethod/1-make-fields-and-variables-final. + * Hypothesis: making the reflective Method field final lets the JIT treat the + * reference as stable and simplifies the reflective call path. + * Expected symptom: strong counter reduction and smaller generated code. + * Loop note: the outer run() loop is intentionally large enough to keep the + * coarse comparator run comfortably above ~10 us/op. + */ +import java.lang.reflect.Method; + +public class MakeMethodFieldFinalCase { + private static final Method METHOD = getSum0Method(); + + private static Method getSum0Method() { + try { + Method method = MakeMethodFieldFinalCase.class.getDeclaredMethod( + "sum0", + int.class, + int.class + ); + method.setAccessible(true); + return method; + } catch (ReflectiveOperationException e) { + throw new RuntimeException("Failed to initialize METHOD", e); + } + } + + private static int sum0(int a, int b) { + return a + b; + } + + public static int sum(int a, int b) { + try { + return (Integer) METHOD.invoke(null, a, b); + } catch (ReflectiveOperationException e) { + throw new RuntimeException("Failed to invoke METHOD", e); + } + } + + public static int run() { + int res = 0; + for (int i = 0; i < 900; i++) { + res = sum(res, i); + } + return res; + } +} diff --git a/reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java b/reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java new file mode 100644 index 0000000..3b87e33 --- /dev/null +++ b/reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java @@ -0,0 +1,50 @@ +/* + * Mechanism: use-arrays-stream as an inlining-budget cliff. + * Aggregate provenance: FuzzInput05_MixedInlineArraysAndFinal/ + * 1-inline-method-1/2-use-arrays-stream. + * Hypothesis: replacing one boxed stream count with Arrays.stream(new int[]) + * should not destabilize unrelated helper inlining, but in practice it can + * change HotSpot's compile plan enough that the run1 -> run0 edge inlines in + * the parent shape and stops inlining in the variant. + * Expected symptom: strong instruction/load/store drift with much smaller JMH + * movement; the JIT log should show a run0 inlining divergence. + * Minimality note: runBody() preserves the original 100-iteration hot loop. + * The outer run() loop only repeats that shape to keep the coarse comparator + * above ~10 us/op without rebuilding the whole fuzzed class. + */ +import java.util.Arrays; + +public class UseArraysStreamInlineBudgetCase { + private int sq(int x) { + return x * x; + } + + public long run0() { + int base = 10; + return Arrays.asList(1, 2, 3).stream().count() + + Arrays.asList("x", "y").stream().count() + + sq(base) + + sq(3) + + 3; + } + + public static int run1() { + return (int) new UseArraysStreamInlineBudgetCase().run0(); + } + + private static int runBody() { + int res = 0; + for (int i = 0; i < 100; i++) { + res += run1(); + } + return res; + } + + public static int run() { + int total = 0; + for (int r = 0; r < 4; r++) { + total += runBody(); + } + return total; + } +} diff --git a/reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java b/reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java new file mode 100644 index 0000000..cb93f03 --- /dev/null +++ b/reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java @@ -0,0 +1,50 @@ +/* + * Mechanism: use-arrays-stream as an inlining-budget cliff. + * Aggregate provenance: FuzzInput05_MixedInlineArraysAndFinal/ + * 1-inline-method-1/2-use-arrays-stream. + * Hypothesis: replacing one boxed stream count with Arrays.stream(new int[]) + * should not destabilize unrelated helper inlining, but in practice it can + * change HotSpot's compile plan enough that the run1 -> run0 edge inlines in + * the parent shape and stops inlining in the variant. + * Expected symptom: strong instruction/load/store drift with much smaller JMH + * movement; the JIT log should show a run0 inlining divergence. + * Minimality note: runBody() preserves the original 100-iteration hot loop. + * The outer run() loop only repeats that shape to keep the coarse comparator + * above ~10 us/op without rebuilding the whole fuzzed class. + */ +import java.util.Arrays; + +public class UseArraysStreamInlineBudgetCase { + private int sq(int x) { + return x * x; + } + + public long run0() { + int base = 10; + return Arrays.stream(new int[] {1, 2, 3}).count() + + Arrays.asList("x", "y").stream().count() + + sq(base) + + sq(3) + + 3; + } + + public static int run1() { + return (int) new UseArraysStreamInlineBudgetCase().run0(); + } + + private static int runBody() { + int res = 0; + for (int i = 0; i < 100; i++) { + res += run1(); + } + return res; + } + + public static int run() { + int total = 0; + for (int r = 0; r < 4; r++) { + total += runBody(); + } + return total; + } +} diff --git a/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java b/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java new file mode 100644 index 0000000..4aafd91 --- /dev/null +++ b/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java @@ -0,0 +1,37 @@ +/* + * Mechanism: plain counted loop vs boxed stream pipeline. + * External provenance: compiler-comparator/examples/loop-computations/ + * PlainForExample.java -> StreamBoxedExample.java. + * Hypothesis: replacing a direct accumulation loop with a boxed stream + * pipeline adds enough library and lambda machinery to change the optimized + * code shape in a compact, easy-to-explain control example. + * Expected symptom: higher JMH and supporting instruction/load/store drift in + * the stream version. + * Minimality note: this is already the control example itself; only the class + * name was unified so the comparator can treat the pair as one refactoring. + */ +import java.util.ArrayList; +import java.util.List; + +public class LoopComputationsStreamBoxedCase { + private static final int N = 2_000; + + private static int compute(int x) { + int y = x * 31; + y ^= y >>> 16; + return y + 7; + } + + public static long run() { + List list = new ArrayList<>(N); + for (int i = 0; i < N; i++) { + list.add(i); + } + + long sum = 0; + for (int value : list) { + sum += compute(value); + } + return sum; + } +} diff --git a/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java b/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java new file mode 100644 index 0000000..763bc84 --- /dev/null +++ b/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java @@ -0,0 +1,36 @@ +/* + * Mechanism: plain counted loop vs boxed stream pipeline. + * External provenance: compiler-comparator/examples/loop-computations/ + * PlainForExample.java -> StreamBoxedExample.java. + * Hypothesis: replacing a direct accumulation loop with a boxed stream + * pipeline adds enough library and lambda machinery to change the optimized + * code shape in a compact, easy-to-explain control example. + * Expected symptom: higher JMH and supporting instruction/load/store drift in + * the stream version. + * Minimality note: this is already the control example itself; only the class + * name was unified so the comparator can treat the pair as one refactoring. + */ +import java.util.ArrayList; +import java.util.List; + +public class LoopComputationsStreamBoxedCase { + private static final int N = 2_000; + + private static int compute(int x) { + int y = x * 31; + y ^= y >>> 16; + return y + 7; + } + + public static long run() { + List list = new ArrayList<>(N); + for (int i = 0; i < N; i++) { + list.add(i); + } + + return list.stream() + .map(LoopComputationsStreamBoxedCase::compute) + .mapToLong(Integer::longValue) + .sum(); + } +} diff --git a/reproducer/run.py b/reproducer/run.py new file mode 100644 index 0000000..df446a8 --- /dev/null +++ b/reproducer/run.py @@ -0,0 +1,567 @@ +#!/usr/bin/env python3 +"""Curated JIT instability reproducer runner.""" + +from __future__ import annotations + +import argparse +import csv +import json +import math +import platform +import re +import shutil +import statistics +import subprocess +import sys +from dataclasses import dataclass +from datetime import datetime +from pathlib import Path + + +MANIFEST_HEADER = [ + "case_id", + "role", + "classpath", + "class_name", + "method_name", + "jit_log", + "jmh_result", + "label", +] + + +@dataclass(frozen=True) +class Case: + """Curated reproducer case.""" + + case_id: str + baseline_source: Path + variant_source: Path + class_name: str + method_name: str = "run" + + +class ReproducerError(RuntimeError): + """Fatal reproducer error.""" + + +def main() -> int: + args = parse_args() + repo_root = Path(__file__).resolve().parents[1] + cases_root = resolve_root(repo_root, args.cases_root) + runs_root = resolve_root(repo_root, args.runs_root) + try: + require_positive_runs(args.runs) + preflight_perf() + cases = selected_cases(discover_cases(cases_root), include_prefixes(args.include_cases)) + session = Session(repo_root, cases_root, runs_root, args.runs, args.include_cases, cases, args.session_id) + session.run() + return 0 + except ReproducerError as error: + print(str(error), file=sys.stderr) + return 1 + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Run curated JIT instability reproducer cases.") + parser.add_argument("--runs", type=int, required=True) + parser.add_argument("--include-cases") + parser.add_argument("--session-id") + parser.add_argument("--cases-root", default="reproducer/cases") + parser.add_argument("--runs-root", default="reproducer/runs") + return parser.parse_args() + + +def resolve_root(repo_root: Path, raw: str) -> Path: + path = Path(raw) + if path.is_absolute(): + return path + return repo_root / path + + +def require_positive_runs(runs: int) -> None: + if runs < 1: + raise ReproducerError("--runs must be a positive integer") + + +def now() -> str: + return datetime.now().astimezone().isoformat(timespec="seconds") + + +def session_id() -> str: + return datetime.now().strftime("%Y%m%d_%H%M%S") + + +def log(message: str) -> None: + print(f"[{now()}] {message}", flush=True) + + +def run_command(command: list[str], cwd: Path | None = None) -> subprocess.CompletedProcess[str]: + return subprocess.run(command, cwd=cwd, capture_output=True, text=True, check=False) + + +def combined_output(process: subprocess.CompletedProcess[str]) -> str: + return process.stdout + process.stderr + + +def command_path(name: str) -> str: + resolved = shutil.which(name) + if resolved is None: + return name + return resolved + + +def classpath_line(line: str) -> bool: + return line.startswith("/") and "build/classes/java/main" in line + + +def preflight_perf() -> None: + version = run_command(["perf", "--version"]) + if version.returncode != 0: + raise ReproducerError( + "perf is required but was not found in PATH.\nInstall Linux perf and rerun reproducer." + ) + probe = run_command(["perf", "stat", "-e", "instructions", "--", "sleep", "0.1"]) + if probe.returncode != 0: + raise ReproducerError( + "perf is installed but cannot collect required events.\n" + "Tried: perf stat -e instructions -- sleep 0.1\n" + "This usually means perf_event_paranoid is too restrictive or the environment does not expose perf " + "counters.\nFix Linux perf permissions, then rerun reproducer." + ) + + +def include_prefixes(raw: str | None) -> list[str]: + if raw is None: + return [] + prefixes = [part.strip() for part in raw.split(",")] + if any(part == "" for part in prefixes): + raise ReproducerError("--include-cases contains an empty item") + return prefixes + + +def discover_cases(cases_root: Path) -> list[Case]: + if not cases_root.is_dir(): + raise ReproducerError(f"Cases root does not exist: {cases_root}") + cases = [case_from_directory(path) for path in sorted(cases_root.iterdir()) if path.is_dir()] + if not cases: + raise ReproducerError(f"No cases found in {cases_root}") + return cases + + +def case_from_directory(path: Path) -> Case: + baseline = single_java_file(path / "baseline", path.name, "baseline") + variant = single_java_file(path / "variant", path.name, "variant") + if baseline.name != variant.name: + raise ReproducerError(f"Baseline and variant class names differ in {path.name}") + source_contract(baseline) + source_contract(variant) + return Case(path.name, baseline, variant, baseline.stem) + + +def single_java_file(directory: Path, case_id: str, role: str) -> Path: + if not directory.is_dir(): + raise ReproducerError(f"Case {case_id} is missing {role} directory: {directory}") + files = sorted(directory.glob("*.java")) + if len(files) != 1: + raise ReproducerError(f"Case {case_id} {role} must contain exactly one .java file") + return files[0] + + +def source_contract(source: Path) -> None: + text = source.read_text(encoding="utf-8") + if re.search(r"^\s*package\s+", text, flags=re.MULTILINE): + raise ReproducerError(f"Source must not declare a package: {source}") + class_pattern = r"\bclass\s+" + re.escape(source.stem) + r"\b" + if re.search(class_pattern, text) is None: + raise ReproducerError(f"Class name must match file name: {source}") + if re.search(r"\bstatic\b[\s\S]*?\brun\s*\(\s*\)", text) is None: + raise ReproducerError(f"Source must expose a no-argument static run method: {source}") + + +def selected_cases(cases: list[Case], prefixes: list[str]) -> list[Case]: + if not prefixes: + return sorted(cases, key=lambda case: case.case_id) + selected: dict[str, Case] = {} + for prefix in prefixes: + matches = [case for case in cases if case.case_id.startswith(prefix)] + if not matches: + raise ReproducerError(f"--include-cases item matches no cases: {prefix}") + for case in matches: + selected[case.case_id] = case + return [selected[key] for key in sorted(selected)] + + +class Session: + """One reproducer execution session.""" + + def __init__( + self, + repo_root: Path, + cases_root: Path, + runs_root: Path, + runs: int, + include_cases: str | None, + cases: list[Case], + requested_session_id: str | None, + ) -> None: + self.repo_root = repo_root + self.cases_root = cases_root + self.runs_root = runs_root + self.runs = runs + self.include_cases = include_prefixes(include_cases) + self.cases = cases + self.session_id = requested_session_id or session_id() + self.root = runs_root / self.session_id + self.index_rows: list[dict[str, str]] = [] + self.metadata = self.initial_metadata() + + def run(self) -> None: + self.root.mkdir(parents=True, exist_ok=False) + self.write_metadata() + try: + runtime_classpath = self.runtime_classpath() + self.metadata["gradle"]["runtime_classpath"] = runtime_classpath + self.write_case_metadata() + for case in self.cases: + self.run_case(case, runtime_classpath) + aggregate_case(self.root, self.session_id, case) + self.metadata["finished_at"] = now() + self.write_index() + self.write_metadata() + self.update_latest() + except ReproducerError: + self.metadata["finished_at"] = now() + self.write_index() + self.write_metadata() + raise + + def initial_metadata(self) -> dict: + return { + "session_id": self.session_id, + "started_at": now(), + "finished_at": "", + "repo_root": str(self.repo_root), + "cases_root": str(self.cases_root), + "runs_root": str(self.runs_root), + "runs": self.runs, + "include_cases": self.include_cases, + "selected_cases": [case.case_id for case in self.cases], + "tools": tools_metadata(), + "environment": environment_metadata(), + "git": git_metadata(self.repo_root), + "gradle": { + "classpath_command": ["./gradlew", "classes", "printRuntimeClasspath"], + "runtime_classpath": "", + "command_output": "", + }, + } + + def runtime_classpath(self) -> str: + command = ["./gradlew", "classes", "printRuntimeClasspath"] + process = run_command(command, self.repo_root) + self.metadata["gradle"]["command_output"] = combined_output(process) + self.write_metadata() + if process.returncode != 0: + raise ReproducerError("Gradle runtime classpath command failed:\n" + combined_output(process)) + lines = [line.strip() for line in process.stdout.splitlines() if classpath_line(line.strip())] + if not lines: + raise ReproducerError("Gradle runtime classpath command produced no classpath") + return lines[-1] + + def write_case_metadata(self) -> None: + for case in self.cases: + case_root = self.root / "cases" / case.case_id + case_root.mkdir(parents=True, exist_ok=True) + write_json( + case_root / "case_metadata.json", + { + "case_id": case.case_id, + "baseline_source": str(case.baseline_source), + "variant_source": str(case.variant_source), + "class_name": case.class_name, + "method_name": case.method_name, + "runs": self.runs, + }, + ) + + def run_case(self, case: Case, runtime_classpath: str) -> None: + for index in range(1, self.runs + 1): + run_name = f"run-{index:03d}" + run_root = self.root / "cases" / case.case_id / "runs" / run_name + try: + self.run_once(case, index, run_name, run_root, runtime_classpath) + self.index_rows.append(index_row(self.session_id, case, index, run_name, "success", run_root)) + except ReproducerError: + self.index_rows.append(index_row(self.session_id, case, index, run_name, "failed", run_root)) + raise + + def run_once(self, case: Case, index: int, run_name: str, run_root: Path, runtime_classpath: str) -> None: + started = now() + run_root.mkdir(parents=True, exist_ok=True) + paths = RunPaths(run_root) + try: + log(f"Starting {case.case_id} {run_name}") + paths.create() + compile_source(case.baseline_source, paths.baseline_classes, case.class_name, "compile-baseline", paths) + compile_source(case.variant_source, paths.variant_classes, case.class_name, "compile-variant", paths) + write_manifest(case, paths) + log(f"Starting comparison for {case.case_id} {run_name}") + compare(case, paths, runtime_classpath, self.repo_root) + log(f"Finished comparison for {case.case_id} {run_name}") + write_json(paths.status, {"status": "success", "stage": "done", "started_at": started, "finished_at": now()}) + except RunFailure as failure: + log(f"Failed {case.case_id} {run_name} at {failure.stage}") + write_json(paths.status, failure.status(started)) + raise ReproducerError(f"Case {case.case_id} {run_name} failed at {failure.stage}") from failure + + def write_index(self) -> None: + write_csv( + self.root / "index.csv", + ["session_id", "case_id", "run_index", "run_name", "status", "comparisons_csv"], + self.index_rows, + ) + + def write_metadata(self) -> None: + write_json(self.root / "metadata.json", self.metadata) + + def update_latest(self) -> None: + latest = self.runs_root / "latest" + try: + if latest.is_symlink() or latest.exists(): + latest.unlink() + latest.symlink_to(self.root, target_is_directory=True) + except OSError as error: + print(f"Warning: unable to update latest symlink: {error}", file=sys.stderr) + + +class RunFailure(Exception): + """Failed run stage with captured command output.""" + + def __init__(self, stage: str, command: list[str], process: subprocess.CompletedProcess[str]) -> None: + super().__init__(stage) + self.stage = stage + self.command = command + self.process = process + + def status(self, started: str) -> dict: + return { + "status": "failed", + "stage": self.stage, + "command": self.command, + "exit_code": self.process.returncode, + "stdout": self.process.stdout, + "stderr": self.process.stderr, + "started_at": started, + "finished_at": now(), + } + + +class RunPaths: + """Filesystem paths for one case run.""" + + def __init__(self, root: Path) -> None: + self.root = root + self.status = root / "status.json" + self.logs = root / "logs" + self.pairs = root / "pairs.csv" + self.comparisons = root / "comparisons.csv" + self.baseline_classes = root / "classes" / "baseline" + self.variant_classes = root / "classes" / "variant" + self.baseline_artifacts = root / "artifacts" / "baseline" + self.variant_artifacts = root / "artifacts" / "variant" + + def create(self) -> None: + for directory in [ + self.baseline_classes, + self.variant_classes, + self.baseline_artifacts, + self.variant_artifacts, + self.logs, + ]: + directory.mkdir(parents=True, exist_ok=True) + + +def compile_source(source: Path, classes: Path, class_name: str, stage: str, paths: RunPaths) -> None: + command = ["javac", "-d", str(classes), str(source)] + process = run_command(command) + save_process_logs(process, paths.logs, stage) + if process.returncode != 0: + raise RunFailure(stage, command, process) + expected = classes / f"{class_name}.class" + if not expected.is_file(): + failed = subprocess.CompletedProcess(command, 1, "", f"Expected class file was not created: {expected}") + raise RunFailure(stage, command, failed) + + +def write_manifest(case: Case, paths: RunPaths) -> None: + rows = [ + manifest_row(case, "baseline", paths.baseline_classes, paths.baseline_artifacts), + manifest_row(case, "variant", paths.variant_classes, paths.variant_artifacts), + ] + write_csv(paths.pairs, MANIFEST_HEADER, rows) + + +def manifest_row(case: Case, role: str, classes: Path, artifacts: Path) -> dict[str, str]: + return { + "case_id": case.case_id, + "role": role, + "classpath": str(classes.resolve()), + "class_name": case.class_name, + "method_name": case.method_name, + "jit_log": str((artifacts / "jit-log.xml").resolve()), + "jmh_result": str((artifacts / "jmh-result.json").resolve()), + "label": f"{case.case_id}/{role}", + } + + +def compare(case: Case, paths: RunPaths, runtime_classpath: str, repo_root: Path) -> None: + command = [ + "java", + "-cp", + runtime_classpath, + "comparator.reproducer.ComparePairs", + "--manifest", + str(paths.pairs), + "--output", + str(paths.comparisons), + ] + process = run_command(command, repo_root) + save_process_logs(process, paths.logs, "compare") + if process.returncode != 0: + raise RunFailure("compare", command, process) + if not paths.comparisons.is_file(): + failed = subprocess.CompletedProcess(command, 1, "", f"Comparisons CSV was not created for {case.case_id}") + raise RunFailure("compare", command, failed) + + +def save_process_logs(process: subprocess.CompletedProcess[str], logs: Path, stage: str) -> None: + logs.mkdir(parents=True, exist_ok=True) + (logs / f"{stage}.stdout.log").write_text(process.stdout, encoding="utf-8") + (logs / f"{stage}.stderr.log").write_text(process.stderr, encoding="utf-8") + + +def aggregate_case(session_root: Path, sid: str, case: Case) -> None: + case_root = session_root / "cases" / case.case_id + rows: list[dict[str, str]] = [] + header: list[str] = [] + for run_dir in sorted((case_root / "runs").glob("run-*")): + run_index = int(run_dir.name.removeprefix("run-")) + with (run_dir / "comparisons.csv").open(newline="", encoding="utf-8") as stream: + reader = csv.DictReader(stream) + header = reader.fieldnames or header + for row in reader: + updated = dict(row) + updated["session_id"] = sid + updated["case_id"] = case.case_id + updated["run_index"] = str(run_index) + updated["run_name"] = run_dir.name + updated["role"] = role_from_target(row.get("Target", "")) + rows.append(updated) + if not rows: + raise ReproducerError(f"No comparison rows found for aggregation: {case.case_id}") + all_header = header + ["session_id", "case_id", "run_index", "run_name", "role"] + write_csv(case_root / "all_runs.csv", all_header, rows) + write_csv(case_root / "summary.csv", ["role", "metric", "count", "mean", "stdev", "min", "max"], summary_rows(rows)) + + +def role_from_target(target: str) -> str: + if target.endswith("/baseline"): + return "baseline" + if target.endswith("/variant"): + return "variant" + return "" + + +def summary_rows(rows: list[dict[str, str]]) -> list[dict[str, str]]: + grouped: dict[str, list[dict[str, str]]] = {} + for row in rows: + grouped.setdefault(row["role"], []).append(row) + result: list[dict[str, str]] = [] + for role in sorted(grouped): + columns = numeric_columns(grouped[role]) + for column in columns: + values = [float(row[column]) for row in grouped[role] if is_number(row.get(column, ""))] + result.append(summary_row(role, column, values)) + return result + + +def numeric_columns(rows: list[dict[str, str]]) -> list[str]: + columns = rows[0].keys() + return [column for column in columns if any(is_number(row.get(column, "")) for row in rows)] + + +def summary_row(role: str, metric: str, values: list[float]) -> dict[str, str]: + return { + "role": role, + "metric": metric, + "count": str(len(values)), + "mean": str(statistics.fmean(values)), + "stdev": str(statistics.stdev(values) if len(values) > 1 else 0.0), + "min": str(min(values)), + "max": str(max(values)), + } + + +def is_number(value: str) -> bool: + try: + number = float(value) + return math.isfinite(number) + except ValueError: + return False + + +def index_row(sid: str, case: Case, index: int, run_name: str, status: str, run_root: Path) -> dict[str, str]: + return { + "session_id": sid, + "case_id": case.case_id, + "run_index": str(index), + "run_name": run_name, + "status": status, + "comparisons_csv": str(run_root / "comparisons.csv"), + } + + +def tools_metadata() -> dict: + return { + "java": tool_metadata("java", ["java", "-version"]), + "javac": tool_metadata("javac", ["javac", "-version"]), + "perf": tool_metadata("perf", ["perf", "--version"]), + } + + +def tool_metadata(name: str, command: list[str]) -> dict: + process = run_command(command) + return {"command": command_path(name), "version_output": combined_output(process)} + + +def environment_metadata() -> dict: + return { + "platform": platform.platform(), + "machine": platform.machine(), + "processor": platform.processor(), + "python_version": platform.python_version(), + } + + +def git_metadata(repo_root: Path) -> dict: + commit = run_command(["git", "rev-parse", "HEAD"], repo_root) + status = run_command(["git", "status", "--porcelain"], repo_root) + return {"commit": commit.stdout.strip(), "dirty": bool(status.stdout.strip())} + + +def write_json(path: Path, value: dict) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8") + + +def write_csv(path: Path, header: list[str], rows: list[dict[str, str]]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("w", newline="", encoding="utf-8") as stream: + writer = csv.DictWriter(stream, fieldnames=header) + writer.writeheader() + writer.writerows(rows) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/reproducer/test_run.py b/reproducer/test_run.py new file mode 100644 index 0000000..b1bdb6f --- /dev/null +++ b/reproducer/test_run.py @@ -0,0 +1,79 @@ +"""Contract tests for the reproducer Python runner.""" + +from __future__ import annotations + +import csv +import subprocess +import tempfile +import unittest +from pathlib import Path + +import run + + +class DiscoveryTest(unittest.TestCase): + """Case discovery contract tests.""" + + def test_discovers_one_valid_case(self) -> None: + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + self.write_case(root / "case01_example") + cases = run.discover_cases(root) + self.assertEqual(["case01_example"], [case.case_id for case in cases]) + + def test_rejects_multiple_baseline_sources(self) -> None: + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + self.write_case(root / "case01_example") + (root / "case01_example" / "baseline" / "Other.java").write_text( + "class Other { public static int run() { return 1; } }", + encoding="utf-8", + ) + with self.assertRaises(run.ReproducerError): + run.discover_cases(root) + + def write_case(self, case_root: Path) -> None: + for role in ["baseline", "variant"]: + source = case_root / role / "Example.java" + source.parent.mkdir(parents=True) + source.write_text("class Example { public static int run() { return 1; } }", encoding="utf-8") + + +class AggregationTest(unittest.TestCase): + """CSV aggregation contract tests.""" + + def test_aggregates_synthetic_comparisons(self) -> None: + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + case = run.Case("case01_example", root / "baseline.java", root / "variant.java", "Example") + run_dir = root / "cases" / case.case_id / "runs" / "run-001" + run_dir.mkdir(parents=True) + self.write_comparisons(run_dir / "comparisons.csv") + run.aggregate_case(root, "session01", case) + all_rows = self.read_csv(root / "cases" / case.case_id / "all_runs.csv") + summary_rows = self.read_csv(root / "cases" / case.case_id / "summary.csv") + self.assertEqual(["baseline", "variant"], [row["role"] for row in all_rows]) + self.assertTrue(any(row["metric"] == "score" for row in summary_rows)) + + def test_writes_process_logs(self) -> None: + with tempfile.TemporaryDirectory() as directory: + logs = Path(directory) / "logs" + process = subprocess.CompletedProcess(["example"], 0, "out", "err") + run.save_process_logs(process, logs, "compare") + self.assertEqual("out", (logs / "compare.stdout.log").read_text(encoding="utf-8")) + self.assertEqual("err", (logs / "compare.stderr.log").read_text(encoding="utf-8")) + + def write_comparisons(self, path: Path) -> None: + with path.open("w", newline="", encoding="utf-8") as stream: + writer = csv.DictWriter(stream, fieldnames=["Target", "score"]) + writer.writeheader() + writer.writerow({"Target": "case01_example/baseline", "score": "1.0"}) + writer.writerow({"Target": "case01_example/variant", "score": "2.0"}) + + def read_csv(self, path: Path) -> list[dict[str, str]]: + with path.open(newline="", encoding="utf-8") as stream: + return list(csv.DictReader(stream)) + + +if __name__ == "__main__": + unittest.main() diff --git a/src/main/java/comparator/reproducer/ComparePairs.java b/src/main/java/comparator/reproducer/ComparePairs.java new file mode 100644 index 0000000..13b03a2 --- /dev/null +++ b/src/main/java/comparator/reproducer/ComparePairs.java @@ -0,0 +1,101 @@ +package comparator.reproducer; + +import comparator.Analysis; +import comparator.comparison.CsvComparison; +import comparator.method.Classpath; +import comparator.method.TargetMethod; +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.StringReader; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.util.List; + +/** + * Batch comparator command line entry point for reproducer manifests. + */ +@SuppressWarnings("PMD.SystemPrintln") +public final class ComparePairs { + private ComparePairs() { + } + + /** + * Main method. + * + * @param args + * command line arguments + */ + public static void main(final String[] args) { + try { + final ComparePairsOptions options = ComparePairsOptions.fromArgs(args); + if (options.help()) { + System.out.println("Usage: ComparePairs --manifest --output "); + } else { + new ComparePairs().run(options); + } + } catch (final IllegalArgumentException | IllegalStateException exception) { + System.err.println(exception.getMessage()); + System.exit(1); + } + } + + private void run(final ComparePairsOptions options) { + try { + Files.createDirectories(options.output().toAbsolutePath().getParent()); + try (BufferedWriter writer = Files.newBufferedWriter(options.output(), StandardCharsets.UTF_8)) { + boolean headerWritten = false; + for (final ManifestPair pair : ComparisonManifest.fromFile(options.manifest()).pairs().values()) { + headerWritten = this.writeComparison(pair, writer, headerWritten); + } + } + } catch (final IOException exception) { + throw new IllegalStateException("Unable to write comparisons: " + options.output(), exception); + } + } + + private boolean writeComparison(final ManifestPair pair, final BufferedWriter writer, + final boolean headerWritten) + throws IOException { + final String csv = new CsvComparison( + this.analysis(pair.baseline()), + this.analysis(pair.variant()) + ).asCsv(); + final List lines = new BufferedReaderLines(csv).asList(); + int start = 0; + if (headerWritten) { + start = 1; + } + for (int index = start; index < lines.size(); index += 1) { + if (headerWritten || index > start) { + writer.newLine(); + } + writer.write(lines.get(index)); + } + return true; + } + + private Analysis analysis(final ManifestEntry entry) { + return new Analysis( + new TargetMethod(new Classpath(entry.classpath()), entry.className(), entry.methodName()), + entry.jitLog(), + entry.jmhResult(), + entry.label() + ); + } + + /** + * Line list extracted from a generated CSV string. + */ + private static final class BufferedReaderLines { + /** CSV content. */ + private final String csv; + + private BufferedReaderLines(final String csv) { + this.csv = csv; + } + + private List asList() { + return new java.io.BufferedReader(new StringReader(this.csv)).lines().toList(); + } + } +} diff --git a/src/main/java/comparator/reproducer/ComparePairsOptions.java b/src/main/java/comparator/reproducer/ComparePairsOptions.java new file mode 100644 index 0000000..8f6168d --- /dev/null +++ b/src/main/java/comparator/reproducer/ComparePairsOptions.java @@ -0,0 +1,85 @@ +package comparator.reproducer; + +import java.nio.file.Path; +import java.util.Arrays; + +/** + * Command line options for reproducer pair comparison. + */ +@SuppressWarnings({ "PMD.ProhibitPublicStaticMethods", "PMD.CyclomaticComplexity" }) +public final class ComparePairsOptions { + /** Help flag. */ + private final boolean help; + + /** Manifest file. */ + private final Path manifest; + + /** Output file. */ + private final Path output; + + private ComparePairsOptions(final boolean help, final Path manifest, final Path output) { + this.help = help; + this.manifest = manifest; + this.output = output; + } + + /** + * Parses command line arguments. + * + * @param args + * command line arguments + * @return parsed options + */ + public static ComparePairsOptions fromArgs(final String... args) { + if (args.length == 1 && "--help".equals(args[0])) { + return new ComparePairsOptions(true, Path.of("."), Path.of(".")); + } + Path manifest = Path.of(""); + Path output = Path.of(""); + int index = 0; + while (index < args.length) { + final String arg = args[index]; + if ("--manifest".equals(arg)) { + manifest = ComparePairsOptions.value(args, index + 1, arg); + index += 2; + } else if ("--output".equals(arg)) { + output = ComparePairsOptions.value(args, index + 1, arg); + index += 2; + } else { + throw new IllegalArgumentException("Unknown argument: " + arg + " in " + Arrays.toString(args)); + } + } + if (manifest.toString().isEmpty() || output.toString().isEmpty()) { + throw new IllegalArgumentException("Both --manifest and --output are required"); + } + return new ComparePairsOptions(false, manifest, output); + } + + /** + * @return help flag + */ + public boolean help() { + return this.help; + } + + /** + * @return manifest file + */ + public Path manifest() { + return this.manifest; + } + + /** + * @return output file + */ + public Path output() { + return this.output; + } + + private static Path value(final String[] args, final int index, final String option) { + if (index >= args.length) { + throw new IllegalArgumentException("Missing value for " + option); + } + return Path.of(args[index]); + } +} diff --git a/src/main/java/comparator/reproducer/ComparisonManifest.java b/src/main/java/comparator/reproducer/ComparisonManifest.java new file mode 100644 index 0000000..b9eb916 --- /dev/null +++ b/src/main/java/comparator/reproducer/ComparisonManifest.java @@ -0,0 +1,146 @@ +package comparator.reproducer; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/** + * Strict CSV manifest of reproducer comparison pairs. + */ +@SuppressWarnings({ "PMD.ProhibitPublicStaticMethods", "PMD.CyclomaticComplexity" }) +public final class ComparisonManifest { + /** Pairs grouped by case identifier. */ + private final Map pairs; + + private ComparisonManifest(final Map pairs) { + this.pairs = Map.copyOf(pairs); + } + + /** + * Reads a manifest file. + * + * @param file + * manifest file + * @return parsed manifest + */ + public static ComparisonManifest fromFile(final Path file) { + try { + return ComparisonManifest.fromLines(Files.readAllLines(file, StandardCharsets.UTF_8)); + } catch (final IOException exception) { + throw new IllegalStateException("Unable to read manifest: " + file, exception); + } + } + + /** + * Reads manifest lines. + * + * @param lines + * manifest lines + * @return parsed manifest + */ + public static ComparisonManifest fromLines(final List lines) { + final List> rows = lines.stream() + .filter(line -> !line.isBlank()) + .filter(line -> !line.stripLeading().startsWith("#")) + .map(ComparisonManifest::parseCsvLine) + .toList(); + if (rows.isEmpty()) { + throw new IllegalArgumentException("Manifest must contain a header"); + } + if (!ManifestEntry.HEADER.equals(rows.get(0))) { + throw new IllegalArgumentException("Manifest header must be exactly: " + ManifestEntry.HEADER); + } + final Map grouped = new LinkedHashMap<>(); + rows.stream().skip(1).map(ManifestEntry::new).forEach(entry -> { + final MutablePair pair = grouped.computeIfAbsent(entry.caseId(), key -> new MutablePair()); + pair.add(entry); + }); + return new ComparisonManifest(ComparisonManifest.freeze(grouped)); + } + + /** + * @return case pairs + */ + public Map pairs() { + return this.pairs; + } + + private static Map freeze(final Map grouped) { + final Map result = new LinkedHashMap<>(); + grouped.forEach((caseId, pair) -> result.put(caseId, pair.freeze(caseId))); + return result; + } + + private static List parseCsvLine(final String line) { + final List values = new ArrayList<>(); + final StringBuilder current = new StringBuilder(); + boolean quoted = false; + int index = 0; + while (index < line.length()) { + final char chr = line.charAt(index); + if (chr == '"') { + if (quoted && index + 1 < line.length() && line.charAt(index + 1) == '"') { + current.append(chr); + index += 1; + } else { + quoted = !quoted; + } + } else if (chr == ',' && !quoted) { + values.add(current.toString()); + current.setLength(0); + } else { + current.append(chr); + } + index += 1; + } + if (quoted) { + throw new IllegalArgumentException("Unclosed quote in manifest line: " + line); + } + values.add(current.toString()); + return List.copyOf(values); + } + + /** + * Mutable pair under construction. + */ + private static final class MutablePair { + /** Baseline entry. */ + private ManifestEntry baseline; + + /** Variant entry. */ + private ManifestEntry variant; + + private void add(final ManifestEntry entry) { + if ("baseline".equals(entry.role())) { + this.baseline = this.requireEmpty(this.baseline, entry); + } else { + this.variant = this.requireEmpty(this.variant, entry); + } + } + + private ManifestPair freeze(final String caseId) { + if (this.baseline == null || this.variant == null) { + throw new IllegalArgumentException( + "Manifest case must contain one baseline and one variant: " + + caseId + ); + } + return new ManifestPair(this.baseline, this.variant); + } + + private ManifestEntry requireEmpty(final ManifestEntry current, final ManifestEntry next) { + if (current != null) { + throw new IllegalArgumentException( + "Duplicate manifest role for case: " + next.caseId() + "/" + + next.role() + ); + } + return next; + } + } +} diff --git a/src/main/java/comparator/reproducer/ManifestEntry.java b/src/main/java/comparator/reproducer/ManifestEntry.java new file mode 100644 index 0000000..e30337e --- /dev/null +++ b/src/main/java/comparator/reproducer/ManifestEntry.java @@ -0,0 +1,144 @@ +package comparator.reproducer; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; + +/** + * Single manifest row for one compared target role. + */ +@SuppressWarnings({ "PMD.DataClass", "PMD.ConstructorOnlyInitializesOrCallOtherConstructors" }) +public final class ManifestEntry { + /** Valid manifest header. */ + public static final List HEADER = List.of( + "case_id", + "role", + "classpath", + "class_name", + "method_name", + "jit_log", + "jmh_result", + "label" + ); + + /** Case identifier. */ + private final String caseId; + + /** Case role. */ + private final String role; + + /** Classpath root. */ + private final Path classpath; + + /** Class name. */ + private final String className; + + /** Method name. */ + private final String methodName; + + /** JIT log file. */ + private final Path jitLog; + + /** JMH result file. */ + private final Path jmhResult; + + /** Stable target label. */ + private final String label; + + /** + * Ctor. + * + * @param values + * manifest row values + */ + public ManifestEntry(final List values) { + if (values.size() != ManifestEntry.HEADER.size()) { + throw new IllegalArgumentException( + "Manifest row must contain exactly " + ManifestEntry.HEADER.size() + + " columns: " + values + ); + } + this.caseId = ManifestEntry.required(values.get(0), "case_id"); + this.role = ManifestEntry.required(values.get(1), "role"); + this.classpath = Path.of(ManifestEntry.required(values.get(2), "classpath")); + this.className = ManifestEntry.required(values.get(3), "class_name"); + this.methodName = ManifestEntry.required(values.get(4), "method_name"); + this.jitLog = Path.of(ManifestEntry.required(values.get(5), "jit_log")); + this.jmhResult = Path.of(ManifestEntry.required(values.get(6), "jmh_result")); + this.label = ManifestEntry.required(values.get(7), "label"); + this.validate(); + } + + /** + * @return case identifier + */ + public String caseId() { + return this.caseId; + } + + /** + * @return case role + */ + public String role() { + return this.role; + } + + /** + * @return classpath root + */ + public Path classpath() { + return this.classpath; + } + + /** + * @return class name + */ + public String className() { + return this.className; + } + + /** + * @return method name + */ + public String methodName() { + return this.methodName; + } + + /** + * @return JIT log file + */ + public Path jitLog() { + return this.jitLog; + } + + /** + * @return JMH result file + */ + public Path jmhResult() { + return this.jmhResult; + } + + /** + * @return stable target label + */ + public String label() { + return this.label; + } + + private void validate() { + if (!"baseline".equals(this.role) && !"variant".equals(this.role)) { + throw new IllegalArgumentException("Manifest role must be baseline or variant: " + this.role); + } + if (!Files.isDirectory(this.classpath)) { + throw new IllegalArgumentException("Manifest classpath must be an existing directory: " + this.classpath); + } + } + + private static String required(final String value, final String column) { + final String trimmed = value.trim(); + if (trimmed.isEmpty()) { + throw new IllegalArgumentException("Manifest column must not be blank: " + column); + } + return trimmed; + } +} diff --git a/src/main/java/comparator/reproducer/ManifestPair.java b/src/main/java/comparator/reproducer/ManifestPair.java new file mode 100644 index 0000000..7595f44 --- /dev/null +++ b/src/main/java/comparator/reproducer/ManifestPair.java @@ -0,0 +1,39 @@ +package comparator.reproducer; + +/** + * Baseline and variant manifest entries for one case. + */ +public final class ManifestPair { + /** Baseline entry. */ + private final ManifestEntry baseline; + + /** Variant entry. */ + private final ManifestEntry variant; + + /** + * Ctor. + * + * @param baseline + * baseline entry + * @param variant + * variant entry + */ + public ManifestPair(final ManifestEntry baseline, final ManifestEntry variant) { + this.baseline = baseline; + this.variant = variant; + } + + /** + * @return baseline entry + */ + public ManifestEntry baseline() { + return this.baseline; + } + + /** + * @return variant entry + */ + public ManifestEntry variant() { + return this.variant; + } +} diff --git a/src/main/java/comparator/reproducer/package-info.java b/src/main/java/comparator/reproducer/package-info.java new file mode 100644 index 0000000..02f4893 --- /dev/null +++ b/src/main/java/comparator/reproducer/package-info.java @@ -0,0 +1,4 @@ +/** + * Reproducer batch comparison command line objects. + */ +package comparator.reproducer; diff --git a/src/test/java/comparator/reproducer/ComparePairsOptionsTest.java b/src/test/java/comparator/reproducer/ComparePairsOptionsTest.java new file mode 100644 index 0000000..5521ef4 --- /dev/null +++ b/src/test/java/comparator/reproducer/ComparePairsOptionsTest.java @@ -0,0 +1,26 @@ +package comparator.reproducer; + +import java.nio.file.Path; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +/** CLI option parser contract tests. */ +final class ComparePairsOptionsTest { + @Test + void parsesManifestAndOutput() { + final ComparePairsOptions options = ComparePairsOptions.fromArgs( + "--manifest", "pairs.csv", "--output", "comparisons.csv" + ); + Assertions.assertEquals(Path.of("pairs.csv"), options.manifest(), "Manifest option should be parsed"); + Assertions.assertEquals(Path.of("comparisons.csv"), options.output(), "Output option should be parsed"); + } + + @Test + void rejectsMissingOutput() { + Assertions.assertThrows( + IllegalArgumentException.class, + () -> ComparePairsOptions.fromArgs("--manifest", "pairs.csv"), + "Missing required options should fail" + ); + } +} diff --git a/src/test/java/comparator/reproducer/ComparisonManifestTest.java b/src/test/java/comparator/reproducer/ComparisonManifestTest.java new file mode 100644 index 0000000..3b73f0e --- /dev/null +++ b/src/test/java/comparator/reproducer/ComparisonManifestTest.java @@ -0,0 +1,46 @@ +package comparator.reproducer; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +/** Manifest parser contract tests. */ +@SuppressWarnings("PMD.SignatureDeclareThrowsException") +final class ComparisonManifestTest { + @Test + void parsesValidBaselineVariantPair(@TempDir final Path tempDir) throws Exception { + final Path baseline = Files.createDirectories(tempDir.resolve("baseline")); + final Path variant = Files.createDirectories(tempDir.resolve("variant")); + final ComparisonManifest manifest = ComparisonManifest.fromLines( + List.of( + String.join(",", ManifestEntry.HEADER), + "case01,baseline," + baseline + ",Example,run," + tempDir.resolve("baseline.xml") + + "," + tempDir.resolve("baseline.json") + ",case01/baseline", + "case01,variant," + variant + ",Example,run," + tempDir.resolve("variant.xml") + + "," + tempDir.resolve("variant.json") + ",case01/variant" + ) + ); + final ManifestPair pair = manifest.pairs().get("case01"); + Assertions.assertEquals("case01/baseline", pair.baseline().label(), "Baseline label should be parsed"); + Assertions.assertEquals("case01/variant", pair.variant().label(), "Variant label should be parsed"); + } + + @Test + void rejectsMissingVariant(@TempDir final Path tempDir) throws Exception { + final Path baseline = Files.createDirectories(tempDir.resolve("baseline")); + Assertions.assertThrows( + IllegalArgumentException.class, + () -> ComparisonManifest.fromLines( + List.of( + String.join(",", ManifestEntry.HEADER), + "case01,baseline," + baseline + ",Example,run," + tempDir.resolve("baseline.xml") + + "," + tempDir.resolve("baseline.json") + ",case01/baseline" + ) + ), + "One-sided manifest cases should be rejected" + ); + } +} diff --git a/src/test/java/comparator/reproducer/package-info.java b/src/test/java/comparator/reproducer/package-info.java new file mode 100644 index 0000000..0d03c49 --- /dev/null +++ b/src/test/java/comparator/reproducer/package-info.java @@ -0,0 +1,4 @@ +/** + * Reproducer command line tests. + */ +package comparator.reproducer; From 3daedbc142de7768a2fd9ab99e41539239971e5a Mon Sep 17 00:00:00 2001 From: Roman Korostinskiy <70313618+c71n93@users.noreply.github.com> Date: Fri, 22 May 2026 20:50:50 +0300 Subject: [PATCH 2/8] Add mean differences plotting script --- reproducer/README.md | 19 +- reproducer/plotting/mean_difference.py | 303 +++++++++++++++++++++++++ 2 files changed, 320 insertions(+), 2 deletions(-) create mode 100644 reproducer/plotting/mean_difference.py diff --git a/reproducer/README.md b/reproducer/README.md index a1c1cc8..8ef2525 100644 --- a/reproducer/README.md +++ b/reproducer/README.md @@ -59,5 +59,20 @@ Important files: - `cases//all_runs.csv` - concatenated rows across runs; - `cases//summary.csv` - count, mean, stdev, min, and max per role. -The MVP intentionally does not generate graphs or normalized percent-difference -reports. +## Plotting + +Generate a mean-difference PDF for one case: + +```bash +python3 reproducer/plotting/mean_difference.py \ + reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop +``` + +By default this reads the case `summary.csv` and creates: + +```text +reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop/mean_difference.pdf +``` + +The chart includes five aggregated metrics: JMH score, allocations, +instructions, memory loads, and memory stores. diff --git a/reproducer/plotting/mean_difference.py b/reproducer/plotting/mean_difference.py new file mode 100644 index 0000000..2884b67 --- /dev/null +++ b/reproducer/plotting/mean_difference.py @@ -0,0 +1,303 @@ +#!/usr/bin/env python3 +"""Mean relative-difference chart for one reproducer case.""" + +from __future__ import annotations + +import argparse +import csv +import math +import os +import sys +import tempfile +from dataclasses import dataclass +from pathlib import Path + +MATPLOTLIB_CACHE = Path(tempfile.gettempdir()) / "comparator-matplotlib" +MATPLOTLIB_CACHE.mkdir(parents=True, exist_ok=True) +os.environ.setdefault("MPLCONFIGDIR", str(MATPLOTLIB_CACHE)) +os.environ.setdefault("XDG_CACHE_HOME", str(MATPLOTLIB_CACHE / "xdg")) + +try: + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + from matplotlib.ticker import FuncFormatter +except ModuleNotFoundError as error: + MATPLOTLIB_IMPORT_ERROR: ModuleNotFoundError | None = error +else: + MATPLOTLIB_IMPORT_ERROR = None + + +REQUIRED_COLUMNS = ("role", "metric", "count", "mean", "stdev") +ROLES = ("baseline", "variant") + + +@dataclass(frozen=True) +class MetricSpec: + """Fixed reproducer metric included in the mean-difference chart.""" + + label: str + csv_name: str + + +@dataclass(frozen=True) +class RoleSummary: + """Aggregated measurement row for one metric role.""" + + role: str + count: int + mean: float + stdev: float + + @property + def cv_percent(self) -> float: + return self.stdev / self.mean * 100.0 + + +@dataclass(frozen=True) +class MetricSummary: + """Mean comparison for one metric across baseline and variant roles.""" + + spec: MetricSpec + baseline: RoleSummary + variant: RoleSummary + + @property + def count(self) -> int: + return self.baseline.count + + @property + def relative_difference_percent(self) -> float: + return (self.variant.mean - self.baseline.mean) / self.baseline.mean * 100.0 + + @property + def cv_label(self) -> str: + return ( + f"{self.spec.label}\n" + f"CV(orig): {self.baseline.cv_percent:.2f}%\n" + f"CV(ref): {self.variant.cv_percent:.2f}%" + ) + + +class PlottingError(RuntimeError): + """Fatal mean-difference plotting error.""" + + +class SummaryCsv: + """Validated summary.csv source for one reproducer case.""" + + def __init__(self, case_dir: Path) -> None: + self.case_dir = case_dir + self.path = case_dir / "summary.csv" + + def metric_summaries(self) -> list[MetricSummary]: + self._require_case_directory() + rows = self._rows() + summaries = [self._summary_for(metric, rows) for metric in METRICS] + self._require_same_count(summaries) + return summaries + + def _require_case_directory(self) -> None: + if not self.case_dir.is_dir(): + raise PlottingError(f"Case directory does not exist: {self.case_dir}") + if not self.path.is_file(): + raise PlottingError(f"Missing summary.csv: {self.path}") + + def _rows(self) -> list[dict[str, str]]: + with self.path.open(newline="", encoding="utf-8") as source: + reader = csv.DictReader(source) + if reader.fieldnames is None: + raise PlottingError(f"summary.csv is empty: {self.path}") + missing = [name for name in REQUIRED_COLUMNS if name not in reader.fieldnames] + if missing: + raise PlottingError( + f"summary.csv is missing required columns {', '.join(missing)}: {self.path}" + ) + return list(reader) + + def _summary_for(self, metric: MetricSpec, rows: list[dict[str, str]]) -> MetricSummary: + by_role = { + role: self._single_role_summary(metric, role, rows) + for role in ROLES + } + baseline = by_role["baseline"] + variant = by_role["variant"] + if baseline.count != variant.count: + raise PlottingError( + f"Inconsistent run count in summary.csv for metric {metric.csv_name}: {self.case_dir}" + ) + if baseline.mean == 0.0: + raise PlottingError( + f"Cannot compute relative difference because baseline mean is zero " + f"for metric {metric.csv_name}: {self.case_dir}" + ) + if variant.mean == 0.0: + raise PlottingError( + f"Cannot compute CV because variant mean is zero for metric {metric.csv_name}: {self.case_dir}" + ) + return MetricSummary(metric, baseline, variant) + + def _single_role_summary( + self, + metric: MetricSpec, + role: str, + rows: list[dict[str, str]], + ) -> RoleSummary: + matches = [ + row + for row in rows + if row.get("role") == role and row.get("metric") == metric.csv_name + ] + if len(matches) == 0: + raise PlottingError(f"Missing metric for role {role}: {metric.csv_name}: {self.case_dir}") + if len(matches) > 1: + raise PlottingError(f"Duplicate metric for role {role}: {metric.csv_name}: {self.case_dir}") + row = matches[0] + count = self._positive_count(row["count"], metric, role) + mean = self._finite_float(row["mean"], "mean", metric, role) + stdev = self._finite_float(row["stdev"], "stdev", metric, role) + return RoleSummary(role, count, mean, stdev) + + def _positive_count(self, raw: str, metric: MetricSpec, role: str) -> int: + value = self._finite_float(raw, "count", metric, role) + if not value.is_integer() or value < 1: + raise PlottingError( + f"Metric has invalid count for role {role}: {metric.csv_name}: {self.case_dir}" + ) + return int(value) + + def _finite_float(self, raw: str, field: str, metric: MetricSpec, role: str) -> float: + try: + value = float(raw) + except ValueError as error: + raise PlottingError( + f"Metric has non-numeric {field} for role {role}: {metric.csv_name}: {self.case_dir}" + ) from error + if not math.isfinite(value): + raise PlottingError( + f"Metric has non-finite {field} for role {role}: {metric.csv_name}: {self.case_dir}" + ) + return value + + def _require_same_count(self, summaries: list[MetricSummary]) -> None: + expected = summaries[0].count + for summary in summaries: + if summary.baseline.count != expected or summary.variant.count != expected: + raise PlottingError( + f"Inconsistent run count in summary.csv for metric {summary.spec.csv_name}: {self.case_dir}" + ) + + +class MeanDifferencePlot: + """PDF chart for mean relative differences in one reproducer case.""" + + def __init__(self, case_dir: Path, summaries: list[MetricSummary], output: Path) -> None: + self.case_dir = case_dir + self.summaries = summaries + self.output = output + + def save(self) -> None: + values = [summary.relative_difference_percent for summary in self.summaries] + labels = [summary.cv_label for summary in self.summaries] + colors = ["#1f9a7a" if value < 0.0 else "#c95f4a" for value in values] + + figure, axis = plt.subplots(figsize=(11.5, 7.0)) + x_positions = list(range(len(self.summaries))) + bars = axis.bar(x_positions, values, color=colors, width=0.62, edgecolor="none") + + axis.axhline(0.0, color="#4f6273", linewidth=1.5) + axis.grid(axis="y", color="#e5eaef", linewidth=1.0) + axis.set_axisbelow(True) + axis.set_ylabel("Разница, %", fontsize=13) + axis.set_xticks(x_positions) + axis.set_xticklabels(labels, fontsize=11, fontweight="bold") + axis.yaxis.set_major_formatter(FuncFormatter(lambda value, _: f"{value:.0f}%")) + axis.tick_params(axis="x", length=0, pad=14) + axis.tick_params(axis="y", labelsize=11) + axis.margins(x=0.04) + + for side in ("top", "right", "left", "bottom"): + axis.spines[side].set_visible(False) + + lower, upper, label_offset = self._limits(values) + axis.set_ylim(lower, upper) + for bar, value in zip(bars, values): + y = value + label_offset if value >= 0.0 else value - label_offset + vertical_alignment = "bottom" if value >= 0.0 else "top" + axis.text( + bar.get_x() + bar.get_width() / 2.0, + y, + f"{value:.1f}%", + ha="center", + va=vertical_alignment, + fontsize=12, + fontweight="bold", + color="#1f2933", + ) + + count = self.summaries[0].count + title = ( + f"{self.case_dir.name}\n" + f"Разница в метриках между оригиналом и изменённым вариантом (N = {count})" + ) + axis.set_title(title, fontsize=16, pad=20) + figure.subplots_adjust(left=0.08, right=0.99, top=0.82, bottom=0.24) + + self.output.parent.mkdir(parents=True, exist_ok=True) + figure.savefig(self.output, format="pdf", bbox_inches="tight") + plt.close(figure) + + def _limits(self, values: list[float]) -> tuple[float, float, float]: + minimum = min(values + [0.0]) + maximum = max(values + [0.0]) + span = maximum - minimum + if span == 0.0: + span = max(abs(maximum), 1.0) + + padding = span * 0.18 + lower = minimum - padding + upper = maximum + padding + + if minimum >= 0.0: + lower = -max(span * 0.15, 1.0) + if maximum <= 0.0: + upper = max(span * 0.15, 1.0) + + label_offset = max(span * 0.025, 0.25) + return lower, upper, label_offset + + +METRICS = ( + MetricSpec("JMH score", "JMH primary score, us/op"), + MetricSpec("Allocations", "Allocations, B/op"), + MetricSpec("Instructions", "Instructions, #/op"), + MetricSpec("Memory loads", "Memory loads, #/op"), + MetricSpec("Memory stores", "Memory stores, #/op"), +) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description="Plot mean relative differences for one reproducer case.") + parser.add_argument("case_dir", help="Path to one reproducer case directory.") + parser.add_argument("--output", help="Output PDF path. Defaults to /mean_difference.pdf.") + return parser.parse_args() + + +def main() -> int: + args = parse_args() + case_dir = Path(args.case_dir) + output = Path(args.output) if args.output else case_dir / "mean_difference.pdf" + try: + if MATPLOTLIB_IMPORT_ERROR is not None: + raise PlottingError("Missing Python dependency: matplotlib") + summaries = SummaryCsv(case_dir).metric_summaries() + MeanDifferencePlot(case_dir, summaries, output).save() + return 0 + except PlottingError as error: + print(str(error), file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) From 863d4149d0152bbf5f05bc89de6e4211a9fdeff5 Mon Sep 17 00:00:00 2001 From: Roman Korostinskiy <70313618+c71n93@users.noreply.github.com> Date: Fri, 22 May 2026 21:08:57 +0300 Subject: [PATCH 3/8] Add run differences plotting script --- reproducer/README.md | 18 +- reproducer/plotting/run_difference.py | 351 ++++++++++++++++++++++++++ 2 files changed, 368 insertions(+), 1 deletion(-) create mode 100644 reproducer/plotting/run_difference.py diff --git a/reproducer/README.md b/reproducer/README.md index 8ef2525..fdf1979 100644 --- a/reproducer/README.md +++ b/reproducer/README.md @@ -61,7 +61,7 @@ Important files: ## Plotting -Generate a mean-difference PDF for one case: +**Generate a mean-difference PDF for one case:** ```bash python3 reproducer/plotting/mean_difference.py \ @@ -76,3 +76,19 @@ reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_ The chart includes five aggregated metrics: JMH score, allocations, instructions, memory loads, and memory stores. + +**Generate a per-run relative-difference PDF for one case:** + +```bash +python3 reproducer/plotting/run_difference.py \ + reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop +``` + +By default this reads the case `all_runs.csv` and creates: + +```text +reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop/run_difference.pdf +``` + +The chart includes six per-run metrics: JMH score, allocations, instructions, +memory loads, memory stores, and native code size. diff --git a/reproducer/plotting/run_difference.py b/reproducer/plotting/run_difference.py new file mode 100644 index 0000000..b42bbf9 --- /dev/null +++ b/reproducer/plotting/run_difference.py @@ -0,0 +1,351 @@ +#!/usr/bin/env python3 +"""Per-run relative-difference chart for one reproducer case.""" + +from __future__ import annotations + +import argparse +import csv +import math +import os +import sys +import tempfile +from dataclasses import dataclass +from pathlib import Path + +MATPLOTLIB_CACHE = Path(tempfile.gettempdir()) / "comparator-matplotlib" +MATPLOTLIB_CACHE.mkdir(parents=True, exist_ok=True) +os.environ.setdefault("MPLCONFIGDIR", str(MATPLOTLIB_CACHE)) +os.environ.setdefault("XDG_CACHE_HOME", str(MATPLOTLIB_CACHE / "xdg")) + +try: + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + from matplotlib.ticker import FuncFormatter, MaxNLocator +except ModuleNotFoundError as error: + MATPLOTLIB_IMPORT_ERROR: ModuleNotFoundError | None = error +else: + MATPLOTLIB_IMPORT_ERROR = None + + +REQUIRED_COLUMNS = ("role", "run_index") +ROLES = ("baseline", "variant") + + +@dataclass(frozen=True) +class MetricSpec: + """Fixed reproducer metric included in the run-difference chart.""" + + label: str + csv_name: str + color: str + marker: str + + +@dataclass(frozen=True) +class MetricRunDifferences: + """Ordered relative differences for one metric across reproducer runs.""" + + spec: MetricSpec + run_indices: tuple[int, ...] + percentages: tuple[float, ...] + + +class PlottingError(RuntimeError): + """Fatal run-difference plotting error.""" + + +class AllRunsCsv: + """Validated all_runs.csv source for one reproducer case.""" + + def __init__(self, case_dir: Path) -> None: + self.case_dir = case_dir + self.path = case_dir / "all_runs.csv" + + def run_differences(self) -> list[MetricRunDifferences]: + self._require_case_directory() + rows = self._rows() + self._require_roles(rows) + return [self._differences_for(metric, rows) for metric in METRICS] + + def _require_case_directory(self) -> None: + if not self.case_dir.is_dir(): + raise PlottingError(f"Case directory does not exist: {self.case_dir}") + if not self.path.is_file(): + raise PlottingError(f"Missing all_runs.csv: {self.path}") + + def _rows(self) -> list[dict[str, str]]: + with self.path.open(newline="", encoding="utf-8") as source: + reader = csv.DictReader(source) + if reader.fieldnames is None: + raise PlottingError(f"all_runs.csv is empty: {self.path}") + missing_required = [name for name in REQUIRED_COLUMNS if name not in reader.fieldnames] + if missing_required: + raise PlottingError( + f"all_runs.csv is missing required columns " + f"{', '.join(missing_required)}: {self.path}" + ) + for metric in METRICS: + if metric.csv_name not in reader.fieldnames: + raise PlottingError( + f"Missing metric column: {metric.csv_name}: {self.case_dir}" + ) + return list(reader) + + def _require_roles(self, rows: list[dict[str, str]]) -> None: + roles = {row.get("role", "") for row in rows} + for role in ROLES: + if role not in roles: + raise PlottingError(f"Missing role {role} in all_runs.csv: {self.case_dir}") + + def _differences_for( + self, + metric: MetricSpec, + rows: list[dict[str, str]], + ) -> MetricRunDifferences: + by_role = { + role: self._values_for(metric, role, rows) + for role in ROLES + } + baseline = by_role["baseline"] + variant = by_role["variant"] + self._require_matching_run_indices(metric, baseline, variant) + + run_indices = tuple(sorted(baseline)) + percentages = tuple( + self._relative_difference(metric, run_index, baseline[run_index], variant[run_index]) + for run_index in run_indices + ) + return MetricRunDifferences(metric, run_indices, percentages) + + def _values_for( + self, + metric: MetricSpec, + role: str, + rows: list[dict[str, str]], + ) -> dict[int, float]: + values: dict[int, float] = {} + for row_number, row in enumerate(rows, start=2): + if row.get("role") != role: + continue + + run_index = self._positive_run_index(row.get("run_index", ""), metric, role, row_number) + if run_index in values: + raise PlottingError( + f"Duplicate value for metric {metric.csv_name} " + f"role {role} at run {run_index}: {self.case_dir}" + ) + values[run_index] = self._finite_float(row[metric.csv_name], metric, role, run_index) + + if not values: + raise PlottingError( + f"Missing values for metric {metric.csv_name} role {role}: {self.case_dir}" + ) + return values + + def _positive_run_index( + self, + raw: str, + metric: MetricSpec, + role: str, + row_number: int, + ) -> int: + try: + value = int(raw) + except ValueError as error: + raise PlottingError( + f"Invalid run_index for metric {metric.csv_name} " + f"role {role} at CSV row {row_number}: {raw!r}: {self.case_dir}" + ) from error + if value < 1: + raise PlottingError( + f"Invalid run_index for metric {metric.csv_name} " + f"role {role} at CSV row {row_number}: {raw!r}: {self.case_dir}" + ) + return value + + def _finite_float(self, raw: str, metric: MetricSpec, role: str, run_index: int) -> float: + try: + value = float(raw) + except ValueError as error: + raise PlottingError( + f"Metric has non-numeric value for role {role} " + f"at run {run_index}: {metric.csv_name}: {self.case_dir}" + ) from error + if not math.isfinite(value): + raise PlottingError( + f"Metric has non-finite value for role {role} " + f"at run {run_index}: {metric.csv_name}: {self.case_dir}" + ) + return value + + def _require_matching_run_indices( + self, + metric: MetricSpec, + baseline: dict[int, float], + variant: dict[int, float], + ) -> None: + baseline_runs = set(baseline) + variant_runs = set(variant) + if baseline_runs != variant_runs: + raise PlottingError( + f"Run index mismatch for metric {metric.csv_name}: " + f"baseline={sorted(baseline_runs)}, variant={sorted(variant_runs)}: {self.case_dir}" + ) + + def _relative_difference( + self, + metric: MetricSpec, + run_index: int, + baseline_value: float, + variant_value: float, + ) -> float: + if baseline_value == 0.0: + raise PlottingError( + f"Cannot compute relative difference because baseline value is zero " + f"for metric {metric.csv_name} at run {run_index}: {self.case_dir}" + ) + return (variant_value - baseline_value) / baseline_value * 100.0 + + +class RunDifferencePlot: + """PDF line chart for per-run relative differences in one reproducer case.""" + + def __init__( + self, + case_dir: Path, + differences: list[MetricRunDifferences], + output: Path, + ) -> None: + self.case_dir = case_dir + self.differences = differences + self.output = output + + def save(self) -> None: + figure, axis = plt.subplots(figsize=(13.8, 7.2)) + + for difference in self.differences: + axis.plot( + difference.run_indices, + difference.percentages, + label=difference.spec.label, + color=difference.spec.color, + marker=difference.spec.marker, + linewidth=2.2, + markersize=6.8, + markeredgecolor="white", + markeredgewidth=1.1, + ) + + axis.axhline(0.0, color="#b8c2cc", linewidth=1.3) + axis.grid(axis="y", color="#e5eaef", linewidth=1.0) + axis.grid(axis="x", color="#edf2f7", linewidth=0.8) + axis.set_axisbelow(True) + axis.set_xlabel("Run index", fontsize=13) + axis.set_ylabel("Разница, %", fontsize=13) + axis.yaxis.set_major_formatter(FuncFormatter(lambda value, _: f"{value:.0f}%")) + axis.xaxis.set_major_locator(MaxNLocator(integer=True)) + axis.tick_params(axis="both", labelsize=11, colors="#4f6273") + axis.margins(x=0.02) + + for side in ("top", "right", "left", "bottom"): + axis.spines[side].set_visible(False) + + axis.set_ylim(*self._limits()) + axis.legend( + loc="upper left", + bbox_to_anchor=(1.02, 1.0), + frameon=False, + fontsize=12, + borderaxespad=0.0, + handlelength=2.6, + ) + + title = ( + f"{self.case_dir.name}\n" + "Разница в метриках между оригиналом " + "и изменённым вариантом " + "для каждого эксперимента" + ) + axis.set_title(title, fontsize=16, pad=18) + figure.subplots_adjust(left=0.08, right=0.78, top=0.84, bottom=0.13) + + self.output.parent.mkdir(parents=True, exist_ok=True) + figure.savefig(self.output, format="pdf", bbox_inches="tight") + plt.close(figure) + + def _limits(self) -> tuple[float, float]: + values = [ + value + for difference in self.differences + for value in difference.percentages + ] + minimum = min(values + [0.0]) + maximum = max(values + [0.0]) + span = maximum - minimum + if span == 0.0: + span = max(abs(maximum), 1.0) + + padding = max(span * 0.12, 1.0) + lower = minimum - padding + upper = maximum + padding + + if minimum >= 0.0: + lower = -padding + if maximum <= 0.0: + upper = padding + return lower, upper + + +METRICS = ( + MetricSpec("JMH score", "JMH primary score, us/op", "#3f7ee8", "o"), + MetricSpec("Allocations", "Allocations, B/op", "#dd7433", "o"), + MetricSpec("Instructions", "Instructions, #/op", "#249b68", "o"), + MetricSpec("Memory loads", "Memory loads, #/op", "#9b5de5", "o"), + MetricSpec("Memory stores", "Memory stores, #/op", "#d94f83", "o"), + MetricSpec("Native code size", "Native code size, B", "#8a6f3f", "o"), +) + + +def load_run_differences(case_dir: Path) -> list[MetricRunDifferences]: + return AllRunsCsv(case_dir).run_differences() + + +def plot_run_differences( + case_dir: Path, + differences: list[MetricRunDifferences], + output: Path, +) -> None: + RunDifferencePlot(case_dir, differences, output).save() + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Plot per-run relative differences for one reproducer case." + ) + parser.add_argument("case_dir", help="Path to one reproducer case directory.") + parser.add_argument( + "--output", + help="Output PDF path. Defaults to /run_difference.pdf.", + ) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + case_dir = Path(args.case_dir) + output = Path(args.output) if args.output else case_dir / "run_difference.pdf" + try: + if MATPLOTLIB_IMPORT_ERROR is not None: + raise PlottingError("Missing Python dependency: matplotlib") + differences = load_run_differences(case_dir) + plot_run_differences(case_dir, differences, output) + return 0 + except PlottingError as error: + print(str(error), file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) From 653a85c47a2e58a5c3b649c8e950f4b71c8dc2f3 Mon Sep 17 00:00:00 2001 From: Roman Korostinskiy <70313618+c71n93@users.noreply.github.com> Date: Fri, 22 May 2026 22:01:41 +0300 Subject: [PATCH 4/8] Add metric differences plotting script --- reproducer/README.md | 17 + reproducer/plotting/metric_difference.py | 553 +++++++++++++++++++++++ 2 files changed, 570 insertions(+) create mode 100644 reproducer/plotting/metric_difference.py diff --git a/reproducer/README.md b/reproducer/README.md index fdf1979..13c7568 100644 --- a/reproducer/README.md +++ b/reproducer/README.md @@ -92,3 +92,20 @@ reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_ The chart includes six per-run metrics: JMH score, allocations, instructions, memory loads, memory stores, and native code size. + +**Generate raw per-metric PDFs for one case:** + +```bash +python3 reproducer/plotting/metric_difference.py \ + reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop +``` + +By default this reads the case `all_runs.csv` and creates one PDF per metric +under: + +```text +reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop/metric_difference/ +``` + +The charts include six raw metrics: JMH score, allocations, instructions, +memory loads, memory stores, and native code size. diff --git a/reproducer/plotting/metric_difference.py b/reproducer/plotting/metric_difference.py new file mode 100644 index 0000000..02ceea9 --- /dev/null +++ b/reproducer/plotting/metric_difference.py @@ -0,0 +1,553 @@ +#!/usr/bin/env python3 +"""Raw per-run metric charts for one reproducer case.""" + +from __future__ import annotations + +import argparse +import csv +import math +import os +import statistics +import sys +import tempfile +import textwrap +from collections import Counter +from dataclasses import dataclass +from pathlib import Path +from typing import ClassVar + +MATPLOTLIB_CACHE = Path(tempfile.gettempdir()) / "comparator-matplotlib" +MATPLOTLIB_CACHE.mkdir(parents=True, exist_ok=True) +os.environ.setdefault("MPLCONFIGDIR", str(MATPLOTLIB_CACHE)) +os.environ.setdefault("XDG_CACHE_HOME", str(MATPLOTLIB_CACHE / "xdg")) + +try: + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + from matplotlib.ticker import FuncFormatter, MaxNLocator +except ModuleNotFoundError as error: + MATPLOTLIB_IMPORT_ERROR: ModuleNotFoundError | None = error +else: + MATPLOTLIB_IMPORT_ERROR = None + + +REQUIRED_COLUMNS = ("role", "run_index") +ROLES = ("baseline", "variant") +ROLE_LABELS = {"baseline": "orig", "variant": "ref"} + + +class PlottingError(RuntimeError): + """Fatal raw metric plotting error.""" + + +@dataclass(frozen=True) +class MetricSpec: + """Fixed reproducer metric included in raw per-run charts.""" + + label: str + csv_name: str + y_label: str + output_name: str + value_kind: str + + +@dataclass(frozen=True) +class RoleSeries: + """Ordered raw values for one metric role.""" + + role: str + run_indices: tuple[int, ...] + values: tuple[float, ...] + + @property + def label(self) -> str: + return ROLE_LABELS[self.role] + + @property + def by_run_index(self) -> dict[int, float]: + return dict(zip(self.run_indices, self.values)) + + +@dataclass(frozen=True) +class MetricSeries: + """Raw baseline and variant series for one reproducer metric.""" + + spec: MetricSpec + baseline: RoleSeries + variant: RoleSeries + + @property + def run_indices(self) -> tuple[int, ...]: + return self.baseline.run_indices + + @property + def roles(self) -> tuple[RoleSeries, RoleSeries]: + return self.baseline, self.variant + + +@dataclass(frozen=True) +class MetricStatistics: + """Calculated stability summary for one metric role.""" + + spec: MetricSpec + series: RoleSeries + count: int + mean: float + stdev: float + cv_percent: float + value_range: float + distinct_values_count: int + frequency: tuple[tuple[float, int], ...] + MAX_FULL_FREQUENCY_ITEMS: ClassVar[int] = 12 + + @classmethod + def from_series( + cls, + spec: MetricSpec, + series: RoleSeries, + case_dir: Path, + ) -> MetricStatistics: + values = list(series.values) + mean = statistics.mean(values) + if mean == 0.0: + raise PlottingError( + f"Cannot compute CV because mean is zero for metric {spec.csv_name} " + f"role {series.role}: {case_dir}" + ) + stdev = statistics.stdev(values) if len(values) > 1 else 0.0 + counts = Counter(values) + return cls( + spec=spec, + series=series, + count=len(values), + mean=mean, + stdev=stdev, + cv_percent=stdev / mean * 100.0, + value_range=max(values) - min(values), + distinct_values_count=len(counts), + frequency=tuple(sorted(counts.items(), key=lambda item: item[0])), + ) + + def panel_text(self) -> str: + formatter = MetricValueFormatter(self.spec) + return "\n".join( + ( + self.series.label, + f"CV: {self.cv_percent:.2f}%", + f"Range: {formatter.with_unit(self.value_range)}", + f"Distinct values: {self.distinct_values_count}", + f"Mean: {formatter.with_unit(self.mean)}", + f"Freq: {self._frequency_text(formatter)}", + ) + ) + + def _frequency_text(self, formatter: MetricValueFormatter) -> str: + if len(self.frequency) > self.MAX_FULL_FREQUENCY_ITEMS: + if all(count == 1 for _, count in self.frequency): + first = formatter.compact(self.frequency[0][0]) + last = formatter.compact(self.frequency[-1][0]) + return f"{len(self.frequency)} unique values ({first}..{last})" + return self._abbreviated_frequency_text(formatter) + items = [ + f"{formatter.compact(value)}x{count}" + for value, count in self.frequency + ] + return ", ".join(items) + + def _abbreviated_frequency_text(self, formatter: MetricValueFormatter) -> str: + head_size = 6 + tail_size = 3 + head = self.frequency[:head_size] + tail = self.frequency[-tail_size:] + omitted = len(self.frequency) - head_size - tail_size + head_text = [f"{formatter.compact(value)}x{count}" for value, count in head] + tail_text = [f"{formatter.compact(value)}x{count}" for value, count in tail] + return ", ".join([*head_text, f"... +{omitted} more", *tail_text]) + + +class MetricValueFormatter: + """Compact numeric formatter for one metric unit.""" + + SI_UNITS = ( + (1_000_000_000.0, "G"), + (1_000_000.0, "M"), + (1_000.0, "K"), + ) + + def __init__(self, spec: MetricSpec) -> None: + self.spec = spec + + def axis_tick(self, value: float) -> str: + number, suffix = self._scaled(value) + if self.spec.value_kind in ("bytes", "bytes_per_op"): + return f"{number}{suffix}B" + return f"{number}{suffix}" + + def with_unit(self, value: float) -> str: + number, suffix = self._scaled(value) + if self.spec.value_kind == "bytes": + return f"{number} {suffix}B" + if self.spec.value_kind == "bytes_per_op": + return f"{number} {suffix}B/op" + if self.spec.value_kind == "jmh": + return f"{number} us/op" + return f"{number} #/op" + + def compact(self, value: float) -> str: + number, suffix = self._scaled(value) + return f"{number}{suffix}" + + def _scaled(self, value: float) -> tuple[str, str]: + absolute = abs(value) + for threshold, suffix in self.SI_UNITS: + if absolute >= threshold: + return self._plain(value / threshold), suffix + return self._plain(value), "" + + def _plain(self, value: float) -> str: + if math.isclose(value, round(value), rel_tol=0.0, abs_tol=1e-9): + return str(int(round(value))) + formatted = f"{value:.4g}" + if "e" in formatted or "E" in formatted: + return formatted + return formatted.rstrip("0").rstrip(".") + + +class AllRunsCsv: + """Validated all_runs.csv source for one reproducer case.""" + + def __init__(self, case_dir: Path) -> None: + self.case_dir = case_dir + self.path = case_dir / "all_runs.csv" + + def metric_series(self) -> list[MetricSeries]: + self._require_case_directory() + rows, fieldnames = self._rows() + self._require_metric_columns(fieldnames) + self._require_roles(rows) + return [self._series_for(metric, rows) for metric in METRICS] + + def _require_case_directory(self) -> None: + if not self.case_dir.is_dir(): + raise PlottingError(f"Case directory does not exist: {self.case_dir}") + if not self.path.is_file(): + raise PlottingError(f"Missing all_runs.csv: {self.path}") + + def _rows(self) -> tuple[list[dict[str, str]], list[str]]: + with self.path.open(newline="", encoding="utf-8") as source: + reader = csv.DictReader(source) + if reader.fieldnames is None: + raise PlottingError(f"all_runs.csv is empty: {self.path}") + missing = [name for name in REQUIRED_COLUMNS if name not in reader.fieldnames] + if missing: + raise PlottingError( + f"all_runs.csv is missing required columns {', '.join(missing)}: {self.path}" + ) + return list(reader), list(reader.fieldnames) + + def _require_metric_columns(self, fieldnames: list[str]) -> None: + for metric in METRICS: + if metric.csv_name not in fieldnames: + raise PlottingError(f"Missing metric column: {metric.csv_name}: {self.case_dir}") + + def _require_roles(self, rows: list[dict[str, str]]) -> None: + roles = {row.get("role", "") for row in rows} + for role in ROLES: + if role not in roles: + raise PlottingError(f"Missing role {role} in all_runs.csv: {self.case_dir}") + + def _series_for(self, metric: MetricSpec, rows: list[dict[str, str]]) -> MetricSeries: + by_role = {role: self._role_series(metric, role, rows) for role in ROLES} + baseline = by_role["baseline"] + variant = by_role["variant"] + self._require_matching_run_indices(metric, baseline, variant) + return MetricSeries(metric, baseline, variant) + + def _role_series( + self, + metric: MetricSpec, + role: str, + rows: list[dict[str, str]], + ) -> RoleSeries: + values: dict[int, float] = {} + for row_number, row in enumerate(rows, start=2): + if row.get("role") != role: + continue + run_index = self._positive_run_index(row.get("run_index", ""), metric, role, row_number) + if run_index in values: + raise PlottingError( + f"Duplicate value for metric {metric.csv_name} " + f"role {role} at run {run_index}: {self.case_dir}" + ) + values[run_index] = self._finite_float(row[metric.csv_name], metric, role, run_index) + + if not values: + raise PlottingError( + f"Missing values for metric {metric.csv_name} role {role}: {self.case_dir}" + ) + run_indices = tuple(sorted(values)) + return RoleSeries(role, run_indices, tuple(values[index] for index in run_indices)) + + def _positive_run_index( + self, + raw: str, + metric: MetricSpec, + role: str, + row_number: int, + ) -> int: + try: + value = int(raw) + except ValueError as error: + raise PlottingError( + f"Invalid run_index for metric {metric.csv_name} " + f"role {role} at CSV row {row_number}: {raw!r}: {self.case_dir}" + ) from error + if value < 1: + raise PlottingError( + f"Invalid run_index for metric {metric.csv_name} " + f"role {role} at CSV row {row_number}: {raw!r}: {self.case_dir}" + ) + return value + + def _finite_float(self, raw: str, metric: MetricSpec, role: str, run_index: int) -> float: + try: + value = float(raw) + except ValueError as error: + raise PlottingError( + f"Metric has non-numeric value for role {role} " + f"at run {run_index}: {metric.csv_name}: {self.case_dir}" + ) from error + if not math.isfinite(value): + raise PlottingError( + f"Metric has non-finite value for role {role} " + f"at run {run_index}: {metric.csv_name}: {self.case_dir}" + ) + return value + + def _require_matching_run_indices( + self, + metric: MetricSpec, + baseline: RoleSeries, + variant: RoleSeries, + ) -> None: + baseline_runs = set(baseline.run_indices) + variant_runs = set(variant.run_indices) + if baseline_runs != variant_runs: + raise PlottingError( + f"Run index mismatch for metric {metric.csv_name}: " + f"baseline={sorted(baseline_runs)}, variant={sorted(variant_runs)}: {self.case_dir}" + ) + + +class MetricDifferencePlot: + """PDF line chart for raw values of one reproducer metric.""" + + COLORS = {"baseline": "#3f7ee8", "variant": "#dd7433"} + MARKERS = {"baseline": "o", "variant": "s"} + + def __init__(self, case_dir: Path, metric: MetricSeries, output: Path) -> None: + self.case_dir = case_dir + self.metric = metric + self.output = output + + def save(self) -> None: + figure, axis = plt.subplots(figsize=(14.8, 7.6)) + formatter = MetricValueFormatter(self.metric.spec) + statistics_by_role = [ + MetricStatistics.from_series(self.metric.spec, series, self.case_dir) + for series in self.metric.roles + ] + + for series, stats in zip(self.metric.roles, statistics_by_role): + color = self.COLORS[series.role] + axis.plot( + series.run_indices, + series.values, + label=series.label, + color=color, + marker=self.MARKERS[series.role], + linewidth=2.2, + markersize=6.8, + markeredgecolor="white", + markeredgewidth=1.1, + ) + axis.axhline( + stats.mean, + color=color, + linestyle=(0, (4, 4)), + linewidth=1.6, + alpha=0.72, + ) + + axis.grid(axis="y", color="#e5eaef", linewidth=1.0) + axis.grid(axis="x", color="#edf2f7", linewidth=0.8) + axis.set_axisbelow(True) + axis.set_xlabel("Run index", fontsize=13) + axis.set_ylabel(self.metric.spec.y_label, fontsize=13) + axis.yaxis.set_major_formatter(FuncFormatter(lambda value, _: formatter.axis_tick(value))) + axis.xaxis.set_major_locator(MaxNLocator(integer=True)) + axis.tick_params(axis="both", labelsize=11, colors="#4f6273") + axis.margins(x=0.02) + + for side in ("top", "right", "left", "bottom"): + axis.spines[side].set_visible(False) + + axis.set_ylim(*self._limits()) + axis.legend( + loc="upper left", + bbox_to_anchor=(1.025, 1.0), + frameon=False, + fontsize=12, + borderaxespad=0.0, + handlelength=2.6, + ) + axis.text( + 1.025, + 0.84, + self._panel_text(statistics_by_role), + transform=axis.transAxes, + ha="left", + va="top", + fontsize=10.8, + color="#34495e", + linespacing=1.35, + bbox={ + "boxstyle": "round,pad=1.0", + "facecolor": "white", + "edgecolor": "#dce3eb", + "linewidth": 1.0, + }, + ) + + title = ( + f"{self.case_dir.name}\n" + f"Значение метрики \"{self.metric.spec.label}\" для каждого эксперимента" + ) + axis.set_title(title, fontsize=16, pad=18) + figure.subplots_adjust(left=0.08, right=0.72, top=0.84, bottom=0.13) + + self.output.parent.mkdir(parents=True, exist_ok=True) + figure.savefig(self.output, format="pdf", bbox_inches="tight") + plt.close(figure) + + def _limits(self) -> tuple[float, float]: + values = [value for series in self.metric.roles for value in series.values] + minimum = min(values) + maximum = max(values) + span = maximum - minimum + if span == 0.0: + span = max(abs(maximum), 1.0) + padding = span * 0.10 + return minimum - padding, maximum + padding + + def _panel_text(self, statistics_by_role: list[MetricStatistics]) -> str: + sections = [stats.panel_text() for stats in statistics_by_role] + wrapped = [self._wrap_frequency(section) for section in sections] + return "\n\n".join(wrapped) + + def _wrap_frequency(self, section: str) -> str: + lines = [] + for line in section.splitlines(): + if not line.startswith("Freq: "): + lines.append(line) + continue + wrapped = textwrap.wrap( + line, + width=38, + subsequent_indent=" ", + break_long_words=False, + break_on_hyphens=False, + ) + lines.extend(wrapped) + return "\n".join(lines) + + +METRICS = ( + MetricSpec( + "JMH score", + "JMH primary score, us/op", + "JMH score, us/op", + "jmh_score_by_run.pdf", + "jmh", + ), + MetricSpec( + "Allocations", + "Allocations, B/op", + "Allocations, B/op", + "allocations_by_run.pdf", + "bytes_per_op", + ), + MetricSpec( + "Instructions", + "Instructions, #/op", + "Instructions, #/op", + "instructions_by_run.pdf", + "number_per_op", + ), + MetricSpec( + "Memory loads", + "Memory loads, #/op", + "Memory loads, #/op", + "memory_loads_by_run.pdf", + "number_per_op", + ), + MetricSpec( + "Memory stores", + "Memory stores, #/op", + "Memory stores, #/op", + "memory_stores_by_run.pdf", + "number_per_op", + ), + MetricSpec( + "Native code size", + "Native code size, B", + "Native code size, B", + "native_code_size_by_run.pdf", + "bytes", + ), +) + + +def load_metric_series(case_dir: Path) -> list[MetricSeries]: + return AllRunsCsv(case_dir).metric_series() + + +def plot_metric(case_dir: Path, metric: MetricSeries, output: Path) -> None: + MetricDifferencePlot(case_dir, metric, output).save() + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Plot raw per-run metric values for one reproducer case." + ) + parser.add_argument("case_dir", help="Path to one reproducer case directory.") + parser.add_argument( + "--output-dir", + help="Output directory. Defaults to /metric_difference/.", + ) + return parser.parse_args() + + +def main() -> int: + args = parse_args() + case_dir = Path(args.case_dir) + output_dir = Path(args.output_dir) if args.output_dir else case_dir / "metric_difference" + try: + if MATPLOTLIB_IMPORT_ERROR is not None: + raise PlottingError("Missing Python dependency: matplotlib") + metrics = load_metric_series(case_dir) + for metric in metrics: + for series in metric.roles: + MetricStatistics.from_series(metric.spec, series, case_dir) + for metric in metrics: + plot_metric(case_dir, metric, output_dir / metric.spec.output_name) + return 0 + except PlottingError as error: + print(str(error), file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) From b1108383565eb1ccf09df96abdc9cdd81dd30f3c Mon Sep 17 00:00:00 2001 From: Roman Korostinskiy <70313618+c71n93@users.noreply.github.com> Date: Sat, 23 May 2026 18:26:18 +0300 Subject: [PATCH 5/8] Edit reproducer README --- reproducer/README.md | 24 +++++++++++++----- .../plotting/examples/mean_difference.png | Bin 0 -> 52404 bytes .../examples/native_code_size_by_run.png | Bin 0 -> 77815 bytes .../plotting/examples/run_difference.png | Bin 0 -> 122290 bytes 4 files changed, 18 insertions(+), 6 deletions(-) create mode 100644 reproducer/plotting/examples/mean_difference.png create mode 100644 reproducer/plotting/examples/native_code_size_by_run.png create mode 100644 reproducer/plotting/examples/run_difference.png diff --git a/reproducer/README.md b/reproducer/README.md index 13c7568..e7a870f 100644 --- a/reproducer/README.md +++ b/reproducer/README.md @@ -65,15 +65,19 @@ Important files: ```bash python3 reproducer/plotting/mean_difference.py \ - reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop + reproducer/runs/example-session/cases/example-case ``` By default this reads the case `summary.csv` and creates: ```text -reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop/mean_difference.pdf +reproducer/runs/example-session/cases/example-case/mean_difference.pdf ``` +Example plot: + +![Mean difference plot](plotting/examples/mean_difference.png) + The chart includes five aggregated metrics: JMH score, allocations, instructions, memory loads, and memory stores. @@ -81,15 +85,19 @@ instructions, memory loads, and memory stores. ```bash python3 reproducer/plotting/run_difference.py \ - reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop + reproducer/runs/example-session/cases/example-case ``` By default this reads the case `all_runs.csv` and creates: ```text -reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop/run_difference.pdf +reproducer/runs/example-session/cases/example-case/run_difference.pdf ``` +Example plot: + +![Run difference plot](plotting/examples/run_difference.png) + The chart includes six per-run metrics: JMH score, allocations, instructions, memory loads, memory stores, and native code size. @@ -97,15 +105,19 @@ memory loads, memory stores, and native code size. ```bash python3 reproducer/plotting/metric_difference.py \ - reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop + reproducer/runs/example-session/cases/example-case ``` By default this reads the case `all_runs.csv` and creates one PDF per metric under: ```text -reproducer/runs/test-run/20260522_165213/cases/case01_use_string_builder_concat_loop/metric_difference/ +reproducer/runs/example-session/cases/example-case/metric_difference/ ``` +Example plot: + +![Native code size by run plot](plotting/examples/native_code_size_by_run.png) + The charts include six raw metrics: JMH score, allocations, instructions, memory loads, memory stores, and native code size. diff --git a/reproducer/plotting/examples/mean_difference.png b/reproducer/plotting/examples/mean_difference.png new file mode 100644 index 0000000000000000000000000000000000000000..ebfb847ec6f121a1e089cfd4fcf307d38bd976cd GIT binary patch literal 52404 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 IHFQb%Ut$|-=Kufz literal 0 HcmV?d00001 diff --git a/reproducer/plotting/examples/native_code_size_by_run.png b/reproducer/plotting/examples/native_code_size_by_run.png new file mode 100644 index 0000000000000000000000000000000000000000..70a0530f8ae91ad439dde60427cbcaaef3dae90c GIT binary patch literal 77815 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 -}2w%T89_ryuj;BGD+1zofAx=7+z^0_%MBr=zug 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 rpk)bi7o|B?;`@VTLDa=lu|A^N`nyU{CI literal 0 HcmV?d00001 diff --git a/reproducer/plotting/examples/run_difference.png b/reproducer/plotting/examples/run_difference.png new file mode 100644 index 0000000000000000000000000000000000000000..cd6c34916cf7fcd80b54a4c3c2280bd216d61c53 GIT binary patch literal 122290 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�uHDR&4(0JnUS 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 e|K@jkK0$LfQ3 Date: Sat, 23 May 2026 21:32:47 +0300 Subject: [PATCH 6/8] Fix plots labels --- .../plotting/examples/mean_difference.png | Bin 52404 -> 83479 bytes .../examples/native_code_size_by_run.png | Bin 77815 -> 123673 bytes .../plotting/examples/run_difference.png | Bin 122290 -> 185974 bytes reproducer/plotting/mean_difference.py | 4 ++-- reproducer/plotting/metric_difference.py | 2 +- reproducer/plotting/run_difference.py | 8 ++++---- 6 files changed, 7 insertions(+), 7 deletions(-) diff --git a/reproducer/plotting/examples/mean_difference.png b/reproducer/plotting/examples/mean_difference.png index ebfb847ec6f121a1e089cfd4fcf307d38bd976cd..eb38d241d893669af3e41daa234035ff1f092cd4 100644 GIT binary patch literal 83479 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

`NBVBQ+=djzp%bxNL<~HgOC*Z{C7` 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 literal 52404 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 IHFQb%Ut$|-=Kufz diff --git a/reproducer/plotting/examples/native_code_size_by_run.png b/reproducer/plotting/examples/native_code_size_by_run.png index 70a0530f8ae91ad439dde60427cbcaaef3dae90c..a9b2fdf1719fa1be8003f4e50c199744dc364ff2 100644 GIT binary patch literal 123673 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�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%0DMo7U< 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 literal 77815 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 -}2w%T89_ryuj;BGD+1zofAx=7+z^0_%MBr=zug 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 rpk)bi7o|B?;`@VTLDa=lu|A^N`nyU{CI diff --git a/reproducer/plotting/examples/run_difference.png b/reproducer/plotting/examples/run_difference.png index cd6c34916cf7fcd80b54a4c3c2280bd216d61c53..62cfc5e54a0da98b1edca377ebece79569f9f487 100644 GIT binary patch literal 185974 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%0DSCLYN3dmA}t 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%0AlP;cYk7bB0cSwh=vM`t+qdQdq>YD$jfS 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 literal 122290 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�uHDR&4(0JnUS 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 e|K@jkK0$LfQ3 None: axis.axhline(0.0, color="#4f6273", linewidth=1.5) axis.grid(axis="y", color="#e5eaef", linewidth=1.0) axis.set_axisbelow(True) - axis.set_ylabel("Разница, %", fontsize=13) + axis.set_ylabel("Difference, %", fontsize=13) axis.set_xticks(x_positions) axis.set_xticklabels(labels, fontsize=11, fontweight="bold") axis.yaxis.set_major_formatter(FuncFormatter(lambda value, _: f"{value:.0f}%")) @@ -239,7 +239,7 @@ def save(self) -> None: count = self.summaries[0].count title = ( f"{self.case_dir.name}\n" - f"Разница в метриках между оригиналом и изменённым вариантом (N = {count})" + f"Metric difference between original and modified variant (N = {count})" ) axis.set_title(title, fontsize=16, pad=20) figure.subplots_adjust(left=0.08, right=0.99, top=0.82, bottom=0.24) diff --git a/reproducer/plotting/metric_difference.py b/reproducer/plotting/metric_difference.py index 02ceea9..61f5758 100644 --- a/reproducer/plotting/metric_difference.py +++ b/reproducer/plotting/metric_difference.py @@ -423,7 +423,7 @@ def save(self) -> None: title = ( f"{self.case_dir.name}\n" - f"Значение метрики \"{self.metric.spec.label}\" для каждого эксперимента" + f"Metric \"{self.metric.spec.label}\" value for each experiment" ) axis.set_title(title, fontsize=16, pad=18) figure.subplots_adjust(left=0.08, right=0.72, top=0.84, bottom=0.13) diff --git a/reproducer/plotting/run_difference.py b/reproducer/plotting/run_difference.py index b42bbf9..aa6d4a0 100644 --- a/reproducer/plotting/run_difference.py +++ b/reproducer/plotting/run_difference.py @@ -243,7 +243,7 @@ def save(self) -> None: axis.grid(axis="x", color="#edf2f7", linewidth=0.8) axis.set_axisbelow(True) axis.set_xlabel("Run index", fontsize=13) - axis.set_ylabel("Разница, %", fontsize=13) + axis.set_ylabel("Difference, %", fontsize=13) axis.yaxis.set_major_formatter(FuncFormatter(lambda value, _: f"{value:.0f}%")) axis.xaxis.set_major_locator(MaxNLocator(integer=True)) axis.tick_params(axis="both", labelsize=11, colors="#4f6273") @@ -264,9 +264,9 @@ def save(self) -> None: title = ( f"{self.case_dir.name}\n" - "Разница в метриках между оригиналом " - "и изменённым вариантом " - "для каждого эксперимента" + "Metric difference between original " + "and modified variant " + "for each experiment" ) axis.set_title(title, fontsize=16, pad=18) figure.subplots_adjust(left=0.08, right=0.78, top=0.84, bottom=0.13) From 87985116c25f1452dd52e5f1e6306511a18499a4 Mon Sep 17 00:00:00 2001 From: Roman Korostinskiy <70313618+c71n93@users.noreply.github.com> Date: Sat, 23 May 2026 22:23:15 +0300 Subject: [PATCH 7/8] Adapt old examples to new reproducer pipeline. Adapt reproducer to old examples. --- README.md | 57 +++++---- reproducer/README.md | 34 ++++- .../baseline/PrimitiveLoopExample.java | 9 +- .../indexed_loop/PrimitiveLoopExample.java | 4 +- .../plain_array/PrimitiveLoopExample.java | 8 +- .../replace_all/PrimitiveLoopExample.java | 13 +- .../stream_boxed/PrimitiveLoopExample.java | 14 +-- .../LoopComputationsStreamBoxedCase.java | 3 +- .../LoopComputationsStreamBoxedCase.java | 3 +- reproducer/run.py | 117 +++++++++++++----- reproducer/test_run.py | 28 ++++- src/main/java/comparator/Main.java | 45 ++++--- .../comparator/reproducer/ComparePairs.java | 10 +- .../reproducer/ComparisonManifest.java | 65 +++++----- .../comparator/reproducer/ManifestCase.java | 41 ++++++ .../comparator/reproducer/ManifestEntry.java | 4 +- .../comparator/reproducer/ManifestPair.java | 39 ------ .../reproducer/ComparisonManifestTest.java | 47 +++++-- 18 files changed, 344 insertions(+), 197 deletions(-) rename examples/loop-computations/PlainForReplaceAllExample.java => reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java (69%) rename examples/loop-computations/PlainForIndexedExample.java => reproducer/cases/case00_primitive_loop_examples/variants/indexed_loop/PrimitiveLoopExample.java (88%) rename examples/loop-computations/PlainForPlainArrayExample.java => reproducer/cases/case00_primitive_loop_examples/variants/plain_array/PrimitiveLoopExample.java (71%) rename examples/loop-computations/PlainForExample.java => reproducer/cases/case00_primitive_loop_examples/variants/replace_all/PrimitiveLoopExample.java (52%) rename examples/loop-computations/StreamBoxedExample.java => reproducer/cases/case00_primitive_loop_examples/variants/stream_boxed/PrimitiveLoopExample.java (51%) create mode 100644 src/main/java/comparator/reproducer/ManifestCase.java delete mode 100644 src/main/java/comparator/reproducer/ManifestPair.java diff --git a/README.md b/README.md index 1e30a44..e1f0eff 100644 --- a/README.md +++ b/README.md @@ -49,15 +49,19 @@ import comparator.Analysis; import comparator.method.TargetMethod; import java.nio.file.Path; -final Path classpath = Path.of("examples", "loop-computations"); -new Analysis(new TargetMethod(classpath, "PlainForExample", "run")) +final Path classpath = Path.of( + "reproducer", "cases", "case00_primitive_loop_examples", "baseline" +); +new Analysis(new TargetMethod(classpath, "PrimitiveLoopExample", "run")) .results() .print(System.out); ``` The classpath argument must point to a directory or JAR that contains compiled classes. -The `examples/` folders do not include `.class` files, so compile them before running the examples. +The `reproducer/cases/` folders do not include `.class` files, so compile the selected +case role before running API examples. For `case00_primitive_loop_examples`, each role +has its own classpath because all variants use the same `PrimitiveLoopExample` class name. ### Run an analysis with label @@ -66,9 +70,11 @@ import comparator.Analysis; import comparator.method.TargetMethod; import java.nio.file.Path; -final Path classpath = Path.of("examples", "loop-computations"); +final Path classpath = Path.of( + "reproducer", "cases", "case00_primitive_loop_examples", "baseline" +); new Analysis( - new TargetMethod(classpath, "PlainForExample", "run"), + new TargetMethod(classpath, "PrimitiveLoopExample", "run"), "baseline-for-loop" ).results().print(System.out); ``` @@ -85,17 +91,18 @@ import comparator.method.Classpath; import comparator.method.TargetMethod; import java.nio.file.Path; -final Classpath classpath = new Classpath(Path.of("examples", "loop-computations")); +final Path caseRoot = Path.of("reproducer", "cases", "case00_primitive_loop_examples"); +final Classpath baseline = new Classpath(caseRoot.resolve("baseline")); +final Classpath plainArray = new Classpath(caseRoot.resolve("variants").resolve("plain_array")); +final Classpath indexedLoop = new Classpath(caseRoot.resolve("variants").resolve("indexed_loop")); +final Classpath streamBoxed = new Classpath(caseRoot.resolve("variants").resolve("stream_boxed")); new CsvComparisons( new CsvComparison( - new Analysis(new TargetMethod(classpath, "PlainForExample", "run")), - new Analysis(new TargetMethod(classpath, "StreamBoxedExample", "run")), - new Analysis(new TargetMethod(classpath, "PlainForIndexedExample", "run")) - ), - new CsvComparison( - new Analysis(new TargetMethod(classpath, "PlainForExample", "run")), - new Analysis(new TargetMethod(classpath, "PlainForReplaceAllExample", "run")) + new Analysis(new TargetMethod(baseline, "PrimitiveLoopExample", "run"), "baseline"), + new Analysis(new TargetMethod(plainArray, "PrimitiveLoopExample", "run"), "plain_array"), + new Analysis(new TargetMethod(indexedLoop, "PrimitiveLoopExample", "run"), "indexed_loop"), + new Analysis(new TargetMethod(streamBoxed, "PrimitiveLoopExample", "run"), "stream_boxed") ) ).saveAsCsv(Path.of("comparisons.csv")); ``` @@ -104,28 +111,20 @@ new CsvComparisons( Example of `comparisons.csv` content in table form. File path columns are shortened for readability: -Comparison 1 - -| Target | JMH primary score, us/op | JMH primary score relative error, ratio | Allocations, B/op | Allocations relative error, ratio | Instructions, #/op | Memory loads, #/op | Memory stores, #/op | Native code size, B | JIT log file | JMH result file | JIT metrics mean dissimilarity score | JIT metrics max dissimilarity score | -| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | --- | --- | --- | -| PlainForExample::run | 22.09 | 0.10 | 38016.15 | 0.00 | 149402.64 | 43000.08 | 20805.29 | 2256.00 | `.../PlainForExample-jit-log-...xml` | `.../PlainForExample-jmh-result-...json` | Original | Original | -| PlainForPlainArrayExample::run | 4.55 | 0.11 | 8040.03 | 0.00 | 25719.34 | 3281.44 | 1151.00 | 1552.00 | `.../PlainForPlainArrayExample-jit-log-...xml` | `.../PlainForPlainArrayExample-jmh-result-...json` | 1.40 | 1.79 | -| PlainForIndexedExample::run | 25.64 | 0.12 | 38016.18 | 0.00 | 149624.24 | 41981.45 | 19787.82 | 1960.00 | `.../PlainForIndexedExample-jit-log-...xml` | `.../PlainForIndexedExample-jmh-result-...json` | 0.09 | 0.15 | - -Comparison 2 - | Target | JMH primary score, us/op | JMH primary score relative error, ratio | Allocations, B/op | Allocations relative error, ratio | Instructions, #/op | Memory loads, #/op | Memory stores, #/op | Native code size, B | JIT log file | JMH result file | JIT metrics mean dissimilarity score | JIT metrics max dissimilarity score | | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | --- | --- | --- | -| PlainForExample::run | 22.09 | 0.10 | 38016.15 | 0.00 | 149402.64 | 43000.08 | 20805.29 | 2256.00 | `.../PlainForExample-jit-log-...xml` | `.../PlainForExample-jmh-result-...json` | Original | Original | -| PlainForReplaceAllExample::run | 36.08 | 0.11 | 69952.25 | 0.00 | 240191.93 | 65149.11 | 32818.88 | 2336.00 | `.../PlainForReplaceAllExample-jit-log-...xml` | `.../PlainForReplaceAllExample-jmh-result-...json` | 0.44 | 0.59 | +| baseline | 22.09 | 0.10 | 38016.15 | 0.00 | 149402.64 | 43000.08 | 20805.29 | 2256.00 | `.../PrimitiveLoopExample-jit-log-...xml` | `.../PrimitiveLoopExample-jmh-result-...json` | Original | Original | +| plain_array | 4.55 | 0.11 | 8040.03 | 0.00 | 25719.34 | 3281.44 | 1151.00 | 1552.00 | `.../PrimitiveLoopExample-jit-log-...xml` | `.../PrimitiveLoopExample-jmh-result-...json` | 1.40 | 1.79 | +| indexed_loop | 25.64 | 0.12 | 38016.18 | 0.00 | 149624.24 | 41981.45 | 19787.82 | 1960.00 | `.../PrimitiveLoopExample-jit-log-...xml` | `.../PrimitiveLoopExample-jmh-result-...json` | 0.09 | 0.15 | +| stream_boxed | 46.05 | 0.10 | 70232.32 | 0.00 | 243005.89 | 74453.67 | 32071.86 | 3528.00 | `.../PrimitiveLoopExample-jit-log-...xml` | `.../PrimitiveLoopExample-jmh-result-...json` | 0.54 | 0.70 | ### Labeled comparison example ```java new CsvComparisons( new CsvComparison( - new Analysis(new TargetMethod(classpath, "PlainForExample", "run"), "Baseline"), - new Analysis(new TargetMethod(classpath, "StreamBoxedExample", "run"), "Stream") + new Analysis(new TargetMethod(baseline, "PrimitiveLoopExample", "run"), "Baseline"), + new Analysis(new TargetMethod(streamBoxed, "PrimitiveLoopExample", "run"), "Stream") ) ).saveAsCsv(Path.of("labels-demo.csv")); ``` @@ -134,8 +133,8 @@ Example of `labels-demo.csv` content in table form: | Target | JMH primary score, us/op | JMH primary score relative error, ratio | Allocations, B/op | Allocations relative error, ratio | Instructions, #/op | Memory loads, #/op | Memory stores, #/op | Native code size, B | JIT log file | JMH result file | JIT metrics mean dissimilarity score | JIT metrics max dissimilarity score | | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | --- | --- | --- | -| Baseline | 22.09 | 0.10 | 38016.15 | 0.00 | 149402.64 | 43000.08 | 20805.29 | 2256.00 | `.../PlainForExample-jit-log-...xml` | `.../PlainForExample-jmh-result-...json` | Original | Original | -| Stream | 46.05 | 0.10 | 70232.32 | 0.00 | 243005.89 | 74453.67 | 32071.86 | 3528.00 | `.../StreamBoxedExample-jit-log-...xml` | `.../StreamBoxedExample-jmh-result-...json` | 0.54 | 0.70 | +| Baseline | 22.09 | 0.10 | 38016.15 | 0.00 | 149402.64 | 43000.08 | 20805.29 | 2256.00 | `.../PrimitiveLoopExample-jit-log-...xml` | `.../PrimitiveLoopExample-jmh-result-...json` | Original | Original | +| Stream | 46.05 | 0.10 | 70232.32 | 0.00 | 243005.89 | 74453.67 | 32071.86 | 3528.00 | `.../PrimitiveLoopExample-jit-log-...xml` | `.../PrimitiveLoopExample-jmh-result-...json` | 0.54 | 0.70 | ## Comparison metrics diff --git a/reproducer/README.md b/reproducer/README.md index e7a870f..7f28f09 100644 --- a/reproducer/README.md +++ b/reproducer/README.md @@ -1,7 +1,9 @@ # Reproducer The reproducer runs curated JIT instability cases from `reproducer/cases`. -Each case contains a `baseline` Java source and an equivalent `variant` Java source. +Each case contains a `baseline` Java source and one or more equivalent variant +Java sources. Existing single-variant cases may use `variant/`; multi-variant +cases use `variants//`. It can: @@ -35,6 +37,12 @@ Run selected cases by prefix: python3 reproducer/run.py --runs 3 --include-cases case01,case03 ``` +Run the primitive loop demonstration case: + +```bash +python3 reproducer/run.py --runs 3 --include-cases case00 +``` + Useful options: - `--runs N` - required number of whole-case repeats; @@ -43,6 +51,30 @@ Useful options: - `--cases-root PATH` - custom cases directory; - `--runs-root PATH` - custom output directory. +## Case layout + +Single-variant cases can use the compatibility layout: + +```text +case01_example/ + baseline/Example.java + variant/Example.java +``` + +Multi-variant cases use named variant roles: + +```text +case00_primitive_loop_examples/ + baseline/PrimitiveLoopExample.java + variants/plain_array/PrimitiveLoopExample.java + variants/indexed_loop/PrimitiveLoopExample.java + variants/replace_all/PrimitiveLoopExample.java + variants/stream_boxed/PrimitiveLoopExample.java +``` + +Each role must contain exactly one package-less Java source with the same file +name as the baseline and a static no-argument `run` method. + ## Output Each run creates a session under `reproducer/runs/` and updates diff --git a/examples/loop-computations/PlainForReplaceAllExample.java b/reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java similarity index 69% rename from examples/loop-computations/PlainForReplaceAllExample.java rename to reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java index f356f7e..3e98954 100644 --- a/examples/loop-computations/PlainForReplaceAllExample.java +++ b/reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java @@ -1,12 +1,12 @@ import java.util.ArrayList; import java.util.List; -public class PlainForReplaceAllExample { +public class PrimitiveLoopExample { private static final int N = 2_000; private static int compute(final int x) { int y = x * 31; - y ^= (y >>> 16); + y ^= y >>> 16; return y + 7; } @@ -15,10 +15,9 @@ public static long run() { for (int i = 0; i < N; i++) { list.add(i); } - list.replaceAll(PlainForReplaceAllExample::compute); long sum = 0; - for (int v : list) { - sum += v; + for (final int value : list) { + sum += compute(value); } return sum; } diff --git a/examples/loop-computations/PlainForIndexedExample.java b/reproducer/cases/case00_primitive_loop_examples/variants/indexed_loop/PrimitiveLoopExample.java similarity index 88% rename from examples/loop-computations/PlainForIndexedExample.java rename to reproducer/cases/case00_primitive_loop_examples/variants/indexed_loop/PrimitiveLoopExample.java index a9292f6..da2b142 100644 --- a/examples/loop-computations/PlainForIndexedExample.java +++ b/reproducer/cases/case00_primitive_loop_examples/variants/indexed_loop/PrimitiveLoopExample.java @@ -1,12 +1,12 @@ import java.util.ArrayList; import java.util.List; -public class PlainForIndexedExample { +public class PrimitiveLoopExample { private static final int N = 2_000; private static int compute(final int x) { int y = x * 31; - y ^= (y >>> 16); + y ^= y >>> 16; return y + 7; } diff --git a/examples/loop-computations/PlainForPlainArrayExample.java b/reproducer/cases/case00_primitive_loop_examples/variants/plain_array/PrimitiveLoopExample.java similarity index 71% rename from examples/loop-computations/PlainForPlainArrayExample.java rename to reproducer/cases/case00_primitive_loop_examples/variants/plain_array/PrimitiveLoopExample.java index 26fdae9..119b247 100644 --- a/examples/loop-computations/PlainForPlainArrayExample.java +++ b/reproducer/cases/case00_primitive_loop_examples/variants/plain_array/PrimitiveLoopExample.java @@ -1,9 +1,9 @@ -public class PlainForPlainArrayExample { +public class PrimitiveLoopExample { private static final int N = 2_000; private static int compute(final int x) { int y = x * 31; - y ^= (y >>> 16); + y ^= y >>> 16; return y + 7; } @@ -13,8 +13,8 @@ public static long run() { values[i] = i; } long sum = 0; - for (final int v : values) { - sum += compute(v); + for (final int value : values) { + sum += compute(value); } return sum; } diff --git a/examples/loop-computations/PlainForExample.java b/reproducer/cases/case00_primitive_loop_examples/variants/replace_all/PrimitiveLoopExample.java similarity index 52% rename from examples/loop-computations/PlainForExample.java rename to reproducer/cases/case00_primitive_loop_examples/variants/replace_all/PrimitiveLoopExample.java index 33ba69f..d2fd52d 100644 --- a/examples/loop-computations/PlainForExample.java +++ b/reproducer/cases/case00_primitive_loop_examples/variants/replace_all/PrimitiveLoopExample.java @@ -1,23 +1,24 @@ import java.util.ArrayList; import java.util.List; -public class PlainForExample { +public class PrimitiveLoopExample { private static final int N = 2_000; - private static int compute(int x) { + private static int compute(final int x) { int y = x * 31; - y ^= (y >>> 16); + y ^= y >>> 16; return y + 7; } public static long run() { - List list = new ArrayList<>(N); + final List list = new ArrayList<>(N); for (int i = 0; i < N; i++) { list.add(i); } + list.replaceAll(PrimitiveLoopExample::compute); long sum = 0; - for (int v : list) { - sum += compute(v); + for (final int value : list) { + sum += value; } return sum; } diff --git a/examples/loop-computations/StreamBoxedExample.java b/reproducer/cases/case00_primitive_loop_examples/variants/stream_boxed/PrimitiveLoopExample.java similarity index 51% rename from examples/loop-computations/StreamBoxedExample.java rename to reproducer/cases/case00_primitive_loop_examples/variants/stream_boxed/PrimitiveLoopExample.java index fa050f1..983e546 100644 --- a/examples/loop-computations/StreamBoxedExample.java +++ b/reproducer/cases/case00_primitive_loop_examples/variants/stream_boxed/PrimitiveLoopExample.java @@ -1,23 +1,23 @@ import java.util.ArrayList; import java.util.List; -public class StreamBoxedExample { +public class PrimitiveLoopExample { private static final int N = 2_000; - private static int compute(int x) { + private static int compute(final int x) { int y = x * 31; - y ^= (y >>> 16); + y ^= y >>> 16; return y + 7; } public static long run() { - List list = new ArrayList<>(N); + final List list = new ArrayList<>(N); for (int i = 0; i < N; i++) { list.add(i); } return list.stream() - .map(x -> compute(x)) - .mapToLong(Integer::longValue) - .sum(); + .map(PrimitiveLoopExample::compute) + .mapToLong(Integer::longValue) + .sum(); } } diff --git a/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java b/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java index 4aafd91..2e79b48 100644 --- a/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java +++ b/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java @@ -1,7 +1,6 @@ /* * Mechanism: plain counted loop vs boxed stream pipeline. - * External provenance: compiler-comparator/examples/loop-computations/ - * PlainForExample.java -> StreamBoxedExample.java. + * External provenance: case00_primitive_loop_examples baseline -> stream_boxed. * Hypothesis: replacing a direct accumulation loop with a boxed stream * pipeline adds enough library and lambda machinery to change the optimized * code shape in a compact, easy-to-explain control example. diff --git a/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java b/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java index 763bc84..b1a1c5a 100644 --- a/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java +++ b/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java @@ -1,7 +1,6 @@ /* * Mechanism: plain counted loop vs boxed stream pipeline. - * External provenance: compiler-comparator/examples/loop-computations/ - * PlainForExample.java -> StreamBoxedExample.java. + * External provenance: case00_primitive_loop_examples baseline -> stream_boxed. * Hypothesis: replacing a direct accumulation loop with a boxed stream * pipeline adds enough library and lambda machinery to change the optimized * code shape in a compact, easy-to-explain control example. diff --git a/reproducer/run.py b/reproducer/run.py index df446a8..56a5274 100644 --- a/reproducer/run.py +++ b/reproducer/run.py @@ -31,15 +31,26 @@ @dataclass(frozen=True) -class Case: +class CaseVariant: + """Variant source for one reproducer case role.""" + + role: str + source: Path + + +@dataclass(frozen=True) +class Case: """Curated reproducer case.""" case_id: str baseline_source: Path - variant_source: Path + variants: tuple[CaseVariant, ...] class_name: str method_name: str = "run" + def roles(self) -> list[str]: + return ["baseline"] + [variant.role for variant in self.variants] + class ReproducerError(RuntimeError): """Fatal reproducer error.""" @@ -151,12 +162,50 @@ def discover_cases(cases_root: Path) -> list[Case]: def case_from_directory(path: Path) -> Case: baseline = single_java_file(path / "baseline", path.name, "baseline") - variant = single_java_file(path / "variant", path.name, "variant") - if baseline.name != variant.name: - raise ReproducerError(f"Baseline and variant class names differ in {path.name}") + variants = variant_sources(path, baseline.name) source_contract(baseline) - source_contract(variant) - return Case(path.name, baseline, variant, baseline.stem) + for variant in variants: + source_contract(variant.source) + return Case(path.name, baseline, tuple(variants), baseline.stem) + + +def variant_sources(case_root: Path, baseline_name: str) -> list[CaseVariant]: + variants: list[CaseVariant] = [] + legacy = case_root / "variant" + if legacy.exists(): + variants.append(CaseVariant("variant", matching_java_file(legacy, case_root.name, "variant", baseline_name))) + modern = case_root / "variants" + if modern.exists(): + if not modern.is_dir(): + raise ReproducerError(f"Case {case_root.name} variants path is not a directory: {modern}") + for role_dir in sorted(path for path in modern.iterdir() if path.is_dir()): + role = role_dir.name + require_role(role, case_root.name) + variants.append( + CaseVariant(role, matching_java_file(role_dir, case_root.name, role, baseline_name)) + ) + if not variants: + raise ReproducerError(f"Case {case_root.name} must contain variant/ or variants// directories") + roles = [variant.role for variant in variants] + if len(roles) != len(set(roles)): + raise ReproducerError(f"Case {case_root.name} contains duplicate variant roles: {','.join(roles)}") + return variants + + +def matching_java_file(directory: Path, case_id: str, role: str, baseline_name: str) -> Path: + source = single_java_file(directory, case_id, role) + if source.name != baseline_name: + raise ReproducerError( + f"Case {case_id} role {role} class file must match baseline file name: {baseline_name}" + ) + return source + + +def require_role(role: str, case_id: str) -> None: + if not re.fullmatch(r"[a-z][a-z0-9_]*", role): + raise ReproducerError(f"Case {case_id} variant role must be a lowercase identifier: {role}") + if role == "baseline": + raise ReproducerError(f"Case {case_id} variant role is reserved: {role}") def single_java_file(directory: Path, case_id: str, role: str) -> Path: @@ -278,7 +327,10 @@ def write_case_metadata(self) -> None: { "case_id": case.case_id, "baseline_source": str(case.baseline_source), - "variant_source": str(case.variant_source), + "variants": [ + {"role": variant.role, "source": str(variant.source)} + for variant in case.variants + ], "class_name": case.class_name, "method_name": case.method_name, "runs": self.runs, @@ -302,9 +354,14 @@ def run_once(self, case: Case, index: int, run_name: str, run_root: Path, runtim paths = RunPaths(run_root) try: log(f"Starting {case.case_id} {run_name}") - paths.create() - compile_source(case.baseline_source, paths.baseline_classes, case.class_name, "compile-baseline", paths) - compile_source(case.variant_source, paths.variant_classes, case.class_name, "compile-variant", paths) + paths.create(case.roles()) + compile_source( + case.baseline_source, paths.classes("baseline"), case.class_name, "compile-baseline", paths + ) + for variant in case.variants: + compile_source( + variant.source, paths.classes(variant.role), case.class_name, f"compile-{variant.role}", paths + ) write_manifest(case, paths) log(f"Starting comparison for {case.case_id} {run_name}") compare(case, paths, runtime_classpath, self.repo_root) @@ -366,19 +423,18 @@ def __init__(self, root: Path) -> None: self.logs = root / "logs" self.pairs = root / "pairs.csv" self.comparisons = root / "comparisons.csv" - self.baseline_classes = root / "classes" / "baseline" - self.variant_classes = root / "classes" / "variant" - self.baseline_artifacts = root / "artifacts" / "baseline" - self.variant_artifacts = root / "artifacts" / "variant" - - def create(self) -> None: - for directory in [ - self.baseline_classes, - self.variant_classes, - self.baseline_artifacts, - self.variant_artifacts, - self.logs, - ]: + + def classes(self, role: str) -> Path: + return self.root / "classes" / role + + def artifacts(self, role: str) -> Path: + return self.root / "artifacts" / role + + def create(self, roles: list[str]) -> None: + for role in roles: + self.classes(role).mkdir(parents=True, exist_ok=True) + self.artifacts(role).mkdir(parents=True, exist_ok=True) + for directory in [self.logs]: directory.mkdir(parents=True, exist_ok=True) @@ -395,10 +451,9 @@ def compile_source(source: Path, classes: Path, class_name: str, stage: str, pat def write_manifest(case: Case, paths: RunPaths) -> None: - rows = [ - manifest_row(case, "baseline", paths.baseline_classes, paths.baseline_artifacts), - manifest_row(case, "variant", paths.variant_classes, paths.variant_artifacts), - ] + rows = [manifest_row(case, "baseline", paths.classes("baseline"), paths.artifacts("baseline"))] + for variant in case.variants: + rows.append(manifest_row(case, variant.role, paths.classes(variant.role), paths.artifacts(variant.role))) write_csv(paths.pairs, MANIFEST_HEADER, rows) @@ -466,10 +521,8 @@ def aggregate_case(session_root: Path, sid: str, case: Case) -> None: def role_from_target(target: str) -> str: - if target.endswith("/baseline"): - return "baseline" - if target.endswith("/variant"): - return "variant" + if "/" in target: + return target.rsplit("/", maxsplit=1)[1] return "" diff --git a/reproducer/test_run.py b/reproducer/test_run.py index b1bdb6f..36f67fe 100644 --- a/reproducer/test_run.py +++ b/reproducer/test_run.py @@ -20,6 +20,21 @@ def test_discovers_one_valid_case(self) -> None: self.write_case(root / "case01_example") cases = run.discover_cases(root) self.assertEqual(["case01_example"], [case.case_id for case in cases]) + self.assertEqual(["variant"], [variant.role for variant in cases[0].variants]) + + def test_discovers_multi_variant_case(self) -> None: + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + case_root = root / "case00_example" + source = case_root / "baseline" / "Example.java" + source.parent.mkdir(parents=True) + source.write_text("class Example { public static int run() { return 1; } }", encoding="utf-8") + for role in ["plain_array", "stream_boxed"]: + variant = case_root / "variants" / role / "Example.java" + variant.parent.mkdir(parents=True) + variant.write_text("class Example { public static int run() { return 1; } }", encoding="utf-8") + cases = run.discover_cases(root) + self.assertEqual(["plain_array", "stream_boxed"], [variant.role for variant in cases[0].variants]) def test_rejects_multiple_baseline_sources(self) -> None: with tempfile.TemporaryDirectory() as directory: @@ -45,14 +60,22 @@ class AggregationTest(unittest.TestCase): def test_aggregates_synthetic_comparisons(self) -> None: with tempfile.TemporaryDirectory() as directory: root = Path(directory) - case = run.Case("case01_example", root / "baseline.java", root / "variant.java", "Example") + case = run.Case( + "case01_example", + root / "baseline.java", + ( + run.CaseVariant("variant", root / "variant.java"), + run.CaseVariant("stream_boxed", root / "stream_boxed.java"), + ), + "Example", + ) run_dir = root / "cases" / case.case_id / "runs" / "run-001" run_dir.mkdir(parents=True) self.write_comparisons(run_dir / "comparisons.csv") run.aggregate_case(root, "session01", case) all_rows = self.read_csv(root / "cases" / case.case_id / "all_runs.csv") summary_rows = self.read_csv(root / "cases" / case.case_id / "summary.csv") - self.assertEqual(["baseline", "variant"], [row["role"] for row in all_rows]) + self.assertEqual(["baseline", "variant", "stream_boxed"], [row["role"] for row in all_rows]) self.assertTrue(any(row["metric"] == "score" for row in summary_rows)) def test_writes_process_logs(self) -> None: @@ -69,6 +92,7 @@ def write_comparisons(self, path: Path) -> None: writer.writeheader() writer.writerow({"Target": "case01_example/baseline", "score": "1.0"}) writer.writerow({"Target": "case01_example/variant", "score": "2.0"}) + writer.writerow({"Target": "case01_example/stream_boxed", "score": "3.0"}) def read_csv(self, path: Path) -> list[dict[str, str]]: with path.open(newline="", encoding="utf-8") as stream: diff --git a/src/main/java/comparator/Main.java b/src/main/java/comparator/Main.java index 074cf25..f68960f 100644 --- a/src/main/java/comparator/Main.java +++ b/src/main/java/comparator/Main.java @@ -11,6 +11,15 @@ public final class Main { /** Run method. */ private static final String RUN_METHOD = "run"; + /** Case root. */ + private static final Path CASE_ROOT = Path.of("reproducer", "cases", "case00_primitive_loop_examples"); + + /** Class name. */ + private static final String CLASS_NAME = "PrimitiveLoopExample"; + + /** Variants directory. */ + private static final String VARIANTS = "variants"; + private Main() { // Intentionally empty. } @@ -21,29 +30,25 @@ private Main() { * @param args command line arguments */ public static void main(final String[] args) { - final Classpath loopComputationsClasspath = new Classpath(Path.of("examples", "loop-computations")); new CsvComparisons( new CsvComparison( - new Analysis( - new TargetMethod(loopComputationsClasspath, "PlainForExample", Main.RUN_METHOD) - ), - new Analysis( - new TargetMethod( - loopComputationsClasspath, "PlainForPlainArrayExample", Main.RUN_METHOD - ) - ), - new Analysis( - new TargetMethod(loopComputationsClasspath, "PlainForIndexedExample", Main.RUN_METHOD) - ), - new Analysis( - new TargetMethod( - loopComputationsClasspath, "PlainForReplaceAllExample", Main.RUN_METHOD - ) - ), - new Analysis( - new TargetMethod(loopComputationsClasspath, "StreamBoxedExample", Main.RUN_METHOD) - ) + Main.analysis(Main.CASE_ROOT.resolve("baseline"), "baseline"), + Main.analysis(Main.variant("plain_array"), "plain_array"), + Main.analysis(Main.variant("indexed_loop"), "indexed_loop"), + Main.analysis(Main.variant("replace_all"), "replace_all"), + Main.analysis(Main.variant("stream_boxed"), "stream_boxed") ) ).saveAsCsv(Path.of("comparisons.csv")); } + + private static Path variant(final String role) { + return Main.CASE_ROOT.resolve(Main.VARIANTS).resolve(role); + } + + private static Analysis analysis(final Path classpath, final String label) { + return new Analysis( + new TargetMethod(new Classpath(classpath), Main.CLASS_NAME, Main.RUN_METHOD), + label + ); + } } diff --git a/src/main/java/comparator/reproducer/ComparePairs.java b/src/main/java/comparator/reproducer/ComparePairs.java index 13b03a2..831334b 100644 --- a/src/main/java/comparator/reproducer/ComparePairs.java +++ b/src/main/java/comparator/reproducer/ComparePairs.java @@ -44,8 +44,8 @@ private void run(final ComparePairsOptions options) { Files.createDirectories(options.output().toAbsolutePath().getParent()); try (BufferedWriter writer = Files.newBufferedWriter(options.output(), StandardCharsets.UTF_8)) { boolean headerWritten = false; - for (final ManifestPair pair : ComparisonManifest.fromFile(options.manifest()).pairs().values()) { - headerWritten = this.writeComparison(pair, writer, headerWritten); + for (final ManifestCase comparison : ComparisonManifest.fromFile(options.manifest()).cases().values()) { + headerWritten = this.writeComparison(comparison, writer, headerWritten); } } } catch (final IOException exception) { @@ -53,12 +53,12 @@ private void run(final ComparePairsOptions options) { } } - private boolean writeComparison(final ManifestPair pair, final BufferedWriter writer, + private boolean writeComparison(final ManifestCase comparison, final BufferedWriter writer, final boolean headerWritten) throws IOException { final String csv = new CsvComparison( - this.analysis(pair.baseline()), - this.analysis(pair.variant()) + this.analysis(comparison.baseline()), + comparison.variants().stream().map(this::analysis).toList() ).asCsv(); final List lines = new BufferedReaderLines(csv).asList(); int start = 0; diff --git a/src/main/java/comparator/reproducer/ComparisonManifest.java b/src/main/java/comparator/reproducer/ComparisonManifest.java index b9eb916..ae86f68 100644 --- a/src/main/java/comparator/reproducer/ComparisonManifest.java +++ b/src/main/java/comparator/reproducer/ComparisonManifest.java @@ -5,20 +5,21 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; +import java.util.Collections; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; /** - * Strict CSV manifest of reproducer comparison pairs. + * Strict CSV manifest of reproducer comparison cases. */ @SuppressWarnings({ "PMD.ProhibitPublicStaticMethods", "PMD.CyclomaticComplexity" }) public final class ComparisonManifest { - /** Pairs grouped by case identifier. */ - private final Map pairs; + /** Cases grouped by case identifier. */ + private final Map cases; - private ComparisonManifest(final Map pairs) { - this.pairs = Map.copyOf(pairs); + private ComparisonManifest(final Map cases) { + this.cases = Collections.unmodifiableMap(new LinkedHashMap<>(cases)); } /** @@ -55,23 +56,23 @@ public static ComparisonManifest fromLines(final List lines) { if (!ManifestEntry.HEADER.equals(rows.get(0))) { throw new IllegalArgumentException("Manifest header must be exactly: " + ManifestEntry.HEADER); } - final Map grouped = new LinkedHashMap<>(); + final Map grouped = new LinkedHashMap<>(); rows.stream().skip(1).map(ManifestEntry::new).forEach(entry -> { - final MutablePair pair = grouped.computeIfAbsent(entry.caseId(), key -> new MutablePair()); + final MutableCase pair = grouped.computeIfAbsent(entry.caseId(), key -> new MutableCase()); pair.add(entry); }); return new ComparisonManifest(ComparisonManifest.freeze(grouped)); } /** - * @return case pairs + * @return manifest cases */ - public Map pairs() { - return this.pairs; + public Map cases() { + return this.cases; } - private static Map freeze(final Map grouped) { - final Map result = new LinkedHashMap<>(); + private static Map freeze(final Map grouped) { + final Map result = new LinkedHashMap<>(); grouped.forEach((caseId, pair) -> result.put(caseId, pair.freeze(caseId))); return result; } @@ -106,41 +107,41 @@ private static List parseCsvLine(final String line) { } /** - * Mutable pair under construction. + * Mutable case under construction. */ - private static final class MutablePair { + private static final class MutableCase { /** Baseline entry. */ private ManifestEntry baseline; - /** Variant entry. */ - private ManifestEntry variant; + /** Variant entries. */ + private final List variants = new ArrayList<>(0); + + /** Seen roles. */ + private final List roles = new ArrayList<>(0); private void add(final ManifestEntry entry) { + if (this.roles.contains(entry.role())) { + throw new IllegalArgumentException( + "Duplicate manifest role for case: " + entry.caseId() + "/" + + entry.role() + ); + } + this.roles.add(entry.role()); if ("baseline".equals(entry.role())) { - this.baseline = this.requireEmpty(this.baseline, entry); + this.baseline = entry; } else { - this.variant = this.requireEmpty(this.variant, entry); + this.variants.add(entry); } } - private ManifestPair freeze(final String caseId) { - if (this.baseline == null || this.variant == null) { + private ManifestCase freeze(final String caseId) { + if (this.baseline == null || this.variants.isEmpty()) { throw new IllegalArgumentException( - "Manifest case must contain one baseline and one variant: " + "Manifest case must contain one baseline and at least one variant: " + caseId ); } - return new ManifestPair(this.baseline, this.variant); - } - - private ManifestEntry requireEmpty(final ManifestEntry current, final ManifestEntry next) { - if (current != null) { - throw new IllegalArgumentException( - "Duplicate manifest role for case: " + next.caseId() + "/" - + next.role() - ); - } - return next; + return new ManifestCase(this.baseline, this.variants); } } } diff --git a/src/main/java/comparator/reproducer/ManifestCase.java b/src/main/java/comparator/reproducer/ManifestCase.java new file mode 100644 index 0000000..5d9e087 --- /dev/null +++ b/src/main/java/comparator/reproducer/ManifestCase.java @@ -0,0 +1,41 @@ +package comparator.reproducer; + +import java.util.List; + +/** + * Manifest entries for one reproducer case. + */ +public final class ManifestCase { + /** Baseline entry. */ + private final ManifestEntry baseline; + + /** Variant entries. */ + private final List variants; + + /** + * Ctor. + * + * @param baseline + * baseline entry + * @param variants + * variant entries + */ + public ManifestCase(final ManifestEntry baseline, final List variants) { + this.baseline = baseline; + this.variants = List.copyOf(variants); + } + + /** + * @return baseline entry + */ + public ManifestEntry baseline() { + return this.baseline; + } + + /** + * @return variant entries + */ + public List variants() { + return this.variants; + } +} diff --git a/src/main/java/comparator/reproducer/ManifestEntry.java b/src/main/java/comparator/reproducer/ManifestEntry.java index e30337e..2f787b9 100644 --- a/src/main/java/comparator/reproducer/ManifestEntry.java +++ b/src/main/java/comparator/reproducer/ManifestEntry.java @@ -126,8 +126,8 @@ public String label() { } private void validate() { - if (!"baseline".equals(this.role) && !"variant".equals(this.role)) { - throw new IllegalArgumentException("Manifest role must be baseline or variant: " + this.role); + if (!this.role.matches("[a-z][a-z0-9_]*")) { + throw new IllegalArgumentException("Manifest role must be a lowercase identifier: " + this.role); } if (!Files.isDirectory(this.classpath)) { throw new IllegalArgumentException("Manifest classpath must be an existing directory: " + this.classpath); diff --git a/src/main/java/comparator/reproducer/ManifestPair.java b/src/main/java/comparator/reproducer/ManifestPair.java deleted file mode 100644 index 7595f44..0000000 --- a/src/main/java/comparator/reproducer/ManifestPair.java +++ /dev/null @@ -1,39 +0,0 @@ -package comparator.reproducer; - -/** - * Baseline and variant manifest entries for one case. - */ -public final class ManifestPair { - /** Baseline entry. */ - private final ManifestEntry baseline; - - /** Variant entry. */ - private final ManifestEntry variant; - - /** - * Ctor. - * - * @param baseline - * baseline entry - * @param variant - * variant entry - */ - public ManifestPair(final ManifestEntry baseline, final ManifestEntry variant) { - this.baseline = baseline; - this.variant = variant; - } - - /** - * @return baseline entry - */ - public ManifestEntry baseline() { - return this.baseline; - } - - /** - * @return variant entry - */ - public ManifestEntry variant() { - return this.variant; - } -} diff --git a/src/test/java/comparator/reproducer/ComparisonManifestTest.java b/src/test/java/comparator/reproducer/ComparisonManifestTest.java index 3b73f0e..156e56e 100644 --- a/src/test/java/comparator/reproducer/ComparisonManifestTest.java +++ b/src/test/java/comparator/reproducer/ComparisonManifestTest.java @@ -10,22 +10,55 @@ /** Manifest parser contract tests. */ @SuppressWarnings("PMD.SignatureDeclareThrowsException") final class ComparisonManifestTest { + /** Target columns. */ + private static final String TARGET = ",Example,run,"; + @Test - void parsesValidBaselineVariantPair(@TempDir final Path tempDir) throws Exception { + void parsesValidBaselineVariantCase(@TempDir final Path tempDir) throws Exception { final Path baseline = Files.createDirectories(tempDir.resolve("baseline")); final Path variant = Files.createDirectories(tempDir.resolve("variant")); final ComparisonManifest manifest = ComparisonManifest.fromLines( List.of( String.join(",", ManifestEntry.HEADER), - "case01,baseline," + baseline + ",Example,run," + tempDir.resolve("baseline.xml") + "case01,baseline," + baseline + ComparisonManifestTest.TARGET + tempDir.resolve("baseline.xml") + "," + tempDir.resolve("baseline.json") + ",case01/baseline", - "case01,variant," + variant + ",Example,run," + tempDir.resolve("variant.xml") + "case01,variant," + variant + ComparisonManifestTest.TARGET + tempDir.resolve("variant.xml") + "," + tempDir.resolve("variant.json") + ",case01/variant" ) ); - final ManifestPair pair = manifest.pairs().get("case01"); - Assertions.assertEquals("case01/baseline", pair.baseline().label(), "Baseline label should be parsed"); - Assertions.assertEquals("case01/variant", pair.variant().label(), "Variant label should be parsed"); + final ManifestCase comparison = manifest.cases().get("case01"); + Assertions.assertEquals("case01/baseline", comparison.baseline().label(), "Baseline label should be parsed"); + Assertions.assertEquals( + "case01/variant", + comparison.variants().get(0).label(), + "Variant label should be parsed" + ); + } + + @Test + void parsesMultipleVariants(@TempDir final Path tempDir) throws Exception { + final Path baseline = Files.createDirectories(tempDir.resolve("baseline")); + final Path plainArray = Files.createDirectories(tempDir.resolve("plain_array")); + final Path streamBoxed = Files.createDirectories(tempDir.resolve("stream_boxed")); + final ComparisonManifest manifest = ComparisonManifest.fromLines( + List.of( + String.join(",", ManifestEntry.HEADER), + "case00,baseline," + baseline + ComparisonManifestTest.TARGET + tempDir.resolve("baseline.xml") + + "," + tempDir.resolve("baseline.json") + ",case00/baseline", + "case00,plain_array," + plainArray + ComparisonManifestTest.TARGET + tempDir.resolve("plain_array.xml") + + "," + tempDir.resolve("plain_array.json") + ",case00/plain_array", + "case00,stream_boxed," + streamBoxed + ComparisonManifestTest.TARGET + + tempDir.resolve("stream_boxed.xml") + + "," + tempDir.resolve("stream_boxed.json") + ",case00/stream_boxed" + ) + ); + final ManifestCase comparison = manifest.cases().get("case00"); + Assertions.assertEquals(2, comparison.variants().size(), "All variants should be parsed"); + Assertions.assertEquals( + List.of("plain_array", "stream_boxed"), + comparison.variants().stream().map(ManifestEntry::role).toList(), + "Variant roles should be preserved" + ); } @Test @@ -36,7 +69,7 @@ void rejectsMissingVariant(@TempDir final Path tempDir) throws Exception { () -> ComparisonManifest.fromLines( List.of( String.join(",", ManifestEntry.HEADER), - "case01,baseline," + baseline + ",Example,run," + tempDir.resolve("baseline.xml") + "case01,baseline," + baseline + ComparisonManifestTest.TARGET + tempDir.resolve("baseline.xml") + "," + tempDir.resolve("baseline.json") + ",case01/baseline" ) ), From a541ac7206a7c1bc429a70d7168433e028575681 Mon Sep 17 00:00:00 2001 From: Roman Korostinskiy <70313618+c71n93@users.noreply.github.com> Date: Sun, 24 May 2026 09:53:37 +0300 Subject: [PATCH 8/8] Fix case description --- .../baseline/PrimitiveLoopExample.java | 9 +++++++++ .../baseline/UseStringBuilderConcatCase.java | 3 ++- .../variant/UseStringBuilderConcatCase.java | 10 ---------- .../baseline/UseArraysStreamPrimitiveCase.java | 3 ++- .../variant/UseArraysStreamPrimitiveCase.java | 9 --------- .../baseline/MakeMethodFieldFinalCase.java | 7 ++++--- .../variant/MakeMethodFieldFinalCase.java | 9 --------- .../baseline/UseArraysStreamInlineBudgetCase.java | 8 ++++---- .../variant/UseArraysStreamInlineBudgetCase.java | 14 -------------- .../baseline/LoopComputationsStreamBoxedCase.java | 4 ++-- .../variant/LoopComputationsStreamBoxedCase.java | 11 ----------- 11 files changed, 23 insertions(+), 64 deletions(-) diff --git a/reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java b/reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java index 3e98954..09645c5 100644 --- a/reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java +++ b/reproducer/cases/case00_primitive_loop_examples/baseline/PrimitiveLoopExample.java @@ -1,3 +1,12 @@ +/* + * Mechanism: primitive loop control examples. + * Hypothesis: equivalent ways to build, traverse, and transform a small + * integer collection can produce different optimized code shapes even when + * they return the same result. + * Expected symptom: plain-array and indexed-loop variants should stay close to + * the baseline, while replaceAll and boxed-stream variants are expected to show + * larger instruction/load/store and native-code-size movement. + */ import java.util.ArrayList; import java.util.List; diff --git a/reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java b/reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java index b3a2f47..b81187d 100644 --- a/reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java +++ b/reproducer/cases/case01_use_string_builder_concat_loop/baseline/UseStringBuilderConcatCase.java @@ -4,7 +4,8 @@ * Hypothesis: replacing repeated string concatenation with an explicit * StringBuilder changes the optimized code shape enough that HotSpot does * not converge to the same machine code. - * Expected symptom: strong allocation drop and supporting counter drift. + * Expected symptom: allocation and supporting-counter drift in the + * StringBuilder variant. * Loop note: the outer run() loop is intentionally large enough to keep the * coarse comparator run comfortably above ~10 us/op. */ diff --git a/reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java b/reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java index c569625..eb572e8 100644 --- a/reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java +++ b/reproducer/cases/case01_use_string_builder_concat_loop/variant/UseStringBuilderConcatCase.java @@ -1,13 +1,3 @@ -/* - * Mechanism: use-string-builder. - * Aggregate provenance: FuzzInput09_PushDownAndConcat/1-use-string-builder. - * Hypothesis: replacing repeated string concatenation with an explicit - * StringBuilder changes the optimized code shape enough that HotSpot does - * not converge to the same machine code. - * Expected symptom: strong allocation drop and supporting counter drift. - * Loop note: the outer run() loop is intentionally large enough to keep the - * coarse comparator run comfortably above ~10 us/op. - */ public class UseStringBuilderConcatCase { private static int render(int seed) { StringBuilder text = new StringBuilder(); diff --git a/reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java b/reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java index ad67cd4..a60de86 100644 --- a/reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java +++ b/reproducer/cases/case02_use_arrays_stream_primitives/baseline/UseArraysStreamPrimitiveCase.java @@ -3,7 +3,8 @@ * Aggregate provenance: FuzzInput02_ArraysStreamAndBoxing/1-use-arrays-stream-3. * Hypothesis: switching from a boxed List stream to a primitive IntStream * changes the stream pipeline enough to perturb JIT counters. - * Expected symptom: visible instruction/load/store drift, not just JMH noise. + * Expected symptom: instruction/load/store drift in addition to any JMH score + * movement. * Loop note: the outer run() loop is intentionally large enough to keep the * coarse comparator run comfortably above ~10 us/op. */ diff --git a/reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java b/reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java index f6cc986..af34168 100644 --- a/reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java +++ b/reproducer/cases/case02_use_arrays_stream_primitives/variant/UseArraysStreamPrimitiveCase.java @@ -1,12 +1,3 @@ -/* - * Mechanism: use-arrays-stream. - * Aggregate provenance: FuzzInput02_ArraysStreamAndBoxing/1-use-arrays-stream-3. - * Hypothesis: switching from a boxed List stream to a primitive IntStream - * changes the stream pipeline enough to perturb JIT counters. - * Expected symptom: visible instruction/load/store drift, not just JMH noise. - * Loop note: the outer run() loop is intentionally large enough to keep the - * coarse comparator run comfortably above ~10 us/op. - */ import java.util.Arrays; public class UseArraysStreamPrimitiveCase { diff --git a/reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java b/reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java index 69166c9..42eb94a 100644 --- a/reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java +++ b/reproducer/cases/case03_make_method_field_final/baseline/MakeMethodFieldFinalCase.java @@ -1,9 +1,10 @@ /* * Mechanism: make-fields-and-variables-final. * Aggregate provenance: FuzzInput04_FieldMethod/1-make-fields-and-variables-final. - * Hypothesis: making the reflective Method field final lets the JIT treat the - * reference as stable and simplifies the reflective call path. - * Expected symptom: strong counter reduction and smaller generated code. + * Hypothesis: making the reflective Method field final gives HotSpot a more + * stable field shape around the reflective call path. + * Expected symptom: counter and generated-code-size movement in the final-field + * variant. * Loop note: the outer run() loop is intentionally large enough to keep the * coarse comparator run comfortably above ~10 us/op. */ diff --git a/reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java b/reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java index a2be046..d3c0a5d 100644 --- a/reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java +++ b/reproducer/cases/case03_make_method_field_final/variant/MakeMethodFieldFinalCase.java @@ -1,12 +1,3 @@ -/* - * Mechanism: make-fields-and-variables-final. - * Aggregate provenance: FuzzInput04_FieldMethod/1-make-fields-and-variables-final. - * Hypothesis: making the reflective Method field final lets the JIT treat the - * reference as stable and simplifies the reflective call path. - * Expected symptom: strong counter reduction and smaller generated code. - * Loop note: the outer run() loop is intentionally large enough to keep the - * coarse comparator run comfortably above ~10 us/op. - */ import java.lang.reflect.Method; public class MakeMethodFieldFinalCase { diff --git a/reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java b/reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java index 3b87e33..e222ddc 100644 --- a/reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java +++ b/reproducer/cases/case04_use_arrays_stream_inline_budget/baseline/UseArraysStreamInlineBudgetCase.java @@ -4,10 +4,10 @@ * 1-inline-method-1/2-use-arrays-stream. * Hypothesis: replacing one boxed stream count with Arrays.stream(new int[]) * should not destabilize unrelated helper inlining, but in practice it can - * change HotSpot's compile plan enough that the run1 -> run0 edge inlines in - * the parent shape and stops inlining in the variant. - * Expected symptom: strong instruction/load/store drift with much smaller JMH - * movement; the JIT log should show a run0 inlining divergence. + * change HotSpot's compile plan enough to perturb whether the run1 -> run0 + * edge is inlined. + * Expected symptom: instruction/load/store drift with smaller JMH movement; the + * JIT log may show a run0 inlining divergence. * Minimality note: runBody() preserves the original 100-iteration hot loop. * The outer run() loop only repeats that shape to keep the coarse comparator * above ~10 us/op without rebuilding the whole fuzzed class. diff --git a/reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java b/reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java index cb93f03..5e070ec 100644 --- a/reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java +++ b/reproducer/cases/case04_use_arrays_stream_inline_budget/variant/UseArraysStreamInlineBudgetCase.java @@ -1,17 +1,3 @@ -/* - * Mechanism: use-arrays-stream as an inlining-budget cliff. - * Aggregate provenance: FuzzInput05_MixedInlineArraysAndFinal/ - * 1-inline-method-1/2-use-arrays-stream. - * Hypothesis: replacing one boxed stream count with Arrays.stream(new int[]) - * should not destabilize unrelated helper inlining, but in practice it can - * change HotSpot's compile plan enough that the run1 -> run0 edge inlines in - * the parent shape and stops inlining in the variant. - * Expected symptom: strong instruction/load/store drift with much smaller JMH - * movement; the JIT log should show a run0 inlining divergence. - * Minimality note: runBody() preserves the original 100-iteration hot loop. - * The outer run() loop only repeats that shape to keep the coarse comparator - * above ~10 us/op without rebuilding the whole fuzzed class. - */ import java.util.Arrays; public class UseArraysStreamInlineBudgetCase { diff --git a/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java b/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java index 2e79b48..c7da068 100644 --- a/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java +++ b/reproducer/cases/case05_loop_computations_stream_boxed/baseline/LoopComputationsStreamBoxedCase.java @@ -4,8 +4,8 @@ * Hypothesis: replacing a direct accumulation loop with a boxed stream * pipeline adds enough library and lambda machinery to change the optimized * code shape in a compact, easy-to-explain control example. - * Expected symptom: higher JMH and supporting instruction/load/store drift in - * the stream version. + * Expected symptom: higher JMH score and supporting instruction/load/store + * drift in the stream version. * Minimality note: this is already the control example itself; only the class * name was unified so the comparator can treat the pair as one refactoring. */ diff --git a/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java b/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java index b1a1c5a..6799c94 100644 --- a/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java +++ b/reproducer/cases/case05_loop_computations_stream_boxed/variant/LoopComputationsStreamBoxedCase.java @@ -1,14 +1,3 @@ -/* - * Mechanism: plain counted loop vs boxed stream pipeline. - * External provenance: case00_primitive_loop_examples baseline -> stream_boxed. - * Hypothesis: replacing a direct accumulation loop with a boxed stream - * pipeline adds enough library and lambda machinery to change the optimized - * code shape in a compact, easy-to-explain control example. - * Expected symptom: higher JMH and supporting instruction/load/store drift in - * the stream version. - * Minimality note: this is already the control example itself; only the class - * name was unified so the comparator can treat the pair as one refactoring. - */ import java.util.ArrayList; import java.util.List;