{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d25588d6",
   "metadata": {},
   "source": [
    "# ROI Sum Acceleration Benchmark\n",
    "\n",
    "Benchmark ROI summing backends on synthetic Pilatus 6M images. The benchmark compares the NumPy reference path with the optional C++ and Numba acceleration backends when they are available. It also times the C++ fitted-background path using a second-order polynomial.\n",
    "\n",
    "Each ROI has a signal region plus left, right, top, and bottom background strips. The counters include image signal/background, correction signal/background, background-image signal/background, and unmasked pixel counts. The accelerated strip-background counters are checked against NumPy before timing results are plotted.\n",
    "\n",
    "The first accelerated call may include setup or compilation overhead, so the benchmark does an explicit warmup before recording timings. Reported per-image timings are runtime-only measurements after warmup.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aeb2b10",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "Start Jupyter from the `benchmarks/` directory and run this notebook there. The benchmark imports the installed `orgui` package from the active Python environment. The benchmark uses synthetic `float64` Pilatus 6M-shaped arrays and randomly generated center/background ROIs.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "roi-backend-selection",
   "metadata": {},
   "source": [
    "## Backend Selection\n",
    "\n",
    "The GUI and batch ROI integration use `orgui.app._roi_sum_accel`. That wrapper selects one process-global ROI backend at import time. C++ is the default and should be used for normal operation:\n",
    "\n",
    "```bash\n",
    "ORGUI_ACCEL_BACKEND=cpp orGUI\n",
    "```\n",
    "\n",
    "To opt into the Numba strip-background ROI backend for the whole process, set the shared backend variable before importing `orgui.app._roi_sum_accel` or starting `orGUI`:\n",
    "\n",
    "```bash\n",
    "ORGUI_ACCEL_BACKEND=numba orGUI\n",
    "```\n",
    "\n",
    "To force the reference fallback:\n",
    "\n",
    "```bash\n",
    "ORGUI_ACCEL_BACKEND=numpy orGUI\n",
    "```\n",
    "\n",
    "The same selection can be changed inside a Python process with `orgui.app._roi_sum_accel.set_accel_backend(\"cpp\" | \"numba\" | \"numpy\")`; selecting `\"numpy\"` disables the accelerator wrapper so the application uses its explicit NumPy fallback code. The Numba ROI backend mirrors the C++ strip-background and image accumulation functions. Polynomial fitted-background integration remains C++ only; when the C++ extension is available, `processImage_polybg_Carr` and `interpolate_polybg_croi` are still provided by the wrapper even if `ORGUI_ACCEL_BACKEND=numba` selects Numba for strip-background counters.\n",
    "\n",
    "This notebook benchmarks local backend callables directly so it can compare NumPy, C++, Numba, and the C++ polynomial path side by side. See **Acceleration Backends** in the main documentation for runtime selection rules.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "212710a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Benchmark directory: C:\\Users\\timof\\Documents\\repos\\orGUI\\benchmarks\n",
      "Benchmark module:    C:\\Users\\timof\\Documents\\repos\\orGUI\\benchmarks\\benchmark_roi_sum_accel.py\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "from types import SimpleNamespace\n",
    "import concurrent.futures\n",
    "import platform\n",
    "import statistics\n",
    "import tempfile\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "BENCHMARK_DIR = Path.cwd().resolve()\n",
    "if (BENCHMARK_DIR / \"orgui\").is_dir():\n",
    "    raise RuntimeError(\n",
    "        \"Notebook is running from the repository root. Start Jupyter from \"\n",
    "        \"benchmarks/ to benchmark the installed package.\"\n",
    "    )\n",
    "\n",
    "import benchmark_roi_sum_accel as roi_bench\n",
    "\n",
    "print(f\"Benchmark directory: {BENCHMARK_DIR}\")\n",
    "print(f\"Benchmark module:    {Path(roi_bench.__file__).resolve()}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c886cdaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CTRsurfacePC\n"
     ]
    }
   ],
   "source": [
    "!hostname\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f7b96512",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "orGUI version 1.5.1.dev39+g72e3872c2.d20260704\n",
      "{'native_optimization': True, 'target_cpu': 'x86_64', 'allowed_instruction_set': ['AVX512'], 'native_arguments': '/arch:AVX512', 'cpp_compiler_id': 'msvc', 'cpp_compiler_version': '19.43.34810', 'host_system': 'windows', 'host_cpu_family': 'x86_64', 'host_cpu': 'x86_64', 'available': True}\n",
      "Python 3.12.3\n",
      "NumPy 1.26.4\n"
     ]
    }
   ],
   "source": [
    "from orgui import __version__, get_build_config\n",
    "\n",
    "print(\"orGUI version\", __version__)\n",
    "print(get_build_config())\n",
    "print(\"Python\", platform.python_version())\n",
    "print(\"NumPy\", np.__version__)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a6de985c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available ROI backends: ['numpy', 'cpp', 'numba']\n",
      "C++ backend: C:\\Users\\timof\\anaconda3\\Lib\\site-packages\\orgui\\app\\_roi_sum_cpp.cp312-win_amd64.pyd\n"
     ]
    }
   ],
   "source": [
    "cpp_backend = roi_bench.import_cpp_backend()\n",
    "backends = {\n",
    "    \"numpy\": roi_bench.wrap_numpy_backend(),\n",
    "    \"cpp\": roi_bench.wrap_backend(cpp_backend),\n",
    "}\n",
    "numba_backend = roi_bench.try_build_numba_backend()\n",
    "if numba_backend is not None:\n",
    "    backends[\"numba\"] = roi_bench.wrap_backend(SimpleNamespace(**numba_backend))\n",
    "\n",
    "print(\"Available ROI backends:\", list(backends))\n",
    "print(\"C++ backend:\", getattr(cpp_backend, \"__file__\", \"installed module\"))\n",
    "polybg_func = cpp_backend.processImage_polybg_Carr\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dbfe7e1",
   "metadata": {},
   "source": [
    "## Benchmark Helpers\n",
    "\n",
    "The synthetic detector uses the Pilatus 6M image shape `(2527, 2463)`. User-facing ROI and background strip sizes are in pixels. The image, correction, and background-image arrays are `float64`, matching the accelerator-facing paths used by the GUI integration code.\n",
    "\n",
    "The fitted-background benchmark uses the same center/background ROI geometry as the strip-background benchmark. Reported background size is the number of unmasked pixels in the four background strips used for each polynomial fit.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ba9e8496",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detector Pilatus 6M\n",
      "shape (2527, 2463)\n",
      "roi_size_px (10, 100)\n",
      "background_strip_px (5, 50)\n",
      "background_counts (5.0, 50.0)\n",
      "mask_fraction 0.01\n",
      "repeats 10\n",
      "fitted_background_order 2\n"
     ]
    }
   ],
   "source": [
    "POLYBG_ORDER = 2\n",
    "POLYBG_BACKEND = f\"cpp_polybg_order{POLYBG_ORDER}\"\n",
    "\n",
    "\n",
    "def make_args(**overrides):\n",
    "    values = {\n",
    "        \"seed\": 12345,\n",
    "        \"repeats\": 10,\n",
    "        \"rois\": 50,\n",
    "        \"shape\": roi_bench.PILATUS_6M_SHAPE,\n",
    "        \"roi_min\": 10,\n",
    "        \"roi_max\": 100,\n",
    "        \"bg_min\": 5,\n",
    "        \"bg_max\": 50,\n",
    "        \"signal_mean\": 100.0,\n",
    "        \"background_min\": 5.0,\n",
    "        \"background_max\": 50.0,\n",
    "        \"mask_fraction\": 0.01,\n",
    "        \"disk_images\": 0,\n",
    "        \"threads\": 1,\n",
    "        \"disk_dir\": None,\n",
    "        \"json\": None,\n",
    "        \"no_numba\": False,\n",
    "    }\n",
    "    values.update(overrides)\n",
    "    return SimpleNamespace(**values)\n",
    "\n",
    "\n",
    "def format_seconds(value):\n",
    "    if value < 1e-3:\n",
    "        return f\"{value * 1e6:8.1f} us\"\n",
    "    if value < 1:\n",
    "        return f\"{value * 1e3:8.2f} ms\"\n",
    "    return f\"{value:8.3f} s\"\n",
    "\n",
    "\n",
    "def print_table(rows, columns):\n",
    "    widths = {key: max(len(str(label)), *(len(str(row[key])) for row in rows)) for key, label in columns}\n",
    "    print(\" \".join(str(label).rjust(widths[key]) for key, label in columns))\n",
    "    for row in rows:\n",
    "        print(\" \".join(str(row[key]).rjust(widths[key]) for key, _ in columns))\n",
    "\n",
    "\n",
    "def run_one_polybg_backend(func, base_image, mask, correction, rois, order=POLYBG_ORDER):\n",
    "    image = base_image.copy(order=\"C\")\n",
    "    all_counters = np.zeros((rois[0].shape[0], 4), dtype=np.float64)\n",
    "    correction_counters = np.zeros_like(all_counters)\n",
    "    start = time.perf_counter()\n",
    "    func(image, mask, correction, *rois, all_counters, correction_counters, order)\n",
    "    duration = time.perf_counter() - start\n",
    "    return duration, (all_counters, correction_counters)\n",
    "\n",
    "\n",
    "def benchmark_polybg_backend(func, base_image, mask, correction, rois, repeats, order=POLYBG_ORDER):\n",
    "    warmup_duration, counters = run_one_polybg_backend(func, base_image, mask, correction, rois, order)\n",
    "    timings = []\n",
    "    for _ in range(repeats):\n",
    "        duration, counters = run_one_polybg_backend(func, base_image, mask, correction, rois, order)\n",
    "        timings.append(duration)\n",
    "    return {\n",
    "        \"name\": POLYBG_BACKEND,\n",
    "        \"warmup_seconds\": warmup_duration,\n",
    "        \"median_seconds\": statistics.median(timings),\n",
    "        \"min_seconds\": min(timings),\n",
    "        \"max_seconds\": max(timings),\n",
    "        \"counters\": counters,\n",
    "    }\n",
    "\n",
    "\n",
    "def integrate_polybg_image(func, image, mask, correction, rois, order=POLYBG_ORDER):\n",
    "    all_counters = np.zeros((rois[0].shape[0], 4), dtype=np.float64)\n",
    "    correction_counters = np.zeros_like(all_counters)\n",
    "    func(image, mask, correction, *rois, all_counters, correction_counters, order)\n",
    "    return all_counters, correction_counters\n",
    "\n",
    "\n",
    "def process_polybg_disk_image(path, func, mask, correction, rois, order=POLYBG_ORDER):\n",
    "    image = np.load(path)\n",
    "    return integrate_polybg_image(func, image, mask, correction, rois, order)\n",
    "\n",
    "\n",
    "def background_pixel_counts(mask, rois):\n",
    "    counts = np.zeros(rois[0].shape[0], dtype=np.int64)\n",
    "    for roi_group in rois[1:]:\n",
    "        for i, roi in enumerate(roi_group):\n",
    "            ys = slice(roi[1, 0], roi[1, 1])\n",
    "            xs = slice(roi[0, 0], roi[0, 1])\n",
    "            counts[i] += np.count_nonzero(~mask[ys, xs])\n",
    "    return counts\n",
    "\n",
    "\n",
    "base_args = make_args()\n",
    "print(\"Detector Pilatus 6M\")\n",
    "print(\"shape\", base_args.shape)\n",
    "print(\"roi_size_px\", (base_args.roi_min, base_args.roi_max))\n",
    "print(\"background_strip_px\", (base_args.bg_min, base_args.bg_max))\n",
    "print(\"background_counts\", (base_args.background_min, base_args.background_max))\n",
    "print(\"mask_fraction\", base_args.mask_fraction)\n",
    "print(\"repeats\", base_args.repeats)\n",
    "print(\"fitted_background_order\", POLYBG_ORDER)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c364362",
   "metadata": {},
   "source": [
    "## Correctness Check\n",
    "\n",
    "The accelerated strip-background paths must reproduce the NumPy reference counters for image, correction, and background-image sums before any strip-background timing result is trusted. The fitted-background path is checked for finite counters and matching signal/background pixel counts, but its fitted background sum is not expected to equal the strip-sum background value.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fb42a004",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available accelerated ROI strip-background backends match NumPy counters\n",
      "C++ second-order fitted-background path returned finite counters with matching pixel counts\n"
     ]
    }
   ],
   "source": [
    "args = make_args(rois=20, repeats=1)\n",
    "image, background, mask, correction, rois = roi_bench.make_inputs(args)\n",
    "reference = None\n",
    "for name, func in backends.items():\n",
    "    result = roi_bench.benchmark_backend(\n",
    "        name,\n",
    "        func,\n",
    "        image,\n",
    "        background,\n",
    "        mask,\n",
    "        correction,\n",
    "        rois,\n",
    "        repeats=1,\n",
    "    )\n",
    "    if name == \"numpy\":\n",
    "        reference = result[\"counters\"]\n",
    "    else:\n",
    "        roi_bench.check_results(reference, result[\"counters\"], name)\n",
    "\n",
    "_, polybg_counters = run_one_polybg_backend(polybg_func, image, mask, correction, rois)\n",
    "np.testing.assert_allclose(polybg_counters[0][:, 1], reference[0][:, 1])\n",
    "np.testing.assert_allclose(polybg_counters[0][:, 3], reference[0][:, 3])\n",
    "assert np.isfinite(polybg_counters[0]).all()\n",
    "assert np.isfinite(polybg_counters[1]).all()\n",
    "\n",
    "print(\"Available accelerated ROI strip-background backends match NumPy counters\")\n",
    "print(\"C++ second-order fitted-background path returned finite counters with matching pixel counts\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03fdf0e9",
   "metadata": {},
   "source": [
    "## ROI Count Sweep\n",
    "\n",
    "This measures one in-memory image for `1, 5, 20, 50, 100, 500` ROIs with background strips enabled. Median time is reported across five measured repeats after one warmup call per backend and ROI count.\n",
    "\n",
    "`cpp_polybg_order2` uses the C++ fitted-background path with a second-order polynomial fit to the pixels in the four background strips. Its fitted background values are not expected to equal the strip-sum background values, so it is timed alongside the other paths but not validated against NumPy strip-background counters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8db6b0d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROIs           backend bg px total bg px/ROI median bg px/ROI range    median       min speedup\n",
      "   1             numpy        5173             5173       5173-5173   2.82 ms   2.71 ms   1.00x\n",
      "   1               cpp        5173             5173       5173-5173   87.6 us   80.6 us  32.18x\n",
      "   1             numba        5173             5173       5173-5173   2.94 ms   2.78 ms   0.96x\n",
      "   1 cpp_polybg_order2        5173             5173       5173-5173  168.3 us  159.5 us  16.75x\n",
      "   5             numpy       30432             5178       2889-9989   3.69 ms   3.64 ms   1.00x\n",
      "   5               cpp       30432             5178       2889-9989  366.9 us  347.2 us  10.05x\n",
      "   5             numba       30432             5178       2889-9989   3.21 ms   3.16 ms   1.15x\n",
      "   5 cpp_polybg_order2       30432             5178       2889-9989  910.6 us  844.9 us   4.05x\n",
      "  20             numpy      121378             5765       543-11579   6.81 ms   6.57 ms   1.00x\n",
      "  20               cpp      121378             5765       543-11579   1.11 ms   1.05 ms   6.13x\n",
      "  20             numba      121378             5765       543-11579   4.15 ms   4.04 ms   1.64x\n",
      "  20 cpp_polybg_order2      121378             5765       543-11579   3.21 ms   3.06 ms   2.12x\n",
      "  50             numpy      284650             5781       544-11879  14.19 ms  12.99 ms   1.00x\n",
      "  50               cpp      284650             5781       544-11879   2.49 ms   2.38 ms   5.71x\n",
      "  50             numba      284650             5781       544-11879   6.56 ms   5.89 ms   2.16x\n",
      "  50 cpp_polybg_order2      284650             5781       544-11879   7.29 ms   7.18 ms   1.95x\n",
      " 100             numpy      594635             5744       550-14296  23.69 ms  22.63 ms   1.00x\n",
      " 100               cpp      594635             5744       550-14296   5.09 ms   5.00 ms   4.65x\n",
      " 100             numba      594635             5744       550-14296   9.69 ms   9.34 ms   2.44x\n",
      " 100 cpp_polybg_order2      594635             5744       550-14296  15.36 ms  15.16 ms   1.54x\n",
      " 500             numpy     2915775             5623       550-16127 106.37 ms 102.09 ms   1.00x\n",
      " 500               cpp     2915775             5623       550-16127  25.13 ms  24.44 ms   4.23x\n",
      " 500             numba     2915775             5623       550-16127  36.84 ms  36.16 ms   2.89x\n",
      " 500 cpp_polybg_order2     2915775             5623       550-16127  78.93 ms  75.25 ms   1.35x\n"
     ]
    }
   ],
   "source": [
    "ROI_COUNTS = (1, 5, 20, 50, 100, 500)\n",
    "roi_results = []\n",
    "\n",
    "for n_rois in ROI_COUNTS:\n",
    "    args = make_args(rois=n_rois)\n",
    "    image, background, mask, correction, rois = roi_bench.make_inputs(args)\n",
    "    bg_counts = background_pixel_counts(mask, rois)\n",
    "    bg_total_px = int(bg_counts.sum())\n",
    "    bg_median_px = float(np.median(bg_counts))\n",
    "    bg_min_px = int(bg_counts.min())\n",
    "    bg_max_px = int(bg_counts.max())\n",
    "\n",
    "    reference = None\n",
    "    row_results = {}\n",
    "    for name, func in backends.items():\n",
    "        result = roi_bench.benchmark_backend(\n",
    "            name,\n",
    "            func,\n",
    "            image,\n",
    "            background,\n",
    "            mask,\n",
    "            correction,\n",
    "            rois,\n",
    "            repeats=args.repeats,\n",
    "        )\n",
    "        if name == \"numpy\":\n",
    "            reference = result[\"counters\"]\n",
    "        else:\n",
    "            roi_bench.check_results(reference, result[\"counters\"], f\"{name} {n_rois} ROIs\")\n",
    "        counters = result.pop(\"counters\")\n",
    "        result[\"counter_checksum\"] = float(sum(np.nansum(counter) for counter in counters))\n",
    "        row_results[name] = result\n",
    "\n",
    "    polybg_result = benchmark_polybg_backend(\n",
    "        polybg_func,\n",
    "        image,\n",
    "        mask,\n",
    "        correction,\n",
    "        rois,\n",
    "        repeats=args.repeats,\n",
    "    )\n",
    "    polybg_counters = polybg_result.pop(\"counters\")\n",
    "    polybg_result[\"counter_checksum\"] = float(sum(np.nansum(counter) for counter in polybg_counters))\n",
    "    row_results[POLYBG_BACKEND] = polybg_result\n",
    "\n",
    "    numpy_median = row_results[\"numpy\"][\"median_seconds\"]\n",
    "    for name, result in row_results.items():\n",
    "        roi_results.append(\n",
    "            {\n",
    "                \"rois\": n_rois,\n",
    "                \"backend\": name,\n",
    "                \"median_s\": result[\"median_seconds\"],\n",
    "                \"min_s\": result[\"min_seconds\"],\n",
    "                \"warmup_s\": result[\"warmup_seconds\"],\n",
    "                \"speedup_vs_numpy\": numpy_median / result[\"median_seconds\"],\n",
    "                \"bg_total_px\": bg_total_px,\n",
    "                \"bg_median_px\": bg_median_px,\n",
    "                \"bg_min_px\": bg_min_px,\n",
    "                \"bg_max_px\": bg_max_px,\n",
    "            }\n",
    "        )\n",
    "\n",
    "summary_rows = [\n",
    "    {\n",
    "        \"rois\": row[\"rois\"],\n",
    "        \"backend\": row[\"backend\"],\n",
    "        \"bg_total\": row[\"bg_total_px\"],\n",
    "        \"bg_median\": f\"{row['bg_median_px']:.0f}\",\n",
    "        \"bg_range\": f\"{row['bg_min_px']}-{row['bg_max_px']}\",\n",
    "        \"median\": format_seconds(row[\"median_s\"]).strip(),\n",
    "        \"min\": format_seconds(row[\"min_s\"]).strip(),\n",
    "        \"speedup\": f\"{row['speedup_vs_numpy']:.2f}x\",\n",
    "    }\n",
    "    for row in roi_results\n",
    "]\n",
    "print_table(\n",
    "    summary_rows,\n",
    "    (\n",
    "        (\"rois\", \"ROIs\"),\n",
    "        (\"backend\", \"backend\"),\n",
    "        (\"bg_total\", \"bg px total\"),\n",
    "        (\"bg_median\", \"bg px/ROI median\"),\n",
    "        (\"bg_range\", \"bg px/ROI range\"),\n",
    "        (\"median\", \"median\"),\n",
    "        (\"min\", \"min\"),\n",
    "        (\"speedup\", \"speedup\"),\n",
    "    ),\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31d28943",
   "metadata": {},
   "source": [
    "## ROI Count Results\n",
    "\n",
    "The runtime plot uses a log y-axis because the NumPy and accelerated paths differ by orders of magnitude for small ROI counts. The speedup plot is normalized to the NumPy median for the same ROI count.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9acde39a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))\n",
    "ax_time, ax_speedup = axes\n",
    "plot_backends = list(backends) + [POLYBG_BACKEND]\n",
    "\n",
    "for backend in plot_backends:\n",
    "    rows = [row for row in roi_results if row[\"backend\"] == backend]\n",
    "    ax_time.plot(\n",
    "        [row[\"rois\"] for row in rows],\n",
    "        [row[\"median_s\"] for row in rows],\n",
    "        marker=\"o\",\n",
    "        label=backend,\n",
    "    )\n",
    "    if backend != \"numpy\":\n",
    "        ax_speedup.plot(\n",
    "            [row[\"rois\"] for row in rows],\n",
    "            [row[\"speedup_vs_numpy\"] for row in rows],\n",
    "            marker=\"o\",\n",
    "            label=backend,\n",
    "        )\n",
    "\n",
    "ax_time.set_title(\"Runtime by ROI count\")\n",
    "ax_time.set_xlabel(\"ROIs\")\n",
    "ax_time.set_ylabel(\"Median runtime per image [s]\")\n",
    "ax_time.set_xscale(\"log\")\n",
    "ax_time.set_yscale(\"log\")\n",
    "ax_time.set_xticks(ROI_COUNTS)\n",
    "ax_time.get_xaxis().set_major_formatter(plt.ScalarFormatter())\n",
    "ax_time.grid(which=\"both\", alpha=0.25)\n",
    "ax_time.legend(title=\"Backend\")\n",
    "\n",
    "ax_speedup.set_title(\"Acceleration vs NumPy\")\n",
    "ax_speedup.set_xlabel(\"ROIs\")\n",
    "ax_speedup.set_ylabel(\"Median speedup [x]\")\n",
    "ax_speedup.set_xscale(\"log\")\n",
    "ax_speedup.set_xticks(ROI_COUNTS)\n",
    "ax_speedup.get_xaxis().set_major_formatter(plt.ScalarFormatter())\n",
    "ax_speedup.grid(which=\"both\", alpha=0.25)\n",
    "ax_speedup.legend(title=\"Backend\")\n",
    "\n",
    "fig.tight_layout()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eec1468",
   "metadata": {},
   "source": [
    "## Threaded Disk-Image Sweep\n",
    "\n",
    "This measures reading 50 synthetic `.npy` images from disk and integrating each image with 50 ROIs plus background strips. The same serial baseline is reused for each backend, then the workload is repeated with `1, 2, 4, 8` worker threads.\n",
    "\n",
    "The fitted-background rows use the C++ second-order polynomial path and the same background-strip pixels reported in the table.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d8c16ce5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Disk image directory: C:\\Users\\timof\\AppData\\Local\\Temp\\tmpbt5pkb9f\n",
      "Disk image format: .npy float64\n",
      "Background pixels total per image: 594635\n",
      "Background pixels per ROI: median 5744, range 550-14296\n",
      "          backend threads bg px total bg px/ROI median bg px/ROI range   serial threaded thread_gain images/s\n",
      "            numpy       1      594635             5744       550-14296 15.310 s 13.386 s       1.14x    14.94\n",
      "            numpy       2      594635             5744       550-14296 15.310 s  8.113 s       1.89x    24.65\n",
      "            numpy       4      594635             5744       550-14296 15.310 s 13.318 s       1.15x    15.02\n",
      "            numpy       8      594635             5744       550-14296 15.310 s 13.093 s       1.17x    15.28\n",
      "            numpy      16      594635             5744       550-14296 15.310 s 13.896 s       1.10x    14.39\n",
      "              cpp       1      594635             5744       550-14296  9.366 s 10.337 s       0.91x    19.35\n",
      "              cpp       2      594635             5744       550-14296  9.366 s  6.354 s       1.47x    31.48\n",
      "              cpp       4      594635             5744       550-14296  9.366 s  3.562 s       2.63x    56.16\n",
      "              cpp       8      594635             5744       550-14296  9.366 s  2.953 s       3.17x    67.72\n",
      "              cpp      16      594635             5744       550-14296  9.366 s  3.455 s       2.71x    57.88\n",
      "            numba       1      594635             5744       550-14296 11.142 s 11.470 s       0.97x    17.44\n",
      "            numba       2      594635             5744       550-14296 11.142 s  6.613 s       1.68x    30.24\n",
      "            numba       4      594635             5744       550-14296 11.142 s  4.081 s       2.73x    49.01\n",
      "            numba       8      594635             5744       550-14296 11.142 s  3.263 s       3.41x    61.30\n",
      "            numba      16      594635             5744       550-14296 11.142 s  3.534 s       3.15x    56.59\n",
      "cpp_polybg_order2       1      594635             5744       550-14296 10.925 s 11.004 s       0.99x    18.17\n",
      "cpp_polybg_order2       2      594635             5744       550-14296 10.925 s  6.991 s       1.56x    28.61\n",
      "cpp_polybg_order2       4      594635             5744       550-14296 10.925 s  4.534 s       2.41x    44.11\n",
      "cpp_polybg_order2       8      594635             5744       550-14296 10.925 s  3.307 s       3.30x    60.48\n",
      "cpp_polybg_order2      16      594635             5744       550-14296 10.925 s  3.385 s       3.23x    59.09\n"
     ]
    }
   ],
   "source": [
    "THREAD_COUNTS = (1, 2, 4, 8, 16)\n",
    "DISK_IMAGES = 200\n",
    "THREAD_ROIS = 100\n",
    "thread_results = []\n",
    "\n",
    "thread_args = make_args(rois=THREAD_ROIS, disk_images=DISK_IMAGES)\n",
    "image, background, mask, correction, rois = roi_bench.make_inputs(thread_args)\n",
    "bg_counts = background_pixel_counts(mask, rois)\n",
    "thread_bg_total_px = int(bg_counts.sum())\n",
    "thread_bg_median_px = float(np.median(bg_counts))\n",
    "thread_bg_min_px = int(bg_counts.min())\n",
    "thread_bg_max_px = int(bg_counts.max())\n",
    "\n",
    "with tempfile.TemporaryDirectory() as tmp:\n",
    "    disk_dir = Path(tmp)\n",
    "    image_paths = roi_bench.make_disk_images(thread_args, disk_dir)\n",
    "    print(f\"Disk image directory: {disk_dir}\")\n",
    "    print(\"Disk image format: .npy float64\")\n",
    "    print(f\"Background pixels total per image: {thread_bg_total_px}\")\n",
    "    print(\n",
    "        \"Background pixels per ROI: \"\n",
    "        f\"median {thread_bg_median_px:.0f}, range {thread_bg_min_px}-{thread_bg_max_px}\"\n",
    "    )\n",
    "\n",
    "    disk_backend_specs = [(name, func, \"strip\") for name, func in backends.items()]\n",
    "    disk_backend_specs.append((POLYBG_BACKEND, polybg_func, \"polybg\"))\n",
    "\n",
    "    for backend, func, mode in disk_backend_specs:\n",
    "        start = time.perf_counter()\n",
    "        if mode == \"polybg\":\n",
    "            serial_counters = [\n",
    "                process_polybg_disk_image(path, func, mask, correction, rois)\n",
    "                for path in image_paths\n",
    "            ]\n",
    "        else:\n",
    "            serial_counters = [\n",
    "                roi_bench.process_disk_image(path, func, background, mask, correction, rois)\n",
    "                for path in image_paths\n",
    "            ]\n",
    "        serial_s = time.perf_counter() - start\n",
    "        serial_checksum = roi_bench.checksum_counters(serial_counters)\n",
    "\n",
    "        for threads in THREAD_COUNTS:\n",
    "            start = time.perf_counter()\n",
    "            with concurrent.futures.ThreadPoolExecutor(max_workers=threads) as executor:\n",
    "                if mode == \"polybg\":\n",
    "                    futures = [\n",
    "                        executor.submit(\n",
    "                            process_polybg_disk_image,\n",
    "                            path,\n",
    "                            func,\n",
    "                            mask,\n",
    "                            correction,\n",
    "                            rois,\n",
    "                        )\n",
    "                        for path in image_paths\n",
    "                    ]\n",
    "                else:\n",
    "                    futures = [\n",
    "                        executor.submit(\n",
    "                            roi_bench.process_disk_image,\n",
    "                            path,\n",
    "                            func,\n",
    "                            background,\n",
    "                            mask,\n",
    "                            correction,\n",
    "                            rois,\n",
    "                        )\n",
    "                        for path in image_paths\n",
    "                    ]\n",
    "                threaded_counters = [future.result() for future in futures]\n",
    "            threaded_s = time.perf_counter() - start\n",
    "\n",
    "            for i, (serial, threaded) in enumerate(zip(serial_counters, threaded_counters, strict=True)):\n",
    "                if mode == \"polybg\":\n",
    "                    for expected, actual in zip(serial, threaded, strict=True):\n",
    "                        np.testing.assert_allclose(actual, expected, rtol=1e-12, atol=1e-9)\n",
    "                else:\n",
    "                    roi_bench.check_results(serial, threaded, f\"{backend} threaded image {i}\")\n",
    "\n",
    "            thread_results.append(\n",
    "                {\n",
    "                    \"backend\": backend,\n",
    "                    \"threads\": threads,\n",
    "                    \"images\": DISK_IMAGES,\n",
    "                    \"rois\": THREAD_ROIS,\n",
    "                    \"serial_s\": serial_s,\n",
    "                    \"threaded_s\": threaded_s,\n",
    "                    \"thread_speedup\": serial_s / threaded_s,\n",
    "                    \"threaded_images_per_s\": DISK_IMAGES / threaded_s,\n",
    "                    \"bg_total_px\": thread_bg_total_px,\n",
    "                    \"bg_median_px\": thread_bg_median_px,\n",
    "                    \"bg_min_px\": thread_bg_min_px,\n",
    "                    \"bg_max_px\": thread_bg_max_px,\n",
    "                    \"serial_checksum\": serial_checksum,\n",
    "                    \"threaded_checksum\": roi_bench.checksum_counters(threaded_counters),\n",
    "                }\n",
    "            )\n",
    "\n",
    "summary_rows = [\n",
    "    {\n",
    "        \"backend\": row[\"backend\"],\n",
    "        \"threads\": row[\"threads\"],\n",
    "        \"bg_total\": row[\"bg_total_px\"],\n",
    "        \"bg_median\": f\"{row['bg_median_px']:.0f}\",\n",
    "        \"bg_range\": f\"{row['bg_min_px']}-{row['bg_max_px']}\",\n",
    "        \"serial\": format_seconds(row[\"serial_s\"]).strip(),\n",
    "        \"threaded\": format_seconds(row[\"threaded_s\"]).strip(),\n",
    "        \"gain\": f\"{row['thread_speedup']:.2f}x\",\n",
    "        \"ips\": f\"{row['threaded_images_per_s']:.2f}\",\n",
    "    }\n",
    "    for row in thread_results\n",
    "]\n",
    "print_table(\n",
    "    summary_rows,\n",
    "    (\n",
    "        (\"backend\", \"backend\"),\n",
    "        (\"threads\", \"threads\"),\n",
    "        (\"bg_total\", \"bg px total\"),\n",
    "        (\"bg_median\", \"bg px/ROI median\"),\n",
    "        (\"bg_range\", \"bg px/ROI range\"),\n",
    "        (\"serial\", \"serial\"),\n",
    "        (\"threaded\", \"threaded\"),\n",
    "        (\"gain\", \"thread_gain\"),\n",
    "        (\"ips\", \"images/s\"),\n",
    "    ),\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51398ebb",
   "metadata": {},
   "source": [
    "## Threaded Results\n",
    "\n",
    "The left plot shows end-to-end time for 50 disk-backed images. The right plot shows throughput for the same workload.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "67bcef5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))\n",
    "ax_time, ax_rate = axes\n",
    "\n",
    "for backend in plot_backends:\n",
    "    rows = [row for row in thread_results if row[\"backend\"] == backend]\n",
    "    ax_time.plot(\n",
    "        [row[\"threads\"] for row in rows],\n",
    "        [row[\"threaded_s\"] for row in rows],\n",
    "        marker=\"o\",\n",
    "        label=backend,\n",
    "    )\n",
    "    ax_rate.plot(\n",
    "        [row[\"threads\"] for row in rows],\n",
    "        [row[\"threaded_images_per_s\"] for row in rows],\n",
    "        marker=\"o\",\n",
    "        label=backend,\n",
    "    )\n",
    "\n",
    "ax_time.set_title(\"50 images: read + integrate\")\n",
    "ax_time.set_xlabel(\"Worker threads\")\n",
    "ax_time.set_ylabel(\"Total threaded runtime [s]\")\n",
    "ax_time.set_xticks(THREAD_COUNTS)\n",
    "ax_time.grid(alpha=0.25)\n",
    "ax_time.legend(title=\"Backend\")\n",
    "\n",
    "ax_rate.set_title(\"50 images: throughput\")\n",
    "ax_rate.set_xlabel(\"Worker threads\")\n",
    "ax_rate.set_ylabel(\"Images / s\")\n",
    "ax_rate.set_xticks(THREAD_COUNTS)\n",
    "ax_rate.grid(alpha=0.25)\n",
    "ax_rate.legend(title=\"Backend\")\n",
    "\n",
    "fig.tight_layout()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d7066f5-7a72-4d6c-a24e-c30fdb16b022",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}