35std::string shammodels::report_perf_timestep(
41 f64 alloc_time_device,
43 size_t max_mem_device,
46 bool report_power_usage,
47 std::optional<u64> nobj_ghost) {
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);
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>{};
66 auto rank_metrics = (report_power_usage) ? shamsys::gather_rank_metrics(system_metrics)
67 : std::vector<shamsys::SystemMetrics>{};
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);
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);
88 = std::accumulate(nobj_ghost_all_ranks.begin(), nobj_ghost_all_ranks.end(), 0_u64);
92 std::vector<shamsys::FormattedSystemMetrics> formatted_rank_metrics{};
94 if (report_power_usage) {
95 for (
const auto &metric : rank_metrics) {
102 auto format_ghost_ratio = [](
u64 ghost,
u64 nobj) {
103 return sham::format(
"{} (x{:.3f})", ghost,
f64(ghost) /
f64(nobj));
106 u32 cols_count = 9_u32;
110 if (report_power_usage) {
111 if (shamsys::support_rank_energy_consummed()) {
114 if (shamsys::support_gpu_energy_consummed()) {
117 if (shamsys::support_cpu_energy_consummed()) {
120 if (shamsys::support_dram_energy_consummed()) {
127 Table table(cols_count);
129 std::vector<std::string> header
140 header.insert(header.begin() + 3,
"Nghost");
142 if (report_power_usage) {
143 if (shamsys::support_rank_energy_consummed()) {
144 header.push_back(
"power");
146 if (shamsys::support_gpu_energy_consummed()) {
147 header.push_back(
"gpu power");
149 if (shamsys::support_cpu_energy_consummed()) {
150 header.push_back(
"cpu power");
152 if (shamsys::support_dram_energy_consummed()) {
153 header.push_back(
"dram power");
157 table.add_double_rule();
158 table.add_data(header, Table::center);
159 table.add_double_rule();
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])),
170 100 * (alloc_time_device_all_ranks[i] / tcompute_all_ranks[i]),
171 100 * (alloc_time_host_all_ranks[i] / tcompute_all_ranks[i])),
180 ? sham::format(
"{:}", nobj_ghost_all_ranks[i])
181 : format_ghost_ratio(nobj_ghost_all_ranks[i], nobj_all_ranks[i]));
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"));
187 if (shamsys::support_gpu_energy_consummed()) {
188 row.push_back(formatted_rank_metrics[i].gpu_power.value_or(
"N/A"));
190 if (shamsys::support_cpu_energy_consummed()) {
191 row.push_back(formatted_rank_metrics[i].cpu_power.value_or(
"N/A"));
193 if (shamsys::support_dram_energy_consummed()) {
194 row.push_back(formatted_rank_metrics[i].dram_power.value_or(
"N/A"));
197 table.add_data(row, Table::right);
200 std::vector<std::string> ruled
201 = {
"",
"<sum N/max t>",
"<sum>",
"<sum>",
"<max>",
"<avg>",
"<avg>",
"<sum>",
"<sum>"};
203 ruled.insert(ruled.begin() + 3,
"<sum (x ratio)>");
205 if (report_power_usage) {
206 if (shamsys::support_rank_energy_consummed()) {
207 ruled.push_back(
"<sum>");
209 if (shamsys::support_gpu_energy_consummed()) {
210 ruled.push_back(
"<sum>");
212 if (shamsys::support_cpu_energy_consummed()) {
213 ruled.push_back(
"<sum>");
215 if (shamsys::support_dram_energy_consummed()) {
216 ruled.push_back(
"<sum>");
219 table.add_rulled_data(ruled);
220 std::vector<std::string> all_row = {
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)),
229 100 * (sum_alloc_device / sum_t),
230 100 * (sum_alloc_host / sum_t)),
235 all_row.insert(all_row.begin() + 3, format_ghost_ratio(nobj_ghost_total, obj_total));
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"));
241 if (shamsys::support_gpu_energy_consummed()) {
242 all_row.push_back(formatted_aggregated_metrics.gpu_power.value_or(
"N/A"));
244 if (shamsys::support_cpu_energy_consummed()) {
245 all_row.push_back(formatted_aggregated_metrics.cpu_power.value_or(
"N/A"));
247 if (shamsys::support_dram_energy_consummed()) {
248 all_row.push_back(formatted_aggregated_metrics.dram_power.value_or(
"N/A"));
251 table.add_data(all_row, Table::right);
255 return "Timestep perf report:" + table.render();
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....
i32 world_rank()
Gives the rank of the current process in the MPI communicator.
i32 world_size()
Gives the size of the MPI communicator.
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.