Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
numeric.hpp
Go to the documentation of this file.
1// -------------------------------------------------------//
2//
3// SHAMROCK code for hydrodynamics
4// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
5// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
6// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
7//
8// -------------------------------------------------------//
9
10#pragma once
11
19
20#include "shambase/assert.hpp"
21#include "shambase/memory.hpp"
26#include "shambackends/sycl.hpp"
27
32namespace shamalgs::numeric {
33
43 template<class T>
44 sycl::buffer<T> scan_exclusive(sycl::queue &q, sycl::buffer<T> &buf1, u32 len);
45
54 template<class T>
55 sham::DeviceBuffer<T> scan_exclusive(
56 sham::DeviceScheduler_ptr sched, sham::DeviceBuffer<T> &buf1, u32 len);
57
66 std::tuple<std::optional<sycl::buffer<u32>>, u32> stream_compact(
67 sycl::queue &q, sycl::buffer<u32> &buf_flags, u32 len);
68
77 sham::DeviceBuffer<u32> stream_compact(
78 const sham::DeviceScheduler_ptr &sched, sham::DeviceBuffer<u32> &buf_flags, u32 len);
79
80 template<class T>
83 sham::DeviceBuffer<T> bins_center;
84 sham::DeviceBuffer<T> bins_width;
85 };
86
121 template<class Tret, class T>
123 const sham::DeviceScheduler_ptr &sched,
124 const sham::DeviceBuffer<T> &bin_edges,
125 u64 nbins,
126 const sham::DeviceBuffer<T> &values,
127 u32 len);
128
129 template<class T>
130 inline sham::DeviceBuffer<u64> device_histogram_u64(
131 const sham::DeviceScheduler_ptr &sched,
132 const sham::DeviceBuffer<T> &bin_edges,
133 u64 nbins,
134 const sham::DeviceBuffer<T> &values,
135 u32 len) {
136 return device_histogram<u64, T>(sched, bin_edges, nbins, values, len);
137 }
138
139 template<class T>
140 inline sham::DeviceBuffer<u32> device_histogram_u32(
141 const sham::DeviceScheduler_ptr &sched,
142 const sham::DeviceBuffer<T> &bin_edges,
143 u64 nbins,
144 const sham::DeviceBuffer<T> &values,
145 u32 len) {
146 return device_histogram<u32, T>(sched, bin_edges, nbins, values, len);
147 }
148
164 template<class T>
166 const sham::DeviceScheduler_ptr &sched,
167 const sham::DeviceBuffer<T> &bin_edges,
168 u64 nbins,
169 const sham::DeviceBuffer<T> &values,
170 u32 len) {
171
172 SHAM_ASSERT(nbins > 1); // at least a sup and a inf
173 SHAM_ASSERT(bin_edges.get_size() == nbins + 1);
174
175 auto &q = shambase::get_check_ref(sched).get_queue();
176
177 sham::DeviceBuffer<u64> counts = device_histogram(sched, bin_edges, nbins, values, len);
178
179 sham::DeviceBuffer<T> bins_center(nbins, sched);
180 sham::DeviceBuffer<T> bins_width(nbins, sched);
181
183 q,
184 sham::MultiRef{bin_edges},
185 sham::MultiRef{bins_center, bins_width},
186 nbins,
187 [](u32 i,
188 const T *__restrict bin_edges,
189 T *__restrict bins_center,
190 T *__restrict bins_width) {
191 bins_center[i] = (bin_edges[i] + bin_edges[i + 1]) / 2;
192 bins_width[i] = bin_edges[i + 1] - bin_edges[i];
193 });
194
195 return {std::move(counts), std::move(bins_center), std::move(bins_width)};
196 }
197
206 template<class T>
212
241 template<class T>
243 const sham::DeviceScheduler_ptr &sched,
244 const sham::DeviceBuffer<T> &bin_edges,
245 u64 nbins,
246 const sham::DeviceBuffer<T> &values, // ie f(r)
247 const sham::DeviceBuffer<T> &keys, // ie r
248 u32 len);
249
286 template<class Tret, class T, class Fct>
288 const sham::DeviceScheduler_ptr &sched,
289 const sham::DeviceBuffer<T> &bin_edges,
290 u64 nbins,
291 const sham::DeviceBuffer<T> &values, // ie f(r)
292 const sham::DeviceBuffer<T> &keys, // ie r
293 u32 len,
294 Fct &&fct) {
295
296 auto bin_compute_in = binned_init_compute(sched, bin_edges, nbins, values, keys, len);
297 auto &valid_values = bin_compute_in.valid_values;
298 auto &offsets_bins = bin_compute_in.offsets_bins;
299
300 auto &q = shambase::get_check_ref(sched).get_queue();
301
302 sham::DeviceBuffer<Tret> bin_compute(nbins, sched);
303
305 q,
306 sham::MultiRef{valid_values, offsets_bins},
307 sham::MultiRef{bin_compute},
308 nbins,
309 [fct](
310 u32 i,
311 const T *__restrict valid_values,
312 const u32 *__restrict offsets_bins,
313 Tret *__restrict bin_averages) {
314 u32 bin_start = offsets_bins[i];
315 u32 bin_end = offsets_bins[i + 1];
316 u32 bin_count = bin_end - bin_start;
317
318 auto for_each_values = [&](auto func) {
319 for (u32 j = bin_start; j < bin_end; j++) {
320 func(valid_values[j]);
321 }
322 };
323
324 bin_averages[i] = fct(for_each_values, bin_count);
325 });
326
327 return bin_compute;
328 }
329
356 template<class T>
358 const sham::DeviceScheduler_ptr &sched,
359 const sham::DeviceBuffer<T> &bin_edges, // r bins
360 u64 nbins,
361 const sham::DeviceBuffer<T> &values, // ie f(r)
362 const sham::DeviceBuffer<T> &keys, // ie r
363 u32 len) {
364
366 sched, bin_edges, nbins, values, keys, len, [](auto for_each_values, u32 bin_count) {
367 T sum = 0;
368 for_each_values([&](T val) {
369 sum += val;
370 });
371 return sum;
372 });
373 }
374
401 template<class T>
403 const sham::DeviceScheduler_ptr &sched,
404 const sham::DeviceBuffer<T> &bin_edges, // r bins
405 u64 nbins,
406 const sham::DeviceBuffer<T> &values, // ie f(r)
407 const sham::DeviceBuffer<T> &keys, // ie r
408 u32 len) {
409
411 sched,
412 bin_edges,
413 nbins,
414 values,
415 keys,
416 len,
417 [](auto for_each_values, u32 bin_count) -> T {
418 T sum = T{};
419 for_each_values([&](T val) {
420 sum += val;
421 });
422 if (bin_count == 0) {
423 return T{};
424 } else {
425 return sum / bin_count;
426 }
427 });
428 }
429
465 template<class Tret, class T>
467 const sham::DeviceScheduler_ptr &sched,
468 const sham::DeviceBuffer<T> &bin_edges,
469 u64 nbins,
470 const sham::DeviceBuffer<T> &values,
471 u32 len) {
472
473 auto local_counts = device_histogram<Tret, T>(sched, bin_edges, nbins, values, len);
474
475 // local counts are now the global counts
476 shamalgs::collective::reduce_buffer_in_place_sum(local_counts, MPI_COMM_WORLD);
477
478 return local_counts;
479 }
480
511 template<class T>
513 const sham::DeviceScheduler_ptr &sched,
514 const sham::DeviceBuffer<T> &bin_edges,
515 u64 nbins,
516 const sham::DeviceBuffer<T> &values,
517 u32 len) {
518 return device_histogram_mpi<u64, T>(sched, bin_edges, nbins, values, len);
519 }
520
551 template<class T>
553 const sham::DeviceScheduler_ptr &sched,
554 const sham::DeviceBuffer<T> &bin_edges,
555 u64 nbins,
556 const sham::DeviceBuffer<T> &values,
557 u32 len) {
558 return device_histogram_mpi<u32, T>(sched, bin_edges, nbins, values, len);
559 }
560
596 template<class T>
598 const sham::DeviceScheduler_ptr &sched,
599 const sham::DeviceBuffer<T> &bin_edges, // r bins
600 u64 nbins,
601 const sham::DeviceBuffer<T> &values, // ie f(r)
602 const sham::DeviceBuffer<T> &keys, // ie r
603 u32 len) {
604
605 auto local_result = binned_sum(sched, bin_edges, nbins, values, keys, len);
606
607 // local result is now the global result
608 shamalgs::collective::reduce_buffer_in_place_sum(local_result, MPI_COMM_WORLD);
609
610 return local_result;
611 }
612
649 template<class T>
651 const sham::DeviceScheduler_ptr &sched,
652 const sham::DeviceBuffer<T> &bin_edges, // r bins
653 u64 nbins,
654 const sham::DeviceBuffer<T> &values, // ie f(r)
655 const sham::DeviceBuffer<T> &keys, // ie r
656 u32 len,
657 const sham::DeviceBuffer<u32> &bin_counts_global) {
658
659 auto bin_sums = binned_sum_mpi(sched, bin_edges, nbins, values, keys, len);
660
662 shambase::get_check_ref(sched).get_queue(),
663 sham::MultiRef{bin_counts_global},
664 sham::MultiRef{bin_sums},
665 nbins,
666 [](u32 i, const u32 *__restrict bin_counts, T *__restrict bin_sums) {
667 u32 bin_count = bin_counts[i];
668 if (bin_count == 0) {
669 bin_sums[i] = T{};
670 } else {
671 bin_sums[i] /= bin_count;
672 }
673 });
674
675 return bin_sums;
676 }
677
713 template<class T>
715 const sham::DeviceScheduler_ptr &sched,
716 const sham::DeviceBuffer<T> &bin_edges, // r bins
717 u64 nbins,
718 const sham::DeviceBuffer<T> &values, // ie f(r)
719 const sham::DeviceBuffer<T> &keys, // ie r
720 u32 len) {
721
722 auto bin_counts = device_histogram_u32_mpi(sched, bin_edges, nbins, keys, len);
723
724 // call the version with global bin counts pre-computed
725 return binned_average_mpi(sched, bin_edges, nbins, values, keys, len, bin_counts);
726 }
727
743 template<class T>
745 const sham::DeviceScheduler_ptr &sched,
746 const sham::DeviceBuffer<T> &bin_edges,
747 u64 nbins,
748 const sham::DeviceBuffer<T> &values,
749 u32 len) {
750
751 SHAM_ASSERT(nbins > 1); // at least a sup and a inf
752 SHAM_ASSERT(bin_edges.get_size() == nbins + 1);
753
754 auto &q = shambase::get_check_ref(sched).get_queue();
755
757 = device_histogram_u64_mpi(sched, bin_edges, nbins, values, len);
758
759 sham::DeviceBuffer<T> bins_center(nbins, sched);
760 sham::DeviceBuffer<T> bins_width(nbins, sched);
761
763 q,
764 sham::MultiRef{bin_edges},
765 sham::MultiRef{bins_center, bins_width},
766 nbins,
767 [](u32 i,
768 const T *__restrict bin_edges,
769 T *__restrict bins_center,
770 T *__restrict bins_width) {
771 bins_center[i] = (bin_edges[i] + bin_edges[i + 1]) / 2;
772 bins_width[i] = bin_edges[i + 1] - bin_edges[i];
773 });
774
775 return {std::move(counts), std::move(bins_center), std::move(bins_width)};
776 }
777
778} // namespace shamalgs::numeric
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
Shamrock assertion utility.
#define SHAM_ASSERT(x)
Shorthand for SHAM_ASSERT_NAMED without a message.
Definition assert.hpp:67
A buffer allocated in USM (Unified Shared Memory).
size_t get_size() const
Gets the number of elements in the buffer.
void kernel_call(sham::DeviceQueue &q, RefIn in, RefOut in_out, u32 n, Functor &&func, SourceLocation &&callsite=SourceLocation{})
Submit a kernel to a SYCL queue.
namespace containing the numeric algorithms of shamalgs
BinnedCompute< T > binned_init_compute(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, const sham::DeviceBuffer< T > &keys, u32 len)
Prepare binned data for per-bin computation.
Definition numeric.cpp:164
sham::DeviceBuffer< u32 > device_histogram_u32_mpi(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, u32 len)
Compute the u32 histogram of values between bin_edges across all MPI ranks.
Definition numeric.hpp:552
sham::DeviceBuffer< Tret > device_histogram(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, u32 len)
Compute the histogram of values between bin_edges.
Definition numeric.cpp:76
sham::DeviceBuffer< Tret > device_histogram_mpi(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, u32 len)
Compute the histogram of values between bin_edges across all MPI ranks.
Definition numeric.hpp:466
sham::DeviceBuffer< T > binned_sum(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, const sham::DeviceBuffer< T > &keys, u32 len)
Compute the sum of values in each bin.
Definition numeric.hpp:357
sham::DeviceBuffer< T > binned_sum_mpi(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, const sham::DeviceBuffer< T > &keys, u32 len)
Compute the sum of values in each bin across all MPI ranks.
Definition numeric.hpp:597
sham::DeviceBuffer< T > binned_average_mpi(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, const sham::DeviceBuffer< T > &keys, u32 len, const sham::DeviceBuffer< u32 > &bin_counts_global)
Compute the average of values in each bin across all MPI ranks (with pre-computed global counts).
Definition numeric.hpp:650
sycl::buffer< T > scan_exclusive(sycl::queue &q, sycl::buffer< T > &buf1, u32 len)
Computes the exclusive sum of elements in a SYCL buffer.
Definition numeric.cpp:35
std::tuple< std::optional< sycl::buffer< u32 > >, u32 > stream_compact(sycl::queue &q, sycl::buffer< u32 > &buf_flags, u32 len)
Stream compaction algorithm.
Definition numeric.cpp:65
sham::DeviceBuffer< T > binned_average(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, const sham::DeviceBuffer< T > &keys, u32 len)
Compute the average of values in each bin.
Definition numeric.hpp:402
histogram_result< T > device_histogram_full_mpi(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, u32 len)
Compute the histogram and bin properties (center, width) for a set of values and bin edges.
Definition numeric.hpp:744
sham::DeviceBuffer< u64 > device_histogram_u64_mpi(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, u32 len)
Compute the u64 histogram of values between bin_edges across all MPI ranks.
Definition numeric.hpp:512
sham::DeviceBuffer< Tret > binned_compute(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, const sham::DeviceBuffer< T > &keys, u32 len, Fct &&fct)
Perform a custom reduction or computation over values in each bin.
Definition numeric.hpp:287
histogram_result< T > device_histogram_full(const sham::DeviceScheduler_ptr &sched, const sham::DeviceBuffer< T > &bin_edges, u64 nbins, const sham::DeviceBuffer< T > &values, u32 len)
Compute the histogram and bin properties (center, width) for a set of values and bin edges.
Definition numeric.hpp:165
T & get_check_ref(const std::unique_ptr< T > &ptr, SourceLocation loc=SourceLocation())
Takes a std::unique_ptr and returns a reference to the object it holds. It throws a std::runtime_erro...
Definition memory.hpp:112
A class that references multiple buffers or similar objects.
Definition MultiRef.hpp:33
Structure holding the result of binning values for further computation.
Definition numeric.hpp:207
sham::DeviceBuffer< u32 > offsets_bins
Offsets for each bin (size nbins+1).
Definition numeric.hpp:210
sham::DeviceBuffer< T > valid_values
Values that are within the bin range, sorted by bin.
Definition numeric.hpp:209