31template <
class Allocator = std::allocator<std::
int32_t>>
52 : _bs(
bs), _remote_inds(0, alloc), _local_inds(0, alloc),
53 _src(map.src().begin(), map.src().end()),
54 _dest(map.dest().begin(), map.dest().end())
60 assert(std::ranges::is_sorted(_src));
61 assert(std::ranges::is_sorted(_dest));
67 MPI_Dist_graph_create_adjacent(
68 map.
comm(), _src.size(), _src.data(), MPI_UNWEIGHTED, _dest.size(),
69 _dest.data(), MPI_UNWEIGHTED, MPI_INFO_NULL,
false, &comm0);
73 MPI_Dist_graph_create_adjacent(
74 map.
comm(), _dest.size(), _dest.data(), MPI_UNWEIGHTED, _src.size(),
75 _src.data(), MPI_UNWEIGHTED, MPI_INFO_NULL,
false, &comm1);
79 std::span owners = map.
owners();
80 std::vector<std::int32_t> perm(owners.size());
81 std::iota(perm.begin(), perm.end(), 0);
86 std::span ghosts = map.
ghosts();
87 std::vector<int> owners_sorted(owners.size());
88 std::vector<std::int64_t> ghosts_sorted(owners.size());
89 std::ranges::transform(perm, owners_sorted.begin(),
90 [&owners](
auto idx) { return owners[idx]; });
91 std::ranges::transform(perm, ghosts_sorted.begin(),
92 [&ghosts](
auto idx) { return ghosts[idx]; });
100 _sizes_remote.resize(_src.size(), 0);
101 _displs_remote.resize(_src.size() + 1, 0);
102 std::vector<std::int32_t>::iterator begin = owners_sorted.begin();
103 for (std::size_t i = 0; i < _src.size(); i++)
105 auto upper = std::upper_bound(begin, owners_sorted.end(), _src[i]);
106 int num_ind = std::distance(begin, upper);
107 _displs_remote[i + 1] = _displs_remote[i] + num_ind;
108 _sizes_remote[i] = num_ind;
119 _sizes_local.resize(_dest.size());
120 _displs_local.resize(_sizes_local.size() + 1);
121 _sizes_remote.reserve(1);
122 _sizes_local.reserve(1);
123 MPI_Neighbor_alltoall(_sizes_remote.data(), 1, MPI_INT32_T,
124 _sizes_local.data(), 1, MPI_INT32_T, _comm1.comm());
125 std::partial_sum(_sizes_local.begin(), _sizes_local.end(),
126 std::next(_displs_local.begin()));
128 assert((std::int32_t)ghosts_sorted.size() == _displs_remote.back());
129 assert((std::int32_t)ghosts_sorted.size() == _displs_remote.back());
133 std::vector<std::int64_t> recv_buffer(_displs_local.back(), 0);
134 MPI_Neighbor_alltoallv(ghosts_sorted.data(), _sizes_remote.data(),
135 _displs_remote.data(), MPI_INT64_T,
136 recv_buffer.data(), _sizes_local.data(),
137 _displs_local.data(), MPI_INT64_T, _comm1.comm());
139 const std::array<std::int64_t, 2> range = map.
local_range();
142 std::ranges::for_each(recv_buffer, [range](
auto idx)
143 { assert(idx >= range[0] and idx < range[1]); });
148 auto rescale = [](
auto& x,
int bs) {
149 std::ranges::transform(x, x.begin(), [
bs](
auto e) { return e *= bs; });
151 rescale(_sizes_local,
bs);
152 rescale(_displs_local,
bs);
153 rescale(_sizes_remote,
bs);
154 rescale(_displs_remote,
bs);
159 _local_inds = std::vector<std::int32_t, allocator_type>(
160 recv_buffer.size() * _bs, alloc);
161 std::int64_t offset = range[0] * _bs;
162 for (std::size_t i = 0; i < recv_buffer.size(); i++)
163 for (
int j = 0; j < _bs; j++)
164 _local_inds[i * _bs + j] = (recv_buffer[i] * _bs + j) - offset;
168 = std::vector<std::int32_t, allocator_type>(perm.size() * _bs, alloc);
169 for (std::size_t i = 0; i < perm.size(); i++)
170 for (
int j = 0; j < _bs; j++)
171 _remote_inds[i * _bs + j] = perm[i] * _bs + j;
194 template <
typename T>
196 std::span<T> recv_buffer,
197 std::span<MPI_Request> requests,
201 if (_sizes_local.empty() and _sizes_remote.empty())
208 assert(requests.size() == std::size_t(1));
209 MPI_Ineighbor_alltoallv(
210 send_buffer.data(), _sizes_local.data(), _displs_local.data(),
211 dolfinx::MPI::mpi_type<T>(), recv_buffer.data(), _sizes_remote.data(),
212 _displs_remote.data(), dolfinx::MPI::mpi_type<T>(), _comm0.comm(),
218 assert(requests.size() == _dest.size() + _src.size());
219 for (std::size_t i = 0; i < _src.size(); i++)
221 MPI_Irecv(recv_buffer.data() + _displs_remote[i], _sizes_remote[i],
222 dolfinx::MPI::mpi_type<T>(), _src[i], MPI_ANY_TAG,
223 _comm0.comm(), &requests[i]);
226 for (std::size_t i = 0; i < _dest.size(); i++)
228 MPI_Isend(send_buffer.data() + _displs_local[i], _sizes_local[i],
229 dolfinx::MPI::mpi_type<T>(), _dest[i], 0, _comm0.comm(),
230 &requests[i + _src.size()]);
235 throw std::runtime_error(
"Scatter::type not recognized");
250 if (_sizes_local.empty() and _sizes_remote.empty())
254 MPI_Waitall(requests.size(), requests.data(), MPI_STATUS_IGNORE);
277 template <
typename T,
typename F>
278 requires std::is_invocable_v<F, std::span<const T>,
279 std::span<const std::int32_t>, std::span<T>>
281 std::span<T> local_buffer, std::span<T> remote_buffer,
282 F pack_fn, std::span<MPI_Request> requests,
285 assert(local_buffer.size() == _local_inds.size());
286 assert(remote_buffer.size() == _remote_inds.size());
287 pack_fn(local_data, _local_inds, local_buffer);
311 template <
typename T,
typename F>
312 requires std::is_invocable_v<F, std::span<const T>,
313 std::span<const std::int32_t>, std::span<T>,
314 std::function<T(T, T)>>
316 std::span<T> remote_data, F unpack_fn,
317 std::span<MPI_Request> requests)
const
319 assert(remote_buffer.size() == _remote_inds.size());
320 assert(remote_data.size() == _remote_inds.size());
322 unpack_fn(remote_buffer, _remote_inds, remote_data,
323 [](T , T b) {
return b; });
337 template <
typename T>
339 std::span<T> remote_data)
const
341 std::vector<MPI_Request> requests(1, MPI_REQUEST_NULL);
344 auto pack_fn = [](
auto&& in,
auto&& idx,
auto&& out)
346 for (std::size_t i = 0; i < idx.size(); ++i)
350 std::span<T>(remote_buffer), pack_fn,
351 std::span<MPI_Request>(requests));
353 auto unpack_fn = [](
auto&& in,
auto&& idx,
auto&& out,
auto op)
355 for (std::size_t i = 0; i < idx.size(); ++i)
356 out[idx[i]] = op(out[idx[i]], in[i]);
359 scatter_fwd_end(std::span<const T>(remote_buffer), remote_data, unpack_fn,
360 std::span<MPI_Request>(requests));
389 template <
typename T>
391 std::span<T> recv_buffer,
392 std::span<MPI_Request> requests,
396 if (_sizes_local.empty() and _sizes_remote.empty())
405 assert(requests.size() == 1);
406 MPI_Ineighbor_alltoallv(send_buffer.data(), _sizes_remote.data(),
407 _displs_remote.data(), MPI::mpi_type<T>(),
408 recv_buffer.data(), _sizes_local.data(),
409 _displs_local.data(), MPI::mpi_type<T>(),
410 _comm1.comm(), &requests[0]);
415 assert(requests.size() == _dest.size() + _src.size());
417 for (std::size_t i = 0; i < _dest.size(); i++)
419 MPI_Irecv(recv_buffer.data() + _displs_local[i], _sizes_local[i],
420 dolfinx::MPI::mpi_type<T>(), _dest[i], MPI_ANY_TAG,
421 _comm0.comm(), &requests[i]);
426 for (std::size_t i = 0; i < _src.size(); i++)
428 MPI_Isend(send_buffer.data() + _displs_remote[i], _sizes_remote[i],
429 dolfinx::MPI::mpi_type<T>(), _src[i], 0, _comm0.comm(),
430 &requests[i + _dest.size()]);
435 throw std::runtime_error(
"Scatter::type not recognized");
450 if (_sizes_local.empty() and _sizes_remote.empty())
454 MPI_Waitall(request.size(), request.data(), MPI_STATUS_IGNORE);
481 template <
typename T,
typename F>
482 requires std::is_invocable_v<F, std::span<const T>,
483 std::span<const std::int32_t>, std::span<T>>
485 std::span<T> remote_buffer, std::span<T> local_buffer,
486 F pack_fn, std::span<MPI_Request> request,
489 assert(local_buffer.size() == _local_inds.size());
490 assert(remote_buffer.size() == _remote_inds.size());
491 pack_fn(remote_data, _remote_inds, remote_buffer);
515 template <
typename T,
typename F,
typename BinaryOp>
516 requires std::is_invocable_v<F, std::span<const T>,
517 std::span<const std::int32_t>, std::span<T>,
519 and std::is_invocable_r_v<T, BinaryOp, T, T>
521 F unpack_fn, BinaryOp op, std::span<MPI_Request> request)
523 assert(local_buffer.size() == _local_inds.size());
524 if (!_local_inds.empty())
526 assert(*std::ranges::max_element(_local_inds)
527 < std::int32_t(local_data.size()));
530 unpack_fn(local_buffer, _local_inds, local_data, op);
535 template <
typename T,
typename BinaryOp>
536 void scatter_rev(std::span<T> local_data, std::span<const T> remote_data,
541 auto pack_fn = [](
auto&& in,
auto&& idx,
auto&& out)
543 for (std::size_t i = 0; i < idx.size(); ++i)
546 auto unpack_fn = [](
auto&& in,
auto&& idx,
auto&& out,
auto op)
548 for (std::size_t i = 0; i < idx.size(); ++i)
549 out[idx[i]] = op(out[idx[i]], in[i]);
551 std::vector<MPI_Request> request(1, MPI_REQUEST_NULL);
553 std::span<T>(local_buffer), pack_fn,
554 std::span<MPI_Request>(request));
555 scatter_rev_end(std::span<const T>(local_buffer), local_data, unpack_fn, op,
556 std::span<MPI_Request>(request));
569 return _remote_inds.size();
590 int bs() const noexcept {
return _bs; }
597 std::vector<MPI_Request> requests;
601 requests = {MPI_REQUEST_NULL};
604 requests.resize(_dest.size() + _src.size(), MPI_REQUEST_NULL);
607 throw std::runtime_error(
"Scatter::type not recognized");
631 std::vector<std::int32_t, allocator_type> _remote_inds;
634 std::vector<int> _sizes_remote;
637 std::vector<int> _displs_remote;
642 std::vector<std::int32_t, allocator_type> _local_inds;
645 std::vector<int> _sizes_local;
648 std::vector<int> _displs_local;
652 std::vector<int> _src;
656 std::vector<int> _dest;
A duplicate MPI communicator and manage lifetime of the communicator.
Definition MPI.h:43
std::span< const int > owners() const
The ranks that own each ghost index.
Definition IndexMap.h:205
std::array< std::int64_t, 2 > local_range() const noexcept
Range of indices (global) owned by this process.
Definition IndexMap.cpp:924
std::span< const std::int64_t > ghosts() const noexcept
Definition IndexMap.cpp:938
MPI_Comm comm() const
Return the MPI communicator that the map is defined on.
Definition IndexMap.cpp:1003
A Scatterer supports the MPI scattering and gathering of data that is associated with a common::Index...
Definition Scatterer.h:33
std::vector< MPI_Request > create_request_vector(Scatterer::type type=type::neighbor)
Create a vector of MPI_Requests for a given Scatterer::type.
Definition Scatterer.h:594
Allocator allocator_type
The allocator type.
Definition Scatterer.h:36
void scatter_fwd_end(std::span< MPI_Request > requests) const
Complete a non-blocking send from the local owner to process ranks that have the index as a ghost.
Definition Scatterer.h:247
void scatter_fwd(std::span< const T > local_data, std::span< T > remote_data) const
Scatter data associated with owned indices to ghosting ranks.
Definition Scatterer.h:338
Scatterer(const IndexMap &map, int bs, const Allocator &alloc=Allocator())
Create a scatterer.
Definition Scatterer.h:51
std::int32_t remote_buffer_size() const noexcept
Buffer size for remote data (ghosts) used in forward and reverse communication.
Definition Scatterer.h:567
std::int32_t local_buffer_size() const noexcept
Size of buffer for local data (owned and shared) used in forward and reverse communication.
Definition Scatterer.h:562
void scatter_fwd_end(std::span< const T > remote_buffer, std::span< T > remote_data, F unpack_fn, std::span< MPI_Request > requests) const
Complete a non-blocking send from the local owner to process ranks that have the index as a ghost,...
Definition Scatterer.h:315
and std::is_invocable_r_v< T, BinaryOp, T, T > void scatter_rev_end(std::span< const T > local_buffer, std::span< T > local_data, F unpack_fn, BinaryOp op, std::span< MPI_Request > request)
End the reverse scatter communication, and unpack the received local buffer into local data.
Definition Scatterer.h:520
void scatter_rev_begin(std::span< const T > remote_data, std::span< T > remote_buffer, std::span< T > local_buffer, F pack_fn, std::span< MPI_Request > request, Scatterer::type type=type::neighbor) const
Scatter data associated with ghost indices to owning ranks.
Definition Scatterer.h:484
type
Types of MPI communication pattern used by the Scatterer.
Definition Scatterer.h:40
void scatter_rev_end(std::span< MPI_Request > request) const
End the reverse scatter communication.
Definition Scatterer.h:447
void scatter_fwd_begin(std::span< const T > send_buffer, std::span< T > recv_buffer, std::span< MPI_Request > requests, Scatterer::type type=type::neighbor) const
Start a non-blocking send of owned data to ranks that ghost the data.
Definition Scatterer.h:195
const std::vector< std::int32_t > & local_indices() const noexcept
Definition Scatterer.h:575
const std::vector< std::int32_t > & remote_indices() const noexcept
Definition Scatterer.h:582
void scatter_rev(std::span< T > local_data, std::span< const T > remote_data, BinaryOp op)
Scatter data associated with ghost indices to ranks that own the indices.
Definition Scatterer.h:536
int bs() const noexcept
The number values (block size) to send per index in the common::IndexMap use to create the scatterer.
Definition Scatterer.h:590
void scatter_fwd_begin(std::span< const T > local_data, std::span< T > local_buffer, std::span< T > remote_buffer, F pack_fn, std::span< MPI_Request > requests, Scatterer::type type=type::neighbor) const
Scatter data associated with owned indices to ghosting ranks.
Definition Scatterer.h:280
void scatter_rev_begin(std::span< const T > send_buffer, std::span< T > recv_buffer, std::span< MPI_Request > requests, Scatterer::type type=type::neighbor) const
Start a non-blocking send of ghost data to ranks that own the data.
Definition Scatterer.h:390
int size(MPI_Comm comm)
Definition MPI.cpp:72
Miscellaneous classes, functions and types.
Definition dolfinx_common.h:8
Top-level namespace.
Definition defines.h:12
constexpr __radix_sort radix_sort
Radix sort.
Definition sort.h:124