Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <map>
7 : #include <pup.h>
8 : #include <tuple>
9 : #include <vector>
10 :
11 : #include "DataStructures/DataBox/Access.hpp"
12 : #include "DataStructures/DataBox/DataBox.hpp"
13 : #include "Domain/Structure/ElementId.hpp"
14 : #include "IO/Observer/ObserverComponent.hpp"
15 : #include "IO/Observer/ReductionActions.hpp"
16 : #include "Options/Auto.hpp"
17 : #include "Options/String.hpp"
18 : #include "Parallel/DistributedObject.hpp"
19 : #include "Parallel/GlobalCache.hpp"
20 : #include "Parallel/Invoke.hpp"
21 : #include "Parallel/Reduction.hpp"
22 : #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
23 : #include "Utilities/PrettyType.hpp"
24 : #include "Utilities/TMPL.hpp"
25 :
26 : namespace Events {
27 :
28 : namespace detail {
29 :
30 : struct map_add {
31 : std::map<std::string, size_t> operator()(
32 : std::map<std::string, size_t> map_1,
33 : const std::map<std::string, size_t>& map_2) {
34 : for (const auto& [key, value] : map_2) {
35 : map_1.at(key) += value;
36 : }
37 : return map_1;
38 : }
39 : };
40 :
41 : using ReductionType = Parallel::ReductionData<
42 : // Time
43 : Parallel::ReductionDatum<double, funcl::AssertEqual<>>,
44 : // Map of total mem usage in MB per item in DataBoxes
45 : Parallel::ReductionDatum<std::map<std::string, size_t>, map_add>>;
46 :
47 : template <typename ContributingComponent>
48 : struct ReduceDataBoxSize {
49 : template <typename ParallelComponent, typename DbTags, typename Metavariables,
50 : typename ArrayIndex>
51 : static void apply(db::DataBox<DbTags>& /*box*/,
52 : Parallel::GlobalCache<Metavariables>& cache,
53 : const ArrayIndex& /*array_index*/, const double time,
54 : const std::map<std::string, size_t>& item_sizes) {
55 : auto& observer_writer_proxy = Parallel::get_parallel_component<
56 : observers::ObserverWriter<Metavariables>>(cache);
57 : const std::string subfile_name =
58 : "/DataBoxSizeInMb/" + pretty_type::name<ContributingComponent>();
59 : std::vector<std::string> legend;
60 : legend.reserve(item_sizes.size() + 1);
61 : legend.emplace_back("Time");
62 : std::vector<double> columns;
63 : columns.reserve(item_sizes.size() + 1);
64 : columns.emplace_back(time);
65 : const double scaling = 1.0 / 1048576.0; // so size is in MB
66 : for (const auto& [name, size] : item_sizes) {
67 : legend.emplace_back(name);
68 : columns.emplace_back(scaling * static_cast<double>(size));
69 : }
70 : Parallel::threaded_action<
71 : observers::ThreadedActions::WriteReductionDataRow>(
72 : // Node 0 is always the writer
73 : observer_writer_proxy[0], subfile_name, legend,
74 : std::make_tuple(columns));
75 : }
76 : };
77 :
78 : struct ContributeDataBoxSize {
79 : template <typename ParallelComponent, typename DbTags, typename Metavariables,
80 : typename ArrayIndex>
81 : static void apply(db::DataBox<DbTags>& box,
82 : Parallel::GlobalCache<Metavariables>& cache,
83 : const ArrayIndex& array_index, const double time) {
84 : const auto& my_proxy =
85 : Parallel::get_parallel_component<ParallelComponent>(cache)[array_index];
86 : auto& target_proxy = Parallel::get_parallel_component<
87 : observers::ObserverWriter<Metavariables>>(cache);
88 : const auto item_sizes = box.size_of_items();
89 : if constexpr (Parallel::is_singleton_v<ParallelComponent>) {
90 : Parallel::simple_action<ReduceDataBoxSize<ParallelComponent>>(
91 : target_proxy[0], time, item_sizes);
92 : } else {
93 : Parallel::contribute_to_reduction<ReduceDataBoxSize<ParallelComponent>>(
94 : ReductionType{time, item_sizes}, my_proxy, target_proxy[0]);
95 : }
96 : }
97 : };
98 : } // namespace detail
99 :
100 : /// \brief Event that will collect the size in MBs used by each DataBox item on
101 : /// each parallel component.
102 : ///
103 : /// \details The data will be written to disk in the reductions file under the
104 : /// `/DataBoxSizeInMb/` group. The name of each file is the `pretty_type::name`
105 : /// of each parallel component. There will be a column for each item in the
106 : /// DataBox that is not a subitem or reference item.
107 1 : class ObserveDataBox : public Event {
108 0 : struct DoNotWrite {};
109 :
110 : public:
111 : /// \cond
112 : explicit ObserveDataBox(CkMigrateMessage* m);
113 : using PUP::able::register_constructor;
114 : WRAPPED_PUPable_decl_template(ObserveDataBox); // NOLINT
115 : /// \endcond
116 :
117 0 : struct WriteTagNamesToFile {
118 0 : using type = ::Options::Auto<std::string, DoNotWrite>;
119 0 : static constexpr Options::String help = {
120 : "The text file to write the names of the DataBox tags to."};
121 : };
122 :
123 0 : using options = tmpl::list<WriteTagNamesToFile>;
124 0 : static constexpr Options::String help = {
125 : "Observe size (in MB) of each item (except reference items) in each "
126 : "DataBox"};
127 :
128 0 : ObserveDataBox() = default;
129 0 : explicit ObserveDataBox(std::optional<std::string> file_name_for_tag_names);
130 :
131 0 : using compute_tags_for_observation_box = tmpl::list<>;
132 :
133 0 : using return_tags = tmpl::list<>;
134 0 : using argument_tags = tmpl::list<::Tags::ObservationBox>;
135 :
136 : template <typename DataBoxType, size_t VolumeDim, typename ParallelComponent,
137 : typename Metavariables, typename ComputeTagsList>
138 0 : void operator()(const ObservationBox<DataBoxType, ComputeTagsList>& box,
139 : Parallel::GlobalCache<Metavariables>& /*cache*/,
140 : const ElementId<VolumeDim>& array_index,
141 : const ParallelComponent* /*meta*/,
142 : const ObservationValue& observation_value) const;
143 :
144 0 : using is_ready_argument_tags = tmpl::list<>;
145 :
146 : template <typename Metavariables, typename ArrayIndex, typename Component>
147 0 : bool is_ready(Parallel::GlobalCache<Metavariables>& /*cache*/,
148 : const ArrayIndex& /*array_index*/,
149 : const Component* const /*meta*/) const {
150 : return true;
151 : }
152 :
153 1 : bool needs_evolved_variables() const override { return false; }
154 :
155 : // NOLINTNEXTLINE(google-runtime-references)
156 0 : void pup(PUP::er& p) override;
157 :
158 : private:
159 : template <size_t VolumeDim>
160 0 : void impl(const db::Access& box_access,
161 : const ElementId<VolumeDim>& array_index,
162 : const ObservationValue& observation_value) const;
163 :
164 0 : std::optional<std::string> file_name_for_tag_names_;
165 : };
166 :
167 : template <typename DataBoxType, size_t VolumeDim, typename ParallelComponent,
168 : typename Metavariables, typename ComputeTagsList>
169 : void ObserveDataBox::operator()(
170 : const ObservationBox<DataBoxType, ComputeTagsList>& box,
171 : Parallel::GlobalCache<Metavariables>& cache,
172 : const ElementId<VolumeDim>& array_index,
173 : const ParallelComponent* const /*meta*/,
174 : const ObservationValue& observation_value) const {
175 : if (is_zeroth_element(array_index)) {
176 : using component_list =
177 : tmpl::push_back<typename Metavariables::component_list>;
178 : tmpl::for_each<component_list>([&observation_value,
179 : &cache](auto component_v) {
180 : using component = tmpl::type_from<decltype(component_v)>;
181 : auto& target_proxy = Parallel::get_parallel_component<component>(cache);
182 : Parallel::simple_action<detail::ContributeDataBoxSize>(
183 : target_proxy, observation_value.value);
184 : });
185 : }
186 : impl(box.databox(), array_index, observation_value);
187 : }
188 : } // namespace Events
|
