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(
66 u32 field_idx,
67 u32 derfield_idx,
68 ComputeField<T> &derfield_old,
69 ComputeField<flt> &field_epsilon,
70 flt hdt) {
71 StackEntry stack_loc{};
72 using namespace shamrock::patch;
73 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
74 integrators::leapfrog_corrector(
75 shamsys::instance::get_compute_scheduler().get_queue(),
76 pdat.get_field<T>(field_idx).get_buf(),
77 pdat.get_field<T>(derfield_idx).get_buf(),
78 derfield_old.get_field(cur_p.id_patch).get_buf(),
79 field_epsilon.get_field(cur_p.id_patch).get_buf(),
80 pdat.get_obj_cnt() * derfield_old.get_nvar(),
81 hdt);
82 });
83 }
84
85 template<class T>
86 inline void fields_apply_periodicity(u32 field_idx, std::pair<T, T> box) {
87 StackEntry stack_loc{};
88 using namespace shamrock::patch;
89 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
90 utilities::sycl_position_modulo(
91 shamsys::instance::get_compute_scheduler().get_queue(),
92 pdat.get_field<T>(field_idx).get_buf(),
93 pdat.get_obj_cnt(),
94 box);
95 });
96 }
97
98 template<class T>
99 inline void fields_apply_shearing_periodicity(
100 u32 field_idx,
101 u32 field_velocity,
102 std::pair<T, T> box,
103 i32_3 shear_base,
104 i32_3 shear_dir,
105 shambase::VecComponent<T> shear_value,
106 shambase::VecComponent<T> shear_speed) {
107
108 StackEntry stack_loc{};
109 using namespace shamrock::patch;
110 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
111 utilities::sycl_position_sheared_modulo(
112 shamsys::instance::get_compute_scheduler().get_queue(),
113 pdat.get_field<T>(field_idx).get_buf(),
114 pdat.get_field<T>(field_velocity).get_buf(),
115 pdat.get_obj_cnt(),
116 box,
117 shear_base,
118 shear_dir,
119 shear_value,
120 shear_speed);
121 });
122 }
123
124 template<class T>
125 inline void fields_swap(u32 field_idx1, u32 field_idx2) {
126 StackEntry stack_loc{};
127 using namespace shamrock::patch;
128 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
129 utilities::swap_fields(
130 shamsys::instance::get_compute_scheduler().get_queue(),
131 pdat.get_field<T>(field_idx1).get_buf(),
132 pdat.get_field<T>(field_idx2).get_buf(),
133 pdat.get_obj_cnt());
134 });
135 }
136
137 template<class T>
138 inline T compute_rank_max(u32 field_idx) {
139 StackEntry stack_loc{};
140 using namespace shamrock::patch;
141 T ret = shambase::VectorProperties<T>::get_min();
142 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
143 ret = sham::max(ret, pdat.get_field<T>(field_idx).compute_max());
144 });
145
146 return ret;
147 }
148
149 template<class T>
150 inline T compute_rank_min(u32 field_idx) {
151 StackEntry stack_loc{};
152 using namespace shamrock::patch;
153 T ret = shambase::VectorProperties<T>::get_max();
154 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
155 ret = sham::min(ret, pdat.get_field<T>(field_idx).compute_min());
156 });
157
158 return ret;
159 }
160
161 template<class T>
162 inline T compute_rank_sum(u32 field_idx) {
163 StackEntry stack_loc{};
164 using namespace shamrock::patch;
165 T ret = shambase::VectorProperties<T>::get_zero();
166 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
167 ret += pdat.get_field<T>(field_idx).compute_sum();
168 });
169
170 return ret;
171 }
172
173 template<class T>
174 inline shambase::VecComponent<T> compute_rank_dot_sum(u32 field_idx) {
175 StackEntry stack_loc{};
176 using namespace shamrock::patch;
177 shambase::VecComponent<T> ret = 0;
178 sched.for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
179 ret += pdat.get_field<T>(field_idx).compute_dot_sum();
180 });
181
182 return ret;
183 }
184
193 template<class T>
194 inline ComputeField<T> save_field(u32 field_idx, std::string new_name) {
195 StackEntry stack_loc{};
196 ComputeField<T> cfield;
197 using namespace shamrock::patch;
198 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
199 PatchDataField<T> &pdat_field = pdat.get_field<T>(field_idx);
200 cfield.field_data.add_obj(id_patch, pdat_field.duplicate(new_name));
201 });
202 return cfield;
203 }
204
205 template<class T>
206 inline ComputeField<T> save_field_custom(
207 std::string new_name, std::function<PatchDataField<T> &(u64)> field_getter) {
208 StackEntry stack_loc{};
209 ComputeField<T> cfield;
210 using namespace shamrock::patch;
211 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
212 PatchDataField<T> &pdat_field = field_getter(id_patch);
213 cfield.field_data.add_obj(id_patch, pdat_field.duplicate(new_name));
214 });
215 return cfield;
216 }
217
226 template<class T>
227 inline ComputeField<T> make_compute_field(std::string new_name, u32 nvar) {
228 StackEntry stack_loc{};
229 ComputeField<T> cfield;
230 using namespace shamrock::patch;
231 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
232 if (pdat.get_obj_cnt() == 0) {
233 return;
234 }
235 auto it = cfield.field_data.add_obj(
236 id_patch, PatchDataField<T>(new_name, nvar, pdat.get_obj_cnt()));
237
238 PatchDataField<T> &ins = it->second;
239 ins.field_raz();
240 });
241 return cfield;
242 }
243
252 template<class T>
253 inline ComputeField<T> make_compute_field(
254 std::string new_name, u32 nvar, std::function<u32(u64)> size_getter) {
255 StackEntry stack_loc{};
256 ComputeField<T> cfield;
257 using namespace shamrock::patch;
258 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
259 if (pdat.get_obj_cnt() == 0) {
260 return;
261 }
262 auto it = cfield.field_data.add_obj(
263 id_patch, PatchDataField<T>(new_name, nvar, size_getter(id_patch)));
264
265 PatchDataField<T> &ins = it->second;
266 ins.field_raz();
267 });
268 return cfield;
269 }
270
280 template<class T>
281 inline ComputeField<T> make_compute_field(std::string new_name, u32 nvar, T value_init) {
282 StackEntry stack_loc{};
283 ComputeField<T> cfield;
284 using namespace shamrock::patch;
285 sched.for_each_patch_data([&](u64 id_patch, Patch cur_p, PatchDataLayer &pdat) {
286 auto it = cfield.field_data.add_obj(
287 id_patch, PatchDataField<T>(new_name, nvar, pdat.get_obj_cnt()));
288
289 PatchDataField<T> &ins = it->second;
290 ins.override(value_init);
291 });
292 return cfield;
293 }
294 };
295
296} // 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:85
PatchScheduler::for_each_patch_data
void for_each_patch_data(Function &&fct)
for each macro for patchadata example usage
Definition PatchScheduler.hpp:258
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:281
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:227
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:194
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:253
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:30
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:211
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:162
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:87
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:313
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