diff --git a/include/aare/ClusterFinderCUDA.hpp b/include/aare/ClusterFinderCUDA.hpp
index e5e8d90..81a528d 100644
--- a/include/aare/ClusterFinderCUDA.hpp
+++ b/include/aare/ClusterFinderCUDA.hpp
@@ -3,9 +3,12 @@
 #include "aare/ClusterFinder.hpp"
 #include "aare/clusterfinder_kernel.cuh"
 #include "aare/utils/cuda_check.cuh"
+#include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <cstdio>
+#include <cstring>
+#include <limits>
 #include <stdexcept>
 
 namespace aare {
@@ -21,6 +24,12 @@ struct StreamContext {
     ClusterType *d_clusters = nullptr;
     uint32_t *d_cluster_count = nullptr;
 
+    // Pinned host staging buffers.  These make cudaMemcpyAsync real async DMA
+    // transfers even when the caller's NDView points to pageable memory.
+    FRAME_TYPE *h_frame = nullptr;
+    uint32_t *h_cluster_count = nullptr;
+    ClusterType *h_clusters = nullptr;
+
     cudaEvent_t kernel_start = nullptr;
     cudaEvent_t kernel_stop = nullptr;
 };
@@ -44,6 +53,9 @@ class ClusterFinderCUDA {
     int n_streams;
     size_t m_capacity;
 
+    size_t m_image_bytes;
+    size_t m_cluster_bytes;
+
     COMPUTE_TYPE m_nSigma;
     Pedestal<PEDESTAL_TYPE> m_pedestal;
     ClusterVector<ClusterType> m_clusters;
@@ -77,6 +89,22 @@ class ClusterFinderCUDA {
           m_image_size(nrows * ncols), n_streams(n_streams_),
           m_capacity(capacity), m_nSigma(nSigma),
           m_pedestal(shape_[0], shape_[1]), m_clusters(capacity) {
+        if (n_streams_ <= 0) {
+            throw std::invalid_argument(
+                "ClusterFinderCUDA: n_streams must be > 0");
+        }
+
+        if (capacity >
+            static_cast<size_t>(std::numeric_limits<uint32_t>::max())) {
+            throw std::invalid_argument(
+                "ClusterFinderCUDA: capacity must fit in uint32_t");
+        }
+
+        if (capacity == 0) {
+            throw std::invalid_argument(
+                "ClusterFinderCUDA: capacity must be > 0");
+        }
+
         // Grid/Block dimensions
         block = dim3(BLOCK_X, BLOCK_Y);
         grid = dim3((static_cast<unsigned int>(ncols) + BLOCK_X - 1) / BLOCK_X,
@@ -89,28 +117,44 @@ class ClusterFinderCUDA {
         shmem_bytes = (BLOCK_X + 2 * col_radius) * (BLOCK_Y + 2 * row_radius) *
                       sizeof(COMPUTE_TYPE);
 
+        m_image_bytes = m_image_size * sizeof(FRAME_TYPE);
+        m_cluster_bytes = m_capacity * sizeof(ClusterType);
+
         v_sc.resize(n_streams);
         for (int k = 0; k < n_streams; ++k) {
             auto &sc = v_sc[k];
-            CUDA_CHECK(cudaStreamCreate(&sc.stream));
+            CUDA_CHECK(
+                cudaStreamCreateWithFlags(&sc.stream, cudaStreamNonBlocking));
             CUDA_CHECK(cudaEventCreate(&sc.kernel_start));
             CUDA_CHECK(cudaEventCreate(&sc.kernel_stop));
-            CUDA_CHECK(
-                cudaMalloc(&sc.d_frame, m_image_size * sizeof(FRAME_TYPE)));
+            CUDA_CHECK(cudaMalloc(&sc.d_frame, m_image_bytes));
             CUDA_CHECK(cudaMalloc(&sc.d_pd_mean,
                                   m_image_size * sizeof(PEDESTAL_TYPE)));
             CUDA_CHECK(
                 cudaMalloc(&sc.d_pd_sum, m_image_size * sizeof(PEDESTAL_TYPE)));
             CUDA_CHECK(cudaMalloc(&sc.d_pd_sum2,
                                   m_image_size * sizeof(PEDESTAL_TYPE)));
-            CUDA_CHECK(
-                cudaMalloc(&sc.d_clusters, capacity * sizeof(ClusterType)));
+            CUDA_CHECK(cudaMalloc(&sc.d_clusters, m_cluster_bytes));
             CUDA_CHECK(cudaMalloc(&sc.d_cluster_count, sizeof(uint32_t)));
+
+            CUDA_CHECK(cudaMallocHost(reinterpret_cast<void **>(&sc.h_frame),
+                                      m_image_bytes));
+            CUDA_CHECK(
+                cudaMallocHost(reinterpret_cast<void **>(&sc.h_cluster_count),
+                               sizeof(uint32_t)));
+            if (m_cluster_bytes > 0) {
+                CUDA_CHECK(
+                    cudaMallocHost(reinterpret_cast<void **>(&sc.h_clusters),
+                                   m_cluster_bytes));
+            }
         }
     }
 
     ~ClusterFinderCUDA() {
         for (auto &sc : v_sc) {
+            if (sc.stream)
+                cudaStreamSynchronize(sc.stream);
+
             if (sc.d_frame)
                 cudaFree(sc.d_frame);
             if (sc.d_pd_mean)
@@ -123,12 +167,20 @@ class ClusterFinderCUDA {
                 cudaFree(sc.d_clusters);
             if (sc.d_cluster_count)
                 cudaFree(sc.d_cluster_count);
-            if (sc.stream)
-                cudaStreamDestroy(sc.stream);
+
+            if (sc.h_frame)
+                cudaFreeHost(sc.h_frame);
+            if (sc.h_clusters)
+                cudaFreeHost(sc.h_clusters);
+            if (sc.h_cluster_count)
+                cudaFreeHost(sc.h_cluster_count);
+
             if (sc.kernel_start)
                 cudaEventDestroy(sc.kernel_start);
             if (sc.kernel_stop)
                 cudaEventDestroy(sc.kernel_stop);
+            if (sc.stream)
+                cudaStreamDestroy(sc.stream);
         }
     }
 
@@ -179,16 +231,18 @@ class ClusterFinderCUDA {
         }
 
         auto &sc = v_sc[0];
-        const size_t image_bytes = m_image_size * sizeof(FRAME_TYPE);
         const uint32_t n_pd_samples =
             static_cast<uint32_t>(m_pedestal.n_samples());
 
+        // First, CPU copies frame into a reusable pinned buffer
+        std::memcpy(sc.h_frame, frame.data(), m_image_bytes);
+
         // Reset cluster counter
         CUDA_CHECK(cudaMemsetAsync(sc.d_cluster_count, 0, sizeof(uint32_t),
                                    sc.stream));
 
         // Upload frame
-        CUDA_CHECK(cudaMemcpyAsync(sc.d_frame, frame.data(), image_bytes,
+        CUDA_CHECK(cudaMemcpyAsync(sc.d_frame, sc.h_frame, m_image_bytes,
                                    cudaMemcpyHostToDevice, sc.stream));
 
         // Timed Kernel launch
@@ -202,9 +256,8 @@ class ClusterFinderCUDA {
         CUDA_CHECK(cudaEventRecord(sc.kernel_stop, sc.stream));
         CUDA_CHECK(cudaGetLastError());
 
-        // Read back cluster count
-        uint32_t n_found = 0;
-        CUDA_CHECK(cudaMemcpyAsync(&n_found, sc.d_cluster_count,
+        // Read back cluster count into pinned buffer
+        CUDA_CHECK(cudaMemcpyAsync(sc.h_cluster_count, sc.d_cluster_count,
                                    sizeof(uint32_t), cudaMemcpyDeviceToHost,
                                    sc.stream));
 
@@ -212,9 +265,11 @@ class ClusterFinderCUDA {
         // clusters
         CUDA_CHECK(cudaStreamSynchronize(sc.stream));
 
+        record_kernel_time(sc);
+
         // Clamp to max in case of overflow
-        if (n_found > m_capacity)
-            n_found = m_capacity;
+        uint32_t n_found = *sc.h_cluster_count;
+        n_found = std::min(n_found, static_cast<uint32_t>(m_capacity));
 
         // Read back clusters
         m_clusters.set_frame_number(frame_number);
@@ -239,19 +294,16 @@ class ClusterFinderCUDA {
         }
 
         const size_t n_frames = frames.shape(0);
-        const size_t image_bytes = m_image_size * sizeof(FRAME_TYPE);
         const uint32_t n_pd_samples =
             static_cast<uint32_t>(m_pedestal.n_samples());
 
         std::vector<ClusterVector<ClusterType>> results;
         results.reserve(n_frames);
         for (size_t i = 0; i < n_frames; ++i) {
-            results.emplace_back(m_capacity);
+            results.emplace_back();
             results.back().set_frame_number(first_frame + i);
         }
 
-        std::vector<uint32_t> host_counts(n_streams, 0);
-
         const size_t n_rounds = (n_frames + n_streams - 1) / n_streams;
         for (size_t round = 0; round < n_rounds; ++round) {
 
@@ -266,11 +318,13 @@ class ClusterFinderCUDA {
                 const FRAME_TYPE *h_src =
                     frames.data() + frame_idx * m_image_size;
 
+                std::memcpy(sc_k.h_frame, h_src, m_image_bytes);
+
                 CUDA_CHECK(cudaMemsetAsync(sc_k.d_cluster_count, 0,
                                            sizeof(uint32_t), sc_k.stream));
-                CUDA_CHECK(cudaMemcpyAsync(sc_k.d_frame, h_src, image_bytes,
-                                           cudaMemcpyHostToDevice,
-                                           sc_k.stream));
+                CUDA_CHECK(
+                    cudaMemcpyAsync(sc_k.d_frame, sc_k.h_frame, m_image_bytes,
+                                    cudaMemcpyHostToDevice, sc_k.stream));
 
                 CUDA_CHECK(cudaEventRecord(sc_k.kernel_start, sc_k.stream));
                 device::find_clusters_in_single_frame<ClusterType, FRAME_TYPE,
@@ -278,10 +332,15 @@ class ClusterFinderCUDA {
                     <<<grid, block, shmem_bytes, sc_k.stream>>>(
                         sc_k.d_frame, sc_k.d_pd_mean, sc_k.d_pd_sum,
                         sc_k.d_pd_sum2, n_pd_samples, m_nSigma, nrows, ncols,
-                        sc_k.d_clusters, sc_k.d_cluster_count, m_capacity);
+                        sc_k.d_clusters, sc_k.d_cluster_count,
+                        static_cast<uint32_t>(m_capacity));
                 CUDA_CHECK(cudaEventRecord(sc_k.kernel_stop, sc_k.stream));
-
                 CUDA_CHECK(cudaGetLastError());
+
+                // Queue count D2H immediately after the kernel
+                CUDA_CHECK(cudaMemcpyAsync(
+                    sc_k.h_cluster_count, sc_k.d_cluster_count,
+                    sizeof(uint32_t), cudaMemcpyDeviceToHost, sc_k.stream));
             }
 
             // Drain phase: fan in results from all streams
@@ -292,14 +351,14 @@ class ClusterFinderCUDA {
 
                 auto &sc_k = v_sc[k];
 
-                CUDA_CHECK(cudaMemcpyAsync(
-                    &host_counts[k], sc_k.d_cluster_count, sizeof(uint32_t),
-                    cudaMemcpyDeviceToHost, sc_k.stream));
+                // Wait for memset -> H2D -> kernel -> count D2H
                 CUDA_CHECK(cudaStreamSynchronize(sc_k.stream));
 
-                uint32_t n_found = host_counts[k];
-                if (n_found > m_capacity)
-                    n_found = m_capacity;
+                record_kernel_time(sc_k);
+
+                uint32_t n_found = *sc_k.h_cluster_count;
+                n_found = std::min<uint32_t>(n_found,
+                                             static_cast<uint32_t>(m_capacity));
 
                 if (n_found > 0) {
                     append_device_clusters_to(results[frame_idx], sc_k,
@@ -354,20 +413,22 @@ class ClusterFinderCUDA {
      */
     void append_device_clusters_to(ClusterVector<ClusterType> &cv, SC &sc,
                                    uint32_t n_found) {
-        std::vector<ClusterType> staging(n_found);
-        CUDA_CHECK(cudaMemcpyAsync(staging.data(), sc.d_clusters,
+
+        CUDA_CHECK(cudaMemcpyAsync(sc.h_clusters, sc.d_clusters,
                                    n_found * sizeof(ClusterType),
                                    cudaMemcpyDeviceToHost, sc.stream));
+
         CUDA_CHECK(cudaStreamSynchronize(sc.stream));
 
-        // Record the total time of all the kernel launches compute time
+        for (uint32_t i = 0; i < n_found; ++i)
+            cv.push_back(sc.h_clusters[i]);
+    }
+
+    void record_kernel_time(SC &sc) {
         float ms = 0.0f;
         CUDA_CHECK(cudaEventElapsedTime(&ms, sc.kernel_start, sc.kernel_stop));
         m_total_kernel_ms += ms;
         m_frames_processed++;
-
-        for (const auto &c : staging)
-            cv.push_back(c);
     }
 };
 
diff --git a/include/aare/clusterfinder_kernel.cuh b/include/aare/clusterfinder_kernel.cuh
index 0879630..74ddcf0 100644
--- a/include/aare/clusterfinder_kernel.cuh
+++ b/include/aare/clusterfinder_kernel.cuh
@@ -172,19 +172,28 @@ __global__ void find_clusters_in_single_frame(
     if (!valid_pixel)
         return;
 
-    // Per-pixel RMS from global pedestal arrays
-    // rms = sqrt( E[X^2] - E[X]^2 )
+    // Per-pixel variance from global pedestal arrays
+    // Variance = rms^2 = E[X^2] - E[X]^2
+    // NOTE: Keep thresholds squared to avoid one sqrtf() per pixel.
     PEDESTAL_TYPE mean_px = d_pd_mean[global_tid];
     PEDESTAL_TYPE var_px =
         d_pd_sum2[global_tid] / n_pd_samples - mean_px * mean_px;
     PEDESTAL_TYPE rms_sq = max(var_px, PEDESTAL_TYPE{0}); // variance = rms^2
-    COMPUTE_TYPE rms_px = sqrtf(static_cast<COMPUTE_TYPE>(rms_sq));
+    PEDESTAL_TYPE nSig_sq_rms_sq = static_cast<PEDESTAL_TYPE>(m_nSigma) *
+                                   static_cast<PEDESTAL_TYPE>(m_nSigma) *
+                                   rms_sq;
 
     // Pedestal-subtracted value of the center pixel (already in shmem)
     COMPUTE_TYPE val_pixel = shmem[shmem_tid];
 
-    // Negative pedestal early exit
-    if (val_pixel < -m_nSigma * rms_px)
+    // Negative pedestal early exit:
+    //     val_pixel < -nSigma * rms
+    // is equivalent to:
+    //     val_pixel < 0 && val_pixel^2 > nSigma^2 * rms^2
+    if (val_pixel < COMPUTE_TYPE{0} &&
+        static_cast<PEDESTAL_TYPE>(val_pixel) *
+                static_cast<PEDESTAL_TYPE>(val_pixel) >
+            nSig_sq_rms_sq)
         return; // NOTE: pedestal update for this pixel is skipped (same as
                 // sequential)
 
@@ -199,9 +208,6 @@ __global__ void find_clusters_in_single_frame(
     // (ir>=0, ic<=0) PEDESTAL_TYPE br = PEDESTAL_TYPE{0};   // bottom-right
     // (ir>=0, ic>=0)
 
-    CT clusterData[CSX * CSY];
-    int idx = 0; // tracks the pixels in the cluster
-
 #pragma unroll
     for (int ir = -row_radius; ir <= row_radius; ++ir) {
 #pragma unroll
@@ -215,15 +221,6 @@ __global__ void find_clusters_in_single_frame(
             // quadrants) if (ir <= 0 && ic <= 0) tl += val; if (ir <= 0 && ic
             // >= 0) tr += val; if (ir >= 0 && ic <= 0) bl += val; if (ir >= 0
             // && ic >= 0) br += val;
-
-            // Store pedestal-subtracted value in register array for later
-            // cluster output
-            if constexpr (std::is_integral_v<CT>)
-                clusterData[idx] = static_cast<CT>(lroundf(val));
-            else
-                clusterData[idx] = static_cast<CT>(val);
-
-            idx++;
         }
     }
 
@@ -240,12 +237,16 @@ __global__ void find_clusters_in_single_frame(
     //  3. Total significance:         total > c3 * nSigma * rms
     //     -> distributed events where the full cluster sum is significant
 
-    PEDESTAL_TYPE nSig_sq_rms_sq = m_nSigma * m_nSigma * rms_sq;
-
     bool is_photon = false;
 
     // Test 1: single-pixel significance
-    if (max_val > m_nSigma * rms_px) {
+    //     max_val > nSigma * rms
+    // is equivalent to:
+    //     max_val > 0 && max_val^2 > nSigma^2 * rms^2
+    if (max_val > COMPUTE_TYPE{0} &&
+        static_cast<PEDESTAL_TYPE>(max_val) *
+                static_cast<PEDESTAL_TYPE>(max_val) >
+            nSig_sq_rms_sq) {
         // Local-max suppression: only the center-pixel thread records the
         // cluster
         if (val_pixel < max_val)
@@ -293,6 +294,25 @@ __global__ void find_clusters_in_single_frame(
     if (!is_photon) return; // Debugging
     */
 
+    // Delay building clusterData until we know this thread will write a photon.
+    // This avoids CSX*CSY conversions/rounds for the overwhelmingly common
+    // background pixels.
+    CT clusterData[CSX * CSY];
+    int idx = 0;
+
+#pragma unroll
+    for (int ir = -row_radius; ir <= row_radius; ++ir) {
+#pragma unroll
+        for (int ic = -col_radius; ic <= col_radius; ++ic) {
+            COMPUTE_TYPE val = shmem[shmem_tid + ir * shmem_stride + ic];
+            if constexpr (std::is_integral_v<CT>)
+                clusterData[idx] = static_cast<CT>(lroundf(val));
+            else
+                clusterData[idx] = static_cast<CT>(val);
+            idx++;
+        }
+    }
+
     // Write cluster to global output buffer using atomic index
     // for coordination across all blocks
     uint32_t write_idx = atomicAdd(d_cluster_count, 1u);
diff --git a/python/tests/ClusterFinderCUDA.ipynb b/python/tests/ClusterFinderCUDA.ipynb
index ed1cd47..6b5df3f 100644
--- a/python/tests/ClusterFinderCUDA.ipynb
+++ b/python/tests/ClusterFinderCUDA.ipynb
@@ -27,13 +27,14 @@
             "outputs": [],
             "source": [
                 "# Helpers\n",
+                "N_BINS = 200\n",
                 "def make_hist(clusters):\n",
-                "    h = bh.Histogram(bh.axis.Regular(100, -2, 4000))\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(100, -2, 4000))\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",
@@ -62,7 +63,7 @@
                 "\n",
                 "n_frames_pd = 1000\n",
                 "N           = 88999\n",
-                "cluster_size = (3, 3)\n",
+                "cluster_size = (9, 9)\n",
                 "image_size   = (f.rows, f.cols)\n",
                 "capacity     = 100_000 #3_000_000\n",
                 "\n",
@@ -115,7 +116,7 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "SERIAL = False"
+                "SERIAL = True"
             ]
         },
         {
@@ -128,7 +129,7 @@
                 "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=24)\n",
+                "    cf_cpu  = ClusterFinderMT(image_size, cluster_size, capacity=capacity, n_threads=48)\n",
                 "    sink = ClusterCollector(cf_cpu)"
             ]
         },
@@ -139,8 +140,8 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "N_STREAMS  = 10\n",
-                "cf_cuda = ClusterFinderCUDA(image_size, cluster_size, capacity=capacity, n_streams=N_STREAMS)"
+                "N_STREAMS  = 5\n",
+                "cf_cuda = ClusterFinderCUDA(image_size, cluster_size, n_sigma=7, capacity=capacity, n_streams=N_STREAMS)"
             ]
         },
         {
@@ -153,7 +154,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Pedestal (1000 frames): 3.212s\n"
+                        "Pedestal (1000 frames): 0.501s\n"
                     ]
                 }
             ],
@@ -184,7 +185,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Reading 88999 frames:        4.269s  (20846 FPS, 6361.676 GB/s)\n"
+                        "Reading 88999 frames:        30.101s  (2957 FPS, 902.311 GB/s)\n"
                     ]
                 }
             ],
@@ -215,7 +216,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "CPU clustering:          14.399s (6181 FPS, 120930205 clusters, 1358.78/frame)\n"
+                        "CPU clustering:          835.664s (107 FPS, 90799856 clusters, 1020.23/frame)\n"
                     ]
                 }
             ],
@@ -236,7 +237,7 @@
                 "    \n",
                 "    clusters_cpu = sink.steal_clusters() #cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
                 "    \n",
-                "    hist_cpu = bh.Histogram(bh.axis.Regular(100, -2, 4000))\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",
@@ -256,7 +257,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 21,
+            "execution_count": 11,
             "id": "4f94cf35-5796-463d-bed8-f44a02d91fc6",
             "metadata": {},
             "outputs": [],
@@ -266,13 +267,13 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 28,
+            "execution_count": 18,
             "id": "50848f8c-2e66-45b8-b6d5-ca80f368e6ba",
             "metadata": {},
             "outputs": [],
             "source": [
                 "if(BATCHED):\n",
-                "    BATCH_SIZE = 10000\n",
+                "    BATCH_SIZE = 2000\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",
@@ -300,20 +301,68 @@
                 "\n",
                 "    cf_cuda.reset_timers()\n",
                 "    t0 = time.perf_counter()\n",
-                "    for frame in data:\n",
-                "        cf_cuda.find_clusters(frame)\n",
-                "    t_cuda = time.perf_counter() - t0\n",
-                "    kernel_ms = cf_cuda.avg_kernel_time_ms()\n",
                 "\n",
-                "    clusters_cuda = cf_cuda.steal_clusters(realloc_same_capacity=False)\n",
-                "    n_clusters_cuda = clusters_cuda.size\n",
-                "    \n",
-                "    hist_cuda = make_hist(clusters_cuda)\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": 29,
+            "execution_count": 19,
+            "id": "502d0d3b-6b1e-4cc9-91df-9d998bd849b5",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "(9, 9)"
+                        ]
+                    },
+                    "execution_count": 19,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "cluster_size"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 25,
+            "id": "2e3e4b9c-7f23-4fb7-bc3e-fa3d766d51fc",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "CPU clustering:          835.664s (107 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": 24,
             "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523",
             "metadata": {},
             "outputs": [
@@ -321,10 +370,10 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "CUDA clustering:          5.111s  (17413 FPS, 124312496 clusters, 1396.79/frame)\n",
-                        "  Kernel only:            0.021 ms/frame\n",
-                        "  PCIe + overhead:        0.036 ms/frame\n",
-                        "Speedup (CPU / CUDA):     2.82×\n"
+                        "CUDA clustering:          8.812s  (10100 FPS, 89995010 clusters, 1011.19/frame)\n",
+                        "  Kernel only:            0.039 ms/frame\n",
+                        "  PCIe + overhead:        0.060 ms/frame\n",
+                        "Speedup (CPU / CUDA):     94.83×\n"
                     ]
                 }
             ],
@@ -348,7 +397,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 24,
+            "execution_count": 21,
             "id": "d3a850df-7df0-485b-971d-381cfdc6be81",
             "metadata": {},
             "outputs": [
@@ -356,7 +405,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Cluster count diff:       3382175 (2.80%)\n"
+                        "Cluster count diff:       804846 (0.89%)\n"
                     ]
                 }
             ],
@@ -376,16 +425,36 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 25,
+            "execution_count": 22,
+            "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": 23,
             "id": "9adeea2f-9309-4c0a-905b-7d1203ba1f4e",
             "metadata": {},
             "outputs": [
                 {
                     "data": {
                         "image/png":
-                            "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",
+                            "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",
                         "text/plain": [
-                            "<Figure size 900x600 with 2 Axes>"
+                            "<Figure size 800x600 with 2 Axes>"
                         ]
                     },
                     "metadata": {},
@@ -394,7 +463,7 @@
             ],
             "source": [
                 "fig, (ax_spec, ax_ratio) = plt.subplots(\n",
-                "    2, 1, figsize=(9, 6), sharex=True,\n",
+                "    2, 1, figsize=(8, 6), sharex=True,\n",
                 "    gridspec_kw={'height_ratios': [3, 1]}\n",
                 ")\n",
                 "\n",
@@ -407,7 +476,7 @@
                 "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.3)\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",
@@ -416,7 +485,7 @@
                 "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, 3.5)\n",
+                "ax_ratio.set_ylim(0.5, 2.0)\n",
                 "ax_ratio.grid(alpha=0.3)\n",
                 "\n",
                 "plt.tight_layout()\n",
@@ -426,7 +495,7 @@
         {
             "cell_type": "code",
             "execution_count": null,
-            "id": "a6ca4581-bb29-4c74-a34a-bd427551a39b",
+            "id": "e33bdd78-8f0c-4690-9153-3f9eaffd4afa",
             "metadata": {},
             "outputs": [],
             "source": []