diff --git a/include/aare/ClusterFinderCUDA.hpp b/include/aare/ClusterFinderCUDA.hpp
index 4c0b70f..e5e8d90 100644
--- a/include/aare/ClusterFinderCUDA.hpp
+++ b/include/aare/ClusterFinderCUDA.hpp
@@ -20,6 +20,9 @@ struct StreamContext {
     PEDESTAL_TYPE *d_pd_sum2 = nullptr;
     ClusterType *d_clusters = nullptr;
     uint32_t *d_cluster_count = nullptr;
+
+    cudaEvent_t kernel_start = nullptr;
+    cudaEvent_t kernel_stop = nullptr;
 };
 
 template <typename ClusterType = Cluster<int32_t, 3, 3>,
@@ -49,6 +52,9 @@ class ClusterFinderCUDA {
     using SC = StreamContext<ClusterType, FRAME_TYPE, PEDESTAL_TYPE>;
     std::vector<SC> v_sc;
 
+    float m_total_kernel_ms = 0.0f;
+    size_t m_frames_processed = 0;
+
     // Kernel parameters
     dim3 grid;
     dim3 block;
@@ -87,6 +93,8 @@ class ClusterFinderCUDA {
         for (int k = 0; k < n_streams; ++k) {
             auto &sc = v_sc[k];
             CUDA_CHECK(cudaStreamCreate(&sc.stream));
+            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_pd_mean,
@@ -117,6 +125,10 @@ class ClusterFinderCUDA {
                 cudaFree(sc.d_cluster_count);
             if (sc.stream)
                 cudaStreamDestroy(sc.stream);
+            if (sc.kernel_start)
+                cudaEventDestroy(sc.kernel_start);
+            if (sc.kernel_stop)
+                cudaEventDestroy(sc.kernel_stop);
         }
     }
 
@@ -179,13 +191,15 @@ class ClusterFinderCUDA {
         CUDA_CHECK(cudaMemcpyAsync(sc.d_frame, frame.data(), image_bytes,
                                    cudaMemcpyHostToDevice, sc.stream));
 
-        // Kernel launch
+        // Timed Kernel launch
+        CUDA_CHECK(cudaEventRecord(sc.kernel_start, sc.stream));
         device::find_clusters_in_single_frame<ClusterType, FRAME_TYPE,
                                               PEDESTAL_TYPE>
             <<<grid, block, shmem_bytes, sc.stream>>>(
                 sc.d_frame, sc.d_pd_mean, sc.d_pd_sum, sc.d_pd_sum2,
                 n_pd_samples, m_nSigma, nrows, ncols, sc.d_clusters,
                 sc.d_cluster_count, static_cast<uint32_t>(m_capacity));
+        CUDA_CHECK(cudaEventRecord(sc.kernel_stop, sc.stream));
         CUDA_CHECK(cudaGetLastError());
 
         // Read back cluster count
@@ -258,12 +272,15 @@ class ClusterFinderCUDA {
                                            cudaMemcpyHostToDevice,
                                            sc_k.stream));
 
+                CUDA_CHECK(cudaEventRecord(sc_k.kernel_start, sc_k.stream));
                 device::find_clusters_in_single_frame<ClusterType, FRAME_TYPE,
                                                       PEDESTAL_TYPE>
                     <<<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);
+                CUDA_CHECK(cudaEventRecord(sc_k.kernel_stop, sc_k.stream));
+
                 CUDA_CHECK(cudaGetLastError());
             }
 
@@ -294,6 +311,16 @@ class ClusterFinderCUDA {
         return results;
     }
 
+    float avg_kernel_time_ms() const {
+        return m_frames_processed > 0 ? m_total_kernel_ms / m_frames_processed
+                                      : 0.0f;
+    }
+
+    void reset_timers() {
+        m_total_kernel_ms = 0.0f;
+        m_frames_processed = 0;
+    }
+
   private:
     /**
      * Upload the current host pedestal (mean, sum, sum2) to every stream's
@@ -332,6 +359,13 @@ class ClusterFinderCUDA {
                                    n_found * sizeof(ClusterType),
                                    cudaMemcpyDeviceToHost, sc.stream));
         CUDA_CHECK(cudaStreamSynchronize(sc.stream));
+
+        // Record the total time of all the kernel launches compute time
+        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/python/src/bind_ClusterFinderCUDA.hpp b/python/src/bind_ClusterFinderCUDA.hpp
index 5ef017e..7abe76b 100644
--- a/python/src/bind_ClusterFinderCUDA.hpp
+++ b/python/src/bind_ClusterFinderCUDA.hpp
@@ -87,8 +87,15 @@ void define_ClusterFinderCUDA(py::module &m, const std::string &typestr) {
             },
             py::arg("frames"), py::arg("first_frame") = 0,
             R"(Process a 3D array of frames (n_frames, nrows, ncols) in parallel
-across the configured CUDA streams. Returns a list of ClusterVector, one per
-input frame.)");
+            across the configured CUDA streams. Returns a list of ClusterVector, one per
+            input frame.)")
+
+        .def("avg_kernel_time_ms", &CF::avg_kernel_time_ms,
+             R"(Average kernel execution time per frame in milliseconds,
+            excluding PCIe transfers. Use wall_time - avg_kernel_time to estimate transfer overhead.)")
+
+        .def("reset_timers", &CF::reset_timers,
+             R"(Reset the internal kernel timing counters.)");
 }
 
 } // namespace aare
diff --git a/python/tests/ClusterFinderCUDA.ipynb b/python/tests/ClusterFinderCUDA.ipynb
index 5a42e7d..ed1cd47 100644
--- a/python/tests/ClusterFinderCUDA.ipynb
+++ b/python/tests/ClusterFinderCUDA.ipynb
@@ -26,9 +26,17 @@
             "metadata": {},
             "outputs": [],
             "source": [
+                "# Helpers\n",
                 "def make_hist(clusters):\n",
                 "    h = bh.Histogram(bh.axis.Regular(100, -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",
+                "    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"
             ]
         },
@@ -44,7 +52,7 @@
                     "text": [
                         "Image size:       (400, 400)\n",
                         "Pedestal frames:  1000\n",
-                        "Data frames:      40000\n"
+                        "Data frames:      88999\n"
                     ]
                 }
             ],
@@ -53,7 +61,7 @@
                 "f = File(base / 'Moench03new/cu_half_speed_master_4.json')\n",
                 "\n",
                 "n_frames_pd = 1000\n",
-                "N           = 40000\n",
+                "N           = 88999\n",
                 "cluster_size = (3, 3)\n",
                 "image_size   = (f.rows, f.cols)\n",
                 "capacity     = 100_000 #3_000_000\n",
@@ -63,6 +71,27 @@
                 "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",
@@ -81,17 +110,17 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 4,
+            "execution_count": 5,
             "id": "6ee7c469-5a23-421a-9bb4-a76e8f57a0c1",
             "metadata": {},
             "outputs": [],
             "source": [
-                "SERIAL = True"
+                "SERIAL = False"
             ]
         },
         {
             "cell_type": "code",
-            "execution_count": 5,
+            "execution_count": 6,
             "id": "9d8f69bf-27f6-48c8-b2da-4157d67e6b04",
             "metadata": {},
             "outputs": [],
@@ -105,7 +134,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 6,
+            "execution_count": 7,
             "id": "cbdcb805-708b-4205-bda9-2aa163d0e81f",
             "metadata": {},
             "outputs": [],
@@ -116,7 +145,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 7,
+            "execution_count": 8,
             "id": "1546f405-1bf6-4073-ab35-8134be695a6c",
             "metadata": {},
             "outputs": [
@@ -124,7 +153,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Pedestal (1000 frames): 0.480s\n"
+                        "Pedestal (1000 frames): 3.212s\n"
                     ]
                 }
             ],
@@ -147,7 +176,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 8,
+            "execution_count": 9,
             "id": "4573be3d-5ba8-4e18-bab0-c874f2b7dcb2",
             "metadata": {},
             "outputs": [
@@ -155,7 +184,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Reading 40000 frames:        1.922s  (20815 FPS, 6352.256 GB/s)\n"
+                        "Reading 88999 frames:        4.269s  (20846 FPS, 6361.676 GB/s)\n"
                     ]
                 }
             ],
@@ -178,7 +207,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 9,
+            "execution_count": 10,
             "id": "fbb14fda-2852-4b73-ba2c-9952abac1d99",
             "metadata": {},
             "outputs": [
@@ -186,7 +215,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "CPU clustering:          73.207s (546 FPS, 55449596 clusters, 1386.24/frame)\n"
+                        "CPU clustering:          14.399s (6181 FPS, 120930205 clusters, 1358.78/frame)\n"
                     ]
                 }
             ],
@@ -227,82 +256,86 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 10,
-            "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523",
+            "execution_count": 21,
+            "id": "4f94cf35-5796-463d-bed8-f44a02d91fc6",
             "metadata": {},
             "outputs": [],
             "source": [
-                "# # Warmup: first kernel launch pays CUDA context + pedestal H2D upload cost\n",
-                "# cf_cuda.find_clusters(data[0])\n",
-                "# _ = cf_cuda.steal_clusters(realloc_same_capacity=False)\n",
-                "\n",
-                "# t0 = time.perf_counter()\n",
-                "# for frame in data:\n",
-                "#     cf_cuda.find_clusters(frame)\n",
-                "# t_cuda = time.perf_counter() - t0\n",
-                "# clusters_cuda = cf_cuda.steal_clusters(realloc_same_capacity=False)\n",
-                "# n_clusters_cuda = clusters_cuda.size\n",
-                "# 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'Speedup (CPU / CUDA):     {t_cpu / t_cuda:.2f}×')\n",
-                "\n",
-                "# hist_cuda = make_hist(clusters_cuda)"
+                "BATCHED = True"
             ]
         },
         {
             "cell_type": "code",
-            "execution_count": 11,
-            "id": "1fda99ee-db54-40c1-8e5b-51168a33fb96",
+            "execution_count": 28,
+            "id": "50848f8c-2e66-45b8-b6d5-ca80f368e6ba",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "if(BATCHED):\n",
+                "    BATCH_SIZE = 10000\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",
+                "        clusters_cuda_per_frame.extend(\n",
+                "            cf_cuda.find_clusters_batched(data[start:stop], first_frame=start)\n",
+                "        )\n",
+                "    t_cuda = time.perf_counter() - t0\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",
+                "    # Warmup\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",
+                "    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"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 29,
+            "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523",
             "metadata": {},
             "outputs": [
                 {
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "CUDA clustering:          2.385s  (16774 FPS, 55081141 clusters, 1377.03/frame)\n",
-                        "Speedup (CPU / CUDA):     30.70×\n"
+                        "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"
                     ]
                 }
             ],
             "source": [
-                "BATCH_SIZE = 2000\n",
-                "\n",
-                "# warmup\n",
-                "_ = cf_cuda.find_clusters_batched(data[0:BATCH_SIZE], first_frame=0)\n",
-                "\n",
-                "t0 = time.perf_counter()\n",
-                "clusters_cuda_per_frame = []\n",
-                "for start in range(0, N, BATCH_SIZE):\n",
-                "    stop = min(start + BATCH_SIZE, N)\n",
-                "    clusters_cuda_per_frame.extend(\n",
-                "        cf_cuda.find_clusters_batched(data[start:stop], first_frame=start)\n",
-                "    )\n",
-                "t_cuda = time.perf_counter() - t0\n",
-                "\n",
-                "n_clusters_cuda = sum(cv.size for cv in clusters_cuda_per_frame)\n",
-                "\n",
                 "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": "code",
-            "execution_count": 12,
-            "id": "b7df7b9d-6873-46c4-b6bc-7e4238a5bdf7",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "def make_hist_from_batch(result_list):\n",
-                "    h = bh.Histogram(bh.axis.Regular(100, -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\n",
-                "\n",
-                "hist_cuda = make_hist_from_batch(clusters_cuda_per_frame)"
-            ]
-        },
         {
             "cell_type": "markdown",
             "id": "b966cce1-0f73-4565-a707-1aec2a69f75e",
@@ -315,7 +348,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 13,
+            "execution_count": 24,
             "id": "d3a850df-7df0-485b-971d-381cfdc6be81",
             "metadata": {},
             "outputs": [
@@ -323,7 +356,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Cluster count diff:       368455 (0.66%)\n"
+                        "Cluster count diff:       3382175 (2.80%)\n"
                     ]
                 }
             ],
@@ -343,14 +376,14 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 14,
+            "execution_count": 25,
             "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>"
                         ]