Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
GSPHGhostHandler.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
18
21#include "shambackends/vec.hpp"
34#include <utility>
35
36namespace shammodels::gsph {
37
38 template<class vec>
39 class GSPHGhostHandler {
40
41 PatchScheduler &sched;
42
43 public:
44 using flt = shambase::VecComponent<vec>;
45 static constexpr u32 dim = shambase::VectorProperties<vec>::dimension;
46 using per_index = sycl::vec<i32, dim>;
47
51
53 InterfaceBuildInfos build_infos;
54 sham::DeviceBuffer<u32> ids_interf;
55 f64 part_cnt_ratio;
56 };
57
59
60 std::shared_ptr<shamrock::patch::PatchDataLayerLayout> &xyzh_ghost_layout;
61
62 std::shared_ptr<shamrock::solvergraph::RankGetter> patch_rank_owner;
63
64 GSPHGhostHandler(
65 PatchScheduler &sched,
66 std::shared_ptr<shamrock::solvergraph::RankGetter> patch_rank_owner,
67 std::shared_ptr<shamrock::patch::PatchDataLayerLayout> &xyzh_ghost_layout)
68 : sched(sched), patch_rank_owner(std::move(patch_rank_owner)),
69 xyzh_ghost_layout(xyzh_ghost_layout) {}
70
72 GeneratorMap &&gen);
73
74 void gen_debug_patch_ghost(shambase::DistributedDataShared<InterfaceIdTable> &interf_info);
75
77
78 template<class T>
79 shambase::DistributedDataShared<T> build_interface_native(
81 std::function<T(u64, u64, InterfaceBuildInfos, sham::DeviceBuffer<u32> &, u32)> fct) {
82 StackEntry stack_loc{};
83
84 return builder.template map<T>([&](u64 sender,
85 u64 receiver,
86 InterfaceIdTable &build_table) {
87 if (build_table.ids_interf.get_size() == 0) {
89 "there is an empty id table in the interface, it should have been removed");
90 }
91
92 return fct(
93 sender,
94 receiver,
95 build_table.build_infos,
96 build_table.ids_interf,
97 build_table.ids_interf.get_size());
98 });
99 }
100
101 template<class T>
102 void modify_interface_native(
103 shambase::DistributedDataShared<InterfaceIdTable> &builder,
104 shambase::DistributedDataShared<T> &mod,
105 std::function<void(u64, u64, InterfaceBuildInfos, sham::DeviceBuffer<u32> &, u32, T &)>
106 fct) {
107 StackEntry stack_loc{};
108
109 struct Args {
110 u64 sender;
111 u64 receiver;
112 InterfaceIdTable &build_table;
113 };
114
115 std::vector<Args> vecarg;
116
117 builder.for_each([&](u64 sender, u64 receiver, InterfaceIdTable &build_table) {
118 if (build_table.ids_interf.get_size() == 0) {
120 "there is an empty id table in the interface, it should have been removed");
121 }
122
123 vecarg.push_back({sender, receiver, build_table});
124 });
125
126 u32 i = 0;
127 mod.for_each([&](u64 sender, u64 receiver, T &ref) {
128 InterfaceIdTable &build_table = vecarg[i].build_table;
129
130 fct(sender,
131 receiver,
132 build_table.build_infos,
133 build_table.ids_interf,
134 build_table.ids_interf.get_size(),
135 ref);
136
137 i++;
138 });
139 }
140
142 // interface generation/communication utility //////////////////////////////////////////////
144
145 inline shambase::DistributedDataShared<shamrock::patch::PatchDataLayer>
146 build_position_interf_field(shambase::DistributedDataShared<InterfaceIdTable> &builder) {
147 StackEntry stack_loc{};
148
149 const u32 ixyz = sched.pdl_old().template get_field_idx<vec>("xyz");
150 const u32 ihpart = sched.pdl_old().template get_field_idx<flt>("hpart");
151
152 // Get field indices from xyzh_ghost_layout for accessing ghost data
153 const u32 ixyz_ghost = xyzh_ghost_layout->template get_field_idx<vec>("xyz");
154 const u32 ihpart_ghost = xyzh_ghost_layout->template get_field_idx<flt>("hpart");
155
156 return build_interface_native<shamrock::patch::PatchDataLayer>(
157 builder,
158 [&, ixyz_ghost, ihpart_ghost](
159 u64 sender,
160 u64 /*receiver*/,
162 sham::DeviceBuffer<u32> &buf_idx,
163 u32 cnt) {
164 using namespace shamrock::patch;
165
166 PatchDataLayer &sender_pdat = sched.patch_data.get_pdat(sender);
167
168 shamrock::patch::PatchDataLayer ret(xyzh_ghost_layout);
169
170 sender_pdat.get_field<vec>(ixyz).append_subset_to(
171 buf_idx, cnt, ret.get_field<vec>(ixyz_ghost));
172 sender_pdat.get_field<flt>(ihpart).append_subset_to(
173 buf_idx, cnt, ret.get_field<flt>(ihpart_ghost));
174
175 ret.get_field<vec>(ixyz_ghost).apply_offset(binfo.offset);
176
177 return ret;
178 });
179 }
180
181 inline shambase::DistributedDataShared<shamrock::patch::PatchDataLayer> communicate_pdat(
182 const std::shared_ptr<shamrock::patch::PatchDataLayerLayout> &pdl_ptr,
183 shambase::DistributedDataShared<shamrock::patch::PatchDataLayer> &&interf) {
184 StackEntry stack_loc{};
185
186 std::shared_ptr<shamrock::solvergraph::PatchDataLayerDDShared> exchange_gz_edge
187 = std::make_shared<shamrock::solvergraph::PatchDataLayerDDShared>("", "");
188
189 exchange_gz_edge->patchdatas
190 = std::forward<shambase::DistributedDataShared<shamrock::patch::PatchDataLayer>>(
191 interf);
192
193 std::shared_ptr<shamrock::solvergraph::ExchangeGhostLayer> exchange_gz_node
194 = std::make_shared<shamrock::solvergraph::ExchangeGhostLayer>(pdl_ptr);
195 exchange_gz_node->set_edges(this->patch_rank_owner, exchange_gz_edge);
196
197 exchange_gz_node->evaluate();
198
199 shambase::DistributedDataShared<shamrock::patch::PatchDataLayer> recv_dat;
200 recv_dat = std::move(exchange_gz_edge->patchdatas);
201
202 return recv_dat;
203 }
204
205 template<class T>
206 inline shambase::DistributedDataShared<PatchDataField<T>> communicate_pdatfield(
207 shambase::DistributedDataShared<PatchDataField<T>> &&interf, u32 nvar) {
208 StackEntry stack_loc{};
209
210 std::shared_ptr<shamrock::solvergraph::PatchDataFieldDDShared<T>> exchange_gz_edge
211 = std::make_shared<shamrock::solvergraph::PatchDataFieldDDShared<T>>("", "");
212
213 exchange_gz_edge->patchdata_fields
214 = std::forward<shambase::DistributedDataShared<PatchDataField<T>>>(interf);
215
216 std::shared_ptr<shamrock::solvergraph::ExchangeGhostField<T>> exchange_gz_node
217 = std::make_shared<shamrock::solvergraph::ExchangeGhostField<T>>();
218 exchange_gz_node->set_edges(this->patch_rank_owner, exchange_gz_edge);
219
220 exchange_gz_node->evaluate();
221
222 shambase::DistributedDataShared<PatchDataField<T>> recv_dat;
223 recv_dat = std::move(exchange_gz_edge->patchdata_fields);
224
225 return recv_dat;
226 }
227
228 inline shambase::DistributedDataShared<shamrock::patch::PatchDataLayer>
229 build_communicate_positions(shambase::DistributedDataShared<InterfaceIdTable> &builder) {
230 auto pos_interf = build_position_interf_field(builder);
231 return communicate_pdat(xyzh_ghost_layout, std::move(pos_interf));
232 }
233
234 template<class T, class Tmerged>
235 inline shambase::DistributedData<Tmerged> merge_native(
236 shambase::DistributedDataShared<T> &&interfs,
237 std::function<
238 Tmerged(const shamrock::patch::Patch, shamrock::patch::PatchDataLayer &pdat)> init,
239 std::function<void(Tmerged &, T &)> appender) {
240
241 StackEntry stack_loc{};
242
243 shambase::DistributedData<Tmerged> merge_f;
244
245 sched.for_each_patchdata_nonempty(
246 [&](const shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
247 Tmerged tmp_merge = init(p, pdat);
248
249 interfs.for_each([&](u64 sender, u64 receiver, T &interface) {
250 if (receiver == p.id_patch) {
251 appender(tmp_merge, interface);
252 }
253 });
254
255 merge_f.add_obj(p.id_patch, std::move(tmp_merge));
256 });
257
258 return merge_f;
259 }
260
261 inline shambase::DistributedData<shamrock::patch::PatchDataLayer> merge_position_buf(
262 shambase::DistributedDataShared<shamrock::patch::PatchDataLayer> &&positioninterfs) {
263 StackEntry stack_loc{};
264
265 const u32 ixyz = sched.pdl_old().template get_field_idx<vec>("xyz");
266 const u32 ihpart = sched.pdl_old().template get_field_idx<flt>("hpart");
267
268 // Get field indices from xyzh_ghost_layout for accessing ghost data
269 const u32 ixyz_ghost = xyzh_ghost_layout->template get_field_idx<vec>("xyz");
270 const u32 ihpart_ghost = xyzh_ghost_layout->template get_field_idx<flt>("hpart");
271
272 return merge_native<shamrock::patch::PatchDataLayer, shamrock::patch::PatchDataLayer>(
273 std::forward<shambase::DistributedDataShared<shamrock::patch::PatchDataLayer>>(
274 positioninterfs),
275 [=, this](const shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
276 PatchDataField<vec> &pos = pdat.get_field<vec>(ixyz);
277 PatchDataField<flt> &hpart = pdat.get_field<flt>(ihpart);
278
279 shamrock::patch::PatchDataLayer ret(xyzh_ghost_layout);
280
281 ret.get_field<vec>(ixyz_ghost).insert(pos);
282 ret.get_field<flt>(ihpart_ghost).insert(hpart);
283 ret.check_field_obj_cnt_match();
284
285 return ret;
286 },
287 [](shamrock::patch::PatchDataLayer &merged, shamrock::patch::PatchDataLayer &pint) {
288 merged.insert_elements(pint);
289
291 });
292 }
293
294 inline shambase::DistributedData<shamrock::patch::PatchDataLayer>
295 build_comm_merge_positions(shambase::DistributedDataShared<InterfaceIdTable> &builder) {
296 auto pos_interf = build_position_interf_field(builder);
297 return merge_position_buf(communicate_pdat(xyzh_ghost_layout, std::move(pos_interf)));
298 }
299 };
300
301} // namespace shammodels::gsph
Solver graph node for exchanging ghost field data between distributed processes.
Solver graph node for exchanging ghost layer data between distributed processes.
constexpr const char * hpart
Smoothing length field.
Header file describing a Node Instance.
Shared distributed data layer for patch data management in solver graphs.
MPI scheduler.
double f64
Alias for double.
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
The MPI scheduler.
A buffer allocated in USM (Unified Shared Memory).
Container for objects shared between two distributed data elements.
void for_each(std::function< void(u64, u64, T &)> &&f)
Apply a function to all stored objects.
iterator add_obj(u64 id, T &&obj)
Adds a new object to the collection.
typename sph::BasicSPHGhostHandler< vec >::InterfaceBuildInfos InterfaceBuildInfos
void check_field_obj_cnt_match()
check that all contained field have the same obj cnt
void append_subset_to(const sham::DeviceBuffer< T > &buf, const sham::DeviceBuffer< u32 > &idxs_buf, u32 nvar, sham::DeviceBuffer< T > &buf_other, u32 start_enque)
Appends a subset of elements from one buffer to another.
ExcptTypes make_except_with_loc(std::string message, SourceLocation loc=SourceLocation{})
Create an exception with a message and a location.
This file contains the definition for the stacktrace related functionality.
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
u64 id_patch
unique key that identify the patch
Definition Patch.hpp:86