mirror of
https://github.com/slsdetectorgroup/aare.git
synced 2026-11-17 05:30:02 +01:00
Port the frozen and CUDA finders to FastPedestal
- main moved ClusterFinder to FastPedestal and dropped Pedestal's
push_fast/get_sum/get_sum2, which ClusterFinderFrozen and both CUDA
drivers still called.
- Move all three to FastPedestal. Its uniform sample count is what the
CUDA kernel already assumes, and matching ClusterFinder keeps CPU and
GPU warm-up identical, which ClusterFinderFrozen exists to verify.
FastPedestal gains get_sum/get_sum2 to de-interleave its internal
Entry{sum,sum2} for the CUDA upload.
- Also expose min_pedestal_samples on these constructors and factories,
make the factories keyword-only after image_size. Same API in C++ and Python.
This commit is contained in:
1 parent
7a8f918a56
commit
d9bead2a07
10 files changed
+128
-47
No files matched your search
@@ -133,7 +133,7 @@ class ClusterFinderCUDA {
|
||||
size_t m_output_bytes_per_frame;
|
||||
|
||||
COMPUTE_TYPE m_nSigma;
|
||||
Pedestal<PEDESTAL_TYPE> m_pedestal;
|
||||
FastPedestal<PEDESTAL_TYPE> m_pedestal;
|
||||
ClusterVector<ClusterType> m_clusters;
|
||||
bool m_pedestal_dirty = true;
|
||||
|
||||
@@ -420,6 +420,10 @@ class ClusterFinderCUDA {
|
||||
* fixed-size D2H
|
||||
* @param n_streams_ number of CUDA streams for multi-frame
|
||||
* overlap
|
||||
* @param min_pedestal_samples number of frames the host pedestal
|
||||
* accumulates before it is ready, and the reciprocal of the steady-state
|
||||
* update weight. Matches ClusterFinder so a CPU/GPU comparison warms up
|
||||
* identically.
|
||||
* @param time_kernels enable per-frame CUDA-event kernel
|
||||
* timing. Off by default: it adds two event records per frame to the
|
||||
* streams and one host-side query per frame, and the resulting number is
|
||||
@@ -427,12 +431,13 @@ class ClusterFinderCUDA {
|
||||
*/
|
||||
ClusterFinderCUDA(Shape<2> shape_, COMPUTE_TYPE nSigma = 5.0,
|
||||
size_t max_clusters_per_frame = 2048, int n_streams_ = 4,
|
||||
size_t min_pedestal_samples = 1000,
|
||||
bool time_kernels = false)
|
||||
: m_shape(shape_), nrows(shape_[0]), ncols(shape_[1]),
|
||||
m_image_size(nrows * ncols), n_streams(n_streams_),
|
||||
m_max_clusters_per_frame(max_clusters_per_frame), m_nSigma(nSigma),
|
||||
m_pedestal(shape_[0], shape_[1]), m_clusters(max_clusters_per_frame),
|
||||
m_time_kernels(time_kernels) {
|
||||
m_pedestal(shape_[0], shape_[1], min_pedestal_samples),
|
||||
m_clusters(max_clusters_per_frame), m_time_kernels(time_kernels) {
|
||||
if (n_streams_ <= 0) {
|
||||
throw std::invalid_argument(
|
||||
"ClusterFinderCUDA: n_streams must be > 0");
|
||||
@@ -539,7 +544,11 @@ class ClusterFinderCUDA {
|
||||
}
|
||||
|
||||
void push_pedestal_frame(NDView<FRAME_TYPE, 2> frame) {
|
||||
m_pedestal.push(frame);
|
||||
if (!m_pedestal.ready()) {
|
||||
m_pedestal.add_init_frame(frame);
|
||||
} else {
|
||||
m_pedestal.push_ema(frame);
|
||||
}
|
||||
m_pedestal_dirty = true;
|
||||
}
|
||||
|
||||
|
||||
@@ -94,7 +94,7 @@ class ClusterFinderCUDAGraph {
|
||||
size_t m_clusters_offset; // offset of cluster array within output block
|
||||
|
||||
COMPUTE_TYPE m_nSigma;
|
||||
Pedestal<PEDESTAL_TYPE> m_pedestal;
|
||||
FastPedestal<PEDESTAL_TYPE> m_pedestal;
|
||||
ClusterVector<ClusterType> m_clusters;
|
||||
bool m_pedestal_dirty = true;
|
||||
bool m_graphs_dirty = true; // set when pedestal or h_output_pinned changes
|
||||
@@ -125,11 +125,13 @@ class ClusterFinderCUDAGraph {
|
||||
*/
|
||||
ClusterFinderCUDAGraph(Shape<2> shape_, COMPUTE_TYPE nSigma = 5.0,
|
||||
size_t max_clusters_per_frame = 2048,
|
||||
int n_streams_ = 4)
|
||||
int n_streams_ = 4,
|
||||
size_t min_pedestal_samples = 1000)
|
||||
: m_shape(shape_), nrows(shape_[0]), ncols(shape_[1]),
|
||||
m_image_size(nrows * ncols), n_streams(n_streams_),
|
||||
m_max_clusters_per_frame(max_clusters_per_frame), m_nSigma(nSigma),
|
||||
m_pedestal(shape_[0], shape_[1]), m_clusters(max_clusters_per_frame) {
|
||||
m_pedestal(shape_[0], shape_[1], min_pedestal_samples),
|
||||
m_clusters(max_clusters_per_frame) {
|
||||
if (n_streams_ <= 0) {
|
||||
throw std::invalid_argument(
|
||||
"ClusterFinderCUDAGraph: n_streams must be > 0");
|
||||
@@ -268,7 +270,11 @@ class ClusterFinderCUDAGraph {
|
||||
}
|
||||
|
||||
void push_pedestal_frame(NDView<FRAME_TYPE, 2> frame) {
|
||||
m_pedestal.push(frame);
|
||||
if (!m_pedestal.ready()) {
|
||||
m_pedestal.add_init_frame(frame);
|
||||
} else {
|
||||
m_pedestal.push_ema(frame);
|
||||
}
|
||||
m_pedestal_dirty = true;
|
||||
}
|
||||
|
||||
@@ -427,8 +433,10 @@ class ClusterFinderCUDAGraph {
|
||||
*/
|
||||
void sync_pedestal_to_device() {
|
||||
NDArray<PEDESTAL_TYPE, 2> h_mean = m_pedestal.mean();
|
||||
NDArray<PEDESTAL_TYPE, 2> h_sum = m_pedestal.get_sum();
|
||||
NDArray<PEDESTAL_TYPE, 2> h_sum2 = m_pedestal.get_sum2();
|
||||
// FastPedestal keeps both moments in double whatever PEDESTAL_TYPE is,
|
||||
// so let the accessors name their own type here.
|
||||
auto h_sum = m_pedestal.get_sum();
|
||||
auto h_sum2 = m_pedestal.get_sum2();
|
||||
|
||||
using DPT = device::DEVICE_PED_TYPE;
|
||||
const double n = static_cast<double>(m_pedestal.n_samples());
|
||||
|
||||
@@ -4,9 +4,9 @@
|
||||
#include "aare/ClusterFinder.hpp" // no_2x2_cluster guard, reused here
|
||||
#include "aare/ClusterVector.hpp"
|
||||
#include "aare/Dtype.hpp"
|
||||
#include "aare/FastPedestal.hpp"
|
||||
#include "aare/NDArray.hpp"
|
||||
#include "aare/NDView.hpp"
|
||||
#include "aare/Pedestal.hpp"
|
||||
#include "aare/defs.hpp"
|
||||
#include <cstddef>
|
||||
#include <utility>
|
||||
@@ -45,7 +45,7 @@ class ClusterFinderFrozen {
|
||||
PEDESTAL_TYPE m_nSigma;
|
||||
const PEDESTAL_TYPE c2;
|
||||
const PEDESTAL_TYPE c3;
|
||||
Pedestal<PEDESTAL_TYPE> m_pedestal;
|
||||
FastPedestal<PEDESTAL_TYPE> m_pedestal;
|
||||
ClusterVector<ClusterType> m_clusters;
|
||||
|
||||
static const uint8_t ClusterSizeX = ClusterType::cluster_size_x;
|
||||
@@ -54,21 +54,28 @@ class ClusterFinderFrozen {
|
||||
|
||||
public:
|
||||
ClusterFinderFrozen(Shape<2> image_size, PEDESTAL_TYPE nSigma = 5.0,
|
||||
size_t capacity = 1000000)
|
||||
size_t capacity = 1000000,
|
||||
size_t min_pedestal_samples = 1000)
|
||||
: m_image_size(image_size), m_nSigma(nSigma),
|
||||
c2(sqrt((ClusterSizeY + 1) / 2 * (ClusterSizeX + 1) / 2)),
|
||||
c3(sqrt(ClusterSizeX * ClusterSizeY)),
|
||||
m_pedestal(image_size[0], image_size[1]), m_clusters(capacity) {
|
||||
m_pedestal(image_size[0], image_size[1], min_pedestal_samples),
|
||||
m_clusters(capacity) {
|
||||
LOG(logDEBUG) << "ClusterFinderFrozen: "
|
||||
<< "image_size: " << image_size[0] << "x" << image_size[1]
|
||||
<< ", nSigma: " << nSigma << ", capacity: " << capacity;
|
||||
<< ", nSigma: " << nSigma << ", capacity: " << capacity
|
||||
<< ", min_pedestal_samples: " << min_pedestal_samples;
|
||||
}
|
||||
|
||||
void set_nSigma(PEDESTAL_TYPE nSigma) { m_nSigma = nSigma; }
|
||||
PEDESTAL_TYPE get_nSigma() const { return m_nSigma; }
|
||||
|
||||
void push_pedestal_frame(NDView<FRAME_TYPE, 2> frame) {
|
||||
m_pedestal.push(frame);
|
||||
if (!m_pedestal.ready()) {
|
||||
m_pedestal.add_init_frame(frame);
|
||||
} else {
|
||||
m_pedestal.push_ema(frame);
|
||||
}
|
||||
}
|
||||
|
||||
NDArray<PEDESTAL_TYPE, 2> pedestal() { return m_pedestal.mean(); }
|
||||
@@ -86,6 +93,11 @@ class ClusterFinderFrozen {
|
||||
}
|
||||
|
||||
void find_clusters(NDView<FRAME_TYPE, 2> frame, uint64_t frame_number = 0) {
|
||||
if (!m_pedestal.ready()) {
|
||||
throw std::runtime_error(
|
||||
"Pedestal is not ready, cannot find clusters");
|
||||
}
|
||||
|
||||
int dy = ClusterSizeY / 2;
|
||||
int dx = ClusterSizeX / 2;
|
||||
int has_center_pixel_x = ClusterSizeX % 2;
|
||||
@@ -177,7 +189,7 @@ class ClusterFinderFrozen {
|
||||
// only affects decisions from the NEXT frame on -> matches CUDA. Each
|
||||
// pixel is visited at most once per frame, so push order is irrelevant.
|
||||
for (const auto &p : deferred)
|
||||
m_pedestal.push_fast(p.first, p.second, frame(p.first, p.second));
|
||||
m_pedestal.push_ema(p.first, p.second, frame(p.first, p.second));
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -145,13 +145,12 @@ class ClusterFinderMT {
|
||||
* the sink
|
||||
*/
|
||||
// void collect() {
|
||||
// bool empty = true;
|
||||
// Backoff backoff;
|
||||
// while (!m_stop_requested || !empty || !m_processing_threads_stopped)
|
||||
// {
|
||||
// while (!m_stop_requested || !output_queues_are_empty() ||
|
||||
// !m_processing_threads_stopped) {
|
||||
// bool moved_any = false;
|
||||
// for (auto &queue : m_output_queues) {
|
||||
// while (auto *front = queue->frontPtr()) {
|
||||
// if (auto *front = queue->frontPtr(); front != nullptr) {
|
||||
// while (!m_sink.write(std::move(*front))) {
|
||||
// backoff.pause();
|
||||
// }
|
||||
@@ -159,7 +158,6 @@ class ClusterFinderMT {
|
||||
// moved_any = true;
|
||||
// }
|
||||
// }
|
||||
// empty = !moved_any;
|
||||
// if (moved_any) {
|
||||
// backoff.reset();
|
||||
// } else {
|
||||
|
||||
@@ -144,6 +144,43 @@ template <typename PEDESTAL_TYPE> class FastPedestal {
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return a copy of the per-pixel first moment, ~ n * E[X].
|
||||
* @throws std::runtime_error if ready() is false.
|
||||
* @note The two moments are stored interleaved for cache locality, so this
|
||||
* de-interleaves them into a plain array. Intended for callers that need a
|
||||
* contiguous moment array rather than per-pixel access, such as the CUDA
|
||||
* pedestal upload.
|
||||
*/
|
||||
NDArray<double, 2> get_sum() const {
|
||||
if (!ready()) {
|
||||
throw std::runtime_error(
|
||||
"Pedestal is not ready, cannot return sum");
|
||||
}
|
||||
NDArray<double, 2> res({m_rows, m_cols});
|
||||
for (ssize_t i = 0; i < m_sum.size(); ++i) {
|
||||
res[i] = m_sum[i].sum;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return a copy of the per-pixel second moment, ~ n * E[X^2].
|
||||
* @throws std::runtime_error if ready() is false.
|
||||
* @see get_sum() for why this is a de-interleaving copy.
|
||||
*/
|
||||
NDArray<double, 2> get_sum2() const {
|
||||
if (!ready()) {
|
||||
throw std::runtime_error(
|
||||
"Pedestal is not ready, cannot return sum2");
|
||||
}
|
||||
NDArray<double, 2> res({m_rows, m_cols});
|
||||
for (ssize_t i = 0; i < m_sum.size(); ++i) {
|
||||
res[i] = m_sum[i].sum2;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Calculate the population standard deviation at (row, col).
|
||||
* @throws std::runtime_error if ready() is false or either index is out of
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
#pragma once
|
||||
#include "aare/Cluster.hpp"
|
||||
#include "aare/FastPedestal.hpp"
|
||||
#include "aare/NDArray.hpp"
|
||||
#include "aare/Pedestal.hpp"
|
||||
#include "aare/clusterfinder_kernel.cuh"
|
||||
#include "aare/utils/cuda_check.cuh"
|
||||
#include <algorithm>
|
||||
@@ -33,7 +33,7 @@ namespace aare::cuda {
|
||||
* HostImage host image of Buffers, ready to upload
|
||||
* Buffers allocate(size_t n_pixels)
|
||||
* View make_view(const Buffers &)
|
||||
* HostImage prepare_pedestal(Pedestal<HostPedT> &) [template on HostPedT]
|
||||
* HostImage prepare_pedestal(FastPedestal<HostPedT> &) [template on HostPedT]
|
||||
* void upload_pedestal(const HostImage &, const Buffers &, cudaStream_t)
|
||||
* void download_mean(const Buffers &, size_t, std::vector<DevicePedT> &,
|
||||
* cudaStream_t)
|
||||
@@ -169,10 +169,12 @@ struct CenteredRunningPedestal {
|
||||
* term that would not survive.
|
||||
*/
|
||||
template <typename HostPedT>
|
||||
static HostImage prepare_pedestal(Pedestal<HostPedT> &host) {
|
||||
static HostImage prepare_pedestal(FastPedestal<HostPedT> &host) {
|
||||
NDArray<HostPedT, 2> h_mean = host.mean();
|
||||
NDArray<HostPedT, 2> h_sum = host.get_sum();
|
||||
NDArray<HostPedT, 2> h_sum2 = host.get_sum2();
|
||||
// FastPedestal keeps both moments in double whatever HostPedT is, so
|
||||
// let the accessors name their own type here.
|
||||
auto h_sum = host.get_sum();
|
||||
auto h_sum2 = host.get_sum2();
|
||||
const size_t n_pixels = static_cast<size_t>(h_mean.size());
|
||||
const double n = static_cast<double>(host.n_samples());
|
||||
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
#pragma once
|
||||
#include "aare/ClusterFinderCUDA.hpp"
|
||||
#include "aare/ClusterVector.hpp"
|
||||
#include "aare/FastPedestal.hpp"
|
||||
#include "aare/NDView.hpp"
|
||||
#include "aare/Pedestal.hpp"
|
||||
#include "np_helper.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
@@ -112,9 +112,10 @@ void define_ClusterFinderCUDA(py::module &m, const std::string &typestr) {
|
||||
coordinates as (x, y).)");
|
||||
|
||||
py::class_<CF>(m, class_name.c_str())
|
||||
.def(py::init<Shape<2>, float, size_t, int, bool>(),
|
||||
.def(py::init<Shape<2>, float, size_t, int, size_t, bool>(),
|
||||
py::arg("image_size"), py::arg("n_sigma") = 5.0f,
|
||||
py::arg("max_clusters_per_frame") = 2048, py::arg("n_streams") = 4,
|
||||
py::arg("min_pedestal_samples") = 1000,
|
||||
py::arg("time_kernels") = false)
|
||||
|
||||
.def_property(
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
#pragma once
|
||||
#include "aare/ClusterFinderCUDA_graph.hpp"
|
||||
#include "aare/ClusterVector.hpp"
|
||||
#include "aare/FastPedestal.hpp"
|
||||
#include "aare/NDView.hpp"
|
||||
#include "aare/Pedestal.hpp"
|
||||
#include "np_helper.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
@@ -31,9 +31,10 @@ void define_ClusterFinderCUDAGraph(py::module &m, const std::string &typestr) {
|
||||
py::array_t<uint16_t, py::array::c_style | py::array::forcecast>;
|
||||
|
||||
py::class_<CF>(m, class_name.c_str())
|
||||
.def(py::init<Shape<2>, float, size_t, int>(), py::arg("image_size"),
|
||||
py::arg("n_sigma") = 5.0f,
|
||||
py::arg("max_clusters_per_frame") = 2048, py::arg("n_streams") = 4)
|
||||
.def(py::init<Shape<2>, float, size_t, int, size_t>(),
|
||||
py::arg("image_size"), py::arg("n_sigma") = 5.0f,
|
||||
py::arg("max_clusters_per_frame") = 2048, py::arg("n_streams") = 4,
|
||||
py::arg("min_pedestal_samples") = 1000)
|
||||
|
||||
.def_property(
|
||||
"nSigma", &CF::get_nSigma, &CF::set_nSigma,
|
||||
|
||||
@@ -27,8 +27,10 @@ void define_ClusterFinderFrozen(py::module &m, const std::string &typestr) {
|
||||
|
||||
py::class_<ClusterFinderFrozen<ClusterType, uint16_t, pd_type>>(
|
||||
m, class_name.c_str())
|
||||
.def(py::init<Shape<2>, pd_type, size_t>(), py::arg("image_size"),
|
||||
py::arg("n_sigma") = 5.0, py::arg("capacity") = 1'000'000)
|
||||
.def(py::init<Shape<2>, pd_type, size_t, size_t>(),
|
||||
py::arg("image_size"), py::arg("n_sigma") = 5.0,
|
||||
py::arg("capacity") = 1'000'000,
|
||||
py::arg("min_pedestal_samples") = 1000)
|
||||
|
||||
.def_property(
|
||||
"nSigma",
|
||||
|
||||
@@ -88,7 +88,7 @@
|
||||
"# reached, which is how you size this for a new dataset.\n",
|
||||
"CAP = 3000\n",
|
||||
"\n",
|
||||
"capacity = 10_000 # initial ClusterVector capacity, CPU side\n",
|
||||
"capacity = 3_000 # initial ClusterVector capacity, CPU side\n",
|
||||
"N_BINS = 200\n",
|
||||
"E_MIN, E_MAX = -2, 4000 # spectrum range, ADU\n",
|
||||
"\n",
|
||||
@@ -113,12 +113,12 @@
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"cf_cpu = ClusterFinderMT(image_size, cluster_size, n_sigma=N_SIGMA,\n",
|
||||
" capacity=capacity, n_threads=N_THREADS)\n",
|
||||
" capacity=capacity, min_pedestal_samples=n_frames_pd, n_threads=N_THREADS)\n",
|
||||
"sink = ClusterCollector(cf_cpu)\n",
|
||||
"\n",
|
||||
"cf_cuda = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
|
||||
" max_clusters_per_frame=CAP, n_streams=N_STREAMS, \n",
|
||||
" time_kernels=False, algorithm=\"fixed_window\")"
|
||||
" n_pedestal_frames=n_frames_pd, algorithm=\"fixed_window\", time_kernels=False)"
|
||||
]
|
||||
},
|
||||
{
|
||||
@@ -175,7 +175,7 @@
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Reading 100000 frames: 82.39s (1,214 FPS, 32.00 GB at 0.39 GB/s)\n"
|
||||
"Reading 100000 frames: 5.20s (19,219 FPS, 32.00 GB at 6.15 GB/s)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
@@ -207,14 +207,14 @@
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"100%|██████████████████████████████████████████████████| 100000/100000 [00:23<00:00, 4191.14it/s]\n"
|
||||
"100%|██████████████████████████████████████████████████████████████| 100000/100000 [00:23<00:00, 4310.91it/s]\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"CPU MT (24 threads): 23.86s 4,190 FPS 233,099,227 clusters (2331.0/frame)\n"
|
||||
"CPU MT (24 threads): 23.20s 4,310 FPS 233,099,227 clusters (2331.0/frame)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
@@ -253,10 +253,21 @@
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"execution_count": 7,
|
||||
"id": "cuda",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"CUDA batched: 3.18s 31,484 FPS 233,093,554 clusters (2330.9/frame)\n",
|
||||
" input pinned in 0.84s, once, outside the loop\n",
|
||||
" vs CPU: 7.30x\n",
|
||||
" peak clusters in one frame: 2,545 of CAP 3,000\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"t0 = time.perf_counter()\n",
|
||||
"cf_cuda.register_input_buffer(data)\n",
|
||||
@@ -309,10 +320,10 @@
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
" s FPS us/frame clusters\n",
|
||||
"CPU MT (24 thr) 23.86 4,190 238.6 233,099,227\n",
|
||||
"CUDA batched 3.34 29,926 33.4 233,093,554\n",
|
||||
"CPU MT (24 thr) 23.20 4,310 232.0 233,099,227\n",
|
||||
"CUDA batched 3.18 31,484 31.8 233,093,554\n",
|
||||
"\n",
|
||||
"speedup: 7.14x\n"
|
||||
"speedup: 7.30x\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
@@ -429,7 +440,7 @@
|
||||
" genuine add / drop 31,395 25,871\n",
|
||||
"\n",
|
||||
"frames touched by a genuine difference: 41,569 of 100,000\n",
|
||||
"[40.6s]\n"
|
||||
"[40.2s]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
|
||||
Reference in new issue
Block a user