Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : // This file is tested in Test_InboxTags.cpp
5 :
6 : #pragma once
7 :
8 : #include <atomic>
9 : #include <boost/container/small_vector.hpp>
10 : #include <cstddef>
11 : #include <map>
12 : #include <tuple>
13 : #include <utility>
14 :
15 : #include "Domain/Structure/DirectionalId.hpp"
16 : #include "Domain/Structure/MaxNumberOfNeighbors.hpp"
17 : #include "Evolution/DiscontinuousGalerkin/BoundaryData.hpp"
18 : #include "Parallel/StaticSpscQueue.hpp"
19 : #include "Time/TimeStepId.hpp"
20 :
21 : /// \cond
22 : namespace PUP {
23 : class er;
24 : } // namespace PUP
25 : /// \endcond
26 :
27 : namespace evolution::dg {
28 : /*!
29 : * \brief Holds the data in the different directions for the nodegroup
30 : * `DgElementArray` implementation.
31 : *
32 : * The reason for this class is to reduce contention between cores and to
33 : * allow the use of a Single-Producer-Single-Consumer (SPSC) queue instead of
34 : * an MPMC queue. This has significant performance improvements since it
35 : * drastically reduces contention.
36 : *
37 : * \warning Only `AtomicInboxBoundaryData` with zero messages can be
38 : * move constructed or serialized. This is necessary in order to be
39 : * able to serialize a
40 : * `std::unordered_map<Key,AtomicInboxBoundaryData>`.
41 : */
42 : template <size_t Dim>
43 1 : struct AtomicInboxBoundaryData {
44 0 : using stored_type = evolution::dg::BoundaryData<Dim>;
45 0 : AtomicInboxBoundaryData() = default;
46 0 : AtomicInboxBoundaryData(const AtomicInboxBoundaryData&) = delete;
47 0 : AtomicInboxBoundaryData& operator=(const AtomicInboxBoundaryData&) = delete;
48 0 : AtomicInboxBoundaryData(AtomicInboxBoundaryData&& rhs) noexcept;
49 0 : AtomicInboxBoundaryData& operator=(AtomicInboxBoundaryData&&) noexcept =
50 : delete;
51 0 : ~AtomicInboxBoundaryData() = default;
52 :
53 : /*!
54 : * Computes the 1d index into the `boundary_data_in_directions` array
55 : * for a specific `directional_id` that has been re-oriented using the
56 : * `OrientationMap` to be put in the same block frame as the element that is
57 : * receiving the data (i.e. that whose inbox this is being inserted into).
58 : *
59 : * The hash is computed as
60 : * \f{align}{
61 : * 2^D d + 2^{D-1} s + e
62 : * \f}
63 : * where \f$D\f$ is the number of spatial dimensions, \f$d\f$ is the logical
64 : * dimension of the direction to the neighbor from the element whose inbox
65 : * this is, \f$s\f$ is the side in the logical dimension \f$d\f$ with a value
66 : * of 1 for upper and 0 for lower, and \f$e\f$ is a hash of the index of the
67 : * `SegmentId`'s of the neighbor's `ElementId` for the dimensions other than
68 : * \f$d\f$. In particular: for \f$d=1\f$, \f$e\f$ is 0 (1) if
69 : * the `SegmentId` index along the face is even (odd); and for \f$d = 3\f$
70 : * \f$e\f$ is 0 (1, 2, 3) if the `SegmentId` indices along the face are both
71 : * even (lower dim odd, higher dim odd, both dims odd). The element segment
72 : * hash is computed as the logical `and` of the `SegmentID`'s index in that
73 : * direction, left shifted by which direction on the face it is.
74 : */
75 1 : static size_t index(const DirectionalId<Dim>& directional_id);
76 :
77 : /*!
78 : * Moves data from the SPSC queues into the `messages` map.
79 : */
80 1 : void collect_messages();
81 :
82 : /*!
83 : * Set a lower bound on the number of messages required for the
84 : * algorithm to make progress since the most recent call to
85 : * `collect_messages`. After that number of new messages have been
86 : * received, `BoundaryCorrectionAndGhostCellsInbox` will restart
87 : * the algorithm.
88 : *
89 : * \return whether enough messages have been received.
90 : */
91 1 : bool set_missing_messages(size_t count);
92 :
93 0 : void pup(PUP::er& p);
94 :
95 : // We use 20 entries in the SPSC under the assumption that each neighbor
96 : // will never insert more than 20 entries before the element uses
97 : // them. While in practice a smaller buffer could be used, this is to
98 : // safeguard against future features.
99 : std::array<Parallel::StaticSpscQueue<
100 : std::tuple<::TimeStepId, stored_type, DirectionalId<Dim>>, 20>,
101 : maximum_number_of_neighbors(Dim)>
102 0 : boundary_data_in_directions{};
103 : std::map<TimeStepId, boost::container::small_vector<
104 : std::pair<DirectionalId<Dim>, stored_type>,
105 : maximum_number_of_neighbors(Dim)>>
106 0 : messages{};
107 0 : std::atomic_int missing_messages{};
108 :
109 : // The number of messages in the SPSC queues is
110 : // passed_missing_messages - missing_messages - processed_messages.
111 : // The various manipulations change these fields as follows:
112 : //
113 : // New message => --missing_messages (by insert_into_inbox)
114 : // collect_messages => processed_messages += num unqueued messages
115 : // set_missing_messages(count) =>
116 : // missing_messages += count + processed_messages - passed_missing_messages
117 : // processed_messages = 0
118 : // passed_missing_messages = count
119 : //
120 : // The processed_messages field exists (rather than just including
121 : // it in missing_messages) so that missing_messages is positive if
122 : // and only if the element is blocked on messages in this queue.
123 0 : int processed_messages{};
124 0 : int passed_missing_messages{};
125 : };
126 :
127 : /// \brief `std::true` if `T` is a `AtomicInboxBoundaryData`
128 : template <typename T>
129 1 : struct is_atomic_inbox_boundary_data : std::false_type {};
130 :
131 : /// \cond
132 : template <size_t Dim>
133 : struct is_atomic_inbox_boundary_data<AtomicInboxBoundaryData<Dim>>
134 : : std::true_type {};
135 : /// \endcond
136 :
137 : /// \brief `true` if `T` is a `AtomicInboxBoundaryData`
138 : template <typename T>
139 1 : constexpr size_t is_atomic_inbox_boundary_data_v =
140 : is_atomic_inbox_boundary_data<T>::value;
141 : } // namespace evolution::dg
|
