CepsProfiler.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/toolbox/CepsProfiler.hpp"
 
#include "common/core/CepsFlags.hpp"
#include "common/core/CepsMemory.hpp"
#include "common/core/CepsParallelTools.hpp"
#include "common/containers/CepsMap.hpp"
#include "common/containers/CepsVector.hpp"
 
#include <regex>
 
Profiler::Profiler() :
  m_maxLen(0)
{
}
 
Profiler::~Profiler()
{
}
 
void
Profiler::start(CepsString key, CepsString displayString)
{
  if (not m_tmpTimes.contains(key))
  {
    m_tmpTimes.insert(std::make_pair(key,clock()));
    m_seconds .insert(std::make_pair(key,0.e0));
    m_dsplStrs.insert(std::make_pair(key,displayString));
    m_maxLen = std::max(m_maxLen,CepsUInt(displayString.length()));
  }
  else
    m_tmpTimes.at(key) = clock();
  return;
}
 
void
Profiler::restart(CepsString key)
{
  m_tmpTimes.at(key) = clock();
  m_seconds .at(key) = 0.e0;
  return;
}
 
void
Profiler::stop(CepsString key)
{
  clock_t now = clock();
  m_seconds.at(key) += double(now - m_tmpTimes.at(key)) / (double) CLOCKS_PER_SEC;
  return;
}
 
void
Profiler::display(const CepsString& key, std::ostream& os) const
{
  if (ceps::isMaster())
    os << "# Time spent " << std::left << std::setw(m_maxLen+2) << m_dsplStrs.at(key) + ": "
       << std::setw(10) << m_seconds.at(key) << " seconds" << std::right << std::endl;
  return;
}
 
void
Profiler::display(const CepsString& key) const
{
  display(key,std::cout);
  return;
}
 
void
Profiler::display() const
{
  display(std::cout);
  return;
}
 
void
Profiler::display(std::ostream& os) const
{
  // Sort by time spent for better identification of costly tasks
  CepsVector<CepsReal  > seconds = ceps::valuesOf(m_seconds);
  CepsVector<CepsString> labels  = ceps::keysOf  (m_seconds);
 
  auto perm = ceps::getSortPermutation(seconds,std::greater<CepsReal>());
  ceps::applyPermutation(labels,perm);
 
  for (auto label : labels)
    display(label,os);
  return;
}
 
void
Profiler::logMemoryUsage(const CepsString& xtic)
{
  size_t l = localMemoryUsage ();
  size_t g = globalMemoryUsage ();
  if (ceps::isMaster())
    ceps::profilingLog () << xtic << " " << l << " " << g << std::endl;
  return;
}
 
void
Profiler::logMemoryUsageIf(CepsBool ifexpr, const CepsString& xtic)
{
  if (ifexpr)
    this->logMemoryUsage (xtic);
  return;
}
 
size_t
Profiler::localMemoryUsage()
{
  #ifndef LINUX
    // not implemented on other systems than linux
    return 0;
  #else
    std::ifstream fichier ("/proc/self/status");
    size_t        size = 0;
    for (CepsString line; getline (fichier, line);)
    {
      std::regex const pattern {".*VmSize:\\s+(\\d+)\\s*kB.*"};
      std::smatch      match;
      if (std::regex_match (line, match, pattern))
        size = std::stoi (match[1]);
    }
    return size;
  #endif
}
 
size_t
Profiler::globalMemoryUsage()
{
  CepsUInt globalMemorySize = 0;
  CepsUInt localMemorySize  = static_cast<CepsUInt> (localMemoryUsage());
  ceps::barrier();
  MPI_Allreduce(&localMemorySize,&globalMemorySize,1,CEPS_MPI_UINT,MPI_SUM,ceps::getCommunicator());
  return static_cast<size_t>(globalMemorySize);
}