monitor.hpp

Go to the documentation of this file.

// Copyright (C) [GPLv3 Licence]
//
// 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 <chrono>
#include <cstdarg>
#include <cstdio>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
 
#include <fftw3.h>
#include <gsl/gsl_version.h>
 
// Declares OMP macros.
#ifdef TRV_USE_OMP
#include <omp.h>
#define OMP_ATOMIC _Pragma("omp atomic")
#define OMP_CRITICAL _Pragma("omp critical")
#else  // !TRV_USE_OMP
#define OMP_ATOMIC
#define OMP_CRITICAL
#endif  // TRV_USE_OMP
 
// Enter debugging mode.
#ifdef DBG_MODE
#include <iostream>
#endif  // DBG_MODE
 
namespace trv {
namespace sys {
 
// ***********************************************************************
// Program tracking
// ***********************************************************************
 
// STYLE: Standard naming convention is not followed below.
 
// RFE: Implement MPI.
extern int currTask;  
 
extern double gbytesMem;     
extern double gbytesMaxMem;  
 
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;
}
 
void update_maxmem();
 
void update_maxcntgrid();
 
std::string show_current_datetime();
 
std::string show_elapsed_time(double duration_in_seconds);
 
std::string show_timestamp();
 
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);
};
 
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();
};
 
 
// ***********************************************************************
// 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
// ***********************************************************************
 
void display_prog_logo();
 
void display_prog_licence();
 
void display_prog_info();
 
void display_prog_logbars(int endpoint);
 
}  // namespace trv::sys
}  // namespace trv
 
#endif  // !TRIUMVIRATE_INCLUDE_MONITOR_HPP_INCLUDED_