aare/python/tests/ClusterFinderCUDA.ipynb

{
    "cells": [
        {
            "cell_type": "code",
            "execution_count": 1,
            "id": "789d5aab-0c75-4ed3-94bf-e66172f6737c",
            "metadata": {},
            "outputs": [],
            "source": [
                "import sys; sys.path.append('/home/ferjao_k/aare/build')\n",
                "\n",
                "from pathlib import Path\n",
                "import matplotlib.pyplot as plt\n",
                "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
                "import numpy as np\n",
                "import boost_histogram as bh\n",
                "import time\n",
                "\n",
                "from aare import File, ClusterFinder, ClusterFinderMT, ClusterCollector, ClusterFinderCUDA"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "id": "3f6089d6-2245-4aca-aad3-2417c16afae2",
            "metadata": {},
            "outputs": [],
            "source": [
                "# Helpers\n",
                "N_BINS = 200\n",
                "def make_hist(clusters):\n",
                "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
                "    h.fill(clusters.sum())\n",
                "    return h\n",
                "\n",
                "def make_hist_from_batch(result_list):\n",
                "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
                "    energies = [np.asarray(cv.sum()).ravel() for cv in result_list if cv.size > 0]\n",
                "    if energies:\n",
                "        h.fill(np.concatenate(energies))\n",
                "    return h"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "id": "415b09d4-d0d0-4166-8601-9d84302617bd",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Image size:       (400, 400)\n",
                        "Pedestal frames:  1000\n",
                        "Data frames:      88999\n"
                    ]
                }
            ],
            "source": [
                "base = Path('/mnt/sls_det_storage/matterhorn_data/aare_test_data/')\n",
                "f = File(base / 'Moench03new/cu_half_speed_master_4.json')\n",
                "\n",
                "n_frames_pd = 1000\n",
                "N           = 88999 #88999\n",
                "cluster_size = (9, 9)\n",
                "rows = f.rows\n",
                "cols = f.cols\n",
                "image_size   = (rows, cols)\n",
                "capacity     = 50_000 #3_000_000\n",
                "\n",
                "print(f'Image size:       {image_size}')\n",
                "print(f'Pedestal frames:  {n_frames_pd}')\n",
                "print(f'Data frames:      {N}')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "id": "3e49d862-45f4-4d37-a078-947e6b9ec9e3",
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "500000"
                        ]
                    },
                    "execution_count": 4,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "f.total_frames"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "5531b79d-12ad-4de6-84b7-0224b10d13c3",
            "metadata": {},
            "source": [
                "## Pedestal (both finders trained on identical frames)"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "e33b421f-969a-41d6-8aa6-5bd859a88fb3",
            "metadata": {},
            "source": [
                "- Modify the boolean `SERIAL` to choose between the sequential CPU version (ClusterFinder) and its multi-threaded homologue (ClusterFinderMT)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "id": "6ee7c469-5a23-421a-9bb4-a76e8f57a0c1",
            "metadata": {},
            "outputs": [],
            "source": [
                "SERIAL = True"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "id": "9d8f69bf-27f6-48c8-b2da-4157d67e6b04",
            "metadata": {},
            "outputs": [],
            "source": [
                "if(SERIAL):\n",
                "    cf_cpu  = ClusterFinder(image_size, cluster_size, capacity=capacity)\n",
                "else:\n",
                "    cf_cpu  = ClusterFinderMT(image_size, cluster_size, capacity=capacity, n_threads=48)\n",
                "    sink = ClusterCollector(cf_cpu)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "id": "00e2f63a-5e64-4d3e-becf-5e2835c6d712",
            "metadata": {},
            "outputs": [],
            "source": [
                "# Runs the destructor under the hood in case cf_cuda has already been constructed\n",
                "# del cf_cuda\n",
                "cf_cuda = None"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "id": "cbdcb805-708b-4205-bda9-2aa163d0e81f",
            "metadata": {},
            "outputs": [],
            "source": [
                "N_STREAMS  = 5\n",
                "cf_cuda = ClusterFinderCUDA(image_size, \n",
                "                            cluster_size, \n",
                "                            n_sigma=7, \n",
                "                            max_clusters_per_frame=1500,\n",
                "                            n_streams=N_STREAMS) "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "id": "1546f405-1bf6-4073-ab35-8134be695a6c",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Pedestal (1000 frames): 0.499s\n"
                    ]
                }
            ],
            "source": [
                "t0 = time.perf_counter()\n",
                "for _ in range(n_frames_pd):\n",
                "    img = f.read_frame()\n",
                "    cf_cpu.push_pedestal_frame(img.copy())\n",
                "    cf_cuda.push_pedestal_frame(img.copy())\n",
                "print(f'Pedestal ({n_frames_pd} frames): {time.perf_counter() - t0:.3f}s')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "5df035f0-7a27-4d5a-8f8d-c94e745bcd1a",
            "metadata": {},
            "source": [
                "## Read all data frames into memory (I/O out of the timing loop)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "id": "4573be3d-5ba8-4e18-bab0-c874f2b7dcb2",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Reading 88999 frames:        51.133s  (1741 FPS, 531.166 GB/s)\n"
                    ]
                }
            ],
            "source": [
                "f.seek(n_frames_pd)\n",
                "t0 = time.perf_counter()\n",
                "data = f.read_n(N)\n",
                "t_io = time.perf_counter() - t0\n",
                "print(f'Reading {N} frames:        {t_io:.3f}s  ({N/t_io:.0f} FPS, '\n",
                "      f'{f.bytes_per_frame * N / 1024**2 / t_io:.3f} GB/s)')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "c1e9362e-dcc2-41af-bfa1-c62d0968477e",
            "metadata": {},
            "source": [
                "## CPU clustering"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "id": "ad47af54-c2ba-441a-a874-88dfe04d8a68",
            "metadata": {},
            "outputs": [],
            "source": [
                "from tqdm import tqdm"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "id": "fbb14fda-2852-4b73-ba2c-9952abac1d99",
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "100%|████████████████████████████████████| 88999/88999 [13:59<00:00, 106.07it/s]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "CPU clustering:          839.049s (106 FPS, 90799856 clusters, 1020.23/frame)\n"
                    ]
                }
            ],
            "source": [
                "t0 = time.perf_counter()\n",
                "for frame in tqdm(data):\n",
                "    cf_cpu.find_clusters(frame)\n",
                "t_cpu = time.perf_counter() - t0\n",
                "\n",
                "if(SERIAL):\n",
                "    clusters_cpu = cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
                "    n_clusters_cpu = clusters_cpu.size\n",
                "    \n",
                "    hist_cpu  = make_hist(clusters_cpu)\n",
                "else:\n",
                "    cf_cpu.stop()\n",
                "    sink.stop()\n",
                "    \n",
                "    clusters_cpu = sink.steal_clusters() #cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
                "    \n",
                "    hist_cpu = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
                "    n_clusters_cpu = 0\n",
                "    for cv in clusters_cpu:\n",
                "        hist_cpu.fill(cv.sum())\n",
                "        n_clusters_cpu += cv.size\n",
                "        \n",
                "print(f'CPU clustering:          {t_cpu:.3f}s ({N/t_cpu:.0f} FPS, '\n",
                "      f'{n_clusters_cpu} clusters, {n_clusters_cpu/N:.2f}/frame)')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "8cfd7091-8020-49ff-b033-28bf773983d8",
            "metadata": {},
            "source": [
                "## CUDA clustering"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "id": "4f94cf35-5796-463d-bed8-f44a02d91fc6",
            "metadata": {},
            "outputs": [],
            "source": [
                "BATCHED = True"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 29,
            "id": "50848f8c-2e66-45b8-b6d5-ca80f368e6ba",
            "metadata": {},
            "outputs": [],
            "source": [
                "if(BATCHED):\n",
                "    BATCH_SIZE = 2000\n",
                "\n",
                "    # Before warmup, pin the fixed size buffer\n",
                "    batch_buffer = np.empty((BATCH_SIZE, rows, cols), dtype=np.uint16)\n",
                "    cf_cuda.register_input_buffer(batch_buffer)       # fixed ~640 MB\n",
                "\n",
                "    # Warmup: first kernel launch pays CUDA context + pedestal H2D upload cost\n",
                "    _ = cf_cuda.find_clusters_batched(data[0:BATCH_SIZE], first_frame=0)\n",
                "    \n",
                "    clusters_cuda_per_frame = []\n",
                "\n",
                "    cf_cuda.reset_timers()\n",
                "    t0 = time.perf_counter()\n",
                "    for start in range(0, N, BATCH_SIZE):\n",
                "        stop = min(start + BATCH_SIZE, N)\n",
                "        batch_buffer[:stop-start] = data[start:stop]  # CPU memcpy into pinned buf\n",
                "        clusters_cuda_per_frame.extend(\n",
                "            cf_cuda.find_clusters_batched(batch_buffer[:stop-start], first_frame=start)\n",
                "        )\n",
                "    t_cuda = time.perf_counter() - t0\n",
                "\n",
                "    cf_cuda.unregister_input_buffer()  # release when done with this dataset\n",
                "\n",
                "    kernel_ms = cf_cuda.avg_kernel_time_ms()\n",
                "    \n",
                "    n_clusters_cuda = sum(cv.size for cv in clusters_cuda_per_frame)\n",
                "\n",
                "    hist_cuda = make_hist_from_batch(clusters_cuda_per_frame)\n",
                "    \n",
                "else:   \n",
                "    # Simpler: (non-batched) per-frame run on non-pinned data\n",
                "    cf_cuda.find_clusters(data[0])\n",
                "    _ = cf_cuda.steal_clusters(realloc_same_capacity=False)\n",
                "\n",
                "    cf_cuda.reset_timers()\n",
                "    t0 = time.perf_counter()\n",
                "\n",
                "    n_clusters_cuda = 0\n",
                "    hist_cuda = None\n",
                "\n",
                "    # steal the clusters as we go rather than at the end of the  dataset \n",
                "    # which might trigger an std::bad_alloc...\n",
                "    for idx, frame in enumerate(data):\n",
                "        cf_cuda.find_clusters(frame)\n",
                "        clusters_frame = cf_cuda.steal_clusters(realloc_same_capacity=True)\n",
                "\n",
                "        n_clusters_cuda += clusters_frame.size\n",
                "\n",
                "        h = make_hist(clusters_frame)\n",
                "        hist_cuda = h if hist_cuda is None else hist_cuda + h\n",
                "        \n",
                "    t_cuda = time.perf_counter() - t0\n",
                "    kernel_ms = cf_cuda.avg_kernel_time_ms()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 30,
            "id": "502d0d3b-6b1e-4cc9-91df-9d998bd849b5",
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "(9, 9)"
                        ]
                    },
                    "execution_count": 30,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "cluster_size"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 31,
            "id": "2e3e4b9c-7f23-4fb7-bc3e-fa3d766d51fc",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "CPU clustering:          839.049s (106 FPS, 90799856 clusters, 1020.23/frame)\n"
                    ]
                }
            ],
            "source": [
                "print(f'CPU clustering:          {t_cpu:.3f}s ({N/t_cpu:.0f} FPS, '\n",
                "      f'{n_clusters_cpu} clusters, {n_clusters_cpu/N:.2f}/frame)')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 32,
            "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "CUDA clustering:          7.039s  (12644 FPS, 89991186 clusters, 1011.15/frame)\n",
                        "  Kernel only:            0.063 ms/frame\n",
                        "  PCIe + overhead:        0.016 ms/frame\n",
                        "Speedup (CPU / CUDA):     119.20×\n"
                    ]
                }
            ],
            "source": [
                "print(f'CUDA clustering:          {t_cuda:.3f}s  ({N/t_cuda:.0f} FPS, '\n",
                "      f'{n_clusters_cuda} clusters, {n_clusters_cuda/N:.2f}/frame)')\n",
                "print(f'  Kernel only:            {kernel_ms:.3f} ms/frame')\n",
                "print(f'  PCIe + overhead:        {t_cuda*1000/N - kernel_ms:.3f} ms/frame')\n",
                "print(f'Speedup (CPU / CUDA):     {t_cpu / t_cuda:.2f}×')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "b966cce1-0f73-4565-a707-1aec2a69f75e",
            "metadata": {},
            "source": [
                "## Agreement check: \n",
                "- Cluster counts should match closely.\n",
                "- However, as the CUDA CF updates the pedestal once per frame rather than per-pixel, a small divergence after the first few frames is expected."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 18,
            "id": "d3a850df-7df0-485b-971d-381cfdc6be81",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Cluster count diff:       2716962 (2.99%)\n"
                    ]
                }
            ],
            "source": [
                "diff = abs(n_clusters_cpu - n_clusters_cuda)\n",
                "rel  = diff / max(n_clusters_cpu, 1)\n",
                "print(f'Cluster count diff:       {diff} ({rel:.2%})')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "81638ad3-6112-4bd7-a93a-f4d97f1f94cf",
            "metadata": {},
            "source": [
                "## Plots"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 19,
            "id": "aff8db7e-8332-4228-857f-a9875cf940d3",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "200 201\n",
                        "200 201\n"
                    ]
                }
            ],
            "source": [
                "print(len(hist_cpu.values()), len(hist_cpu.axes[0].edges))\n",
                "print(len(hist_cuda.values()), len(hist_cuda.axes[0].edges))"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 20,
            "id": "9adeea2f-9309-4c0a-905b-7d1203ba1f4e",
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png":
                            "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",
                        "text/plain": [
                            "<Figure size 800x600 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "fig, (ax_spec, ax_ratio) = plt.subplots(\n",
                "    2, 1, figsize=(8, 6), sharex=True,\n",
                "    gridspec_kw={'height_ratios': [3, 1]}\n",
                ")\n",
                "\n",
                "edges = hist_cpu.axes[0].edges\n",
                "cpu_vals = hist_cpu.values()\n",
                "cuda_vals = hist_cuda.values()\n",
                "\n",
                "ax_spec.stairs(cpu_vals, edges, label=f'CPU  ({n_clusters_cpu} clusters)')\n",
                "ax_spec.stairs(cuda_vals, edges, label=f'CUDA ({n_clusters_cuda} clusters)', linestyle='--')\n",
                "ax_spec.set_ylabel('Counts')\n",
                "ax_spec.set_title('Cluster energy spectrum: CPU vs CUDA')\n",
                "ax_spec.legend()\n",
                "ax_spec.grid(alpha=0.2)\n",
                "\n",
                "with np.errstate(divide='ignore', invalid='ignore'):\n",
                "    ratio = np.where(cpu_vals > 0, cuda_vals / cpu_vals, np.nan)\n",
                "\n",
                "ax_ratio.stairs(ratio, edges, color='k')\n",
                "ax_ratio.axhline(1.0, color='gray', linewidth=0.5)\n",
                "ax_ratio.set_ylabel('CUDA / CPU')\n",
                "ax_ratio.set_xlabel('Energy [ADU]')\n",
                "ax_ratio.set_ylim(0.5, 2.0)\n",
                "ax_ratio.grid(alpha=0.3)\n",
                "\n",
                "plt.tight_layout()\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "id": "f9b7c128-6d30-425c-87db-645ea8cda143",
            "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.11.15"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 5
}