Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
timestep_report.cpp
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
17
22#include "shambase/string.hpp"
23#include "shambase/tabulate.hpp"
26#include "shamcomm/logs.hpp"
29#include <numeric>
30#include <optional>
31#include <string>
32#include <variant>
33#include <vector>
34
35std::string shammodels::report_perf_timestep(
36 f64 rate,
37 u64 nobj,
38 u64 npatch,
39 f64 tcompute,
40 f64 mpi_timer,
41 f64 alloc_time_device,
42 f64 alloc_time_host,
43 size_t max_mem_device,
44 size_t max_mem_host,
45 shamsys::SystemMetrics system_metrics,
46 bool report_power_usage,
47 std::optional<u64> nobj_ghost) {
48
50
51 std::vector<f64> rate_all_ranks = shamalgs::collective::gather(rate);
52 std::vector<u64> nobj_all_ranks = shamalgs::collective::gather(nobj);
53 std::vector<u64> npatch_all_ranks = shamalgs::collective::gather(npatch);
54 std::vector<f64> tcompute_all_ranks = shamalgs::collective::gather(tcompute);
55 std::vector<f64> mpi_timer_all_ranks = shamalgs::collective::gather(mpi_timer);
56 std::vector<f64> alloc_time_device_all_ranks = shamalgs::collective::gather(alloc_time_device);
57 std::vector<f64> alloc_time_host_all_ranks = shamalgs::collective::gather(alloc_time_host);
58 std::vector<size_t> max_mem_device_all_ranks = shamalgs::collective::gather(max_mem_device);
59 std::vector<size_t> max_mem_host_all_ranks = shamalgs::collective::gather(max_mem_host);
60
61 // all ranks call the same solver, so either all or none of them report ghost counts
62 bool report_ghost = nobj_ghost.has_value();
63 std::vector<u64> nobj_ghost_all_ranks
64 = (report_ghost) ? shamalgs::collective::gather(*nobj_ghost) : std::vector<u64>{};
65
66 auto rank_metrics = (report_power_usage) ? shamsys::gather_rank_metrics(system_metrics)
67 : std::vector<shamsys::SystemMetrics>{};
68
69 if (shamcomm::world_rank() != 0) {
70 return "";
71 }
72
73 // be careful with overflows
74 u64 obj_total = std::accumulate(nobj_all_ranks.begin(), nobj_all_ranks.end(), 0_u64);
75 u64 npatch_total = std::accumulate(npatch_all_ranks.begin(), npatch_all_ranks.end(), 0_u64);
76 f64 max_t = *std::max_element(tcompute_all_ranks.begin(), tcompute_all_ranks.end());
77 f64 sum_t = std::accumulate(tcompute_all_ranks.begin(), tcompute_all_ranks.end(), 0.0);
78 f64 sum_mpi = std::accumulate(mpi_timer_all_ranks.begin(), mpi_timer_all_ranks.end(), 0.0);
79 f64 sum_alloc_device = std::accumulate(
80 alloc_time_device_all_ranks.begin(), alloc_time_device_all_ranks.end(), 0.0);
81 f64 sum_alloc_host
82 = std::accumulate(alloc_time_host_all_ranks.begin(), alloc_time_host_all_ranks.end(), 0.0);
83 size_t sum_mem_device_total
84 = std::accumulate(max_mem_device_all_ranks.begin(), max_mem_device_all_ranks.end(), 0_u64);
85 size_t sum_mem_host_total
86 = std::accumulate(max_mem_host_all_ranks.begin(), max_mem_host_all_ranks.end(), 0_u64);
87 u64 nobj_ghost_total
88 = std::accumulate(nobj_ghost_all_ranks.begin(), nobj_ghost_all_ranks.end(), 0_u64);
89
90 shamsys::SystemMetrics aggregated_metrics = shamsys::aggregate_rank_metrics(rank_metrics);
91
92 std::vector<shamsys::FormattedSystemMetrics> formatted_rank_metrics{};
93 shamsys::FormattedSystemMetrics formatted_aggregated_metrics = {};
94 if (report_power_usage) {
95 for (const auto &metric : rank_metrics) {
96 formatted_rank_metrics.push_back(shamsys::format_system_metrics(metric));
97 }
98 formatted_aggregated_metrics = shamsys::format_system_metrics(aggregated_metrics);
99 }
100
101 // ghost count followed by the ratio ghost count / object count
102 auto format_ghost_ratio = [](u64 ghost, u64 nobj) {
103 return sham::format("{} (x{:.3f})", ghost, f64(ghost) / f64(nobj));
104 };
105
106 u32 cols_count = 9_u32;
107 if (report_ghost) {
108 cols_count += 1_u32;
109 }
110 if (report_power_usage) {
111 if (shamsys::support_rank_energy_consummed()) {
112 cols_count += 1_u32;
113 }
114 if (shamsys::support_gpu_energy_consummed()) {
115 cols_count += 1_u32;
116 }
117 if (shamsys::support_cpu_energy_consummed()) {
118 cols_count += 1_u32;
119 }
120 if (shamsys::support_dram_energy_consummed()) {
121 cols_count += 1_u32;
122 }
123 }
124
125 using Table = shambase::table;
126
127 Table table(cols_count);
128
129 std::vector<std::string> header
130 = {"rank",
131 "rate (N/s)",
132 "Nobj",
133 "Npatch",
134 "tstep",
135 "MPI",
136 "alloc d% h%",
137 "mem (max) d",
138 "mem (max) h"};
139 if (report_ghost) {
140 header.insert(header.begin() + 3, "Nghost");
141 }
142 if (report_power_usage) {
143 if (shamsys::support_rank_energy_consummed()) {
144 header.push_back("power");
145 }
146 if (shamsys::support_gpu_energy_consummed()) {
147 header.push_back("gpu power");
148 }
149 if (shamsys::support_cpu_energy_consummed()) {
150 header.push_back("cpu power");
151 }
152 if (shamsys::support_dram_energy_consummed()) {
153 header.push_back("dram power");
154 }
155 }
156
157 table.add_double_rule();
158 table.add_data(header, Table::center);
159 table.add_double_rule();
160 for (u32 i = 0; i < shamcomm::world_size(); i++) {
161 std::vector<std::string> row = {
162 sham::format("{:<4}", i),
163 sham::format("{:.4e}", rate_all_ranks[i]),
164 sham::format("{:}", nobj_all_ranks[i]),
165 sham::format("{:}", npatch_all_ranks[i]),
166 sham::format("{:.3e}", tcompute_all_ranks[i]),
167 sham::format("{:.1f}%", 100 * (mpi_timer_all_ranks[i] / tcompute_all_ranks[i])),
168 sham::format(
169 "{:>.1f}% {:<.1f}%",
170 100 * (alloc_time_device_all_ranks[i] / tcompute_all_ranks[i]),
171 100 * (alloc_time_host_all_ranks[i] / tcompute_all_ranks[i])),
172 sham::format("{}", shambase::readable_sizeof(max_mem_device_all_ranks[i])),
173 sham::format("{}", shambase::readable_sizeof(max_mem_host_all_ranks[i])),
174 };
175 if (report_ghost) {
176 // with a single rank there is no total row, so show the ratio here
177 row.insert(
178 row.begin() + 3,
180 ? sham::format("{:}", nobj_ghost_all_ranks[i])
181 : format_ghost_ratio(nobj_ghost_all_ranks[i], nobj_all_ranks[i]));
182 }
183 if (report_power_usage) {
184 if (shamsys::support_rank_energy_consummed()) {
185 row.push_back(formatted_rank_metrics[i].rank_power.value_or("N/A"));
186 }
187 if (shamsys::support_gpu_energy_consummed()) {
188 row.push_back(formatted_rank_metrics[i].gpu_power.value_or("N/A"));
189 }
190 if (shamsys::support_cpu_energy_consummed()) {
191 row.push_back(formatted_rank_metrics[i].cpu_power.value_or("N/A"));
192 }
193 if (shamsys::support_dram_energy_consummed()) {
194 row.push_back(formatted_rank_metrics[i].dram_power.value_or("N/A"));
195 }
196 }
197 table.add_data(row, Table::right);
198 }
199 if (shamcomm::world_size() > 1) {
200 std::vector<std::string> ruled
201 = {"", "<sum N/max t>", "<sum>", "<sum>", "<max>", "<avg>", "<avg>", "<sum>", "<sum>"};
202 if (report_ghost) {
203 ruled.insert(ruled.begin() + 3, "<sum (x ratio)>");
204 }
205 if (report_power_usage) {
206 if (shamsys::support_rank_energy_consummed()) {
207 ruled.push_back("<sum>");
208 }
209 if (shamsys::support_gpu_energy_consummed()) {
210 ruled.push_back("<sum>");
211 }
212 if (shamsys::support_cpu_energy_consummed()) {
213 ruled.push_back("<sum>");
214 }
215 if (shamsys::support_dram_energy_consummed()) {
216 ruled.push_back("<sum>");
217 }
218 }
219 table.add_rulled_data(ruled);
220 std::vector<std::string> all_row = {
221 "all",
222 sham::format("{:.4e}", f64(obj_total) / max_t),
223 sham::format("{:}", obj_total),
224 sham::format("{:}", npatch_total),
225 sham::format("{:.3e}", max_t),
226 sham::format("{:.1f}%", 100 * (sum_mpi / sum_t)),
227 sham::format(
228 "{:>.1f}% {:<.1f}%",
229 100 * (sum_alloc_device / sum_t),
230 100 * (sum_alloc_host / sum_t)),
231 sham::format("{}", shambase::readable_sizeof(sum_mem_device_total)),
232 sham::format("{}", shambase::readable_sizeof(sum_mem_host_total)),
233 };
234 if (report_ghost) {
235 all_row.insert(all_row.begin() + 3, format_ghost_ratio(nobj_ghost_total, obj_total));
236 }
237 if (report_power_usage) {
238 if (shamsys::support_rank_energy_consummed()) {
239 all_row.push_back(formatted_aggregated_metrics.rank_power.value_or("N/A"));
240 }
241 if (shamsys::support_gpu_energy_consummed()) {
242 all_row.push_back(formatted_aggregated_metrics.gpu_power.value_or("N/A"));
243 }
244 if (shamsys::support_cpu_energy_consummed()) {
245 all_row.push_back(formatted_aggregated_metrics.cpu_power.value_or("N/A"));
246 }
247 if (shamsys::support_dram_energy_consummed()) {
248 all_row.push_back(formatted_aggregated_metrics.dram_power.value_or("N/A"));
249 }
250 }
251 table.add_data(all_row, Table::right);
252 }
253 table.add_rule();
254
255 return "Timestep perf report:" + table.render();
256}
double f64
Alias for double.
std::uint32_t u32
32 bit unsigned integer
std::uint64_t u64
64 bit unsigned integer
MPI string gather / allgather helpers (declarations; implementations in shamalgs/src/collective/gathe...
std::string readable_sizeof(double size)
given a sizeof value return a readble string Example : readable_sizeof(1e9) -> "1....
Definition string.hpp:80
i32 world_rank()
Gives the rank of the current process in the MPI communicator.
Definition worldInfo.cpp:41
i32 world_size()
Gives the size of the MPI communicator.
Definition worldInfo.cpp:39
FormattedSystemMetrics format_system_metrics(const SystemMetrics &input)
Only to be used on deltas, not the raw one.
This file contains the definition for the stacktrace related functionality.
#define __shamrock_stack_entry()
Macro to create a stack entry.
Functions related to the MPI communicator.