@reekon-tools/react-native-pdf-canvas 0.1.1 → 0.2.0

package/android/src/androidTest/java/tools/reekon/pdfcanvas/PdfCanvasPhaseTimingTest.java

@@ -1,1388 +0,0 @@
-package tools.reekon.pdfcanvas;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.Color;
-import android.graphics.Matrix;
-import android.graphics.pdf.PdfRenderer;
-import android.os.ParcelFileDescriptor;
-import android.util.Base64;
-import android.util.Log;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.platform.app.InstrumentationRegistry;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
-
-import tools.reekon.pdfcanvas.jsi.PdfCanvasPixelBridge;
-
-/**
- * MEASUREMENT, NOT VERIFICATION — the same contract as
- * {@link PdfCanvasDeviceTimingTest}, one level finer. That file answers "how long
- * does a tile take". This one answers the two questions a tile timing cannot:
- *
- * <ol>
- *   <li>WHERE inside a tile the time goes — {@code openPage}, bitmap allocation,
- *       the white fill, {@code PdfRenderer.render}, the copy to a Java
- *       {@code byte[]}, and the base64 encode, each timed separately.
- *   <li>WHETHER the renderer pool actually buys wall-clock. The controller
- *       renders an epoch's pieces strictly one at a time; the whole case for
- *       parallelising it rests on N renderers finishing N tiles in meaningfully
- *       less than N times one tile. That is measured here at N = 2, 3, 4 and 6.
- * </ol>
- *
- * <h3>What is NOT measured here, and cannot be</h3>
- *
- * The bridge hop and everything past it — the base64 STRING crossing into JS,
- * the hand-rolled {@code decodeBase64} in {@code src/rasterizer/android.ts}, and
- * {@code Skia.Data.fromBytes} + {@code MakeImage}. None of that exists in a
- * process with no React Native in it, which this test build deliberately is (see
- * {@code android/build.gradle}). What this file CAN do about them is state the
- * exact byte volumes they are handed, which it logs: raw bytes, base64 chars,
- * and the encode cost that produced them.
- *
- * <h3>Why the phase harness re-implements the render instead of calling it</h3>
- *
- * {@link PdfCanvasRasterizer#render} is one opaque call; splitting it from
- * outside is impossible and adding timing hooks to it would put measurement
- * scaffolding in production code forever. So {@link #renderPhases} mirrors
- * {@code renderLeased} step for step — and then {@link #phaseHarnessMatchesTheRealRender}
- * proves the mirror is exact by comparing its pixels byte-for-byte against the
- * real thing. A drifted copy would measure a render nobody performs.
- */
-@RunWith(AndroidJUnit4.class)
-public class PdfCanvasPhaseTimingTest {
-
-  private static final String TAG = "PDFCANVAS";
-
-  /**
-   * The viewport the field report was taken at: 131.25 device px per PDF point,
-   * i.e. zoom 50x on a 2.625 dpr phone. Everything in this file is measured
-   * there, because the complaint is about that state and cost does not
-   * necessarily scale linearly out of it.
-   */
-  private static final float PROBE_SCALE = 131.25f;
-
-  /** {@code maxPieceDimension}'s current default. */
-  private static final int TILE_PX = 1024;
-
-  /** The probe document's shape: 6 x US Letter, stacked. */
-  private static final int PROBE_PAGES = 6;
-
-  private static final int SAMPLES = 20;
-
-  /** Same convention as {@link PdfCanvasDeviceTimingTest}: push one to use it. */
-  private static final String REAL_PDF = "customer.pdf";
-
-  private static Context ctx() {
-    return InstrumentationRegistry.getInstrumentation().getTargetContext();
-  }
-
-  /* ================================================================ *
-   * Fixtures
-   * ================================================================ */
-
-  /** The real drawing if one was pushed, else the synthetic 6-page letter sheet. */
-  private static File fixture() throws IOException {
-    File dir = ctx().getExternalFilesDir(null);
-    File real = dir == null ? null : new File(dir, REAL_PDF);
-    if (real != null && real.isFile()) {
-      return real;
-    }
-    Log.w(
-        TAG,
-        "no "
-            + REAL_PDF
-            + " — falling back to the SYNTHETIC 6-page letter pattern, which is "
-            + "vector rects and lines and is therefore an OPTIMISTIC bound. Push a "
-            + "real drawing to:\n  adb push drawing.pdf /sdcard/Android/data/"
-            + ctx().getPackageName()
-            + "/files/"
-            + REAL_PDF);
-    return TestPdfs.pattern(
-        ctx(), "phase-letter6.pdf", TestPdfs.LETTER_W, TestPdfs.LETTER_H, PROBE_PAGES);
-  }
-
-  private static boolean usingRealPdf() {
-    File dir = ctx().getExternalFilesDir(null);
-    return dir != null && new File(dir, REAL_PDF).isFile();
-  }
-
-  /**
-   * The six pieces of the field report's detail epoch, laid out the way the
-   * planner lays them out: a 2-wide, 3-tall grid of {@code TILE_PX} tiles anchored
-   * at the visible rect's origin.
-   *
-   * The real epoch's right and bottom pieces are CLIPPED (the detail rect is
-   * 1345 x 2133 px, so the third row is 85 px tall). Full 1024 squares are used
-   * throughout anyway: the question here is what one full-size piece costs and
-   * how N of them scale, and a clipped piece only ever costs less.
-   */
-  private static List<RasterRequest> epochPieces(int count, int page) {
-    float side = TILE_PX / PROBE_SCALE; // 7.8019 pt
-    List<RasterRequest> out = new ArrayList<>(count);
-    for (int i = 0; i < count; i++) {
-      float x = 242.9f + (i % 2) * side;
-      float y = 549.4f + (i / 2) * side;
-      out.add(
-          new RasterRequest(
-              page, x, y, side, side, PROBE_SCALE, false, RasterRequest.BACKGROUND_WHITE));
-    }
-    return out;
-  }
-
-  /* ================================================================ *
-   * 1. Phase decomposition
-   * ================================================================ */
-
-  /** Every timed segment of one tile, in nanoseconds. */
-  private static final class Phases {
-    long openPage;
-    long alloc;
-    long erase;
-    long render;
-    long extract;
-    long base64;
-    long teardown;
-    long total;
-    int rawBytes;
-    int base64Chars;
-    int rowBytes;
-    byte[] bytes;
-  }
-
-  /**
-   * MIRRORS {@code PdfCanvasRasterizer.renderLeased} exactly, plus the base64
-   * encode that {@code PdfCanvasModule.render} does on the same worker thread.
-   * Pinned against the real render by {@link #phaseHarnessMatchesTheRealRender}.
-   */
-  private static Phases renderPhases(PdfRenderer renderer, RasterRequest request) {
-    Phases p = new Phases();
-    int pxW = request.pixelWidth();
-    int pxH = request.pixelHeight();
-
-    long t0 = System.nanoTime();
-    PdfRenderer.Page page = renderer.openPage(request.page);
-    long t1 = System.nanoTime();
-
-    Bitmap bitmap = Bitmap.createBitmap(pxW, pxH, Bitmap.Config.ARGB_8888);
-    long t2 = System.nanoTime();
-
-    bitmap.eraseColor(
-        request.background == RasterRequest.BACKGROUND_TRANSPARENT
-            ? Color.TRANSPARENT
-            : Color.WHITE);
-    long t3 = System.nanoTime();
-
-    Matrix matrix = new Matrix();
-    matrix.setScale(request.scale, request.scale);
-    matrix.postTranslate(-request.docX * request.scale, -request.docY * request.scale);
-    page.render(bitmap, null, matrix, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);
-    long t4 = System.nanoTime();
-
-    int rowBytes = bitmap.getRowBytes();
-    byte[] bytes = new byte[bitmap.getByteCount()];
-    bitmap.copyPixelsToBuffer(ByteBuffer.wrap(bytes));
-    long t5 = System.nanoTime();
-
-    String encoded = Base64.encodeToString(bytes, Base64.NO_WRAP);
-    long t6 = System.nanoTime();
-
-    bitmap.recycle();
-    page.close();
-    long t7 = System.nanoTime();
-
-    p.openPage = t1 - t0;
-    p.alloc = t2 - t1;
-    p.erase = t3 - t2;
-    p.render = t4 - t3;
-    p.extract = t5 - t4;
-    p.base64 = t6 - t5;
-    p.teardown = t7 - t6;
-    p.total = t7 - t0;
-    p.rawBytes = bytes.length;
-    p.base64Chars = encoded.length();
-    p.rowBytes = rowBytes;
-    p.bytes = bytes;
-    return p;
-  }
-
-  /**
-   * CATCHES: {@link #renderPhases} drifting away from
-   * {@code PdfCanvasRasterizer.renderLeased}, which would make every number in
-   * this file a measurement of code that never runs in production.
-   *
-   * Byte-for-byte, not "close enough" — the two paths build the same matrix from
-   * the same request, so any difference at all means a step was dropped or
-   * reordered.
-   */
-  @Test
-  public void phaseHarnessMatchesTheRealRender() throws Exception {
-    File pdf = fixture();
-    RasterRequest request = epochPieces(1, 0).get(0);
-
-    PdfCanvasRasterizer real = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    RasterPixels expected;
-    try {
-      expected = real.render(request, null);
-    } finally {
-      real.close();
-    }
-
-    ParcelFileDescriptor pfd =
-        ParcelFileDescriptor.open(pdf, ParcelFileDescriptor.MODE_READ_ONLY);
-    PdfRenderer renderer = new PdfRenderer(pfd);
-    Phases got;
-    try {
-      got = renderPhases(renderer, request);
-    } finally {
-      renderer.close();
-    }
-
-    assertEquals("rowBytes", expected.rowBytes, got.rowBytes);
-    assertEquals("byte count", expected.bytes.length, got.rawBytes);
-    RasterPixels mirrored =
-        new RasterPixels(
-            got.bytes,
-            expected.width,
-            expected.height,
-            got.rowBytes,
-            RasterPixels.FORMAT_RGBA_8888);
-    PdfCanvasRasterizerTest.Diff diff =
-        PdfCanvasRasterizerTest.compareRegion(mirrored, expected, 0, 0);
-    assertEquals(
-        "the phase harness must render exactly what the rasterizer renders: " + diff,
-        0,
-        diff.mismatches);
-  }
-
-  /**
-   * The decomposition. One 1024 px tile at the field report's scale, broken into
-   * its six phases plus teardown, {@value #SAMPLES} times.
-   *
-   * The tile WALKS between samples, for the reason
-   * {@link PdfCanvasDeviceTimingTest#report} gives: re-rendering one rect
-   * measures PDFium's cache, and panning does not get that.
-   */
-  @Test
-  public void phaseBreakdownOfOneTileAtProbeScale() throws Exception {
-    File pdf = fixture();
-    ParcelFileDescriptor pfd =
-        ParcelFileDescriptor.open(pdf, ParcelFileDescriptor.MODE_READ_ONLY);
-    PdfRenderer renderer = new PdfRenderer(pfd);
-    try {
-      Log.i(
-          TAG,
-          "PHASES fixture="
-              + (usingRealPdf() ? "REAL " + REAL_PDF : "SYNTHETIC 6-page letter")
-              + " "
-              + pdf.length()
-              + " bytes, "
-              + renderer.getPageCount()
-              + " pages, scale="
-              + PROBE_SCALE
-              + " devpx/pt");
-      for (int px : new int[] {TILE_PX, 512}) {
-        phaseReport(renderer, px, Math.min(PROBE_PAGES, renderer.getPageCount()));
-      }
-    } finally {
-      renderer.close();
-    }
-  }
-
-  private static void phaseReport(PdfRenderer renderer, int px, int pages) {
-    float side = px / PROBE_SCALE;
-    long[] openPage = new long[SAMPLES];
-    long[] alloc = new long[SAMPLES];
-    long[] erase = new long[SAMPLES];
-    long[] render = new long[SAMPLES];
-    long[] extract = new long[SAMPLES];
-    long[] base64 = new long[SAMPLES];
-    long[] teardown = new long[SAMPLES];
-    long[] total = new long[SAMPLES];
-    Phases last = null;
-
-    for (int i = 0; i < SAMPLES; i++) {
-      // Walk over the page BODY so no two samples share PDFium's per-region
-      // cache — and, just as importantly, so no sample lands in the margin. A
-      // 7.8 pt tile stepped by 3 x itself never leaves the top-left corner of a
-      // letter page, which on a real drawing is white space: the first run of
-      // this test measured PdfRenderer.render at 0.076 ms for exactly that
-      // reason. These 20 positions span 60..500 pt across and 90..540 pt down.
-      float x = 60f + (i % 5) * 110f;
-      float y = 90f + (i / 5) * 150f;
-      RasterRequest request =
-          new RasterRequest(
-              i % Math.max(1, pages),
-              x,
-              y,
-              side,
-              side,
-              PROBE_SCALE,
-              false,
-              RasterRequest.BACKGROUND_WHITE);
-      Phases p = renderPhases(renderer, request);
-      openPage[i] = p.openPage;
-      alloc[i] = p.alloc;
-      erase[i] = p.erase;
-      render[i] = p.render;
-      extract[i] = p.extract;
-      base64[i] = p.base64;
-      teardown[i] = p.teardown;
-      total[i] = p.total;
-      p.bytes = null; // 4 MiB per sample; do not hold 20 of them.
-      last = p;
-    }
-
-    Log.i(
-        TAG,
-        "PHASES "
-            + px
-            + "px@"
-            + PROBE_SCALE
-            + "x  n="
-            + SAMPLES
-            + "  raw="
-            + (last == null ? 0 : last.rawBytes)
-            + "B base64="
-            + (last == null ? 0 : last.base64Chars)
-            + "chars rowBytes="
-            + (last == null ? 0 : last.rowBytes));
-    line("1 PdfRenderer.render", render, total);
-    line("2 Bitmap alloc+zero", alloc, total);
-    line("2b eraseColor(WHITE)", erase, total);
-    line("3 extract to byte[]", extract, total);
-    line("4 base64 encode    ", base64, total);
-    line("- openPage         ", openPage, total);
-    line("- recycle+close    ", teardown, total);
-    line("= TOTAL            ", total, total);
-  }
-
-  /** One phase row: p50/p95 in microseconds, plus its share of the tile's p50. */
-  private static void line(String label, long[] ns, long[] totalNs) {
-    long[] s = ns.clone();
-    Arrays.sort(s);
-    long[] t = totalNs.clone();
-    Arrays.sort(t);
-    long p50 = percentile(s, 50);
-    long totalP50 = Math.max(1L, percentile(t, 50));
-    Log.i(
-        TAG,
-        String.format(
-            "  %s  p50=%8.3f ms  p95=%8.3f ms  min=%8.3f  max=%8.3f  share(p50)=%5.1f%%",
-            label,
-            p50 / 1e6,
-            percentile(s, 95) / 1e6,
-            s[0] / 1e6,
-            s[s.length - 1] / 1e6,
-            (100.0 * p50) / totalP50));
-  }
-
-  /* ================================================================ *
-   * 2. Concurrency headroom — the number the fix depends on
-   * ================================================================ */
-
-  /**
-   * N tiles one at a time versus N tiles across N threads through a pool of N,
-   * for N = 2, 3, 4 and 6.
-   *
-   * This is the whole case for parallelising the controller's per-piece loop, and
-   * it is reported rather than asserted: a speedup assertion fails on a warm
-   * phone and teaches nobody anything. What the numbers can show is the failure
-   * mode the pool's own header warns about — AOSP has historically serialised
-   * every {@code PdfRenderer} native call behind a process-wide PDFium lock, and
-   * if that lock is present on this build the parallel row will match the serial
-   * row and no amount of controller work will change it.
-   *
-   * N = 6 exceeds {@link PdfRendererPool#MAX_POOL_SIZE}, deliberately: the field
-   * report's epoch is 6 pieces, so the honest question is what 6 pieces cost with
-   * the pool as it is actually capped, not with a hypothetical pool of 6.
-   */
-  @Test
-  public void poolConcurrencyScalingAtProbeScale() throws Exception {
-    File pdf = fixture();
-    Log.i(
-        TAG,
-        "CONCURRENCY fixture="
-            + (usingRealPdf() ? "REAL " + REAL_PDF : "SYNTHETIC 6-page letter")
-            + " tile="
-            + TILE_PX
-            + "px scale="
-            + PROBE_SCALE
-            + " MAX_POOL_SIZE="
-            + PdfRendererPool.MAX_POOL_SIZE
-            + " cores="
-            + Runtime.getRuntime().availableProcessors());
-
-    for (int n : new int[] {2, 3, 4, 6}) {
-      List<RasterRequest> pieces = epochPieces(n, 0);
-      long serial = bestOfFive(() -> renderSerially(pdf, pieces));
-      int poolSize = Math.min(n, PdfRendererPool.MAX_POOL_SIZE);
-      long parallel = bestOfFive(() -> renderInParallel(pdf, pieces, n, poolSize));
-      Log.i(
-          TAG,
-          String.format(
-              "CONCURRENCY n=%d  serial=%5d ms (%6.1f ms/tile)  parallel(pool=%d,threads=%d)"
-                  + "=%5d ms (%6.1f ms/tile)  speedup=%.2fx",
-              n,
-              serial,
-              serial / (double) n,
-              poolSize,
-              n,
-              parallel,
-              parallel / (double) n,
-              serial / (double) Math.max(1L, parallel)));
-    }
-  }
-
-  private interface Run {
-    long runMs() throws Exception;
-  }
-
-  /**
-   * BEST of five, not median.
-   *
-   * The opposite of what {@link PdfCanvasDeviceTimingTest} wants for a cadence
-   * constant, and for the opposite reason: this test is a RATIO of two runs, and
-   * a thermal or scheduler stall lands in whichever run it happens to hit and
-   * moves the ratio in a direction that means nothing. The floor of each side is
-   * the number least polluted by the phone doing something else — and the user is
-   * actively using this one, so that is not a hypothetical.
-   */
-  private static long bestOfFive(Run run) throws Exception {
-    long best = Long.MAX_VALUE;
-    for (int i = 0; i < 5; i++) {
-      best = Math.min(best, run.runMs());
-    }
-    return best;
-  }
-
-  /**
-   * The Java-side work of ONE tile as {@code PdfCanvasModule} actually performs
-   * it: the raster, and then the base64 encode of its pixels on the same worker
-   * thread, before the promise resolves.
-   *
-   * Including the encode is not padding. It is 75-80% of the Java cost of a
-   * 1024 px tile (see {@link #phaseBreakdownOfOneTileAtProbeScale}), it sits in
-   * the serial chain the user waits on, and it is exactly as parallelisable as
-   * the render — so a concurrency measurement that left it out would answer a
-   * question nobody asked.
-   */
-  private static void renderAndEncode(PdfCanvasRasterizer r, RasterRequest request)
-      throws PdfRasterException {
-    RasterPixels pixels = r.render(request, null);
-    // The result is used, so neither the encode nor the raster can be optimised
-    // away — and the length is the payload the bridge is handed.
-    if (Base64.encodeToString(pixels.bytes, Base64.NO_WRAP).isEmpty()) {
-      throw new AssertionError("empty base64 for " + request);
-    }
-  }
-
-  private static long renderSerially(File pdf, List<RasterRequest> pieces) throws Exception {
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 1);
-    try {
-      warm(r, pieces, 1);
-      long t0 = System.nanoTime();
-      for (RasterRequest request : pieces) {
-        renderAndEncode(r, request);
-      }
-      return (System.nanoTime() - t0) / 1_000_000L;
-    } finally {
-      r.close();
-    }
-  }
-
-  private static long renderInParallel(
-      File pdf, List<RasterRequest> pieces, int threads, int poolSize) throws Exception {
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, poolSize);
-    assertEquals("pool size", poolSize, r.poolSize());
-    ExecutorService exec = Executors.newFixedThreadPool(threads);
-    CountDownLatch ready = new CountDownLatch(threads);
-    CountDownLatch go = new CountDownLatch(1);
-    CountDownLatch done = new CountDownLatch(threads);
-    AtomicReference<Throwable> failure = new AtomicReference<>();
-    long t0;
-    try {
-      // Warms EVERY renderer in the pool before the clock starts. Without this
-      // the parallel run pays for N independent page parses that the serial run
-      // paid once, and the comparison measures the warm-up rather than the lock.
-      warm(r, pieces, poolSize);
-
-      for (int t = 0; t < threads; t++) {
-        final RasterRequest request = pieces.get(t % pieces.size());
-        exec.execute(
-            () -> {
-              try {
-                ready.countDown();
-                go.await();
-                renderAndEncode(r, request);
-              } catch (Throwable e) {
-                failure.compareAndSet(null, e);
-              } finally {
-                done.countDown();
-              }
-            });
-      }
-      // Thread CREATION happens before the clock starts; only the wake-up from
-      // the latch is inside it. Without this barrier the first round of a
-      // 6-thread run charges the parallel side for spawning threads that the
-      // serial side never spawns.
-      assertTrue("threads did not start in 30s", ready.await(30, TimeUnit.SECONDS));
-      t0 = System.nanoTime();
-      go.countDown();
-      assertTrue("threads did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-    } finally {
-      exec.shutdownNow();
-      r.close();
-    }
-    Throwable f = failure.get();
-    if (f != null) {
-      throw new AssertionError("a parallel render failed: " + f, f);
-    }
-    return (System.nanoTime() - t0) / 1_000_000L;
-  }
-
-  /**
-   * Touches every renderer in the pool, by keeping {@code poolSize} renders in
-   * flight at once — a serial loop would warm renderer #0 and nothing else,
-   * because the pool hands back the one it just took.
-   */
-  private static void warm(PdfCanvasRasterizer r, List<RasterRequest> pieces, int poolSize)
-      throws Exception {
-    if (poolSize <= 1) {
-      r.render(pieces.get(0), null);
-      return;
-    }
-    ExecutorService exec = Executors.newFixedThreadPool(poolSize);
-    CountDownLatch done = new CountDownLatch(poolSize);
-    AtomicReference<Throwable> failure = new AtomicReference<>();
-    try {
-      for (int i = 0; i < poolSize; i++) {
-        final RasterRequest request = pieces.get(i % pieces.size());
-        exec.execute(
-            () -> {
-              try {
-                r.render(request, null);
-              } catch (Throwable e) {
-                failure.compareAndSet(null, e);
-              } finally {
-                done.countDown();
-              }
-            });
-      }
-      assertTrue("warm-up did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-    } finally {
-      exec.shutdownNow();
-    }
-    Throwable f = failure.get();
-    if (f != null) {
-      throw new AssertionError("warm-up render failed: " + f, f);
-    }
-  }
-
-  /**
-   * WHY the parallel row of {@link #poolConcurrencyScalingAtProbeScale} comes out
-   * SLOWER, phase by phase.
-   *
-   * A wall-clock ratio says the pool does not scale; it cannot say whether that
-   * is a PDFium lock, the bitmap allocator, memory bandwidth, or nothing but
-   * thread wake-up skew. So this renders the same tiles twice — once serially on
-   * one renderer, once with one renderer per thread — through the SAME phase
-   * harness, and prints both breakdowns side by side. Whichever phase inflates is
-   * the mechanism.
-   *
-   * The base64 encode is included on both sides because it runs on the render
-   * worker in {@code PdfCanvasModule}, so it is part of what parallelising the
-   * controller's loop would actually spread out.
-   *
-   * {@code wake} is the gap between the starting gun and a thread's first
-   * instruction, recorded so that "the threads never overlapped" cannot be
-   * mistaken for "the work does not parallelise".
-   */
-  @Test
-  public void phaseBreakdownUnderConcurrency() throws Exception {
-    File pdf = fixture();
-    int n = 4;
-    List<RasterRequest> pieces = epochPieces(n, 0);
-
-    List<ParcelFileDescriptor> fds = new ArrayList<>();
-    List<PdfRenderer> renderers = new ArrayList<>();
-    try {
-      for (int i = 0; i < n; i++) {
-        ParcelFileDescriptor pfd =
-            ParcelFileDescriptor.open(pdf, ParcelFileDescriptor.MODE_READ_ONLY);
-        fds.add(pfd);
-        renderers.add(new PdfRenderer(pfd));
-      }
-
-      // Warm every renderer on its own tile, on its own thread, so neither run
-      // pays for a first-touch page parse inside the timed section.
-      runAcross(renderers, pieces, n);
-
-      Phases[] serial = new Phases[n];
-      long serialStart = System.nanoTime();
-      for (int i = 0; i < n; i++) {
-        serial[i] = renderPhases(renderers.get(0), pieces.get(i));
-        serial[i].bytes = null;
-      }
-      long serialMs = (System.nanoTime() - serialStart) / 1_000_000L;
-
-      Concurrent concurrent = runAcross(renderers, pieces, n);
-
-      Log.i(
-          TAG,
-          String.format(
-              "CONC-PHASES n=%d tile=%dpx@%.2fx  serial wall=%d ms  parallel wall=%d ms"
-                  + "  wake(max)=%.2f ms",
-              n, TILE_PX, PROBE_SCALE, serialMs, concurrent.wallMs, concurrent.maxWakeNs / 1e6));
-      comparePhase("1 PdfRenderer.render", serial, concurrent.phases, p -> p.render);
-      comparePhase("2 Bitmap alloc+zero ", serial, concurrent.phases, p -> p.alloc);
-      comparePhase("2b eraseColor(WHITE)", serial, concurrent.phases, p -> p.erase);
-      comparePhase("3 extract to byte[] ", serial, concurrent.phases, p -> p.extract);
-      comparePhase("4 base64 encode     ", serial, concurrent.phases, p -> p.base64);
-      comparePhase("- openPage          ", serial, concurrent.phases, p -> p.openPage);
-      comparePhase("- recycle+close     ", serial, concurrent.phases, p -> p.teardown);
-      comparePhase("= TOTAL             ", serial, concurrent.phases, p -> p.total);
-    } finally {
-      for (PdfRenderer renderer : renderers) {
-        renderer.close();
-      }
-      for (ParcelFileDescriptor pfd : fds) {
-        try {
-          pfd.close();
-        } catch (IOException ignored) {
-          // PdfRenderer.close() already closed it; nothing to salvage.
-        }
-      }
-    }
-  }
-
-  private static final class Concurrent {
-    Phases[] phases;
-    long wallMs;
-    long maxWakeNs;
-  }
-
-  /** One tile per thread, one renderer per thread, released by a single latch. */
-  private static Concurrent runAcross(
-      List<PdfRenderer> renderers, List<RasterRequest> pieces, int n) throws Exception {
-    Phases[] out = new Phases[n];
-    long[] wake = new long[n];
-    ExecutorService exec = Executors.newFixedThreadPool(n);
-    CountDownLatch ready = new CountDownLatch(n);
-    CountDownLatch go = new CountDownLatch(1);
-    CountDownLatch done = new CountDownLatch(n);
-    AtomicReference<Throwable> failure = new AtomicReference<>();
-    long[] released = new long[1];
-    try {
-      for (int i = 0; i < n; i++) {
-        final int index = i;
-        exec.execute(
-            () -> {
-              try {
-                ready.countDown();
-                go.await();
-                wake[index] = System.nanoTime() - released[0];
-                Phases p = renderPhases(renderers.get(index), pieces.get(index));
-                p.bytes = null;
-                out[index] = p;
-              } catch (Throwable e) {
-                failure.compareAndSet(null, e);
-              } finally {
-                done.countDown();
-              }
-            });
-      }
-      // Every thread is parked on `go` before the clock starts, so thread
-      // CREATION is outside the measurement and only the wake-up is inside it.
-      assertTrue("threads did not start in 30s", ready.await(30, TimeUnit.SECONDS));
-      long t0 = System.nanoTime();
-      released[0] = t0;
-      go.countDown();
-      assertTrue("threads did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-      Concurrent result = new Concurrent();
-      result.wallMs = (System.nanoTime() - t0) / 1_000_000L;
-      result.phases = out;
-      for (long w : wake) {
-        result.maxWakeNs = Math.max(result.maxWakeNs, w);
-      }
-      Throwable f = failure.get();
-      if (f != null) {
-        throw new AssertionError("a concurrent render failed: " + f, f);
-      }
-      return result;
-    } finally {
-      exec.shutdownNow();
-    }
-  }
-
-  private interface PhasePick {
-    long of(Phases p);
-  }
-
-  private static void comparePhase(
-      String label, Phases[] serial, Phases[] parallel, PhasePick pick) {
-    Log.i(
-        TAG,
-        String.format(
-            "  %s  serial p50=%8.3f ms max=%8.3f  |  parallel p50=%8.3f ms max=%8.3f"
-                + "  inflation=%.2fx",
-            label,
-            median(serial, pick) / 1e6,
-            max(serial, pick) / 1e6,
-            median(parallel, pick) / 1e6,
-            max(parallel, pick) / 1e6,
-            median(parallel, pick) / Math.max(1.0, median(serial, pick))));
-  }
-
-  private static double median(Phases[] samples, PhasePick pick) {
-    long[] values = new long[samples.length];
-    for (int i = 0; i < samples.length; i++) {
-      values[i] = samples[i] == null ? 0L : pick.of(samples[i]);
-    }
-    Arrays.sort(values);
-    return percentile(values, 50);
-  }
-
-  private static double max(Phases[] samples, PhasePick pick) {
-    long best = 0;
-    for (Phases p : samples) {
-      if (p != null) {
-        best = Math.max(best, pick.of(p));
-      }
-    }
-    return best;
-  }
-
-  /* ================================================================ *
-   * 2b. WHY it does not scale — PDFium versus everything else
-   * ================================================================ */
-
-  /**
-   * THE DECISIVE EXPERIMENT. Runs the two halves of a tile SEPARATELY across N
-   * threads and asks which one refuses to parallelise.
-   *
-   *   A — PDFium only: {@code openPage}, {@code render} into a bitmap allocated
-   *       once per thread up front, {@code close}. No allocation, no copy, no
-   *       encode inside the timed region.
-   *   B — pure Java only: base64 of a 4 MiB {@code byte[]} allocated up front.
-   *       Same byte volume as one 1024 px tile, no native PDF code anywhere.
-   *
-   * If A's per-operation cost inflates by roughly N while its wall clock stays
-   * flat, every thread was queueing behind one lock — which is what
-   * {@link PdfRendererPool}'s own header says AOSP does, and the difference
-   * between "the pool buys throughput" and "the pool buys correctness only".
-   * B is the control: it is bounded by memory bandwidth and nothing else, so
-   * whatever inflation it shows is the floor that any parallel scheme on this
-   * phone pays regardless.
-   *
-   * Reported, never asserted — the presence of the lock is a property of this
-   * platform build, and a test that failed when a future Android removed it
-   * would be a test that punishes good news.
-   *
-   * READ THE RATIOS, NOT THE ABSOLUTES. Each round here is one operation per
-   * thread with executor churn either side, so the CPU governor never ramps and
-   * the scheduler is free to park the work on a little core — measured per-op
-   * costs come out 2-4x the tight-loop figures in
-   * {@link #phaseBreakdownOfOneTileAtProbeScale} for that reason. A and B are
-   * measured identically in the same run, so how each one's THROUGHPUT moves with
-   * N is sound even though neither absolute is.
-   */
-  @Test
-  public void whichPhasesSerialiseUnderConcurrency() throws Exception {
-    File pdf = fixture();
-    int maxThreads = 4;
-    RasterRequest piece = epochPieces(1, 0).get(0);
-    int px = piece.pixelWidth();
-
-    List<ParcelFileDescriptor> fds = new ArrayList<>();
-    List<PdfRenderer> renderers = new ArrayList<>();
-    List<Bitmap> bitmaps = new ArrayList<>();
-    List<byte[]> buffers = new ArrayList<>();
-    try {
-      for (int i = 0; i < maxThreads; i++) {
-        ParcelFileDescriptor pfd =
-            ParcelFileDescriptor.open(pdf, ParcelFileDescriptor.MODE_READ_ONLY);
-        fds.add(pfd);
-        renderers.add(new PdfRenderer(pfd));
-        bitmaps.add(Bitmap.createBitmap(px, px, Bitmap.Config.ARGB_8888));
-        buffers.add(new byte[px * px * 4]);
-      }
-
-      Matrix matrix = new Matrix();
-      matrix.setScale(piece.scale, piece.scale);
-      matrix.postTranslate(-piece.docX * piece.scale, -piece.docY * piece.scale);
-
-      ThreadOp openOnly =
-          thread -> {
-            long t0 = System.nanoTime();
-            renderers.get(thread).openPage(piece.page).close();
-            return System.nanoTime() - t0;
-          };
-      ThreadOp pdfium =
-          thread -> {
-            long t0 = System.nanoTime();
-            PdfRenderer.Page page = renderers.get(thread).openPage(piece.page);
-            page.render(
-                bitmaps.get(thread), null, matrix, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);
-            page.close();
-            return System.nanoTime() - t0;
-          };
-      ThreadOp pureJava =
-          thread -> {
-            long t0 = System.nanoTime();
-            if (Base64.encodeToString(buffers.get(thread), Base64.NO_WRAP).isEmpty()) {
-              throw new AssertionError("empty base64");
-            }
-            return System.nanoTime() - t0;
-          };
-
-      Log.i(
-          TAG,
-          "SERIALISATION fixture="
-              + (usingRealPdf() ? "REAL " + REAL_PDF : "SYNTHETIC 6-page letter")
-              + " tile="
-              + px
-              + "px@"
-              + PROBE_SCALE
-              + "x  A=PDFium(openPage+render+close)  B=pure-Java(base64 of "
-              + (px * px * 4)
-              + " B)");
-      // Warm every renderer on its own thread first, so no probe round pays for
-      // a first-touch page parse and the n=1 baselines are honest.
-      probe("warm-up  ", maxThreads, pdfium);
-      for (int n : new int[] {1, 2, 4}) {
-        probe("A0 openPg", n, openOnly);
-        probe("A PDFium ", n, pdfium);
-        probe("B Java   ", n, pureJava);
-      }
-    } finally {
-      for (Bitmap bitmap : bitmaps) {
-        bitmap.recycle();
-      }
-      for (PdfRenderer renderer : renderers) {
-        renderer.close();
-      }
-      for (ParcelFileDescriptor pfd : fds) {
-        try {
-          pfd.close();
-        } catch (IOException ignored) {
-          // PdfRenderer.close() already closed it.
-        }
-      }
-    }
-  }
-
-  private interface ThreadOp {
-    /** @return nanoseconds spent inside the operation itself, on this thread. */
-    long run(int thread) throws Exception;
-  }
-
-  /** Best of five, for the reason {@link #bestOfFive} gives. */
-  private static void probe(String label, int n, ThreadOp op) throws Exception {
-    long bestWall = Long.MAX_VALUE;
-    long bestMedianOp = Long.MAX_VALUE;
-    for (int round = 0; round < 5; round++) {
-      long[] ops = new long[n];
-      ExecutorService exec = Executors.newFixedThreadPool(n);
-      CountDownLatch ready = new CountDownLatch(n);
-      CountDownLatch go = new CountDownLatch(1);
-      CountDownLatch done = new CountDownLatch(n);
-      AtomicReference<Throwable> failure = new AtomicReference<>();
-      long wall;
-      try {
-        for (int i = 0; i < n; i++) {
-          final int index = i;
-          exec.execute(
-              () -> {
-                try {
-                  ready.countDown();
-                  go.await();
-                  ops[index] = op.run(index);
-                } catch (Throwable e) {
-                  failure.compareAndSet(null, e);
-                } finally {
-                  done.countDown();
-                }
-              });
-        }
-        assertTrue("threads did not start in 30s", ready.await(30, TimeUnit.SECONDS));
-        long t0 = System.nanoTime();
-        go.countDown();
-        assertTrue("threads did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-        wall = System.nanoTime() - t0;
-      } finally {
-        exec.shutdownNow();
-      }
-      Throwable f = failure.get();
-      if (f != null) {
-        throw new AssertionError("probe " + label + " failed: " + f, f);
-      }
-      Arrays.sort(ops);
-      bestWall = Math.min(bestWall, wall);
-      bestMedianOp = Math.min(bestMedianOp, percentile(ops, 50));
-    }
-    Log.i(
-        TAG,
-        String.format(
-            "  %s n=%d  wall=%8.3f ms  per-op(p50)=%8.3f ms  ops/ms=%.3f",
-            label, n, bestWall / 1e6, bestMedianOp / 1e6, n / (bestWall / 1e6)));
-  }
-
-  /* ================================================================ *
-   * 3. Whole-epoch wall clock — what the user actually waits for
-   * ================================================================ */
-
-  /**
-   * The field report's epoch end to end: 6 x 1024 px pieces at 131.25x, rendered
-   * the way the controller renders them today (strictly one at a time through a
-   * pool of ONE, which is what a single-threaded {@code await} loop reduces the
-   * pool to) against the same six across four threads.
-   *
-   * Reported with the base64 encode included, because that runs on the same
-   * worker as the render in {@code PdfCanvasModule} and is therefore part of the
-   * serial chain the user waits on.
-   */
-  @Test
-  public void wholeEpochWallClock() throws Exception {
-    File pdf = fixture();
-    List<RasterRequest> pieces = epochPieces(6, 0);
-
-    long serial = bestOfFive(() -> renderSerially(pdf, pieces));
-
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, 4);
-    long encodeNs = 0;
-    int rawBytes = 0;
-    long base64Chars = 0;
-    try {
-      warm(r, pieces, 4);
-      for (RasterRequest request : pieces) {
-        RasterPixels px = r.render(request, null);
-        long t0 = System.nanoTime();
-        String encoded = Base64.encodeToString(px.bytes, Base64.NO_WRAP);
-        encodeNs += System.nanoTime() - t0;
-        rawBytes += px.bytes.length;
-        base64Chars += encoded.length();
-      }
-    } finally {
-      r.close();
-    }
-
-    Log.i(
-        TAG,
-        String.format(
-            "EPOCH 6 x %dpx@%.2fx  serial render+encode=%d ms  of which encode=%.1f ms"
-                + "  payload raw=%d B base64=%d chars (%.2f MiB / %.2f MiB)",
-            TILE_PX,
-            PROBE_SCALE,
-            serial,
-            encodeNs / 1e6,
-            rawBytes,
-            base64Chars,
-            rawBytes / (1024.0 * 1024.0),
-            base64Chars / (1024.0 * 1024.0)));
-  }
-
-  /* ================================================================ *
-   * 5. The controller's lane scheduler, before and after
-   * ================================================================ */
-
-  /**
-   * BEFORE vs AFTER for the change that replaced the controller's sequential
-   * {@code for ... await handle.render(...)} loop with
-   * {@code maxConcurrentRenders} lanes.
-   *
-   * This is the same shape as {@link #poolConcurrencyScalingAtProbeScale} with
-   * one difference that matters: that test gives every thread its own piece,
-   * which is a fan-out, whereas the controller runs LANES — N workers pulling
-   * from one shared queue of plan items until it is empty. With 6 pieces and 2
-   * lanes those are not the same schedule, and the shipped code is the lane one,
-   * so it is the one measured here.
-   *
-   * WHAT THIS NUMBER IS, AND — MORE IMPORTANTLY — WHAT IT IS NOT. It is the
-   * whole JAVA side of a 6-piece detail epoch: {@code openPage}, the bitmap, the
-   * white fill, {@code PdfRenderer.render}, the copy to a {@code byte[]}, and the
-   * base64 encode, exactly as {@code PdfCanvasModule} performs them on its render
-   * executor. It is NOT the epoch the user waits for. The field probe timed one
-   * tile at 595 ms while the whole Java side of that tile is 27.5 ms p50, so
-   * roughly 95% of what the user waits for is the transport — a 5,592,408-char
-   * base64 string crossing the bridge and being decoded one {@code charCodeAt} at
-   * a time on the JS thread — and none of that exists in a process with no React
-   * Native in it. Lanes cannot overlap the JS half with itself; the JS thread is
-   * one thread. So the honest end-to-end expectation is the SMALL number this
-   * measures, not a multiple of it, and the 4x has to come out of the transport.
-   */
-  @Test
-  public void laneSchedulerEpochWallClock() throws Exception {
-    File pdf = fixture();
-    List<RasterRequest> pieces = epochPieces(6, 0);
-
-    Log.i(
-        TAG,
-        "LANES fixture="
-            + (usingRealPdf() ? "REAL " + REAL_PDF : "SYNTHETIC 6-page letter")
-            + " pieces="
-            + pieces.size()
-            + " tile="
-            + TILE_PX
-            + "px scale="
-            + PROBE_SCALE);
-
-    long before = bestOfFive(() -> renderInLanes(pdf, pieces, 1));
-    for (int lanes : new int[] {2, 3, 4}) {
-      long after = bestOfFive(() -> renderInLanes(pdf, pieces, lanes));
-      Log.i(
-          TAG,
-          String.format(
-              "LANES  before(1 lane)=%4d ms   after(%d lanes)=%4d ms   speedup=%.2fx"
-                  + "   [JAVA SIDE ONLY — see javadoc]",
-              before, lanes, after, before / (double) Math.max(1L, after)));
-    }
-
-    laneScheduleOnTheJsiTransport(pdf, pieces);
-  }
-
-  /**
-   * THE SAME LANE SCHEDULE WITH THE BASE64 ENCODE DELETED, which is what the JSI
-   * transport actually ships.
-   *
-   * <h3>Why the rows above do not transfer</h3>
-   *
-   * Every lane win in the base64 block comes from spreading the ENCODE — 75-80%
-   * of the Java cost of a 1024 px tile, and the one phase in it that is pure Java
-   * and therefore genuinely parallel (see
-   * {@link #whichPhasesSerialiseUnderConcurrency}: {@code openPage} and
-   * {@code render} are flat-to-convoying across threads while a pure-Java control
-   * scales 2.8x). On the JSI path that phase is gone: the worker moves the raster
-   * into C++-owned memory and the promise resolves with a slot number. So the
-   * parallel fraction of a tile collapses, and the lane question has to be asked
-   * again against the work that is left.
-   *
-   * <h3>TWO ROWS, and the difference between them is the change under test</h3>
-   *
-   * {@code LANES-JSI} is the two-copy store: {@code render()} produces a
-   * {@code byte[]} and {@link PdfCanvasPixelBridge#nativeStore} copies it into
-   * the slot. {@code LANES-JSI-DIRECT} is
-   * {@link PdfCanvasRasterizer#renderToNativeSlot}, which fills the slot from the
-   * {@code Bitmap} and never allocates the array at all — one full-raster ART
-   * allocation and one full-raster memcpy less, per tile.
-   *
-   * <p>THE DELTA IS THE POINT, not the absolute numbers, and it is a per-tile
-   * delta on the render executor, which
-   * {@link #whichPhasesSerialiseUnderConcurrency} shows is the serialised
-   * bottleneck — so it does not spread across lanes and does not shrink as lanes
-   * are added. Read {@code ms/tile at p50} between the two blocks at MATCHED lane
-   * counts; comparing a 4-lane DIRECT row against a 1-lane JSI row measures the
-   * lane count instead.
-   *
-   * <p>Both are measured in the SAME interleaved schedule for the reason the next
-   * paragraph gives: run one block to completion and then the other, and the
-   * second one is charged for the first one heating the phone.
-   *
-   * <h3>Why the lane counts are interleaved rather than measured in a row</h3>
-   *
-   * The phone heats up and the governor moves, so measuring 1 lane five times and
-   * then 4 lanes five times charges the later block for the earlier one. Each
-   * round runs every lane count once, and the round number rotates which goes
-   * first, so no lane count is systematically on a cold or a hot phone.
-   *
-   * <h3>Why min AND p50 AND max</h3>
-   *
-   * A single best-of-N cannot say whether two lane counts genuinely differ or
-   * merely sit inside each other spread, and that is exactly the verdict this
-   * measurement exists to support.
-   */
-  private static void laneScheduleOnTheJsiTransport(File pdf, List<RasterRequest> pieces)
-      throws Exception {
-    assertTrue(
-        "libpdfcanvasjsi.so did not load, so there is no JSI path to measure.",
-        PdfCanvasPixelBridge.isLoaded());
-
-    final int[] laneCounts = {1, 2, 3, 4};
-    final int rounds = 21;
-    long[][] store = new long[laneCounts.length][rounds];
-    long[][] direct = new long[laneCounts.length][rounds];
-    for (int round = 0; round < rounds; round++) {
-      for (int k = 0; k < laneCounts.length; k++) {
-        int idx = (k + round) % laneCounts.length;
-        // Both fills at every lane count in every round, and which one goes
-        // first alternates. Otherwise whichever is second is systematically
-        // measured on a hotter phone, which is a bias the size of the effect.
-        if ((round & 1) == 0) {
-          store[idx][round] = renderInLanesOverJsi(pdf, pieces, laneCounts[idx], false);
-          direct[idx][round] = renderInLanesOverJsi(pdf, pieces, laneCounts[idx], true);
-        } else {
-          direct[idx][round] = renderInLanesOverJsi(pdf, pieces, laneCounts[idx], true);
-          store[idx][round] = renderInLanesOverJsi(pdf, pieces, laneCounts[idx], false);
-        }
-      }
-    }
-
-    reportLaneBlock("LANES-JSI", store, laneCounts, pieces.size());
-    reportLaneBlock("LANES-JSI-DIRECT", direct, laneCounts, pieces.size());
-
-    // The number the decision rests on: same lane count, both fills, per tile.
-    for (int k = 0; k < laneCounts.length; k++) {
-      long[] a = store[k].clone();
-      long[] b = direct[k].clone();
-      Arrays.sort(a);
-      Arrays.sort(b);
-      double perTileStore = percentile(a, 50) / (double) pieces.size();
-      double perTileDirect = percentile(b, 50) / (double) pieces.size();
-      Log.i(
-          TAG,
-          String.format(
-              "LANES-JSI-DELTA lanes=%d  store=%5.2f ms/tile  direct=%5.2f ms/tile"
-                  + "  saved=%5.2f ms/tile (%+.1f%%)  [p50, matched lanes]",
-              laneCounts[k],
-              perTileStore,
-              perTileDirect,
-              perTileStore - perTileDirect,
-              perTileStore == 0 ? 0 : -100.0 * (perTileStore - perTileDirect) / perTileStore));
-    }
-  }
-
-  private static void reportLaneBlock(
-      String label, long[][] runs, int[] laneCounts, int pieceCount) {
-    long[] baseline = runs[0].clone();
-    Arrays.sort(baseline);
-    for (int k = 0; k < laneCounts.length; k++) {
-      long[] sorted = runs[k].clone();
-      Arrays.sort(sorted);
-      Log.i(
-          TAG,
-          String.format(
-              "%s lanes=%d  min=%4d ms  p50=%4d ms  max=%4d ms"
-                  + "  mean=%6.1f ms  (%5.1f ms/tile at p50)"
-                  + "  vs 1 lane: min=%.2fx p50=%.2fx mean=%.2fx",
-              label,
-              laneCounts[k],
-              sorted[0],
-              percentile(sorted, 50),
-              sorted[sorted.length - 1],
-              mean(sorted),
-              percentile(sorted, 50) / (double) pieceCount,
-              baseline[0] / (double) Math.max(1L, sorted[0]),
-              percentile(baseline, 50) / (double) Math.max(1L, percentile(sorted, 50)),
-              mean(baseline) / Math.max(1.0, mean(sorted))));
-    }
-  }
-
-  /**
-   * The controller's schedule, in Java: {@code lanes} workers pulling plan items
-   * off one shared cursor until it is empty, each doing the full production
-   * per-tile work. A pool of {@code min(lanes, MAX_POOL_SIZE)}, because that is
-   * what the rasterizer now declares as {@code maxConcurrentRenders}.
-   */
-  private static long renderInLanes(File pdf, List<RasterRequest> pieces, int lanes)
-      throws Exception {
-    int poolSize = Math.min(lanes, PdfRendererPool.MAX_POOL_SIZE);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, poolSize);
-    ExecutorService exec = Executors.newFixedThreadPool(lanes);
-    CountDownLatch ready = new CountDownLatch(lanes);
-    CountDownLatch go = new CountDownLatch(1);
-    CountDownLatch done = new CountDownLatch(lanes);
-    AtomicInteger cursor = new AtomicInteger(0);
-    AtomicReference<Throwable> failure = new AtomicReference<>();
-    long t0;
-    try {
-      warm(r, pieces, poolSize);
-      for (int i = 0; i < lanes; i++) {
-        exec.execute(
-            () -> {
-              try {
-                ready.countDown();
-                go.await();
-                for (; ; ) {
-                  int slot = cursor.getAndIncrement();
-                  if (slot >= pieces.size()) {
-                    return;
-                  }
-                  renderAndEncode(r, pieces.get(slot));
-                }
-              } catch (Throwable e) {
-                failure.compareAndSet(null, e);
-              } finally {
-                done.countDown();
-              }
-            });
-      }
-      assertTrue("lanes did not start in 30s", ready.await(30, TimeUnit.SECONDS));
-      t0 = System.nanoTime();
-      go.countDown();
-      assertTrue("lanes did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-    } finally {
-      exec.shutdownNow();
-      r.close();
-    }
-    Throwable f = failure.get();
-    if (f != null) {
-      throw new AssertionError("a lane failed: " + f, f);
-    }
-    return (System.nanoTime() - t0) / 1_000_000L;
-  }
-
-  /**
-   * The identical lane schedule with the production JSI per-tile work.
-   *
-   * {@code PdfCanvasModule.render} on the fast transport does exactly two things
-   * per tile on its render worker: the raster, and
-   * {@code PdfCanvasPixelBridge.nativeStore} of the finished {@code byte[]} into
-   * C++-owned memory. There is no string and no encode. Both are inside the clock
-   * because both are on the worker.
-   *
-   * WHAT IS DELIBERATELY OUTSIDE THE CLOCK: freeing the slots. In production the
-   * buffer is handed to JS as an ArrayBuffer and freed when that is collected, so
-   * the render worker never pays for the free — charging this measurement for it
-   * would invent a cost the shipped path does not have. The slots are drained
-   * after the clock stops instead, which is also what stops a run leaving 24 MiB
-   * of native memory behind for the next one.
-   */
-  private static long renderInLanesOverJsi(
-      File pdf, List<RasterRequest> pieces, int lanes, boolean direct) throws Exception {
-    int poolSize = Math.min(lanes, PdfRendererPool.MAX_POOL_SIZE);
-    PdfCanvasRasterizer r = PdfCanvasRasterizer.openFile(pdf, null, poolSize);
-    ExecutorService exec = Executors.newFixedThreadPool(lanes);
-    CountDownLatch ready = new CountDownLatch(lanes);
-    CountDownLatch go = new CountDownLatch(1);
-    CountDownLatch done = new CountDownLatch(lanes);
-    AtomicInteger cursor = new AtomicInteger(0);
-    AtomicReference<Throwable> failure = new AtomicReference<>();
-    // Every lane stores; the drain below happens on this thread once they are all
-    // finished, so the queue is the only shared mutable thing between them.
-    ConcurrentLinkedQueue<Long> parked = new ConcurrentLinkedQueue<>();
-    long elapsedMs;
-    long t0;
-    try {
-      warm(r, pieces, poolSize);
-      for (int i = 0; i < lanes; i++) {
-        exec.execute(
-            () -> {
-              try {
-                ready.countDown();
-                go.await();
-                for (; ; ) {
-                  int slot = cursor.getAndIncrement();
-                  if (slot >= pieces.size()) {
-                    return;
-                  }
-                  if (direct) {
-                    renderAndFillDirect(r, pieces.get(slot), parked);
-                  } else {
-                    renderAndStore(r, pieces.get(slot), parked);
-                  }
-                }
-              } catch (Throwable e) {
-                failure.compareAndSet(null, e);
-              } finally {
-                done.countDown();
-              }
-            });
-      }
-      assertTrue("lanes did not start in 30s", ready.await(30, TimeUnit.SECONDS));
-      t0 = System.nanoTime();
-      go.countDown();
-      assertTrue("lanes did not finish in 120s", done.await(120, TimeUnit.SECONDS));
-      elapsedMs = (System.nanoTime() - t0) / 1_000_000L;
-    } finally {
-      exec.shutdownNow();
-      r.close();
-      for (Long slot : parked) {
-        PdfCanvasPixelBridge.nativeRelease(slot);
-      }
-    }
-    Throwable f = failure.get();
-    if (f != null) {
-      throw new AssertionError("a lane failed: " + f, f);
-    }
-    return elapsedMs;
-  }
-
-  /**
-   * The Java-side work of ONE tile on the two-copy JSI store — what
-   * {@code PdfCanvasModule} did before the one-copy fill replaced it.
-   *
-   * The counterpart of {@link #renderAndEncode}, and the difference between the
-   * two IS the change being measured.
-   */
-  private static void renderAndStore(
-      PdfCanvasRasterizer r, RasterRequest request, ConcurrentLinkedQueue<Long> parked)
-      throws PdfRasterException {
-    RasterPixels pixels = r.render(request, null);
-    long slot = JSI_SLOT.getAndIncrement();
-    PdfCanvasPixelBridge.nativeStore(slot, pixels.bytes);
-    parked.add(slot);
-  }
-
-  /**
-   * The Java-side work of ONE tile on the ONE-COPY fill, as
-   * {@code PdfCanvasModule.render} performs it today.
-   *
-   * The counterpart of {@link #renderAndStore}: identical except that the raster
-   * is written into the slot from the {@code Bitmap} instead of into a
-   * {@code byte[]} and then into the slot. Everything else — the request, the
-   * pool, the lane schedule, the deliberate exclusion of the free — is held
-   * constant, so the difference between the two rows is one full-raster ART
-   * allocation plus one full-raster memcpy and nothing else.
-   *
-   * A refusal is a FAILURE here, not a fallback. In production it degrades to
-   * base64 and the tile is still correct, but a measurement that quietly
-   * switched to the path it was comparing against would report the two rows as
-   * identical and call the change worthless.
-   */
-  private static void renderAndFillDirect(
-      PdfCanvasRasterizer r, RasterRequest request, ConcurrentLinkedQueue<Long> parked)
-      throws PdfRasterException {
-    long slot = JSI_SLOT.getAndIncrement();
-    RasterPixels pixels = r.renderToNativeSlot(request, null, slot);
-    if (!pixels.isInNativeSlot()) {
-      throw new AssertionError(
-          "the direct fill refused and fell back to the heap, so this sample is "
-              + "measuring the path it is supposed to be compared against");
-    }
-    parked.add(slot);
-  }
-
-  /**
-   * Slot ids for this file, in a range of its own.
-   *
-   * {@code PdfCanvasJsiTransportTest} owns 1_000_000 upward and drains every slot
-   * in an {@code @Before}, so one shared counter would let whichever class ran
-   * second reuse a live id.
-   */
-  private static final AtomicLong JSI_SLOT = new AtomicLong(9_000_000L);
-
-  /* ================================================================ */
-
-  private static double mean(long[] values) {
-    long sum = 0;
-    for (long value : values) {
-      sum += value;
-    }
-    return sum / (double) values.length;
-  }
-
-  private static long percentile(long[] sorted, int p) {
-    int rank = (int) Math.ceil((p / 100.0) * sorted.length) - 1;
-    return sorted[Math.max(0, Math.min(sorted.length - 1, rank))];
-  }
-}