CepsFlags.cpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS 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.
 
   CEPS 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 CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "common/core/CepsFlags.hpp"
#include "common/core/CepsIoMacros.hpp"
 
#include <sys/types.h>  //*nix only !
#include <unistd.h>
#include <iomanip>
#include <ctime>
#include <csignal>
 
Flags::Flags(int argc, CepsChar** argv) :
    m_profiling(false),
    m_verbose  (false),
    m_warnings (false),
    m_testing  (false)
{
  #ifdef CEPS_DEBUG_ENABLED
    enableDebug();
  #endif
 
  int optionChar;
  optind = 1;
  while ((optionChar=getopt(argc,argv,"vqwph"))!=EOF)
  {
    switch (optionChar)
    {
      case 'p':
      {
        enableProfiling();
        break;
      }
      case 'v': 
        m_verbose = true; 
        break;
      case 'q': 
        m_verbose = false; 
        break;
      case 'w': 
        enableWarnings(); 
        break;
      case 'h': 
      case '?':
      default: 
        printHelp(argv);
        exit(EXIT_SUCCESS);
    }
  }
}
 
void
Flags::setVerbose(CepsBool v)
{
  m_verbose = v;
}
 
void
Flags::enableDebug()
{
  auto now = std::time(nullptr);
  auto tm  = *std::localtime(&now);
 
  if (m_debugLog.is_open())
    return;
 
  if (ceps::isMaster())
  {
    std::stringstream ss;
    ss << "debug_" << getpid() << ".log";
    m_debugLogName = ss.str();
    m_debugLog.open(m_debugLogName.c_str());
 
    m_debugLog << std::string(77, '-') << std::endl;
    m_debugLog << " Debug log file opened at " << std::put_time(&tm,"%d-%m-%Y %H-%M-%S")
               << std::endl;
    m_debugLog << std::string(77, '-') << std::endl;
  }
}
 
void
Flags::enableProfiling()
{
  auto now = std::time(nullptr);
  auto tm  = *std::localtime(&now);
 
  if (m_profiling)
    return;
 
  m_profiling = true;
 
  if (ceps::isMaster())
  {
    std::stringstream ss;
    ss << "profiling_" << getpid() << ".log";
    m_profilingLogName = ss.str();
    m_profilingLog.open(m_profilingLogName.c_str ());
    m_profilingLog << "# " << std::string(77, '-') << std::endl;
    m_profilingLog << "#  Profiling log file opened at " << std::put_time(&tm, "%d-%m-%Y %H-%M-%S")
                   << std::endl;
    m_profilingLog << "# " << std::string(77, '-') << std::endl;
  }
}
 
void
Flags::enableTesting()
{
  m_testing = true;
}
 
void
Flags::disableTesting()
{
  m_testing = true;
}
 
void
Flags::enableWarnings()
{
  m_warnings = true;
}
 
void
Flags::disableWarnings()
{
  m_warnings = false;
}
 
Flags::~Flags()
{
  auto now = std::time(nullptr);
  auto tm  = *std::localtime(&now);
 
  m_debugLog << std::string(77, '-') << std::endl;
  m_debugLog << " Debug log file closed at " << std::put_time(&tm,"%d-%m-%Y %H-%M-%S")
             << std::endl;
  m_debugLog << std::string(77, '-') << std::endl;
 
  if (m_profiling and ceps::isMaster())
  {
    if (m_verbose)
    {
      getProfiler()->display();
      std::cout << CepsString(77,'=') << std::endl;
    }
    getProfiler()->display(m_profilingLog);
 
 
    m_profilingLog << "# " << std::string(77, '-') << std::endl;
    m_profilingLog << "#  Profiling log file closed at " << std::put_time(&tm,"%d-%m-%Y %H-%M-%S")
                   << std::endl;
    m_profilingLog << "# " << std::string(77, '-') << std::endl;
  }
}
 
CepsBool
Flags::profiling() const
{
  return m_profiling;
}
 
CepsBool
Flags::testing() const
{
  return m_testing;
}
 
CepsBool
Flags::verbose() const
{
  return m_verbose;
}
 
CepsBool
Flags::warnings() const
{
  return m_warnings;
}
 
void
Flags::printHelp(CepsChar** argv)
{
  std::cout << " Usage:\n " << argv[0] << " <paramFile>" << std::endl;
  std::cout << std::string(77, '-') << std::endl;
  std::cout << " Options :" << std::endl
            << "  -v       verbose mode, prints stuff on screen" << std::endl
            << "  -q       quiet, no output on stdout (default)" << std::endl
            << "  -w       prints all warnings" << std::endl
            << "  -p       profiling mode, writes a profiling_XXXX.log file" << std::endl
            << "  -h       prints this help and quits" << std::endl;
  std::cout << std::string(77, '-') << std::endl;
}
 
CepsString
Flags::getDebugLogName() const
{
  return m_debugLogName;
}
 
CepsString
Flags::getProfilingLogName() const
{
  return m_profilingLogName;
}
 
std::ofstream&
Flags::getDebugLog()
{
  return m_debugLog;
}
 
std::ofstream&
Flags::getProfilingLog()
{
  return m_profilingLog;
}
 
std::ofstream&
ceps::debugLog()
{
  return flags->getDebugLog();
}
 
std::ofstream&
ceps::profilingLog()
{
  return flags->getProfilingLog();
}
 
CepsBool
ceps::isProfiling()
{
  return flags->profiling();
}
 
CepsBool
ceps::isVerbose()
{
  return ceps::isMaster() and flags->verbose();
}
 
CepsBool
ceps::isWarnings()
{
  return ceps::isMaster() and flags->warnings();
}
 
CepsBool
ceps::isDebug()
{
  #ifdef CEPS_DEBUG_ENABLED
    return ceps::isMaster();
  #else
    return false;
  #endif
}
 
void
ceps::disableAbortOnError()
{
  flags->enableTesting();
}
 
void
ceps::enableAbortOnError()
{
  flags->disableTesting();
}