From 4c668029808a8d1c56e0702e669ae855da461a80 Mon Sep 17 00:00:00 2001 From: kferjaoui Date: Thu, 21 May 2026 14:12:02 +0200 Subject: [PATCH] perf(ClusterFinderCUDA): FP32 device pedestal and bulk memcpy drain MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Device pedestal arrays (mean/sum/sum2) are now float instead of double: halves global-memory bandwidth for pedestal reads/writes and eliminates FP64 arithmetic in the kernel (3.3x kernel speedup, 15µs -> 4.6µs). - Replace the per-cluster push_back loop in the D2H drain with a single resize()+memcpy(). --- include/aare/ClusterFinderCUDA.hpp | 47 +++++++++------- include/aare/clusterfinder_kernel.cuh | 53 ++++++++---------- python/tests/ClusterFinderCUDA.ipynb | 77 +++++++++++++++++---------- src/ClusterFinderCUDA.test.cu | 17 +++--- 4 files changed, 107 insertions(+), 87 deletions(-) diff --git a/include/aare/ClusterFinderCUDA.hpp b/include/aare/ClusterFinderCUDA.hpp index cb3d5cb..b99ee01 100644 --- a/include/aare/ClusterFinderCUDA.hpp +++ b/include/aare/ClusterFinderCUDA.hpp @@ -7,8 +7,10 @@ #include #include #include +#include #include #include +#include namespace aare { @@ -18,9 +20,9 @@ template struct StreamContext { cudaStream_t stream = nullptr; FRAME_TYPE *d_frame = nullptr; - PEDESTAL_TYPE *d_pd_mean = nullptr; - PEDESTAL_TYPE *d_pd_sum = nullptr; - PEDESTAL_TYPE *d_pd_sum2 = nullptr; + float *d_pd_mean = nullptr; // always float on device; host stays double + float *d_pd_sum = nullptr; + float *d_pd_sum2 = nullptr; uint8_t *d_output = nullptr; // [uint32_t count | ClusterType clusters[max]] }; @@ -145,12 +147,9 @@ class ClusterFinderCUDA { CUDA_CHECK( cudaStreamCreateWithFlags(&sc.stream, cudaStreamNonBlocking)); 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_pd_mean, m_image_size * sizeof(float))); + CUDA_CHECK(cudaMalloc(&sc.d_pd_sum, m_image_size * sizeof(float))); + CUDA_CHECK(cudaMalloc(&sc.d_pd_sum2, m_image_size * sizeof(float))); CUDA_CHECK(cudaMalloc(&sc.d_output, m_output_bytes_per_frame)); } } @@ -322,8 +321,7 @@ class ClusterFinderCUDA { sc.d_output + m_clusters_offset); CUDA_CHECK( cudaEventRecord(m_kernel_start_pool[frame_idx], sc.stream)); - device::find_clusters_in_single_frame + device::find_clusters_in_single_frame <<>>( sc.d_frame, sc.d_pd_mean, sc.d_pd_sum, sc.d_pd_sum2, n_pd_samples, m_nSigma, nrows, ncols, d_clusters, @@ -357,8 +355,9 @@ class ClusterFinderCUDA { if (n_found > 0) { const auto *src = reinterpret_cast( static_cast(h_slot) + m_clusters_offset); - for (uint32_t i = 0; i < n_found; ++i) - results[frame_idx].push_back(src[i]); + results[frame_idx].resize(n_found); + std::memcpy(results[frame_idx].data(), src, + n_found * sizeof(ClusterType)); } float kernel_ms = 0.0f; @@ -389,20 +388,28 @@ class ClusterFinderCUDA { * host pedestal has been updated. */ void sync_pedestal_to_device() { - // These return-by-value NDArrays must stay alive until the async - // copies complete, so we synchronise at the end before they go out - // of scope. NDArray h_mean = m_pedestal.mean(); NDArray h_sum = m_pedestal.get_sum(); NDArray h_sum2 = m_pedestal.get_sum2(); - const size_t bytes = m_image_size * sizeof(PEDESTAL_TYPE); + // Host accumulates in double for precision; cast to float for device + // to halve global-memory bandwidth and eliminate FP64 arithmetic. + std::vector f_mean(m_image_size); + std::vector f_sum(m_image_size); + std::vector f_sum2(m_image_size); + for (size_t i = 0; i < m_image_size; ++i) { + f_mean[i] = static_cast(h_mean.data()[i]); + f_sum[i] = static_cast(h_sum.data()[i]); + f_sum2[i] = static_cast(h_sum2.data()[i]); + } + + const size_t bytes = m_image_size * sizeof(float); for (auto &sc : v_sc) { - CUDA_CHECK(cudaMemcpyAsync(sc.d_pd_mean, h_mean.data(), bytes, + CUDA_CHECK(cudaMemcpyAsync(sc.d_pd_mean, f_mean.data(), bytes, cudaMemcpyHostToDevice, sc.stream)); - CUDA_CHECK(cudaMemcpyAsync(sc.d_pd_sum, h_sum.data(), bytes, + CUDA_CHECK(cudaMemcpyAsync(sc.d_pd_sum, f_sum.data(), bytes, cudaMemcpyHostToDevice, sc.stream)); - CUDA_CHECK(cudaMemcpyAsync(sc.d_pd_sum2, h_sum2.data(), bytes, + CUDA_CHECK(cudaMemcpyAsync(sc.d_pd_sum2, f_sum2.data(), bytes, cudaMemcpyHostToDevice, sc.stream)); } for (auto &sc : v_sc) diff --git a/include/aare/clusterfinder_kernel.cuh b/include/aare/clusterfinder_kernel.cuh index 74ddcf0..2686bf7 100644 --- a/include/aare/clusterfinder_kernel.cuh +++ b/include/aare/clusterfinder_kernel.cuh @@ -10,13 +10,13 @@ namespace aare::device { using COMPUTE_TYPE = float; template , - typename FRAME_TYPE = uint16_t, typename PEDESTAL_TYPE = double, + typename FRAME_TYPE = uint16_t, typename = std::enable_if_t::value>> __global__ void find_clusters_in_single_frame( - const FRAME_TYPE *__restrict__ d_frame, - PEDESTAL_TYPE *__restrict__ d_pd_mean, PEDESTAL_TYPE *__restrict__ d_pd_sum, - PEDESTAL_TYPE *__restrict__ d_pd_sum2, const uint32_t n_pd_samples, - const COMPUTE_TYPE m_nSigma, const size_t nrows, const size_t ncols, + const FRAME_TYPE *__restrict__ d_frame, float *__restrict__ d_pd_mean, + float *__restrict__ d_pd_sum, float *__restrict__ d_pd_sum2, + const uint32_t n_pd_samples, const COMPUTE_TYPE m_nSigma, + const size_t nrows, const size_t ncols, // const uint64_t frame_number, ClusterType *d_clusters, uint32_t *d_cluster_count, const uint32_t max_clusters) { @@ -87,8 +87,7 @@ __global__ void find_clusters_in_single_frame( // Returns the pedestal-subtracted value. auto load_pixel = [&] __device__(ssize_t gr, ssize_t gc) -> COMPUTE_TYPE { auto gid = gc + ncols * gr; - return static_cast(d_frame[gid]) - - static_cast(d_pd_mean[gid]); + return static_cast(d_frame[gid]) - d_pd_mean[gid]; }; // A. Interior: every valid thread loads its own pixel @@ -175,13 +174,11 @@ __global__ void find_clusters_in_single_frame( // 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 - PEDESTAL_TYPE nSig_sq_rms_sq = static_cast(m_nSigma) * - static_cast(m_nSigma) * - rms_sq; + float mean_px = d_pd_mean[global_tid]; + float var_px = d_pd_sum2[global_tid] / static_cast(n_pd_samples) - + mean_px * mean_px; + float rms_sq = fmaxf(var_px, 0.0f); + float nSig_sq_rms_sq = m_nSigma * m_nSigma * rms_sq; // Pedestal-subtracted value of the center pixel (already in shmem) COMPUTE_TYPE val_pixel = shmem[shmem_tid]; @@ -190,10 +187,7 @@ __global__ void find_clusters_in_single_frame( // 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(val_pixel) * - static_cast(val_pixel) > - nSig_sq_rms_sq) + if (val_pixel < 0.0f && val_pixel * val_pixel > nSig_sq_rms_sq) return; // NOTE: pedestal update for this pixel is skipped (same as // sequential) @@ -243,10 +237,7 @@ __global__ void find_clusters_in_single_frame( // 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(max_val) * - static_cast(max_val) > - nSig_sq_rms_sq) { + if (max_val > 0.0f && max_val * max_val > nSig_sq_rms_sq) { // Local-max suppression: only the center-pixel thread records the // cluster if (val_pixel < max_val) @@ -264,9 +255,8 @@ __global__ void find_clusters_in_single_frame( // Test 3: total significance (only if tests 1 & 2 didn't fire) if (!is_photon) { - if (total > 0 && static_cast(total) * - static_cast(total) > - pow2_c3 * nSig_sq_rms_sq) { + if (total > 0.0f && + total * total > static_cast(pow2_c3) * nSig_sq_rms_sq) { is_photon = true; } } @@ -277,16 +267,17 @@ __global__ void find_clusters_in_single_frame( // frame simultaneously. So the updated pedestal will only be used starting // from the next frame. -> This avoids a/serialization and b/global mem I/O. if (!is_photon && valid_pixel) { - PEDESTAL_TYPE raw_val = static_cast(d_frame[global_tid]); - PEDESTAL_TYPE sum = d_pd_sum[global_tid]; - PEDESTAL_TYPE sum2 = d_pd_sum2[global_tid]; + float raw_val = static_cast(d_frame[global_tid]); + float sum = d_pd_sum[global_tid]; + float sum2 = d_pd_sum2[global_tid]; + float n = static_cast(n_pd_samples); - sum += raw_val - sum / n_pd_samples; - sum2 += raw_val * raw_val - sum2 / n_pd_samples; + sum += raw_val - sum / n; + sum2 += raw_val * raw_val - sum2 / n; d_pd_sum[global_tid] = sum; d_pd_sum2[global_tid] = sum2; - d_pd_mean[global_tid] = sum / n_pd_samples; + d_pd_mean[global_tid] = sum / n; return; } diff --git a/python/tests/ClusterFinderCUDA.ipynb b/python/tests/ClusterFinderCUDA.ipynb index be4c139..1a47474 100644 --- a/python/tests/ClusterFinderCUDA.ipynb +++ b/python/tests/ClusterFinderCUDA.ipynb @@ -53,7 +53,7 @@ "text": [ "Image size: (400, 400)\n", "Pedestal frames: 1000\n", - "Data frames: 20000\n" + "Data frames: 88999\n" ] } ], @@ -62,9 +62,11 @@ "f = File(base / 'Moench03new/cu_half_speed_master_4.json')\n", "\n", "n_frames_pd = 1000\n", - "N = 20000 #88999\n", + "N = 88999 #88999\n", "cluster_size = (9, 9)\n", - "image_size = (f.rows, f.cols)\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", @@ -156,7 +158,7 @@ "cf_cuda = ClusterFinderCUDA(image_size, \n", " cluster_size, \n", " n_sigma=7, \n", - " max_clusters_per_frame=2048,\n", + " max_clusters_per_frame=1500,\n", " n_streams=N_STREAMS) " ] }, @@ -170,7 +172,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pedestal (1000 frames): 0.496s\n" + "Pedestal (1000 frames): 0.499s\n" ] } ], @@ -201,7 +203,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Reading 20000 frames: 1.195s (16742 FPS, 5109.275 GB/s)\n" + "Reading 88999 frames: 51.133s (1741 FPS, 531.166 GB/s)\n" ] } ], @@ -225,20 +227,37 @@ { "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: 188.615s (106 FPS, 20325971 clusters, 1016.30/frame)\n" + "CPU clustering: 839.049s (106 FPS, 90799856 clusters, 1020.23/frame)\n" ] } ], "source": [ "t0 = time.perf_counter()\n", - "for frame in data:\n", + "for frame in tqdm(data):\n", " cf_cpu.find_clusters(frame)\n", "t_cpu = time.perf_counter() - t0\n", "\n", @@ -273,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "4f94cf35-5796-463d-bed8-f44a02d91fc6", "metadata": {}, "outputs": [], @@ -283,16 +302,17 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 29, "id": "50848f8c-2e66-45b8-b6d5-ca80f368e6ba", "metadata": {}, "outputs": [], "source": [ "if(BATCHED):\n", - " BATCH_SIZE = 5000\n", + " BATCH_SIZE = 2000\n", "\n", - " # Before warmup, pin the entire data array once\n", - " cf_cuda.register_input_buffer(data)\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", @@ -303,8 +323,9 @@ " 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(data[start:stop], first_frame=start)\n", + " cf_cuda.find_clusters_batched(batch_buffer[:stop-start], first_frame=start)\n", " )\n", " t_cuda = time.perf_counter() - t0\n", "\n", @@ -344,7 +365,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 30, "id": "502d0d3b-6b1e-4cc9-91df-9d998bd849b5", "metadata": {}, "outputs": [ @@ -354,7 +375,7 @@ "(9, 9)" ] }, - "execution_count": 46, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -365,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 31, "id": "2e3e4b9c-7f23-4fb7-bc3e-fa3d766d51fc", "metadata": {}, "outputs": [ @@ -373,7 +394,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU clustering: 188.615s (106 FPS, 20325971 clusters, 1016.30/frame)\n" + "CPU clustering: 839.049s (106 FPS, 90799856 clusters, 1020.23/frame)\n" ] } ], @@ -384,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 32, "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523", "metadata": {}, "outputs": [ @@ -392,10 +413,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "CUDA clustering: 1.304s (15332 FPS, 20238568 clusters, 1011.93/frame)\n", - " Kernel only: 0.038 ms/frame\n", - " PCIe + overhead: 0.027 ms/frame\n", - "Speedup (CPU / CUDA): 144.60×\n" + "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" ] } ], @@ -419,7 +440,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 18, "id": "d3a850df-7df0-485b-971d-381cfdc6be81", "metadata": {}, "outputs": [ @@ -427,7 +448,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Cluster count diff: 87403 (0.43%)\n" + "Cluster count diff: 2716962 (2.99%)\n" ] } ], @@ -447,7 +468,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 19, "id": "aff8db7e-8332-4228-857f-a9875cf940d3", "metadata": {}, "outputs": [ @@ -467,14 +488,14 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 20, "id": "9adeea2f-9309-4c0a-905b-7d1203ba1f4e", "metadata": {}, "outputs": [ { "data": { "image/png": - "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", + "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", "text/plain": [ "
" ] diff --git a/src/ClusterFinderCUDA.test.cu b/src/ClusterFinderCUDA.test.cu index 2c5703f..ac831c5 100644 --- a/src/ClusterFinderCUDA.test.cu +++ b/src/ClusterFinderCUDA.test.cu @@ -312,6 +312,12 @@ int main(int argc, char *argv[]) { COLS = first_frame.cols(); } + constexpr size_t MAX_CLUSTERS_PER_FRAME = 2048; + + // Parameters for batched / mutli-stream runs + constexpr size_t BATCH_SIZE = 2000; + constexpr int N_STREAMS = 5; + printf("=== Cluster Finder: CPU vs CUDA ===\n"); printf("Detector: %zu x %zu\n", ROWS, COLS); printf("Cluster: %d x %d\n", ClusterType::cluster_size_x, @@ -474,11 +480,8 @@ int main(int argc, char *argv[]) { // --- Batched H2D + multi-stream (enable this block and disable the one // above to benchmark the batched path against the CPU results) --- { - constexpr size_t BATCH_SIZE = 2000; - constexpr int N_STREAMS = 5; - aare::ClusterFinderCUDA cuda_cf( - {ROWS, COLS}, nSigma, 4096, N_STREAMS); + {ROWS, COLS}, nSigma, MAX_CLUSTERS_PER_FRAME, N_STREAMS); feed_pedestal(cuda_cf, pedestal_frames); @@ -645,11 +648,9 @@ int main(int argc, char *argv[]) { // --- GPU benchmark (batched + multi-streamed) --- { - constexpr size_t BATCH_SIZE = 2000; - constexpr int N_STREAMS = 5; - aare::ClusterFinderCUDA - cuda_cf({ROWS, COLS}, nSigma, 4096, N_STREAMS); + cuda_cf({ROWS, COLS}, nSigma, MAX_CLUSTERS_PER_FRAME, + N_STREAMS); feed_pedestal(cuda_cf, pedestal_frames); // Build one contiguous batch of BATCH_SIZE copies of bench_frame.