Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
SchedulerUtility.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
17
18#include "shambase/DistributedData.hpp"
19#include "shambase/memory.hpp"
20#include "ComputeField.hpp"
21#include "shambackends/sycl.hpp"
22#include "shambackends/vec.hpp"
23#include "shamrock/math/integrators.hpp"
24#include "shamrock/scheduler/PatchScheduler.hpp"
25#include "shamsys/NodeInstance.hpp"
26namespace shamrock {
27
28 class SchedulerUtility {
29 PatchScheduler &sched;
30
31 public:
32 SchedulerUtility(PatchScheduler &sched) : sched(sched) {}
33
34 template<class T, class flt>
35 inline void fields_forward_euler(u32 field_idx, u32 derfield_idx, flt dt) {
36 StackEntry stack_loc{};
37 using namespace shamrock::patch;
38 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
39 integrators::forward_euler(
40 shamsys::instance::get_compute_scheduler().get_queue(),
41 pdat.get_field<T>(field_idx).get_buf(),
42 pdat.get_field<T>(derfield_idx).get_buf(),
43 pdat.get_obj_cnt(),
44 dt);
45 });
46 }
47
48 template<class T, class flt>
49 inline void fields_leapfrog_corrector(
50 u32 field_idx, u32 derfield_idx, u32 derfield_old_idx, flt hdt) {
51 StackEntry stack_loc{};
52 using namespace shamrock::patch;
53 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
54 integrators::leapfrog_corrector(
55 shamsys::instance::get_compute_scheduler().get_queue(),
56 pdat.get_field<T>(field_idx).get_buf(),
57 pdat.get_field<T>(derfield_idx).get_buf(),
58 pdat.get_field<T>(derfield_old_idx).get_buf(),
59 pdat.get_obj_cnt(),
60 hdt);
61 });
62 }
63
64 template<class T, class flt>
65 inline void fields_leapfrog_corrector_positive_only(
66 u32 field_idx, u32 derfield_idx, u32 derfield_old_idx, flt hdt) {
67 StackEntry stack_loc{};
68 using namespace shamrock::patch;
69 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
70 integrators::leapfrog_corrector_positive_only(
71 shamsys::instance::get_compute_scheduler().get_queue(),
72 pdat.get_field<T>(field_idx).get_buf(),
73 pdat.get_field<T>(derfield_idx).get_buf(),
74 pdat.get_field<T>(derfield_old_idx).get_buf(),
75 pdat.get_obj_cnt(),
76 hdt);
77 });
78 }
79
80 template<class T, class flt>
81 inline void fields_leapfrog_corrector(
82 u32 field_idx,
83 u32 derfield_idx,
84 ComputeField<T> &derfield_old,
85 ComputeField<flt> &field_epsilon,
86 flt hdt) {
87 StackEntry stack_loc{};
88 using namespace shamrock::patch;
89 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
90 integrators::leapfrog_corrector(
91 shamsys::instance::get_compute_scheduler().get_queue(),
92 pdat.get_field<T>(field_idx).get_buf(),
93 pdat.get_field<T>(derfield_idx).get_buf(),
94 derfield_old.get_field(cur_p.id_patch).get_buf(),
95 field_epsilon.get_field(cur_p.id_patch).get_buf(),
96 pdat.get_obj_cnt() * derfield_old.get_nvar(),
97 hdt);
98 });
99 }
100
101 template<class T, class flt>
102 inline void fields_leapfrog_corrector_positive_only(
103 u32 field_idx,
104 u32 derfield_idx,
105 ComputeField<T> &derfield_old,
106 ComputeField<flt> &field_epsilon,
107 flt hdt) {
108 StackEntry stack_loc{};
109 using namespace shamrock::patch;
110 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
111 integrators::leapfrog_corrector_positive_only(
112 shamsys::instance::get_compute_scheduler().get_queue(),
113 pdat.get_field<T>(field_idx).get_buf(),
114 pdat.get_field<T>(derfield_idx).get_buf(),
115 derfield_old.get_field(cur_p.id_patch).get_buf(),
116 field_epsilon.get_field(cur_p.id_patch).get_buf(),
117 pdat.get_obj_cnt() * derfield_old.get_nvar(),
118 hdt);
119 });
120 }
121
122 template<class T>
123 inline void fields_apply_periodicity(u32 field_idx, std::pair<T, T> box) {
124 StackEntry stack_loc{};
125 using namespace shamrock::patch;
126 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
127 utilities::sycl_position_modulo(
128 shamsys::instance::get_compute_scheduler().get_queue(),
129 pdat.get_field<T>(field_idx).get_buf(),
130 pdat.get_obj_cnt(),
131 box);
132 });
133 }
134
135 template<class T>
136 inline void fields_apply_shearing_periodicity(
137 u32 field_idx,
138 u32 field_velocity,
139 std::pair<T, T> box,
140 i32_3 shear_base,
141 i32_3 shear_dir,
142 shambase::VecComponent<T> shear_value,
143 shambase::VecComponent<T> shear_speed) {
144
145 StackEntry stack_loc{};
146 using namespace shamrock::patch;
147 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
148 utilities::sycl_position_sheared_modulo(
149 shamsys::instance::get_compute_scheduler().get_queue(),
150 pdat.get_field<T>(field_idx).get_buf(),
151 pdat.get_field<T>(field_velocity).get_buf(),
152 pdat.get_obj_cnt(),
153 box,
154 shear_base,
155 shear_dir,
156 shear_value,
157 shear_speed);
158 });
159 }
160
161 template<class T>
162 inline void fields_swap(u32 field_idx1, u32 field_idx2) {
163 StackEntry stack_loc{};
164 using namespace shamrock::patch;
165 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
166 utilities::swap_fields(
167 shamsys::instance::get_compute_scheduler().get_queue(),
168 pdat.get_field<T>(field_idx1).get_buf(),
169 pdat.get_field<T>(field_idx2).get_buf(),
170 pdat.get_obj_cnt());
171 });
172 }
173
174 template<class T>
175 inline T compute_rank_max(u32 field_idx) {
176 StackEntry stack_loc{};
177 using namespace shamrock::patch;
178 T ret = shambase::VectorProperties<T>::get_min();
179 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
180 ret = sham::max(ret, pdat.get_field<T>(field_idx).compute_max());
181 });
182
183 return ret;
184 }
185
186 template<class T>
187 inline T compute_rank_min(u32 field_idx) {
188 StackEntry stack_loc{};
189 using namespace shamrock::patch;
190 T ret = shambase::VectorProperties<T>::get_max();
191 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
192 ret = sham::min(ret, pdat.get_field<T>(field_idx).compute_min());
193 });
194
195 return ret;
196 }
197
198 template<class T>
199 inline T compute_rank_sum(u32 field_idx) {
200 StackEntry stack_loc{};
201 using namespace shamrock::patch;
202 T ret = shambase::VectorProperties<T>::get_zero();
203 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
204 ret += pdat.get_field<T>(field_idx).compute_sum();
205 });
206
207 return ret;
208 }
209
210 template<class T>
211 inline shambase::VecComponent<T> compute_rank_dot_sum(u32 field_idx) {
212 StackEntry stack_loc{};
213 using namespace shamrock::patch;
214 shambase::VecComponent<T> ret = 0;
215 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
216 ret += pdat.get_field<T>(field_idx).compute_dot_sum();
217 });
218
219 return ret;
220 }
221
230 template<class T>
231 inline ComputeField<T> save_field(u32 field_idx, std::string new_name) {
232 StackEntry stack_loc{};
233 ComputeField<T> cfield;
234 using namespace shamrock::patch;
235 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
236 PatchDataField<T> &pdat_field = pdat.get_field<T>(field_idx);
237 cfield.field_data.add_obj(id_patch, pdat_field.duplicate(new_name));
238 });
239 return cfield;
240 }
241
242 template<class T>
243 inline ComputeField<T> save_field_custom(
244 std::string new_name, std::function<PatchDataField<T> &(u64)> field_getter) {
245 StackEntry stack_loc{};
246 ComputeField<T> cfield;
247 using namespace shamrock::patch;
248 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
249 PatchDataField<T> &pdat_field = field_getter(id_patch);
250 cfield.field_data.add_obj(id_patch, pdat_field.duplicate(new_name));
251 });
252 return cfield;
253 }
254
263 template<class T>
264 inline ComputeField<T> make_compute_field(std::string new_name, u32 nvar) {
265 StackEntry stack_loc{};
266 ComputeField<T> cfield;
267 using namespace shamrock::patch;
268 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
269 if (pdat.get_obj_cnt() == 0) {
270 return;
271 }
272 auto it = cfield.field_data.add_obj(
273 id_patch, PatchDataField<T>(new_name, nvar, pdat.get_obj_cnt()));
274
275 PatchDataField<T> &ins = it->second;
276 ins.field_raz();
277 });
278 return cfield;
279 }
280
289 template<class T>
290 inline ComputeField<T> make_compute_field(
291 std::string new_name, u32 nvar, std::function<u32(u64)> size_getter) {
292 StackEntry stack_loc{};
293 ComputeField<T> cfield;
294 using namespace shamrock::patch;
295 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
296 if (pdat.get_obj_cnt() == 0) {
297 return;
298 }
299 auto it = cfield.field_data.add_obj(
300 id_patch, PatchDataField<T>(new_name, nvar, size_getter(id_patch)));
301
302 PatchDataField<T> &ins = it->second;
303 ins.field_raz();
304 });
305 return cfield;
306 }
307
317 template<class T>
318 inline ComputeField<T> make_compute_field(std::string new_name, u32 nvar, T value_init) {
319 StackEntry stack_loc{};
320 ComputeField<T> cfield;
321 using namespace shamrock::patch;
322 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
323 auto it = cfield.field_data.add_obj(
324 id_patch, PatchDataField<T>(new_name, nvar, pdat.get_obj_cnt()));
325
326 PatchDataField<T> &ins = it->second;
327 ins.override(value_init);
328 });
329 return cfield;
330 }
331 };
332
333} // namespace shamrock
NodeInstance.hpp
Header file describing a Node Instance.
PatchScheduler.hpp
MPI scheduler.
u32
std::uint32_t u32
32 bit unsigned integer
Definition aliases_int.hpp:27
u64
std::uint64_t u64
64 bit unsigned integer
Definition aliases_int.hpp:26
PatchScheduler
The MPI scheduler.
Definition PatchScheduler.hpp:86
PatchScheduler::for_each_patch_data
void for_each_patch_data(Function &&fct)
for each macro for patchadata example usage
Definition PatchScheduler.hpp:261
shamrock::SchedulerUtility::make_compute_field
ComputeField< T > make_compute_field(std::string new_name, u32 nvar, T value_init)
create a compute field and init it to the set value
Definition SchedulerUtility.hpp:318
shamrock::SchedulerUtility::make_compute_field
ComputeField< T > make_compute_field(std::string new_name, u32 nvar)
create a compute field and init it to zeros
Definition SchedulerUtility.hpp:264
shamrock::SchedulerUtility::save_field
ComputeField< T > save_field(u32 field_idx, std::string new_name)
save a field in patchdata to a compute field
Definition SchedulerUtility.hpp:231
shamrock::SchedulerUtility::make_compute_field
ComputeField< T > make_compute_field(std::string new_name, u32 nvar, std::function< u32(u64)> size_getter)
create a compute field and init it to zeros, and specify size for each cases
Definition SchedulerUtility.hpp:290
shamrock::patch::PatchDataLayer
PatchDataLayer container class, the layout is described in patchdata_layout.
Definition PatchDataLayer.hpp:35
shamrock::integrators::forward_euler
void forward_euler(sham::DeviceQueue &queue, sham::DeviceBuffer< T > &buf_val, sham::DeviceBuffer< T > &buf_der, sycl::range< 1 > elem_range, flt dt)
Perform forward Euler integration step.
Definition integrators.cpp:31
shamrock::utilities::sycl_position_sheared_modulo
void sycl_position_sheared_modulo(sham::DeviceQueue &queue, sham::DeviceBuffer< T > &buf_xyz, sham::DeviceBuffer< T > &buf_vxyz, sycl::range< 1 > elem_range, std::pair< T, T > box, i32_3 shear_base, i32_3 shear_dir, shambase::VecComponent< T > shear_value, shambase::VecComponent< T > shear_speed)
Apply periodic boundary conditions with shearing.
Definition integrators.cpp:256
shamrock::utilities::sycl_position_modulo
void sycl_position_modulo(sham::DeviceQueue &queue, sham::DeviceBuffer< T > &buf_xyz, sycl::range< 1 > elem_range, std::pair< T, T > box)
Apply periodic boundary conditions to positions.
Definition integrators.cpp:207
shamrock::integrators::leapfrog_corrector
void leapfrog_corrector(sham::DeviceQueue &queue, sham::DeviceBuffer< T > &buf_val, sham::DeviceBuffer< T > &buf_der, sham::DeviceBuffer< T > &buf_der_old, sham::DeviceBuffer< flt > &buf_eps_sq, sycl::range< 1 > elem_range, flt hdt)
Perform leapfrog corrector step with adaptive softening.
Definition integrators.cpp:88
shamrock::utilities::swap_fields
void swap_fields(sham::DeviceQueue &queue, sham::DeviceBuffer< T > &b1, sham::DeviceBuffer< T > &b2, u32 cnt)
Swap contents of two buffers.
Definition integrators.cpp:358
shamrock
namespace for the main framework
Definition __init__.py:1
StackEntry
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
Definition stacktrace.hpp:242
shamrock::patch::Patch
Patch object that contain generic patch information.
Definition Patch.hpp:33
shamrock::patch::Patch::id_patch
u64 id_patch
unique key that identify the patch
Definition Patch.hpp:86
Generated on for Shamrock by doxygen 1.15.0