M3::Utils Namespace Reference

Utility helpers used across MaCh3. More...

Functions
void	MaCh3Welcome ()
	KS: Prints welcome message with MaCh3 logo. More...
std::string	GetMaCh3Version ()
	KS: Get version of MaCh3. More...
void	GetOSInfo ()
	KS: Find out more about operational system. More...
void	GetCPUInfo ()
	KS: Check what CPU you are using. More...
void	NThreadsSanity ()
	KS: Check if user is not using huge number of threads and throw error. More...
void	GetGPUInfo ()
	KS: Check what GPU you are using. More...
void	GetDiskUsage ()
	KS: Find out about Disk usage. More...
std::string	TerminalToString (std::string cmd)
	KS: Convoluted code to grab output from terminal to string. More...
void	EstimateDataTransferRate (TChain *chain, const Long64_t entry)
	KS: Check what CPU you are using. More...
void	PrintProgressBar (const Long64_t Done, const Long64_t All)
	KS: Simply print progress bar. More...
int	getValue (const std::string &Type)
	CW: Get info like RAM. More...
int	parseLine (const std::string &line)
	CW: Get memory, which is probably silly. More...
void	PrintConfig (const YAML::Node &node)
	KS: Print Yaml config using logger. More...
void	Print (const TTree *tree)
void	MaCh3Usage (int argc, char **argv)
	KS: Almost all MaCh3 executables have the same usage, prepare simple printer. More...
double	GetMassFromPDG (const int PDG)
	Return mass for given PDG. More...
int	PDGToNuOscillatorFlavour (const int NuPdg)
	Convert from PDG flavour to NuOscillator type beware that in the case of anti-neutrinos the NuOscillator type simply gets multiplied by -1. More...
std::string	FormatDouble (const double value, const int precision)
	Convert double into string for precision, useful for playing with yaml if you don't want to have in config floating point precision... More...

Detailed Description

Utility helpers used across MaCh3.

Function Documentation

EstimateDataTransferRate()

void M3::Utils::EstimateDataTransferRate	(	TChain *	chain,
		const Long64_t	entry
	)

KS: Check what CPU you are using.

Definition at line 212 of file Monitor.cpp.

                                                                  {
// ************************
  TStopwatch timer;
 
  timer.Start();
  Int_t bytesProcessed{ chain->GetEntry(entry) };
 
  timer.Stop();
 
  Double_t timeInSeconds = timer.RealTime();
  Double_t dataRateMBps = (double(bytesProcessed) / (1024.0 * 1024.0)) / timeInSeconds;
 
  MACH3LOG_INFO("Data transfer: {} B, rate: {:.2f} MB/s", bytesProcessed, dataRateMBps);
}

FormatDouble()

std::string M3::Utils::FormatDouble ( const double  value, const int  precision  )

inline

Convert double into string for precision, useful for playing with yaml if you don't want to have in config floating point precision...

Definition at line 833 of file SampleStructs.h.

                                                                         {
  // ***************************
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(precision) << value;
    return oss.str();
  }

GetCPUInfo()

void M3::Utils::GetCPUInfo

(

)

KS: Check what CPU you are using.

Definition at line 100 of file Monitor.cpp.

                  {
// ************************
  //KS: Use -m 1 to limit to only one grep because in one computing node there is a lot of CPU which are the same
  MACH3LOG_INFO("Using following CPU:");
 
  MACH3LOG_INFO("{}", TerminalToString("cat /proc/cpuinfo | grep -m 1 name"));
  MACH3LOG_INFO("{}", TerminalToString("cat /proc/cpuinfo | grep -m 1 MHz"));
  //KS: Below code is convoluted because I mostly work on English based Linux but sometimes on Polish based Linux, this ensures it works on both. We can add support for other languages if needed
  MACH3LOG_INFO("{}", TerminalToString("lscpu | grep -i Archit"));
  MACH3LOG_INFO("{}", TerminalToString("lscpu | grep -m 1 -E 'L1d |L1d:'"));
  MACH3LOG_INFO("{}", TerminalToString("lscpu | grep -m 1 -E 'L1i |L1i:'"));
  MACH3LOG_INFO("{}", TerminalToString("lscpu | grep -m 1 -E 'L2 |L2:'"));
  MACH3LOG_INFO("{}", TerminalToString("lscpu | grep -m 1 -E 'L3 |L3:'"));
  MACH3LOG_INFO("{}", TerminalToString("lscpu | grep -m 1 -E 'Thread.* per core:|Wątków na rdzeń:'"));
  MACH3LOG_INFO("{}", TerminalToString("lscpu | grep -m 1 -E '^CPU(:|\\(s\\)):?\\s+[0-9]+'"));
  MACH3LOG_INFO("With available threads                {}", M3::GetNThreads());
 
  NThreadsSanity();
  //KS: /proc/cpuinfo and lscpu holds much more info I have limited it but one can expand it if needed
}

GetDiskUsage()

void M3::Utils::GetDiskUsage

(

)

KS: Find out about Disk usage.

Definition at line 177 of file Monitor.cpp.

                    {
// ************************
  MACH3LOG_INFO("Disk Usage:");
 
  // Get disk usage
  MACH3LOG_INFO("{}", TerminalToString("df -h --total | grep total"));
}

GetGPUInfo()

void M3::Utils::GetGPUInfo

(

)

KS: Check what GPU you are using.

Definition at line 144 of file Monitor.cpp.

                 {
// ************************
#ifdef MaCh3_CUDA
  int nDevices;
  cudaGetDeviceCount(&nDevices);
  if (nDevices == 0) {
    MACH3LOG_CRITICAL("MaCh3 compiled with CUDA support (for GPU acceleration) but could not find GPU");
    MACH3LOG_CRITICAL("Either allocate GPU for your job or recompile MaCh3 without GPU support");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  MACH3LOG_INFO("Using following GPU:");
  // Print GPU name
  MACH3LOG_INFO("GPU Name: {}", TerminalToString("nvidia-smi --query-gpu=name --format=csv,noheader"));
  // Print number of GPUs
  MACH3LOG_INFO("Number of GPUs: {}", TerminalToString("nvidia-smi --query-gpu=count --format=csv,noheader"));
  // Print total VRAM
  MACH3LOG_INFO("Total VRAM: {} MB", TerminalToString("nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits"));
  // Print Driver Version
  MACH3LOG_INFO("Driver Version: {}", TerminalToString("nvidia-smi --query-gpu=driver_version --format=csv,noheader"));
  // Print N GPU thread
  MACH3LOG_INFO("Currently used GPU has: {} threads", GetNumGPUThreads());
  // Print L2 cache
  MACH3LOG_INFO("Currently used GPU has: {} KB L2 cache", GetL2CacheSize() / 1024);
  // Shared memory info
  MACH3LOG_INFO("Max shared memory per block: {} KB", GetSharedMemoryPerBlock() / 1024);
  // Print 1D texture size
  MACH3LOG_INFO("Max 1D texture size: {}", GetMaxTexture1DSize());
#endif
}

GetMaCh3Version()

std::string M3::Utils::GetMaCh3Version

(

)

KS: Get version of MaCh3.

Returns

The current MaCh3 version as a string.

This function fetches and returns the version of the MaCh3 software being used.

Definition at line 47 of file Monitor.cpp.

                            {
// ************************
  //KS: Find MaCh3 version based on header file. There could be better way to just include version.h but as long as we don't have to hardcode version I am content
  std::string MaCh3_VERSION = "";
 
  if(std::getenv("MaCh3_ROOT") == nullptr){
    throw MaCh3Exception(__FILE__, __LINE__, "Error: you haven't sourced setup.MaCh3.sh in core!");
  }
 
  std::string file = std::string(std::getenv("MaCh3_ROOT")) + "/version.h";
  // Open the version.h file
  std::ifstream versionFile(file);
 
  // Check if the file is opened successfully
  if (!versionFile.is_open()) {
    MACH3LOG_ERROR("Error: Couldn't open version.h {}", file);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  std::string line;
  const std::string searchKey = "MaCh3_VERSION=";
 
  // Read each line from the file
  while (std::getline(versionFile, line)) {
    // Search for the line containing MaCh3_VERSION
    auto pos = line.find(searchKey);
    if (pos != std::string::npos) {
      // Extract the version string
      MaCh3_VERSION = line.substr(pos + searchKey.length());
      MaCh3_VERSION.erase(0, MaCh3_VERSION.find_first_not_of("\"")); // Remove leading quote
      MaCh3_VERSION.erase(MaCh3_VERSION.find_last_not_of("\";") + 1); // Remove trailing quote and semicolon
      break; // Stop searching once found
    }
  }
  // Close the file
  versionFile.close();
 
  return MaCh3_VERSION;
}

GetMassFromPDG()

double M3::Utils::GetMassFromPDG ( const int  PDG )

inline

Return mass for given PDG.

Note

Get the mass of a particle from the PDG In GeV, not MeV! [26] (particle masses) [36] (nuclear masses)

Todo:

this could be constexpr in c++17

Definition at line 749 of file SampleStructs.h.

                                              {
  // *****************************
    switch (abs(PDG)) {
      // Leptons
      case 11: return 0.00051099895; // e
      case 13: return 0.1056583755;  // mu
      case 15: return 1.77693;       // tau
      // Neutrinos
      case 12:
      case 14:
      case 16:
        return 0.;
      // Photon
      case 22: return 0.;
      // Mesons
      case 211: return 0.13957039; // pi_+/-
      case 111: return 0.1349768;  // pi_0
      case 221: return 0.547862;   // eta
      case 311:                    // K_0
      case 130:                    // K_0_L
      case 310:                    // K_0_S
        return 0.497611;
      case 321: return 0.493677;   // K_+/-
      // Baryons
      case 2112: return 0.939565; // n
      case 2212: return 0.938272; // p
      case 3122: return 1.115683; // lambda
      case 3222: return 1.118937; // sig_+
      case 3112: return 1.197449; // sig_-
      case 3212: return 1.192642; // sig_0
      // Nuclei
      case 1000050110: return 10.255103; // Boron-11
      case 1000060120: return 11.177929; // Carbon-12
      case 1000070140: return 13.043781; // Nitrogen-14
      case 1000080160: return 14.899169; // Oxygen-16
      case 1000090190: return 17.696901; // Fluorine-19
      case 1000110230: return 21.414835; // Sodium-23
      case 1000130270: return 25.133144; // Aluminum-27
      case 1000140280: return 26.060342; // Silicon-28
      case 1000190390: return 36.294463; // Potassium-39
      case 1000180400: return 37.224724; // Argon-40
      case 1000220480: return 44.663224; // Titanium-48
      case 1000300640: return 59.549619; // Zinc-64
      default:
        MACH3LOG_ERROR("Haven't got a saved mass for PDG: {}", PDG);
        MACH3LOG_ERROR("Please implement me!");
        throw MaCh3Exception(__FILE__, __LINE__);
    } // End switch
    return 0;
  }

GetOSInfo()

void M3::Utils::GetOSInfo

(

)

KS: Find out more about operational system.

Definition at line 89 of file Monitor.cpp.

                 {
// ************************
  MACH3LOG_INFO("Operating System Information:");
 
  // Distribution and version
  MACH3LOG_INFO("Distribution: {}", TerminalToString("lsb_release -d | awk -F':' '{print $2}'"));
  MACH3LOG_INFO("Kernel Version: {}", TerminalToString("uname -r"));
}

getValue()

int M3::Utils::getValue

(

const std::string &

Type

)

CW: Get info like RAM.

Parameters

Type	The type of system information to retrieve (e.g., RAM, CPU usage).

Returns

The requested system information as an integer.

This function fetches system information like RAM usage or other hardware details based on the specified type.

Definition at line 252 of file Monitor.cpp.

                                    { //Note: this value is in KB!
// ***************************************************************************
  std::ifstream file("/proc/self/status");
  int result = -1;
  std::string line;
 
  if (Type == "VmSize")
  {
    while (std::getline(file, line))
    {
      if (line.compare(0, 7, "VmSize:") == 0)
      {
        result = parseLine(line.substr(7));
        break;
      }
    }
  }
  else if (Type == "VmRSS")
  {
    while (std::getline(file, line))
    {
      if (line.compare(0, 6, "VmRSS:") == 0)
      {
        result = parseLine(line.substr(6));
        break;
      }
    }
  }
  else if (Type == "MemTotal")
  {
    std::ifstream meminfo("/proc/meminfo");
    while (std::getline(meminfo, line))
    {
      if (line.find("MemTotal:") != std::string::npos) {
        result = parseLine(line.substr(9));
        break;
      }
    }
  }
  else
  {
    MACH3LOG_ERROR("Not supported getValue: {}", Type);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
  return result;
}

MaCh3Usage()

void M3::Utils::MaCh3Usage	(	int	argc,
		char **	argv
	)

KS: Almost all MaCh3 executables have the same usage, prepare simple printer.

Parameters

argc	The number of command-line arguments.
argv	The array of command-line arguments.

This function prints a simple usage guide for MaCh3 executables, typically called when incorrect arguments are passed.

Definition at line 360 of file Monitor.cpp.

                                       {
// ***************************************************************************
  if (argc != 2) {
    MACH3LOG_ERROR("Wrong usage of MaCh3 executable!");
    MACH3LOG_ERROR("Syntax is $: {} config.yaml", argv[0]);
    MACH3LOG_ERROR("Where config.yaml is a valid config file, compatible with the manager class (manager/manager.cpp/h)");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
}

MaCh3Welcome()

void M3::Utils::MaCh3Welcome

(

)

KS: Prints welcome message with MaCh3 logo.

Definition at line 13 of file Monitor.cpp.

                    {
// *************************
  // KS: Just make sure we only call it once
  static bool MaCh3WelcomeInitialised = false;
 
  if(MaCh3WelcomeInitialised) return;
 
  std::string MaCh3_VERSION = GetMaCh3Version();
 
  MACH3LOG_INFO("##################################");
  MACH3LOG_INFO("Welcome to:  ");
  MACH3LOG_INFO("  __  __        _____ _     ____  ");
  MACH3LOG_INFO(" |  \\/  |      / ____| |   |___ \\ ");
  MACH3LOG_INFO(" | \\  / | __ _| |    | |__   __) |");
  MACH3LOG_INFO(" | |\\/| |/ _` | |    | '_ \\ |__ < ");
  MACH3LOG_INFO(" | |  | | (_| | |____| | | |___) |");
  MACH3LOG_INFO(" |_|  |_|\\__,_|\\_____|_| |_|____/ ");
  MACH3LOG_INFO("Version: {}", MaCh3_VERSION);
  MACH3LOG_INFO("##################################");
 
  GetCPUInfo();
 
  GetGPUInfo();
 
  #ifdef MACH3_DEBUG
  GetOSInfo();
  GetDiskUsage();
  #endif
 
  MaCh3WelcomeInitialised = true;
}

NThreadsSanity()

void M3::Utils::NThreadsSanity

(

)

KS: Check if user is not using huge number of threads and throw error.

Definition at line 123 of file Monitor.cpp.

                      {
// ************************
  //KS: If OMP_NUM_THREADS is exported, assume user did this on purpose
  if (std::getenv("OMP_NUM_THREADS") != nullptr) return;
 
  const int nThreads = M3::GetNThreads();
  constexpr int MaxAllowedThreads = 16;
  constexpr int RecommendedThreads = 8;
 
  if (nThreads > MaxAllowedThreads) {
    MACH3LOG_CRITICAL("You specified more than {} threads ({})", MaxAllowedThreads, nThreads);
    MACH3LOG_CRITICAL("With so many threads code will be slower, please use:");
    MACH3LOG_CRITICAL("export OMP_NUM_THREADS={}", RecommendedThreads);
    MACH3LOG_CRITICAL("To use different number of threads");
    throw MaCh3Exception(__FILE__, __LINE__, "Too many threads");
  }
}

parseLine()

int M3::Utils::parseLine

(

const std::string &

line

)

CW: Get memory, which is probably silly.

Parameters

line	The line of text to parse.

Returns

The extracted memory value as an integer.

This function is used to parse a line of text and extract memory-related information.

Definition at line 301 of file Monitor.cpp.

                                    {
// ***************************************************************************
  std::istringstream iss(line);
  int value;
  iss >> value;
  return value;
}

PDGToNuOscillatorFlavour()

int M3::Utils::PDGToNuOscillatorFlavour ( const int  NuPdg )

inline

Convert from PDG flavour to NuOscillator type beware that in the case of anti-neutrinos the NuOscillator type simply gets multiplied by -1.

Definition at line 805 of file SampleStructs.h.

                                                       {
    int NuOscillatorFlavour = M3::_BAD_INT_;
    switch(std::abs(NuPdg)){
      case NuPDG::kNue:
        NuOscillatorFlavour = NuOscillator::kElectron;
        break;
      case NuPDG::kNumu:
        NuOscillatorFlavour = NuOscillator::kMuon;
        break;
      case NuPDG::kNutau:
        NuOscillatorFlavour = NuOscillator::kTau;
        break;
      default:
        MACH3LOG_ERROR("Unknown Neutrino PDG {}, cannot convert to NuOscillator type", NuPdg);
        break;
    }
 
    //This is very cheeky but if the PDG is negative then multiply the PDG by -1
    // This is consistent with the treatment that NuOscillator expects as enums only
    // exist for the generic matter flavour and not the anti-matter version
    if(NuPdg < 0){NuOscillatorFlavour *= -1;}
 
    return NuOscillatorFlavour;
  }

Print()

void M3::Utils::Print

(

const TTree *

tree

)

Parameters

tree	content of TTree using logger

Definition at line 326 of file Monitor.cpp.

                              {
// ***************************************************************************
  if (!tree) return;
 
  // Create a temporary file to capture stdout
  FILE* tmpFile = tmpfile();
  if (!tmpFile) return;
 
  // Save old stdout
  int oldStdout = dup(fileno(stdout));
  // Redirect stdout to tmpFile
  dup2(fileno(tmpFile), fileno(stdout));
 
  tree->Print();  // ROOT writes to stdout
 
  fflush(stdout);
  // Restore old stdout
  dup2(oldStdout, fileno(stdout));
  close(oldStdout);
 
  // Read tmpFile content
  fseek(tmpFile, 0, SEEK_SET);
  char buffer[1024];
  while (fgets(buffer, sizeof(buffer), tmpFile)) {
    std::string line(buffer);
    if (!line.empty() && line.back() == '\n') line.pop_back();
    MACH3LOG_INFO("{}", line);
  }
 
  fclose(tmpFile);
}

PrintConfig()

void M3::Utils::PrintConfig

(

const YAML::Node &

node

)

KS: Print Yaml config using logger.

Parameters

node	yaml config node

Definition at line 311 of file Monitor.cpp.

                                      {
// ***************************************************************************
  std::stringstream ss;
  ss << node;
  std::string yamlString = ss.str();
 
  std::istringstream iss(yamlString);
  std::string line;
  while (std::getline(iss, line)) {
    MACH3LOG_INFO("{}", line);
  }
}

PrintProgressBar()

void M3::Utils::PrintProgressBar	(	const Long64_t	Done,
		const Long64_t	All
	)

KS: Simply print progress bar.

Parameters

Done	The number of tasks completed.
All	The total number of tasks.

This function prints a progress bar to the terminal, indicating the percentage of tasks completed.

Definition at line 229 of file Monitor.cpp.

                                                               {
// ************************
  double progress = double(Done)/double(All);
  const int barWidth = 20;
  std::ostringstream progressBar;
 
  progressBar << "[";
  int pos = int(barWidth * progress);
  for (int i = 0; i < barWidth; ++i) {
    if (i < pos)
      progressBar << "=";
    else if (i == pos)
      progressBar << ">";
    else
      progressBar << " ";
  }
 
  progressBar << "] " << std::setw(3) << Done <<"/"<< All<<" ("<<static_cast<int>(progress * 100.0)<<"%)\r";
  MACH3LOG_INFO("{}", progressBar.str());
}

TerminalToString()

std::string M3::Utils::TerminalToString

(

std::string

cmd

)

KS: Convoluted code to grab output from terminal to string.

Parameters

cmd	The terminal command to execute.

Returns

The output of the terminal command as a string.

Definition at line 187 of file Monitor.cpp.

                                          {
// ************************
  std::array<char, 128> buffer;
  std::string result;
  
  struct PCloseDeleter {
    void operator()(FILE* f) const {
      if (f) pclose(f);
    }
  };
  std::unique_ptr<FILE, PCloseDeleter> pipe(popen(cmd.c_str(), "r"));
 
  if (!pipe) {
    throw MaCh3Exception(__FILE__, __LINE__, "popen() failed!");
  }
  while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
    result += buffer.data();
  }
  // Remove trailing newline characters
  result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
  return result;
}