CepsParallelTools.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/CepsParallelTools.hpp"
#include "common/core/CepsFlags.hpp"
#include "common/core/CepsException.hpp"
#include "common/abstract/CepsObject.hpp"
#include "common/core/CepsMemory.hpp"
#include "common/core/CepsIoMacros.hpp"
#include "common/toolbox/CepsString.hpp"
 
#include <fstream>
#include <regex>
#include <unistd.h>
 
CepsUInt 
ceps::initialize(int argc, char* argv[])
{
  CepsUInt err = 0U;
  #ifdef CEPS_USE_PETSC
    // This call is to make Petsc Quiet about extra options... that CEPS uses!
    PetscOptionsSetValue(PETSC_NULL,"-options_left","0");
    // PetscOptionsSetValue(PETSC_NULL,"-ksp_converged_reason",PETSC_NULL);
    // PetscOptionsSetValue(PETSC_NULL,"-on_error_attach_debugger",PETSC_NULL);
    // PetscOptionsSetValue(PETSC_NULL,"-objects_dump",PETSC_NULL);
    // err = PetscInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);
    //  Tell Petsc to still shut up if option -v is in command line
    err = PetscInitialize(0, 0, 0, 0);
  #else
    MPI_Init(&argc, &argv);
  #endif
 
  std::set_terminate(ceps::finalizeWithError);
 
  flags = ceps::getNew<Flags>(argc,argv);
 
  if (ceps::isVerbose())
  {
    std::cout << std::endl;
    std::cout << CepsString(CEPS_SEPARATOR_LENGTH+3, '=') << std::endl;
    CepsString toWrite  = " CEPS : Cardiac ElectroPhysiology Simulator";
    CepsInt    length   = std::max(0,CEPS_SEPARATOR_LENGTH+2-CepsInt(toWrite.length()));
    std::cout << toWrite << std::setw(length) << std::right << ",d88b.d88b," << std::endl;
    toWrite = " (" + CepsString(CEPS_GIT_HASH) + ")";
    length  =  std::max(0,CEPS_SEPARATOR_LENGTH+2-CepsInt(toWrite.length()));
    std::cout << toWrite << std::setw(length) << std::right << "88888888888" << std::endl;
    toWrite = " ";
    length  =  std::max(0,CEPS_SEPARATOR_LENGTH+2-CepsInt(toWrite.length()));
    std::cout << toWrite << std::setw(length) << std::right << "`Y8888888Y'" << std::endl;
    toWrite = " Running with " + ceps::toString(ceps::getGridSize()) + " core(s) on";
    length  =  std::max(0,CEPS_SEPARATOR_LENGTH+2-CepsInt(toWrite.length()));
    std::cout << toWrite << std::setw(length) << std::right <<   "`Y888Y'  " << std::endl;
    CepsChar hn[1024];
    gethostname(hn, 1024);
    toWrite = " " + CepsString(hn);
    length  =  std::max(0,CEPS_SEPARATOR_LENGTH+2-CepsInt(toWrite.length()));
    std::cout << toWrite << std::setw(length) << std::right <<     "`Y'    " << std::endl;
    #ifdef CEPS_DEBUG_ENABLED
      std::cout << std::endl;
      std::cout << " CEPS was compiled in Debug mode." << std::endl;
      std::cout << " Debug information can be found in file: " << flags->getDebugLogName() << std::endl;
    #endif
    if (ceps::isProfiling())
    {
      std::cout << std::endl;
      std::cout << " Profiling is ON." << std::endl;
      std::cout << " Profiling information can be found in file: " << flags->getProfilingLogName() << std::endl;
    }
    std::cout << CepsString(CEPS_SEPARATOR_LENGTH+3, '=') << std::endl;
  }
 
  // Force call to finalize when quitting
  std::atexit(&ceps::finalize);
 
  return err;
}
 
void
ceps::finalize()
{
  if (ceps::isVerbose())
  {
    std::cout << CepsString(CEPS_SEPARATOR_LENGTH+3,'=') << std::endl;
    std::cout << " Computation done, see you soon !" << std::endl;
    std::cout << CepsString(CEPS_SEPARATOR_LENGTH+3,'=') << std::endl;
  }
  ceps::destroyObject(flags);
  #ifdef CEPS_USE_PETSC
    PetscFinalize();
  #else
    MPI_Finalize();
  #endif
  return;
}
 
void
ceps::finalizeWithError()
{
 
  std::exception_ptr eptr = std::current_exception();
  try
  {
    if (eptr)
      std::rethrow_exception(eptr);
  }
  catch (const CepsException& e)
  {
    if (ceps::isMaster())
    {
      std::cerr << e.errorMessage() << std::endl;
      #ifdef CEPS_DEBUG_ENABLED
        ceps::debugLog() << e.errorMessage(false) << std::endl;
      #endif
    }
    // Insert breakpoint here for debug of CEPS_ABORT messages
  }
  catch (...)
  {
    if (ceps::isMaster())
      std::cerr << "<!> Wrong termination <!>" << std::endl;
  }
  if (not flags->testing())
    MPI_Abort(ceps::getCommunicator(),EXIT_FAILURE);
 
}
 
CepsUInt
ceps::getRank()
{
  int rank;
  #ifdef CEPS_USE_PETSC
    MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
  #else
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  #endif
  return (CepsUInt) rank;
}
 
CepsUInt
ceps::getGridSize()
{
  int gridSize;
  #ifdef CEPS_USE_PETSC
    MPI_Comm_size(PETSC_COMM_WORLD,&gridSize);
  #else
    MPI_Comm_size(MPI_COMM_WORLD  ,&gridSize);
  #endif
  return (CepsUInt)gridSize;
}
 
CepsBool
ceps::isMaster()
{
  return (getRank() == CEPS_MASTER_PROC);
}
 
CepsBool
ceps::isLast()
{
  return (getRank() == (getGridSize()-1));
}
 
CepsBool 
ceps::isParallel()
{
  // true if we have more than 1 processor running
  return (getGridSize() > 1);
}
 
void
ceps::barrier()
{
  #ifdef CEPS_USE_PETSC
    PetscBarrier(PETSC_NULL);
  #else
    MPI_Barrier(MPI_COMM_WORLD);
  #endif
}
 
void 
ceps::beginSequential()
{
  if (ceps::isMaster())
    std::cout << "Begin Round Robin (sequential block)" << std::endl;
 
  #ifdef CEPS_USE_PETSC
    PetscSequentialPhaseBegin(PETSC_COMM_WORLD,1);
  #else
    barrier();
    CepsUInt i, rank = getRank();
    for (i=0; i<rank; i++)
      barrier();
  #endif
}
 
void 
ceps::endSequential()
{
  #ifdef CEPS_USE_PETSC
    PetscSequentialPhaseEnd(PETSC_COMM_WORLD,1);
  #else
    CepsUInt i, nbProc = getGridSize ();
    for (i=getRank(); i<nbProc; i++)
      barrier();
  #endif
 
  barrier();
  if (getRank()==getGridSize()-1)
    std::cout << std::endl << "End Round Robin" << std::endl << std::endl;
}
 
MPI_Comm 
ceps::getCommunicator()
{
  return *ceps::getPtrCommunicator();
}
 
MPI_Comm* 
ceps::getPtrCommunicator()
{
  #ifdef CEPS_USE_PETSC
    return &PETSC_COMM_WORLD;
  #else
    return &MPI_COMM_WORLD;
  #endif
}
 
CepsString
ceps::execute(CepsString command, CepsBool withErr, CepsBool abortOnErr)
{
  CepsString output;
 
  if (withErr)
    command += CepsString(" 2>&1");
 
  // Reading from popen file output
  const int bufsize=128;
  std::array<char, bufsize> buffer;
  auto pipe = popen(command.c_str(),"r");
 
  int notOkExec = 0;
 
  if (pipe)
  {
    size_t count;
    do
    {
      if ((count = fread(buffer.data(),1,bufsize,pipe))>0)
        output.insert(output.end(),std::begin(buffer),std::next(std::begin(buffer),count));
    } while(count > 0);
    notOkExec = pclose(pipe);
  }
  if (not pipe or notOkExec)
  {
    CEPS_ABORT_IF(abortOnErr,
      "Failed system call:\n     " + command
    );
  }
  return output;
}