monitor.hpp

Go to the documentation of this file.

// Triumvirate: Three-Point Clustering Measurements in LSS
//
// Copyright (C) 2023 Mike S Wang & Naonori S Sugiyama [GPL-3.0-or-later]
//
// This file is part of the Triumvirate program. See the COPYRIGHT
// and LICENCE files at the top-level directory of this distribution
// for details of copyright and licensing.
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

 
#ifndef TRIUMVIRATE_INCLUDE_MONITOR_HPP_INCLUDED_
#define TRIUMVIRATE_INCLUDE_MONITOR_HPP_INCLUDED_
 
#include <gsl/gsl_version.h>
 
#if defined(TRV_USE_HIP)
#include <hipfft/hipfftXt.h>
#elif defined(TRV_USE_CUDA)  // !TRV_USE_HIP && TRV_USE_CUDA
#include <cufftXt.h>
#endif                       // TRV_USE_HIP
#include <fftw3.h>
 
#ifdef TRV_USE_OMP
#include <omp.h>
#endif  // TRV_USE_OMP
 
#include <chrono>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <regex>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
#ifdef TRV_USE_H5
#include "highfive/H5File.hpp"
#endif  // TRV_USE_H5
 
// Enter debugging mode.
#ifdef DBG_MODE
#include <iostream>
#endif  // DBG_MODE

// Declares OMP macros.
#ifdef TRV_USE_OMP
#define OMP_ATOMIC _Pragma("omp atomic")
#define OMP_CRITICAL _Pragma("omp critical")
// NOTE: OpenMP is unavailabled in separate GPU compilation pass.
#ifndef __HIP_DEVICE_COMPILE__
#define _OMP_VERSION std::to_string(_OPENMP)
#else   // !__HIP_DEVICE_COMPILE__
#define _OMP_VERSION std::string("unknown")
#endif  // __HIP_DEVICE_COMPILE__
#define _OMP_NTHREADS omp_get_max_threads()
#else   // !TRV_USE_OMP
#define OMP_ATOMIC
#define OMP_CRITICAL
#define _OMP_VERSION std::string("unknown")
#define _OMP_NTHREADS 1
#endif  // TRV_USE_OMP
 
#ifndef GSL_VERSION
#define GSL_VERSION "unknown"
#endif  // !GSL_VERSION
 
// Record (fallback) version number.
#ifndef __TRV_VERSION__
#define __TRV_VERSION__ "0.6+"
#endif  // !__TRV_VERSION__
 
// Indicate external interface call.
#ifdef TRV_EXTCALL
#define SHOW_CPPSTATE " C++"
#else   // !TRV_EXTCALL
#define SHOW_CPPSTATE ""
#endif  // TRV_EXTCALL
 
// Record (fallback) build timezone offset.
#ifndef __TZOFFSET__
#define __TZOFFSET__ "+0000"
#endif  // !__TZOFFSET__
 
#if defined(TRV_USE_HIP)
#ifndef HIP_EXEC
#define HIP_EXEC(hip_call) {                                             \
  auto ret_status = static_cast<hipError_t>(hip_call);                   \
  if (ret_status != hipSuccess) {                                        \
    std::fprintf(                                                        \
      stderr,                                                            \
      "HIP error: %s. "                                                  \
      "Function <%s> returned error code %d "                            \
      "in file \"%s\", line %d.\n",                                      \
      hipGetErrorString(ret_status),                                     \
      #hip_call, ret_status,                                             \
      __FILE__, __LINE__                                                 \
    );                                                                   \
  }                                                                      \
}
#endif  // !HIP_EXEC
 
#ifndef HIPFFT_EXEC
#define HIPFFT_EXEC(hipfft_call) {                                       \
  auto ret_status = static_cast<hipfftResult>(hipfft_call);              \
  if (ret_status != HIPFFT_SUCCESS) {                                    \
    std::fprintf(                                                        \
      stderr,                                                            \
      "hipFFT error: function <%s> returned error code %d "              \
      "in file \"%s\", line %d.\n",                                      \
      #hipfft_call, ret_status,                                          \
      __FILE__, __LINE__                                                 \
    );                                                                   \
  }                                                                      \
}
#endif  // !HIPFFT_EXEC
 
#elif defined(TRV_USE_CUDA)
#ifndef CUDA_EXEC
#define CUDA_EXEC(cuda_call) {                                           \
  auto ret_status = static_cast<cudaError_t>(cuda_call);                 \
  if (ret_status != cudaSuccess) {                                       \
    std::fprintf(                                                        \
      stderr,                                                            \
      "CUDA error: %s. "                                                 \
      "Function <%s> returned error code %d "                            \
      "in file \"%s\", line %d.\n",                                      \
      cudaGetErrorString(ret_status),                                    \
      #cuda_call, ret_status,                                            \
      __FILE__, __LINE__                                                 \
    );                                                                   \
  }                                                                      \
}
#endif  // !CUDA_EXEC
 
#ifndef CUFFT_EXEC
#define CUFFT_EXEC(cufft_call) {                                         \
  auto ret_status = static_cast<cufftResult>(cufft_call);                \
  if (ret_status != CUFFT_SUCCESS) {                                     \
    std::fprintf(                                                        \
      stderr,                                                            \
      "cuFFT error: function <%s> returned error code %d "               \
      "in file \"%s\", line %d.\n",                                      \
      #cufft_call, ret_status,                                           \
      __FILE__, __LINE__                                                 \
    );                                                                   \
  }                                                                      \
}
#endif // !CUFFT_EXEC
 
#endif  // TRV_USE_HIP
 
namespace trv {
namespace sys {
 
// ***********************************************************************
// Program helpers
// ***********************************************************************

const std::string fn_delimiter = "::";

bool has_extension(const std::string& fname, const std::string& fext);

std::string join_strings(
  const std::vector<std::string>& strings, const std::string& delimiter
);

std::vector<std::string> split_string(
  const std::string& str, const std::string& delimiter
);
 
 
// ***********************************************************************
// Program tracking
// ***********************************************************************
 
// STYLE: Standard naming convention is not followed below.
 
// RFE: Implement MPI.
extern int currTask;  
 
extern double gbytesMem;     
extern double gbytesMaxMem;  
 
extern double gbytesMemGPU;     
extern double gbytesMaxMemGPU;  
 
extern int count_rgrid;       
extern int count_cgrid;       
extern float count_grid;      
extern int max_count_rgrid;   
extern int max_count_cgrid;   
extern float max_count_grid;  
 
extern int count_fft;   
extern int count_ifft;  

extern bool fftw_wisdom_f_imported;
extern bool fftw_wisdom_b_imported;

template <typename T>
double size_in_gb(long long num) {
  const double BYTES_PER_GBYTES = 1073741824.;  // 1024³ bytes per gibibyte
  return double(num) * sizeof(T) / BYTES_PER_GBYTES;
}

template <typename T>
double size_in_gb(int num) {
  const double BYTES_PER_GBYTES = 1073741824.;  // 1024³ bytes per gibibyte
  return double(num) * sizeof(T) / BYTES_PER_GBYTES;
}
 
#if defined(TRV_USE_HIP)
double worksize_in_gb(
  hipfftHandle plan,
  hipfftType ffttype,
  int nx, int ny, int nz,
  std::vector<int> gpus
);
#elif defined(TRV_USE_CUDA)  // !TRV_USE_HIP && TRV_USE_CUDA
double worksize_in_gb(
  cufftHandle plan,
  cufftType ffttype,
  int nx, int ny, int nz,
  std::size_t* worksizes,
  std::vector<int> gpus
);
#endif                       // TRV_USE_HIP

void update_maxmem(bool gpu = false);

void update_maxcntgrid();

std::string show_current_datetime(bool utc = false);

std::string show_elapsed_time(double duration_in_seconds);

std::string show_timestamp();

int get_gpu_count(bool sys = false);

std::vector<int> get_gpu_ids();

bool is_gpu_available();

bool is_gpu_enabled();

bool is_gpu_single();
 
// Determine CUDA stream support for multi-GPU cuFFT (in cuFFT 10.4.0+).
#if defined(TRV_USE_CUDA) && CUFFT_VERSION >= 10400
#define _CUDA_STREAM
#endif  // TRV_USE_CUDA && CUFFT_VERSION >= 10400

void exit_fatal(const std::string& msg);

enum LogLevel {
  // CAVEAT: Discretionary choices.
  NSET = 0,   
  DBUG = 10,  
  STAT = 20,  
  INFO = 30,  
  WARN = 40,  
  ERRO = 50   
};

class Logger {
 public:
  int level_limit;  

  Logger(LogLevel level);

  Logger(int level);

  void reset_level(LogLevel level);

  void reset_level(int level);

  void log(LogLevel level_entry, const char* fmt_string, ...);

  void log(int level_entry, const char* fmt_string, ...);

  void debug(const char* fmt_string, ...);

  void stat(const char* fmt_string, ...);

  void info(const char* fmt_string, ...);

  void warn(const char* fmt_string, ...);

  void error(const char* fmt_string, ...);
 
 private:
  void emit(std::string log_type, const char* fmt_string, std::va_list args);
};

bool is_colourable();
 
extern Logger logger;  

class ProgressBar {
 public:
  std::string name;     
  int task_count = 1;   
  int task_idx = 0;     
  float progress = 0.;  

  explicit ProgressBar(int task_count, std::string name = "");

  void set_bar_width(int bar_width);

  void set_nodes(std::vector<float> nodes);

  void set_task_idx(int task_idx);

  void set_progress(float progress);

  void update(int task_idx_now);

  void update(float progress_now);
 
 private:
  int bar_width = 50;        
 
  std::vector<float> nodes;  
  int next_node_idx = 0;     

  void set_default_pcpt_nodes();
};

std::vector<float> set_nodes_by_str(std::string interval_str);
 
 
// ***********************************************************************
// Program exceptions
// ***********************************************************************

class UnimplementedError: public std::logic_error {
 public:
  std::string err_mesg;  

  UnimplementedError(const char* fmt_string, ...);

  virtual const char* what() const noexcept;
};

class IOError: public std::runtime_error {
 public:
  std::string err_mesg;  

  IOError(const char* fmt_string, ...);

  virtual const char* what() const noexcept;
};

class InvalidParameterError: public std::invalid_argument {
 public:
  std::string err_mesg;  

  InvalidParameterError(const char* fmt_string, ...);

  virtual const char* what() const noexcept;
};

class InvalidDataError: public std::runtime_error {
 public:
  std::string err_mesg;  

  InvalidDataError(const char* fmt_string, ...);

  virtual const char* what() const noexcept;
};
 
 
// ***********************************************************************
// Program notices
// ***********************************************************************

std::string get_build_datetime();

void display_help();

void display_prog_logo();

void display_prog_licence(bool brief = false);

void display_prog_info(bool runtime = false);

void display_prog_logbars(int endpoint);
 
 
// ***********************************************************************
// Program utilities
// ***********************************************************************

void expand_envar_in_path(std::string& path_str);
 
}  // namespace trv::sys
}  // namespace trv
 
#endif  // !TRIUMVIRATE_INCLUDE_MONITOR_HPP_INCLUDED_