Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
reduction.cpp
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
17#include "shamalgs/primitives/reduction.hpp"
18#include "shambase/StlContainerConversion.hpp"
19#include "shambase/exception.hpp"
20#include "shambase/logs/loglevels.hpp"
21#include "fmt/std.h"
22#include "shamalgs/details/reduction/fallbackReduction.hpp"
23#include "shamalgs/details/reduction/fallbackReduction_usm.hpp"
24#include "shamalgs/details/reduction/groupReduction.hpp"
25#include "shamalgs/details/reduction/groupReduction_usm.hpp"
26#include "shamalgs/details/reduction/reduction.hpp"
27#include "shamalgs/details/reduction/sycl2020reduction.hpp"
28
29namespace shamalgs::primitives {
30
31 enum class REDUCTION_IMPL : u32 {
32 FALLBACK,
33#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
34 GROUP_REDUCTION16,
35 GROUP_REDUCTION128,
36 GROUP_REDUCTION256,
37#endif
38 };
39
40 REDUCTION_IMPL get_default_reduction_impl() {
41#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
42 return REDUCTION_IMPL::GROUP_REDUCTION128;
43#else
44 return REDUCTION_IMPL::FALLBACK;
45#endif
46 }
47
48 REDUCTION_IMPL reduction_impl = get_default_reduction_impl();
49
50 inline REDUCTION_IMPL reduction_impl_from_params(const std::string &impl) {
51 if (impl == "fallback") {
52 return REDUCTION_IMPL::FALLBACK;
53#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
54 } else if (impl == "group_reduction16") {
55 return REDUCTION_IMPL::GROUP_REDUCTION16;
56 } else if (impl == "group_reduction128") {
57 return REDUCTION_IMPL::GROUP_REDUCTION128;
58 } else if (impl == "group_reduction256") {
59 return REDUCTION_IMPL::GROUP_REDUCTION256;
60#endif
61 }
62 throw shambase::make_except_with_loc<std::invalid_argument>(shambase::format(
63 "invalid implementation : {}, possible implementations : {}",
64 impl,
65 impl::get_default_impl_list_reduction()));
66 }
67
68 inline shamalgs::impl_param reduction_impl_to_params(const REDUCTION_IMPL &impl) {
69 if (impl == REDUCTION_IMPL::FALLBACK) {
70 return {"fallback", ""};
71#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
72 } else if (impl == REDUCTION_IMPL::GROUP_REDUCTION16) {
73 return {"group_reduction16", ""};
74 } else if (impl == REDUCTION_IMPL::GROUP_REDUCTION128) {
75 return {"group_reduction128", ""};
76 } else if (impl == REDUCTION_IMPL::GROUP_REDUCTION256) {
77 return {"group_reduction256", ""};
78#endif
79 }
80 throw shambase::make_except_with_loc<std::invalid_argument>(
81 shambase::format("unknown reduction implementation : {}", u32(impl)));
82 }
83
84 std::vector<shamalgs::impl_param> impl::get_default_impl_list_reduction() {
85 return {
86 {"fallback", ""},
87#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
88 {"group_reduction16", ""},
89 {"group_reduction128", ""},
90 {"group_reduction256", ""}
91#endif
92 };
93 }
94
95 shamalgs::impl_param impl::get_current_impl_reduction() {
96 return reduction_impl_to_params(reduction_impl);
97 }
98
99 void impl::set_impl_reduction(const std::string &impl, const std::string &param) {
100 shamlog_info_ln("tree", "setting reduction implementation to impl :", impl);
101 reduction_impl = reduction_impl_from_params(impl);
102 }
103
104 template<class T>
105 T sum(
106 const sham::DeviceScheduler_ptr &sched,
107 const sham::DeviceBuffer<T> &buf1,
108 u32 start_id,
109 u32 end_id) {
110
111 using namespace shamalgs::reduction::details;
112
113 switch (reduction_impl) {
114 case REDUCTION_IMPL::FALLBACK: return sum_usm_fallback(sched, buf1, start_id, end_id);
115#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
116 case REDUCTION_IMPL::GROUP_REDUCTION16:
117 return sum_usm_group(sched, buf1, start_id, end_id, 16);
118 case REDUCTION_IMPL::GROUP_REDUCTION128:
119 return sum_usm_group(sched, buf1, start_id, end_id, 128);
120 case REDUCTION_IMPL::GROUP_REDUCTION256:
121 return sum_usm_group(sched, buf1, start_id, end_id, 256);
122#endif
123 default:
124 shambase::throw_with_loc<std::invalid_argument>(
125 shambase::format("unimplemented case : {}", u32(reduction_impl)));
126 }
127 }
128
129 template<class T>
130 T min(
131 const sham::DeviceScheduler_ptr &sched,
132 const sham::DeviceBuffer<T> &buf1,
133 u32 start_id,
134 u32 end_id) {
135
136 using namespace shamalgs::reduction::details;
137
138 switch (reduction_impl) {
139 case REDUCTION_IMPL::FALLBACK: return min_usm_fallback(sched, buf1, start_id, end_id);
140#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
141 case REDUCTION_IMPL::GROUP_REDUCTION16:
142 return min_usm_group(sched, buf1, start_id, end_id, 16);
143 case REDUCTION_IMPL::GROUP_REDUCTION128:
144 return min_usm_group(sched, buf1, start_id, end_id, 128);
145 case REDUCTION_IMPL::GROUP_REDUCTION256:
146 return min_usm_group(sched, buf1, start_id, end_id, 256);
147#endif
148 default:
149 shambase::throw_with_loc<std::invalid_argument>(
150 shambase::format("unimplemented case : {}", u32(reduction_impl)));
151 }
152 }
153
154 template<class T>
155 T max(
156 const sham::DeviceScheduler_ptr &sched,
157 const sham::DeviceBuffer<T> &buf1,
158 u32 start_id,
159 u32 end_id) {
160
161 using namespace shamalgs::reduction::details;
162
163 switch (reduction_impl) {
164 case REDUCTION_IMPL::FALLBACK: return max_usm_fallback(sched, buf1, start_id, end_id);
165#ifdef SYCL2020_FEATURE_GROUP_REDUCTION
166 case REDUCTION_IMPL::GROUP_REDUCTION16:
167 return max_usm_group(sched, buf1, start_id, end_id, 16);
168 case REDUCTION_IMPL::GROUP_REDUCTION128:
169 return max_usm_group(sched, buf1, start_id, end_id, 128);
170 case REDUCTION_IMPL::GROUP_REDUCTION256:
171 return max_usm_group(sched, buf1, start_id, end_id, 256);
172#endif
173 default:
174 shambase::throw_with_loc<std::invalid_argument>(
175 shambase::format("unimplemented case : {}", u32(reduction_impl)));
176 }
177 }
178
179#ifndef DOXYGEN
180 #define XMAC_TYPES \
181 X(f32) \
182 X(f32_2) \
183 X(f32_3) \
184 X(f32_4) \
185 X(f32_8) \
186 X(f32_16) \
187 X(f64) \
188 X(f64_2) \
189 X(f64_3) \
190 X(f64_4) \
191 X(f64_8) \
192 X(f64_16) \
193 X(u32) \
194 X(u64) \
195 X(i32) \
196 X(i64) \
197 X(u32_3) \
198 X(u64_3) \
199 X(i64_3) \
200 X(i32_3)
201
202 #define X(_arg_) \
203 template _arg_ sum<_arg_>( \
204 const sham::DeviceScheduler_ptr &sched, \
205 const sham::DeviceBuffer<_arg_> &buf1, \
206 u32 start_id, \
207 u32 end_id); \
208 template _arg_ min<_arg_>( \
209 const sham::DeviceScheduler_ptr &sched, \
210 const sham::DeviceBuffer<_arg_> &buf1, \
211 u32 start_id, \
212 u32 end_id); \
213 template _arg_ max<_arg_>( \
214 const sham::DeviceScheduler_ptr &sched, \
215 const sham::DeviceBuffer<_arg_> &buf1, \
216 u32 start_id, \
217 u32 end_id);
218
219 XMAC_TYPES
220 #undef X
221#endif
222
223} // namespace shamalgs::primitives
u32
std::uint32_t u32
32 bit unsigned integer
Definition aliases_int.hpp:27
sham::DeviceBuffer
A buffer allocated in USM (Unified Shared Memory)
Definition DeviceBuffer.hpp:106
exception.hpp
This header file contains utility functions related to exception handling in the code.
fallbackReduction_usm.hpp
groupReduction_usm.hpp
shamalgs::primitives::impl::set_impl_reduction
void set_impl_reduction(const std::string &impl, const std::string &param="")
Set the implementation for reduction.
Definition reduction.cpp:99
shamalgs::primitives::impl::get_default_impl_list_reduction
std::vector< shamalgs::impl_param > get_default_impl_list_reduction()
Get list of available reduction implementations.
Definition reduction.cpp:84
shamalgs::primitives::impl::get_current_impl_reduction
shamalgs::impl_param get_current_impl_reduction()
Get the current implementation for reduction.
Definition reduction.cpp:95
shamalgs::primitives
namespace for primitive algorithm (e.g. sort, scan, reductions, ...)
Definition ImplControl.hpp:23
shambase::throw_with_loc
void throw_with_loc(std::string message, SourceLocation loc=SourceLocation{})
Throw an exception and append the source location to it.
Definition exception.hpp:132
shamalgs::impl_param
Definition impl_utils.hpp:27
Generated on Wed May 13 2026 13:21:48 for Shamrock by doxygen 1.9.8