memory_reporter.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#pragma once
 
#include "openpfc/core/world.hpp"
#include "openpfc/core/world_queries.hpp"
#include "openpfc/logging.hpp"
#include "openpfc/mpi.hpp"
#include "openpfc/utils.hpp"
#include <cstddef>
#include <fstream>
#include <iomanip>
#include <mpi.h>
#include <sstream>
#include <string>
 
namespace pfc {
namespace utils {
 
struct MemoryUsage {
  size_t m_application_bytes = 0; 
  size_t m_fft_bytes = 0;         
 
  size_t total_bytes() const noexcept { return m_application_bytes + m_fft_bytes; }
};
 
inline size_t get_system_memory_bytes() noexcept {
  std::ifstream meminfo("/proc/meminfo");
  if (!meminfo) return 0;
 
  std::string line;
  while (std::getline(meminfo, line)) {
    if (line.find("MemTotal:") == 0) {
      // Format: "MemTotal:       16384000 kB"
      std::istringstream iss(line);
      std::string label;
      size_t mem_kb;
      iss >> label >> mem_kb;
      return mem_kb * 1024; // Convert kB to bytes
    }
  }
  return 0;
}
 
inline std::string format_bytes(size_t bytes) {
  const double KB = 1024.0;
  const double MB = KB * 1024.0;
  const double GB = MB * 1024.0;
  const double TB = GB * 1024.0;
 
  std::ostringstream oss;
  oss.precision(2);
  oss << std::fixed;
 
  if (bytes >= TB) {
    oss << (bytes / TB) << " TB";
  } else if (bytes >= GB) {
    oss << (bytes / GB) << " GB";
  } else if (bytes >= MB) {
    oss << (bytes / MB) << " MB";
  } else if (bytes >= KB) {
    oss << (bytes / KB) << " KB";
  } else {
    oss << bytes << " B";
  }
  return oss.str();
}
 
template <typename WorldType>
inline void report_memory_usage(const MemoryUsage &usage, const WorldType &world,
                                const Logger &logger,
                                MPI_Comm comm = MPI_COMM_WORLD) {
  int rank = pfc::mpi::get_comm_rank(comm);
  int num_ranks = pfc::mpi::get_comm_size(comm);
 
  // Gather memory data to rank 0
  size_t local_mem[3] = {usage.m_application_bytes, usage.m_fft_bytes,
                         usage.total_bytes()};
  size_t global_mem[3] = {0, 0, 0};
 
  MPI_Reduce(local_mem, global_mem, 3, MPI_UNSIGNED_LONG_LONG, MPI_SUM, 0, comm);
 
  // Only rank 0 logs the report
  if (rank == 0) {
    log_info(logger, "");
    log_info(logger, "=== Memory Usage Report ===");
 
    // Per-rank memory
    std::ostringstream rank_msg;
    rank_msg << "  Rank 0 - Application: " << format_bytes(usage.m_application_bytes)
             << ", FFT: " << format_bytes(usage.m_fft_bytes)
             << ", Total: " << format_bytes(usage.total_bytes());
    log_info(logger, rank_msg.str());
 
    // Global total
    std::ostringstream global_msg;
    global_msg << "  Global Total: " << format_bytes(global_mem[2]) << " ("
               << num_ranks << " ranks)";
    log_info(logger, global_msg.str());
 
    // Per-voxel memory
    auto [Nx, Ny, Nz] = get_size(world);
    size_t total_voxels = static_cast<size_t>(Nx) * Ny * Nz;
    double mem_per_voxel = static_cast<double>(global_mem[2]) / total_voxels;
 
    std::ostringstream voxel_msg;
    voxel_msg << "  Per Voxel: " << format_bytes(static_cast<size_t>(mem_per_voxel))
              << "/voxel (" << total_voxels << " voxels)";
    log_info(logger, voxel_msg.str());
 
    // System memory (if available)
    size_t system_mem = get_system_memory_bytes();
    if (system_mem > 0) {
      double usage_pct = (static_cast<double>(global_mem[2]) / system_mem) * 100.0;
      std::ostringstream sys_msg;
      sys_msg << "  System Memory: " << format_bytes(system_mem)
              << ", Usage: " << std::fixed << std::setprecision(1) << usage_pct
              << "%";
      log_info(logger, sys_msg.str());
    }
 
    log_info(logger, "===========================");
    log_info(logger, "");
  }
}
 
} // namespace utils
} // namespace pfc