images;
+
+ @Setup
+ public void setUp() {
+ images = IntStream.range(0, IMAGES)
+ .mapToObj(ImageBenchmarkFixtures::distinctImage)
+ .toList();
+ }
+
+ /**
+ * Renders the image-heavy document to PDF bytes.
+ *
+ * @param blackhole JMH sink
+ * @throws Exception if rendering fails
+ */
+ @Benchmark
+ public void renderImageDocument(Blackhole blackhole) throws Exception {
+ try (DocumentSession document = GraphCompose.document()
+ .pageSize(DocumentPageSize.A4)
+ .margin(DocumentInsets.of(28))
+ .create()) {
+ PageFlowBuilder flow = document.pageFlow().name("ImageBenchmark").spacing(8);
+ for (DocumentImageData image : images) {
+ // 60x33 pt -> ~120x66 px target at 144 DPI, i.e. <50% of the
+ // 360x200 native, so the cache builds a downscaled variant.
+ flow.addImage(spec -> spec.source(image).size(60, 33));
+ }
+ flow.build();
+ blackhole.consume(document.toPdfBytes());
+ }
+ }
+
+ /**
+ * Runs the JMH harness over this benchmark.
+ *
+ * @param args JMH CLI arguments
+ * @throws Exception if the JMH runner fails
+ */
+ public static void main(String[] args) throws Exception {
+ org.openjdk.jmh.Main.main(args);
+ }
+}
diff --git a/benchmarks/src/main/java/com/demcha/compose/jmh/LargeTableJmhBenchmark.java b/benchmarks/src/main/java/com/demcha/compose/jmh/LargeTableJmhBenchmark.java
new file mode 100644
index 000000000..82f45a20a
--- /dev/null
+++ b/benchmarks/src/main/java/com/demcha/compose/jmh/LargeTableJmhBenchmark.java
@@ -0,0 +1,96 @@
+package com.demcha.compose.jmh;
+
+import com.demcha.compose.GraphCompose;
+import com.demcha.compose.document.api.DocumentPageSize;
+import com.demcha.compose.document.api.DocumentSession;
+import com.demcha.compose.document.style.DocumentInsets;
+import com.demcha.compose.document.table.DocumentTableColumn;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Strict JMH micro-benchmark: end-to-end render of a production-scale priced
+ * table that paginates across many pages, parameterized over row count so the
+ * scaling trend of large-table pagination + render is visible.
+ *
+ * The rest of the suite renders small documents; nothing measured how the
+ * engine handles a genuinely large multi-page table (the existing
+ * {@code TablePaginationAllocProbe} measures layout-compile allocation only, not
+ * end-to-end render). The header repeats on every page (the realistic report
+ * layout), so this exercises per-page header re-emission as well as row layout
+ * and slicing at scale.
+ *
+ *
+ * ./mvnw -f benchmarks/pom.xml clean package -DskipTests
+ * java -jar benchmarks/target/benchmarks.jar LargeTable
+ *
+ *
+ * @author Artem Demchyshyn
+ */
+@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 3, time = 2)
+@Measurement(iterations = 5, time = 2)
+@Fork(1)
+public class LargeTableJmhBenchmark {
+
+ @Param({"100", "500", "1000"})
+ public int rows;
+
+ /**
+ * Renders the priced table document to PDF bytes.
+ *
+ * @param blackhole JMH sink
+ * @throws Exception if rendering fails
+ */
+ @Benchmark
+ public void renderLargeTable(Blackhole blackhole) throws Exception {
+ // Equal full-width columns (page width minus the 28pt L/R margins, split
+ // five ways) so the table fills the page like a real report, not its text.
+ final double columnWidth = (DocumentPageSize.A4.width() - 2 * 28) / 5.0;
+ try (DocumentSession document = GraphCompose.document()
+ .pageSize(DocumentPageSize.A4)
+ .margin(DocumentInsets.of(28))
+ .create()) {
+ document.pageFlow(flow -> {
+ flow.name("LargeTable").spacing(8);
+ flow.addParagraph("Priced line items");
+ flow.addTable(t -> {
+ t.columns(
+ DocumentTableColumn.fixed(columnWidth),
+ DocumentTableColumn.fixed(columnWidth),
+ DocumentTableColumn.fixed(columnWidth),
+ DocumentTableColumn.fixed(columnWidth),
+ DocumentTableColumn.fixed(columnWidth))
+ .header("#", "Item", "Qty", "Unit", "Total").repeatHeader();
+ for (int r = 1; r <= rows; r++) {
+ t.row(String.valueOf(r), "Line item " + r, "3", "12.50", "37.50");
+ }
+ });
+ });
+ blackhole.consume(document.toPdfBytes());
+ }
+ }
+
+ /**
+ * Runs the JMH harness over this benchmark.
+ *
+ * @param args JMH CLI arguments
+ * @throws Exception if the JMH runner fails
+ */
+ public static void main(String[] args) throws Exception {
+ org.openjdk.jmh.Main.main(args);
+ }
+}
diff --git a/benchmarks/src/main/java/com/demcha/compose/jmh/MixedShowcaseJmhBenchmark.java b/benchmarks/src/main/java/com/demcha/compose/jmh/MixedShowcaseJmhBenchmark.java
new file mode 100644
index 000000000..ae139a705
--- /dev/null
+++ b/benchmarks/src/main/java/com/demcha/compose/jmh/MixedShowcaseJmhBenchmark.java
@@ -0,0 +1,95 @@
+package com.demcha.compose.jmh;
+
+import com.demcha.compose.ChartBenchmarkFixtures;
+import com.demcha.compose.GraphCompose;
+import com.demcha.compose.SvgBenchmarkFixtures;
+import com.demcha.compose.document.api.DocumentPageSize;
+import com.demcha.compose.document.api.DocumentSession;
+import com.demcha.compose.document.dsl.PageFlowBuilder;
+import com.demcha.compose.document.style.DocumentColor;
+import com.demcha.compose.document.style.DocumentInsets;
+import com.demcha.compose.document.style.DocumentPaint;
+import com.demcha.compose.document.svg.SvgIcon;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Strict JMH micro-benchmark: a representative "v1.8 showcase" document that
+ * mixes every new vector feature in one render — running prose with two inline
+ * sparklines, a grouped bar chart and a pie chart, a row of SVG icons, and
+ * gradient accent paths. This is the integration canary: it answers "did adding
+ * any v1.8 feature blow up a realistic document?" in one number.
+ *
+ *
+ * ./mvnw -f benchmarks/pom.xml clean package -DskipTests
+ * java -jar benchmarks/target/benchmarks.jar MixedShowcase
+ *
+ *
+ * @author Artem Demchyshyn
+ */
+@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 3, time = 2)
+@Measurement(iterations = 5, time = 2)
+@Fork(1)
+public class MixedShowcaseJmhBenchmark {
+
+ private static final int ICONS = 8;
+
+ /** Parsed once; the bench measures the mixed render, not icon parsing. */
+ private final SvgIcon icon = SvgIcon.parse(SvgBenchmarkFixtures.MULTI_LAYER_ICON_SVG);
+
+ /**
+ * Renders the mixed v1.8 showcase document to PDF bytes.
+ *
+ * @param blackhole JMH sink
+ * @throws Exception if rendering fails
+ */
+ @Benchmark
+ public void renderMixedShowcase(Blackhole blackhole) throws Exception {
+ DocumentPaint accent = DocumentPaint.linear(
+ DocumentColor.rgb(167, 139, 250), DocumentColor.rgb(97, 40, 217));
+ try (DocumentSession document = GraphCompose.document()
+ .pageSize(DocumentPageSize.A4)
+ .margin(DocumentInsets.of(32))
+ .create()) {
+ PageFlowBuilder flow = document.pageFlow().name("MixedShowcase").spacing(12);
+ flow.addParagraph("v1.8 feature showcase");
+ flow.addRich(r -> r
+ .plain("Revenue ")
+ .sparkline(42, 9, DocumentColor.rgb(20, 80, 95), 65.2, 69.8, 74.1, 81.3, 88.2)
+ .plain(" profit ")
+ .sparklineLine(42, 9, 1.6, DocumentColor.rgb(196, 153, 76), 28.1, 30.7, 32.9, 36.4, 39.5));
+ flow.chart(ChartBenchmarkFixtures.barSpec(), ChartBenchmarkFixtures.barStyle());
+ flow.chart(ChartBenchmarkFixtures.pieSpec());
+ for (int i = 0; i < ICONS; i++) {
+ flow.addSvgIcon(icon, 32);
+ }
+ flow.addPath(p -> p.size(220, 28)
+ .moveTo(0.0, 0.5).curveTo(0.25, 1.0, 0.75, 0.0, 1.0, 0.5).fill(accent));
+ flow.build();
+ blackhole.consume(document.toPdfBytes());
+ }
+ }
+
+ /**
+ * Runs the JMH harness over this benchmark.
+ *
+ * @param args JMH CLI arguments
+ * @throws Exception if the JMH runner fails
+ */
+ public static void main(String[] args) throws Exception {
+ org.openjdk.jmh.Main.main(args);
+ }
+}
diff --git a/benchmarks/src/main/java/com/demcha/compose/jmh/SparklineRampJmhBenchmark.java b/benchmarks/src/main/java/com/demcha/compose/jmh/SparklineRampJmhBenchmark.java
new file mode 100644
index 000000000..492aba9f1
--- /dev/null
+++ b/benchmarks/src/main/java/com/demcha/compose/jmh/SparklineRampJmhBenchmark.java
@@ -0,0 +1,83 @@
+package com.demcha.compose.jmh;
+
+import com.demcha.compose.GraphCompose;
+import com.demcha.compose.document.api.DocumentPageSize;
+import com.demcha.compose.document.api.DocumentSession;
+import com.demcha.compose.document.dsl.PageFlowBuilder;
+import com.demcha.compose.document.style.DocumentColor;
+import com.demcha.compose.document.style.DocumentInsets;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Strict JMH micro-benchmark: a "sparkline ramp" — a rich paragraph carrying
+ * {@code N} inline sparklines — rendered to PDF, parameterized over N so the
+ * per-sparkline inline-fragment cost (build + layout + vector draw) is visible.
+ * Sparklines were otherwise only exercised once inside
+ * {@code MixedShowcaseJmhBenchmark}, where a regression would dilute into the
+ * surrounding charts and icons; this isolates and scales them.
+ *
+ *
+ * ./mvnw -f benchmarks/pom.xml clean package -DskipTests
+ * java -jar benchmarks/target/benchmarks.jar SparklineRamp
+ *
+ *
+ * @author Artem Demchyshyn
+ */
+@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 3, time = 2)
+@Measurement(iterations = 5, time = 2)
+@Fork(1)
+public class SparklineRampJmhBenchmark {
+
+ private static final DocumentColor ACCENT = DocumentColor.rgb(20, 80, 95);
+
+ @Param({"8", "32", "128"})
+ public int sparklineCount;
+
+ /**
+ * Renders a paragraph of {@code sparklineCount} inline sparklines to PDF bytes.
+ *
+ * @param blackhole JMH sink
+ * @throws Exception if rendering fails
+ */
+ @Benchmark
+ public void renderSparklineRamp(Blackhole blackhole) throws Exception {
+ try (DocumentSession document = GraphCompose.document()
+ .pageSize(DocumentPageSize.A4)
+ .margin(DocumentInsets.of(28))
+ .create()) {
+ PageFlowBuilder flow = document.pageFlow().name("SparklineRamp").spacing(4);
+ flow.addRich(r -> {
+ for (int i = 0; i < sparklineCount; i++) {
+ r.plain("m ").sparkline(42, 9, ACCENT, 65.2, 69.8, 74.1, 81.3, 88.2);
+ }
+ });
+ flow.build();
+ blackhole.consume(document.toPdfBytes());
+ }
+ }
+
+ /**
+ * Runs the JMH harness over this benchmark.
+ *
+ * @param args JMH CLI arguments
+ * @throws Exception if the JMH runner fails
+ */
+ public static void main(String[] args) throws Exception {
+ org.openjdk.jmh.Main.main(args);
+ }
+}
diff --git a/benchmarks/src/main/java/com/demcha/compose/jmh/SvgJmhBenchmark.java b/benchmarks/src/main/java/com/demcha/compose/jmh/SvgJmhBenchmark.java
new file mode 100644
index 000000000..58ed3f99f
--- /dev/null
+++ b/benchmarks/src/main/java/com/demcha/compose/jmh/SvgJmhBenchmark.java
@@ -0,0 +1,98 @@
+package com.demcha.compose.jmh;
+
+import com.demcha.compose.SvgBenchmarkFixtures;
+import com.demcha.compose.document.svg.SvgIcon;
+import com.demcha.compose.document.svg.SvgPath;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Strict JMH micro-benchmark for the v1.8 SVG-import surface — the first
+ * feature-object benchmark (the rest of the suite renders text / tables only).
+ *
+ * Three measured operations, all pure CPU + allocation (no
+ * {@code DocumentSession}, no PDF render):
+ *
+ * - {@code parseSvgPath} — {@link SvgPath#parse} of a real Material icon
+ * {@code d} string (tokenize, relative/absolute resolution, cubic/line
+ * lowering, viewBox normalization).
+ * - {@code readSvgIcon} — {@link SvgIcon#parse} of a multi-layer icon (XML
+ * parse, {@code } transform accumulation, gradient resolution, one
+ * {@link SvgPath} per layer).
+ * - {@code svgIconToNode} — {@link SvgIcon#node} on a pre-parsed icon (the
+ * {@code PathNode} / layer-stack allocation done once per placement).
+ *
+ *
+ * Microsecond-scale work, so it needs the forked, JIT-stable JMH harness
+ * (an {@code exec:java} run cannot fork). Build the runner jar and run:
+ *
+ *
+ * ./mvnw -f benchmarks/pom.xml clean package -DskipTests
+ * java -jar benchmarks/target/benchmarks.jar Svg
+ *
+ *
+ * @author Artem Demchyshyn
+ */
+@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 3, time = 2)
+@Measurement(iterations = 5, time = 2)
+@Fork(1)
+public class SvgJmhBenchmark {
+
+ /** Parsed once so {@code svgIconToNode} measures only the node-build cost. */
+ private final SvgIcon icon = SvgIcon.parse(SvgBenchmarkFixtures.MULTI_LAYER_ICON_SVG);
+
+ /**
+ * Parses a real icon path-data string into normalized segments.
+ *
+ * @param blackhole JMH sink
+ */
+ @Benchmark
+ public void parseSvgPath(Blackhole blackhole) {
+ blackhole.consume(SvgPath.parse(
+ SvgBenchmarkFixtures.MATERIAL_HEART_D,
+ 0, 0, SvgBenchmarkFixtures.HEART_VIEWBOX, SvgBenchmarkFixtures.HEART_VIEWBOX));
+ }
+
+ /**
+ * Reads a whole multi-layer SVG icon (XML parse → layers).
+ *
+ * @param blackhole JMH sink
+ */
+ @Benchmark
+ public void readSvgIcon(Blackhole blackhole) {
+ blackhole.consume(SvgIcon.parse(SvgBenchmarkFixtures.MULTI_LAYER_ICON_SVG));
+ }
+
+ /**
+ * Builds a placeable node (path nodes + layer stack) from a parsed icon.
+ *
+ * @param blackhole JMH sink
+ */
+ @Benchmark
+ public void svgIconToNode(Blackhole blackhole) {
+ blackhole.consume(icon.node(48.0));
+ }
+
+ /**
+ * Runs the JMH harness over this benchmark.
+ *
+ * @param args JMH CLI arguments
+ * @throws Exception if the JMH runner fails
+ */
+ public static void main(String[] args) throws Exception {
+ org.openjdk.jmh.Main.main(args);
+ }
+}
diff --git a/benchmarks/src/main/java/com/demcha/compose/jmh/VectorPaintJmhBenchmark.java b/benchmarks/src/main/java/com/demcha/compose/jmh/VectorPaintJmhBenchmark.java
new file mode 100644
index 000000000..382ad4d57
--- /dev/null
+++ b/benchmarks/src/main/java/com/demcha/compose/jmh/VectorPaintJmhBenchmark.java
@@ -0,0 +1,109 @@
+package com.demcha.compose.jmh;
+
+import com.demcha.compose.GraphCompose;
+import com.demcha.compose.document.api.DocumentPageSize;
+import com.demcha.compose.document.api.DocumentSession;
+import com.demcha.compose.document.dsl.PageFlowBuilder;
+import com.demcha.compose.document.style.DocumentColor;
+import com.demcha.compose.document.style.DocumentPaint;
+import com.demcha.compose.document.style.DocumentInsets;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Strict JMH micro-benchmark: render {@code N} identical curved blob paths in one
+ * paint mode — flat solid fill, linear gradient, or translucent (alpha) fill —
+ * parameterized over the mode, so the render-time cost of each vector
+ * paint branch is isolated. This is the timing complement to
+ * {@code VectorRenderOperatorProbe} (which counts the PDF operators each mode
+ * emits): gradient shading and alpha ExtGState are heavier than the flat fast
+ * fill path, and this puts a millisecond number on that.
+ *
+ *
+ * ./mvnw -f benchmarks/pom.xml clean package -DskipTests
+ * java -jar benchmarks/target/benchmarks.jar VectorPaint
+ *
+ *
+ * @author Artem Demchyshyn
+ */
+@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 3, time = 2)
+@Measurement(iterations = 5, time = 2)
+@Fork(1)
+public class VectorPaintJmhBenchmark {
+
+ private static final int PATHS = 40;
+
+ @Param({"flat", "gradient", "alpha"})
+ public String paint;
+
+ private DocumentPaint gradient;
+ private DocumentColor flat;
+ private DocumentColor translucent;
+
+ /** Paint objects built once per trial, outside the measured render. */
+ @Setup
+ public void setUp() {
+ gradient = DocumentPaint.linear(
+ DocumentColor.rgb(167, 139, 250), DocumentColor.rgb(97, 40, 217));
+ flat = DocumentColor.rgb(40, 90, 160);
+ translucent = DocumentColor.rgb(40, 90, 160).withOpacity(0.5);
+ }
+
+ /**
+ * Renders {@code PATHS} blob paths in the parameterized paint mode to PDF bytes.
+ *
+ * @param blackhole JMH sink
+ * @throws Exception if rendering fails
+ */
+ @Benchmark
+ public void renderVectorPaint(Blackhole blackhole) throws Exception {
+ try (DocumentSession document = GraphCompose.document()
+ .pageSize(DocumentPageSize.A4)
+ .margin(DocumentInsets.of(28))
+ .create()) {
+ PageFlowBuilder flow = document.pageFlow().name("VectorPaint").spacing(4);
+ for (int i = 0; i < PATHS; i++) {
+ flow.addPath(p -> {
+ p.size(60, 36)
+ .moveTo(0.0, 0.5)
+ .curveTo(0.25, 1.0, 0.75, 1.0, 1.0, 0.5)
+ .curveTo(0.75, 0.0, 0.25, 0.0, 0.0, 0.5)
+ .closePath();
+ switch (paint) {
+ case "flat" -> p.fillColor(flat);
+ case "gradient" -> p.fill(gradient);
+ case "alpha" -> p.fillColor(translucent);
+ default -> throw new IllegalArgumentException("Unknown paint mode: " + paint);
+ }
+ });
+ }
+ flow.build();
+ blackhole.consume(document.toPdfBytes());
+ }
+ }
+
+ /**
+ * Runs the JMH harness over this benchmark.
+ *
+ * @param args JMH CLI arguments
+ * @throws Exception if the JMH runner fails
+ */
+ public static void main(String[] args) throws Exception {
+ org.openjdk.jmh.Main.main(args);
+ }
+}
diff --git a/benchmarks/src/test/java/com/demcha/compose/BenchmarkDiffToolTest.java b/benchmarks/src/test/java/com/demcha/compose/BenchmarkDiffToolTest.java
index 783ad2479..d3319131c 100644
--- a/benchmarks/src/test/java/com/demcha/compose/BenchmarkDiffToolTest.java
+++ b/benchmarks/src/test/java/com/demcha/compose/BenchmarkDiffToolTest.java
@@ -93,6 +93,35 @@ void currentSpeedDiffKeepsOnlyScenariosPresentInBothRuns() throws Exception {
assertThat(diff.path("throughput").get(0).path("scenario").asText()).isEqualTo("shared");
}
+ @Test
+ void currentSpeedDiffSurfacesAddedRemovedScenariosAndStageDeltas() throws Exception {
+ System.setProperty("graphcompose.benchmark.root", tempDir.toString());
+ Path baseline = write("baseline.json", currentSpeedWithStages("full",
+ latency("shared", 10.0, 10.0, 100.0, 1.0, 100.0) + ","
+ + latency("only-in-baseline", 10.0, 10.0, 100.0, 1.0, 100.0),
+ stage("shared", 1.0, 2.0, 4.0, 7.0),
+ throughput("shared", 1, 50.0, 20.0)));
+ Path candidate = write("candidate.json", currentSpeedWithStages("full",
+ latency("shared", 10.0, 10.0, 100.0, 1.0, 100.0) + ","
+ + latency("only-in-candidate", 5.0, 5.0, 200.0, 0.5, 90.0),
+ stage("shared", 1.0, 2.0, 8.0, 11.0),
+ throughput("shared", 1, 50.0, 20.0)));
+
+ BenchmarkDiffTool.main(new String[]{baseline.toString(), candidate.toString()});
+
+ JsonNode diff = readDiff("current-speed");
+ // Loud set-changes: one-sided scenarios are surfaced, not silently dropped.
+ assertThat(toStrings(diff.path("addedScenarios"))).containsExactly("only-in-candidate");
+ assertThat(toStrings(diff.path("removedScenarios"))).containsExactly("only-in-baseline");
+ // The shared scenario is still the only intersected latency delta row.
+ assertThat(diff.path("latency").size()).isEqualTo(1);
+ // Stage diff: render 4 -> 8 = +100%, compose unchanged.
+ JsonNode stageDiff = diff.path("stages").get(0);
+ assertThat(stageDiff.path("scenario").asText()).isEqualTo("shared");
+ assertThat(stageDiff.path("renderDeltaPct").asDouble()).isCloseTo(100.0, within(EPS));
+ assertThat(stageDiff.path("composeDeltaPct").asDouble()).isCloseTo(0.0, within(EPS));
+ }
+
@Test
void currentSpeedDiffTreatsZeroBaselineAsHundredPercentAndZeroToZeroAsZero() throws Exception {
System.setProperty("graphcompose.benchmark.root", tempDir.toString());
@@ -228,6 +257,38 @@ private static String latency(String scenario,
""".formatted(scenario, scenario, avgMillis, p95Millis, docsPerSecond, avgKilobytes, peakHeapMb);
}
+ private static String currentSpeedWithStages(String profile, String latencyItems,
+ String stageItems, String throughputItems) {
+ return """
+ {
+ "timestamp": "2026-04-14 21:00:00",
+ "profile": "%s",
+ "latency": [%s],
+ "stages": [%s],
+ "throughput": [%s]
+ }
+ """.formatted(profile, latencyItems, stageItems, throughputItems);
+ }
+
+ private static String stage(String scenario, double composeMs, double layoutMs,
+ double renderMs, double totalMs) {
+ return """
+ {
+ "scenario": "%s",
+ "composeMillis": %s,
+ "layoutMillis": %s,
+ "renderMillis": %s,
+ "totalMillis": %s
+ }
+ """.formatted(scenario, composeMs, layoutMs, renderMs, totalMs);
+ }
+
+ private static java.util.List toStrings(JsonNode array) {
+ java.util.List values = new java.util.ArrayList<>();
+ array.forEach(node -> values.add(node.asText()));
+ return values;
+ }
+
private static String throughput(String scenario, int threads, double docsPerSecond, double avgMillisPerDoc) {
return """
{
diff --git a/benchmarks/src/test/java/com/demcha/compose/BenchmarkMedianToolTest.java b/benchmarks/src/test/java/com/demcha/compose/BenchmarkMedianToolTest.java
index ee449b4b7..c1bc150b8 100644
--- a/benchmarks/src/test/java/com/demcha/compose/BenchmarkMedianToolTest.java
+++ b/benchmarks/src/test/java/com/demcha/compose/BenchmarkMedianToolTest.java
@@ -148,6 +148,11 @@ void shouldWriteMedianCurrentSpeedAggregateForRepeatedRuns() throws Exception {
assertThat(aggregate.path("latency").get(0).path("peakHeapMb").asDouble()).isEqualTo(120.0);
assertThat(aggregate.path("throughput").get(0).path("docsPerSecond").asDouble()).isEqualTo(40.0);
assertThat(aggregate.path("totalBytes").asLong()).isEqualTo(2000L);
+ // None of these runs carried a stages[] (smoke < 20 iters emits none), so the
+ // lenient aggregation must omit stages without throwing.
+ assertThat(aggregate.path("stages").isEmpty())
+ .as("median omits stages when no source run carries them")
+ .isTrue();
}
@Test
@@ -209,4 +214,52 @@ void shouldWriteMedianComparativeAggregateForRepeatedRuns() throws Exception {
assertThat(aggregate.path("libraries").get(1).path("avgHeapMb").asDouble()).isEqualTo(0.25);
}
+ @Test
+ void shouldMedianStagesWhenSourceRunsCarryThem() throws Exception {
+ System.setProperty("graphcompose.benchmark.root", tempDir.toString());
+
+ Path suiteDir = Files.createDirectories(tempDir.resolve("current-speed"));
+ // Three runs whose render stage is 10 / 20 / 30 (median 20) and total
+ // 13 / 23 / 33 (median 23); compose/layout are constant (median 1 / 2).
+ double[] renders = {10.0, 20.0, 30.0};
+ String[] paths = new String[renders.length];
+ for (int i = 0; i < renders.length; i++) {
+ double render = renders[i];
+ double total = render + 3.0;
+ Path run = suiteDir.resolve("run-20260415-2200" + i + "0.json");
+ Files.writeString(run, """
+ {
+ "profile": "full",
+ "warmupIterations": 12,
+ "measurementIterations": 40,
+ "docsPerThread": 12,
+ "threadCounts": [1],
+ "latency": [
+ {"scenario": "invoice-template", "description": "Invoice", "avgMillis": %1$s,
+ "p50Millis": 0.0, "p95Millis": 0.0, "maxMillis": 0.0, "docsPerSecond": 0.0,
+ "avgKilobytes": 0.0, "peakHeapMb": 0.0}
+ ],
+ "stages": [
+ {"scenario": "invoice-template", "composeMillis": 1.0, "layoutMillis": 2.0,
+ "renderMillis": %1$s, "totalMillis": %2$s}
+ ],
+ "throughput": [],
+ "totalBytes": 1000
+ }
+ """.formatted(render, total));
+ paths[i] = run.toString();
+ }
+
+ BenchmarkMedianTool.main(new String[]{"current-speed", paths[0], paths[1], paths[2]});
+
+ JsonNode aggregate = JSON.readTree(
+ Files.readAllBytes(tempDir.resolve("aggregates/current-speed/full/latest.json")));
+
+ JsonNode stage = aggregate.path("stages").get(0);
+ assertThat(stage.path("scenario").asText()).isEqualTo("invoice-template");
+ assertThat(stage.path("composeMillis").asDouble()).isEqualTo(1.0);
+ assertThat(stage.path("renderMillis").asDouble()).isEqualTo(20.0);
+ assertThat(stage.path("totalMillis").asDouble()).isEqualTo(23.0);
+ }
+
}
diff --git a/benchmarks/src/test/java/com/demcha/compose/CurrentSpeedBenchmarkPerfGateTest.java b/benchmarks/src/test/java/com/demcha/compose/CurrentSpeedBenchmarkPerfGateTest.java
index cae8d91f0..6a1efc07a 100644
--- a/benchmarks/src/test/java/com/demcha/compose/CurrentSpeedBenchmarkPerfGateTest.java
+++ b/benchmarks/src/test/java/com/demcha/compose/CurrentSpeedBenchmarkPerfGateTest.java
@@ -53,14 +53,16 @@ void failsWhenAverageLatencyExceedsThreshold() {
}
@Test
- void failsWhenPeakHeapExceedsThreshold() {
+ void treatsPeakHeapAsAdvisoryNotAGateFailure() {
CurrentSpeedBenchmark.PerformanceGateResult result =
CurrentSpeedBenchmark.evaluatePerformanceGate(
CurrentSpeedBenchmark.BenchmarkProfile.SMOKE,
- List.of(latency(ENGINE_SIMPLE, 1.0, 999.0))); // 999 > 96
+ List.of(latency(ENGINE_SIMPLE, 1.0, 999.0))); // heap 999 > 96, avg 1.0 ok
- assertThat(result.passed()).isFalse();
- assertThat(result.message()).contains("peak heap");
+ assertThat(result.passed())
+ .as("peak heap is GC-noisy and advisory — a heap-only breach must not fail the gate")
+ .isTrue();
+ assertThat(result.message()).contains("peak heap").contains("advisory");
}
@Test
diff --git a/benchmarks/src/test/java/com/demcha/compose/CurrentSpeedScenarioGateTest.java b/benchmarks/src/test/java/com/demcha/compose/CurrentSpeedScenarioGateTest.java
new file mode 100644
index 000000000..da7296d45
--- /dev/null
+++ b/benchmarks/src/test/java/com/demcha/compose/CurrentSpeedScenarioGateTest.java
@@ -0,0 +1,35 @@
+package com.demcha.compose;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Guards that every CurrentSpeed latency scenario is covered by a SMOKE gate
+ * threshold.
+ *
+ * The smoke perf gate silently ignores a scenario that has no configured
+ * threshold (by design — see
+ * {@link CurrentSpeedBenchmarkPerfGateTest#ignoresScenariosWithoutAConfiguredThreshold()}).
+ * That defensive behaviour means a newly added scenario would escape the gate
+ * unnoticed. This test makes the omission fail loudly instead: adding a scenario
+ * to {@code SCENARIO_DEFS} without a matching {@code SMOKE} threshold breaks the
+ * build.
+ */
+class CurrentSpeedScenarioGateTest {
+
+ @Test
+ void everyScenarioHasASmokeGateThreshold() {
+ var gated = CurrentSpeedBenchmark.BenchmarkProfile.SMOKE.smokeThresholds().keySet();
+
+ List ungated = CurrentSpeedBenchmark.scenarioNames().stream()
+ .filter(name -> !gated.contains(name))
+ .toList();
+
+ assertThat(ungated)
+ .as("CurrentSpeed scenarios missing a SMOKE gate threshold")
+ .isEmpty();
+ }
+}
diff --git a/benchmarks/src/test/java/com/demcha/compose/ImageCacheGateTest.java b/benchmarks/src/test/java/com/demcha/compose/ImageCacheGateTest.java
new file mode 100644
index 000000000..e28a2d9c9
--- /dev/null
+++ b/benchmarks/src/test/java/com/demcha/compose/ImageCacheGateTest.java
@@ -0,0 +1,49 @@
+package com.demcha.compose;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Deterministic regression gate for {@code PdfImageCache} dedup, driving
+ * {@link ImageCacheOperatorProbe}'s render + count helpers.
+ *
+ * The cache keys embedded image XObjects by content fingerprint, so the same
+ * image placed many times must embed once (referenced by many draws) while
+ * distinct images embed once each. Counting the embedded XObjects in the output
+ * PDF makes that structural invariant a build-failing assertion — a regression
+ * that re-embeds the same image per placement (PDF bloat) breaks this test
+ * rather than silently passing CI.
+ */
+class ImageCacheGateTest {
+
+ @Test
+ void sameImageEmbedsOnceRegardlessOfPlacements() throws Exception {
+ int placements = 30;
+
+ ImageCacheOperatorProbe.EmbedCounts counts =
+ ImageCacheOperatorProbe.countPdf(ImageCacheOperatorProbe.renderSameImage(placements));
+
+ assertThat(counts.embeds())
+ .as("the same image placed %d times must embed exactly one XObject", placements)
+ .isEqualTo(1);
+ assertThat(counts.draws())
+ .as("each placement must still draw the cached image")
+ .isGreaterThanOrEqualTo(placements);
+ }
+
+ @Test
+ void distinctImagesEachEmbedOnce() throws Exception {
+ int distinct = 8;
+
+ ImageCacheOperatorProbe.EmbedCounts counts =
+ ImageCacheOperatorProbe.countPdf(ImageCacheOperatorProbe.renderDistinctImages(distinct));
+
+ assertThat(counts.embeds())
+ .as("%d distinct images must embed %d XObjects (no over-dedup)", distinct, distinct)
+ .isEqualTo(distinct);
+ assertThat(counts.draws())
+ .as("each distinct image must be drawn")
+ .isGreaterThanOrEqualTo(distinct);
+ }
+}
diff --git a/benchmarks/src/test/java/com/demcha/compose/RenderOperatorGateTest.java b/benchmarks/src/test/java/com/demcha/compose/RenderOperatorGateTest.java
new file mode 100644
index 000000000..01807d4bf
--- /dev/null
+++ b/benchmarks/src/test/java/com/demcha/compose/RenderOperatorGateTest.java
@@ -0,0 +1,41 @@
+package com.demcha.compose;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Deterministic regression gate for the F5 render-operator coalescing, driving
+ * {@link RenderOperatorProbe#countOperators}.
+ *
+ * Before F5 the paragraph handler emitted one {@code setFont} (Tf) and one
+ * non-stroking-colour op per text-show, so font/colour ops scaled 1:1 with the
+ * per-line {@code Tj}/{@code TJ} draws. After F5 they are coalesced, so a single
+ * styled paragraph that wraps to many lines emits far fewer Tf/colour ops than
+ * draws. Asserting {@code tf < draws} and {@code rg < draws} pins that
+ * structural win as a build-failing check — a regression back to per-span font
+ * ops (bloated content streams) breaks this test instead of passing CI. The
+ * assertion is content-independent: it does not hardcode brittle exact counts.
+ */
+class RenderOperatorGateTest {
+
+ private static final String LONG_PARAGRAPH =
+ ("GraphCompose lays out structured business documents across many pages "
+ + "while keeping header and footer placement stable. ").repeat(30);
+
+ @Test
+ void fontAndColourOpsStayCoalescedBelowTextDraws() throws Exception {
+ RenderOperatorProbe.OpCounts counts =
+ RenderOperatorProbe.countOperators(flow -> flow.addParagraph(LONG_PARAGRAPH));
+
+ assertThat(counts.draws())
+ .as("a long paragraph must wrap to many text-show ops")
+ .isGreaterThanOrEqualTo(10);
+ assertThat(counts.tf())
+ .as("setFont ops must be coalesced below the per-line draw count (F5), not 1:1")
+ .isLessThan(counts.draws());
+ assertThat(counts.rg())
+ .as("non-stroking colour ops must be coalesced below the per-line draw count (F5)")
+ .isLessThan(counts.draws());
+ }
+}
diff --git a/benchmarks/src/test/java/com/demcha/compose/VectorRenderOperatorGateTest.java b/benchmarks/src/test/java/com/demcha/compose/VectorRenderOperatorGateTest.java
new file mode 100644
index 000000000..5aa3d91ef
--- /dev/null
+++ b/benchmarks/src/test/java/com/demcha/compose/VectorRenderOperatorGateTest.java
@@ -0,0 +1,85 @@
+package com.demcha.compose;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Deterministic regression gate for the v1.8 vector-paint render branches,
+ * driving {@link VectorRenderOperatorProbe#countOperators}.
+ *
+ * A flat fill takes the fast path (no shading / alpha / clip); a linear
+ * gradient clips to the shape and paints a shading (one {@code W} clip + one
+ * {@code sh} per shape); a translucent fill sets an ExtGState alpha (one
+ * {@code gs} per shape). Pinning these operator counts makes a regression — a
+ * flat path accidentally taking the heavier gradient branch, or the gradient
+ * clip/shading being dropped — a build failure rather than a silent CI pass.
+ */
+class VectorRenderOperatorGateTest {
+
+ @Test
+ void flatFillTakesTheFastPathWithNoShadingAlphaOrClip() throws Exception {
+ VectorRenderOperatorProbe.OperatorCounts flat =
+ VectorRenderOperatorProbe.countOperators(VectorRenderOperatorProbe.PaintMode.FLAT);
+
+ assertThat(flat.curves()).as("flat paths still emit curve operators").isGreaterThan(0);
+ assertThat(flat.shadings()).as("flat fill must not paint a shading").isZero();
+ assertThat(flat.extGStates()).as("flat fill must not set an ExtGState alpha").isZero();
+ assertThat(flat.clips()).as("flat fill must not clip").isZero();
+ assertThat(flat.strokes()).as("a flat fill must not stroke").isZero();
+ assertThat(flat.dashes()).as("a flat fill must not set a dash array").isZero();
+ }
+
+ @Test
+ void strokedPathStrokesOncePerShapeWithoutFillPaint() throws Exception {
+ VectorRenderOperatorProbe.OperatorCounts stroked =
+ VectorRenderOperatorProbe.countOperators(VectorRenderOperatorProbe.PaintMode.STROKED);
+
+ assertThat(stroked.strokes())
+ .as("a stroked path strokes once per shape")
+ .isEqualTo(VectorRenderOperatorProbe.PATHS);
+ assertThat(stroked.dashes()).as("a solid stroke sets no dash array").isZero();
+ assertThat(stroked.shadings()).as("a stroke must not paint a shading").isZero();
+ assertThat(stroked.extGStates()).as("a stroke must not set an ExtGState alpha").isZero();
+ }
+
+ @Test
+ void dashedStrokeSetsADashArrayPerShape() throws Exception {
+ VectorRenderOperatorProbe.OperatorCounts dashed =
+ VectorRenderOperatorProbe.countOperators(VectorRenderOperatorProbe.PaintMode.DASHED);
+
+ assertThat(dashed.dashes())
+ .as("a dashed stroke sets a dash array once per shape")
+ .isEqualTo(VectorRenderOperatorProbe.PATHS);
+ assertThat(dashed.strokes())
+ .as("a dashed path still strokes once per shape")
+ .isEqualTo(VectorRenderOperatorProbe.PATHS);
+ assertThat(dashed.shadings()).as("a dashed stroke must not paint a shading").isZero();
+ }
+
+ @Test
+ void gradientFillClipsAndShadesOncePerShape() throws Exception {
+ VectorRenderOperatorProbe.OperatorCounts gradient =
+ VectorRenderOperatorProbe.countOperators(VectorRenderOperatorProbe.PaintMode.GRADIENT);
+
+ assertThat(gradient.shadings())
+ .as("a linear gradient paints one shading per shape")
+ .isEqualTo(VectorRenderOperatorProbe.PATHS);
+ assertThat(gradient.clips())
+ .as("a gradient clips to each shape before shading")
+ .isEqualTo(VectorRenderOperatorProbe.PATHS);
+ }
+
+ @Test
+ void translucentFillSetsOneExtGStatePerShape() throws Exception {
+ VectorRenderOperatorProbe.OperatorCounts alpha =
+ VectorRenderOperatorProbe.countOperators(VectorRenderOperatorProbe.PaintMode.ALPHA);
+
+ assertThat(alpha.extGStates())
+ .as("a translucent fill sets one ExtGState alpha per shape")
+ .isEqualTo(VectorRenderOperatorProbe.PATHS);
+ assertThat(alpha.shadings())
+ .as("a translucent solid fill must not paint a shading")
+ .isZero();
+ }
+}
diff --git a/docs/operations/benchmarks.md b/docs/operations/benchmarks.md
index 315f4d523..1c6bd6d75 100644
--- a/docs/operations/benchmarks.md
+++ b/docs/operations/benchmarks.md
@@ -36,15 +36,17 @@ The script prints numbered sections so you can map console output to the pipelin
1. `01-build-classpath`
Builds the test classpath once and writes `target/benchmark.classpath`.
2. `02-current-speed`
- Runs `CurrentSpeedBenchmark` in the selected profile.
+ Runs `CurrentSpeedBenchmark` in the selected profile. The full profile also
+ runs the thread-scaling throughput sweep (1 → 16 threads).
3. `03-comparative`
- Runs the GraphCompose canonical vs iText 5 vs JasperReports comparison.
-4. `04-core-engine`
- Runs `GraphComposeBenchmark`.
-5. `05-full-cv`
- Runs `FullCvBenchmark`.
-6. `06-scalability`
- Runs the thread-scaling throughput benchmark.
+ Runs the GraphCompose canonical vs iText 9 vs JasperReports comparison: a
+ small-invoice tier plus a report-scaling sweep (40 / 200 / 1000 rows) that
+ prints a per-size GraphCompose-advantage ratio and dumps a sample PDF per
+ library/size.
+
+ _Steps 04–06 (`core-engine`, `full-cv`, `scalability`) were retired. The
+ surviving steps keep their original `NN-` console prefixes, so the labels
+ jump from `03-` to `07-`._
7. `07-stress`
Runs the concurrent stability stress test.
8. `08-endurance`
diff --git a/docs/operations/performance.md b/docs/operations/performance.md
index ecf02c5b7..7fc02d480 100644
--- a/docs/operations/performance.md
+++ b/docs/operations/performance.md
@@ -1,7 +1,13 @@
# Performance — v1.4 numbers
-All numbers below come from `scripts/run-benchmarks.ps1` — the full local
-benchmark workflow that builds the test classpath once and runs
+> **Historical snapshot (v1.4).** The numbers and suite list below are frozen
+> as captured for v1.4 and are kept for reference. The pipeline has since
+> changed: the `core-engine`, `full-cv`, and `scalability` suites were retired,
+> and current numbers come from the `current-speed` / `comparative` / `stress`
+> pipeline plus the JMH suite. See [docs/operations/benchmarks.md](./benchmarks.md).
+
+All numbers below were captured from `scripts/run-benchmarks.ps1` — the full
+local benchmark workflow that built the test classpath once and ran
`current-speed`, `comparative`, `core-engine`, `full-cv`, `scalability`,
and `stress` suites in sequence. They were captured on a developer
laptop; CI machines are typically 1.5–2× slower. The benchmark
@@ -93,5 +99,9 @@ snapshots.
## Engine-only timings
+_The `GraphComposeBenchmark` and `FullCvBenchmark` mains below were retired
+after v1.4. Equivalent timings now come from the `CurrentSpeedBenchmark`
+`engine-simple` scenario and the JMH `TemplateCvJmhBenchmark`._
+
- `GraphComposeBenchmark` (engine-only, no PDF render): avg **1.04 ms**, p50 **0.97 ms**, p95 **1.64 ms**.
- `FullCvBenchmark` (full CV template, including render): avg **4.14 ms**, p50 **3.80 ms**, p95 **6.37 ms**.
diff --git a/scripts/ab-bench.ps1 b/scripts/ab-bench.ps1
index 5a3e4eb42..a237ec203 100644
--- a/scripts/ab-bench.ps1
+++ b/scripts/ab-bench.ps1
@@ -110,21 +110,10 @@ function Parse-Comparative($jsonPath) {
}
function Parse-Logs($logsDir) {
$o = @{}
- $scal = Join-Path $logsDir "06-scalability.log"
- if (Test-Path $scal) {
- foreach ($line in (Get-Content $scal)) {
- if ($line -match '^\s*(\d+)\s*\|\s*\d+\s*\|\s*([\d.]+)\s*$') {
- $o["scalability | $($matches[1])t | docs/s"] = [double]$matches[2]
- }
- }
- }
- foreach ($pair in @(@("04-core-engine.log", "core-engine"), @("05-full-cv.log", "full-cv"))) {
- $p = Join-Path $logsDir $pair[0]
- if (Test-Path $p) {
- $txt = Get-Content $p -Raw
- if ($txt -match 'Median[^\r\n]*?:\s*([\d.]+)\s*ms') { $o["$($pair[1]) | median ms"] = [double]$matches[1] }
- }
- }
+ # Steps 04-06 (core-engine, full-cv, scalability) were retired, so their logs
+ # are no longer produced. Current-speed throughput — including the
+ # thread-scaling series — is read from the JSON report by Parse-CurrentSpeed;
+ # only the surviving stress log is parsed here.
$stress = Join-Path $logsDir "07-stress.log"
if (Test-Path $stress) {
$txt = Get-Content $stress -Raw
diff --git a/scripts/run-benchmarks.ps1 b/scripts/run-benchmarks.ps1
index dbe162c08..a0dd2c777 100644
--- a/scripts/run-benchmarks.ps1
+++ b/scripts/run-benchmarks.ps1
@@ -5,8 +5,10 @@ Runs the local GraphCompose benchmark pipeline and stores timestamped logs and r
.DESCRIPTION
The wrapper performs a staged local run:
-01 build classpath, 02 current-speed, 03 comparative, 04 core engine, 05 full CV, 06 scalability,
-07 stress, optional 08 endurance, then 09/10 diff steps.
+01 build classpath, 02 current-speed, 03 comparative, 07 stress,
+optional 08 endurance, then 09/10 diff and 11 verdict steps. Steps 04-06
+(core-engine, full-cv, scalability) were retired; the surviving steps keep
+their original numeric prefixes, so the numbering jumps from 03 to 07.
Current-speed diffs are profile-aware. The wrapper only compares reports
from the same current-speed profile (`smoke` or `full`) and skips the
@@ -368,9 +370,6 @@ try {
-InputPaths $comparativeRuns | Out-Null
}
- Invoke-JavaMain -Name "04-core-engine" -Classpath $javaClasspath -MainClass "com.demcha.compose.GraphComposeBenchmark"
- Invoke-JavaMain -Name "05-full-cv" -Classpath $javaClasspath -MainClass "com.demcha.compose.FullCvBenchmark"
- Invoke-JavaMain -Name "06-scalability" -Classpath $javaClasspath -MainClass "com.demcha.compose.ScalabilityBenchmark"
Invoke-JavaMain -Name "07-stress" -Classpath $javaClasspath -MainClass "com.demcha.compose.GraphComposeStressTest"
if ($IncludeEndurance) {