PCPPProgram.H

Go to the documentation of this file.

#ifndef __PC2_PROGRAM_GLOBAL_H__
#define __PC2_PROGRAM_GLOBAL_H__

#include <cmath>
#include "PCPPTypes.H"
typedef pcpp::ConfigType        ConfigurationType;
typedef pcpp::PartitionInfoType PartitionInfoType;
typedef pcpp::CommunicatorType  CommunicatorType;

namespace pcpp {
  
  class commandline : public CommandLineType
  {
  public:
    commandline() : CommandLineType() {};
    commandline(const char *args[]) : CommandLineType(args) {};
    commandline(commandline &inComLine) : CommandLineType(inComLine) {};
    virtual void Initialize();
    void InitializeDefaults() {
      AddOption('d',"debuglevel",1);
      AddOption('h',"help");
      AddOption('v',"verblevel",1);
      AddOption('p',"enable-profiling",1);
      AddHelp('h',"Produces this long help message");
      AddHelp('d',"Set the debugging level for the program.(default=1)");
      AddHelp('p',std::string("Enable profiling. Profiling level > 1 enables profiling")+
              std::string("\n\t\tbarriers, with the following settings available:\n\t\t\t")+
              std::string("level=1 enables async profiling w/report on rank 0.\n\t\t\t")+
              std::string("level=2 enables barrier sync w/report on rank 0.\n\t\t\t")+
              std::string("level=3 enables async with output on all ranks.\n\t\t\t")+
              std::string("level=4 enables sync with output on all ranks."));
      AddHelp('v',std::string("Set the verbosity level for the program.")+
              std::string(" Anything\n\t\tlarger than 3 is debugging level.")+
              std::string("\n\t\tExamples:\n\t\t\t-v (defaults to 1)\n\t\t\t")+
              std::string("-v 0  (silence)\n\t\t\t")+
              std::string("-v 1  (default: some normal output)\n\t\t\t")+ 
              std::string("-v 2  (verbose: more than normal output)\n\t\t\t")+
              std::string("-v 3  (verbose indeed: some control flow information)\n\t\t\t")+
              std::string("-v 4  (ridiculously verbose debugging mode)\n\t\t\t")+
              std::string("-v 10 (ranks other than 0 create output logs."));
      SetDescription(std::string("This text should describe the program."));
    };
  };
  
  typedef ix::global::Program<GlobalType,commandline> SerialProgramType;
  typedef ix::global::mpiprogram<commandline> ParallelProgramType;
  
  class serialprogram : public SerialProgramType
  {
    
  public:
    serialprogram(int narg,char **args) :
      SerialProgramType(narg,args){};
    serialprogram(GlobalType &inglob) :
      SerialProgramType(inglob){};
    serialprogram(commandline &incom) :
      SerialProgramType(incom){};
    serialprogram(commandline &incom,GlobalType &inglob) :
      SerialProgramType(incom,inglob){};
    virtual int Initialize()
    {
      if(SerialProgramType::Initialize()){
        ErrOut("Failed to initialize.\n");
        ErrOut(CommandLine().ErrorReport()+std::string("\n"));
        ErrOut("Use -h,--help for usage help.\n\n");
        ErrOut(CommandLine().ShortUsage()+std::string("\n"));
        return(1);
      }
      if(!CommandLine().GetOption('h').empty()){
        StdOut(CommandLine().LongUsage());
        return(1);
      }
      // Verbosity level processing intent:
      // 0 - be silent
      // 1 - normal verbosity
      // 2 - increased verbosity
      // 3 - increased verbosity with some control flow information
      // 4+ - debug mode (with debugging logged on all processors)
      std::string sverb(CommandLine().GetOption('v'));
      if(!sverb.empty()){
        if(sverb == ".true.")
          SetVerbLevel(1);
        else {
          std::istringstream Istr(sverb);
          int verbLevel;
          Istr >> verbLevel;
          SetVerbLevel(verbLevel);
          if(verbLevel > 1){
            SetDebugStream(ErrStream());
            SetDebugLevel(verbLevel - 1);
          }
        }
      }
      // Process profiling control
      std::string sprof(CommandLine().GetOption('p'));
      if(!sprof.empty()){
        if(sprof == ".true.")
          Profiling(true);
        else {
          std::istringstream Istr(sprof);
          int profLevel;
          Istr >> profLevel;
          if(profLevel == 0)
            Profiling(false);
          if(profLevel >= 1){
            Profiling(true);
          }
        }
      }
      return(0);
    };
    virtual int Run(){return(0);};
    virtual int Finalize()
    {
      if(OutStreamReady())
        Report(OutStream());
      if(SerialProgramType::Finalize()){
        ErrOut("Failed to finalize.\n");
        DumpErrors(ErrStream());
        return(1);
      }
      return(0);
    };
    virtual ~serialprogram(){};
  };

  class parallelprogram : public ParallelProgramType
  {
  protected:
    std::string outFileName;
    int verblevel;
    std::ofstream *outFilePtr;
    int ndiv;
    int numProcessors;
    int numThreads;
  public:
    parallelprogram() :
      ParallelProgramType()
    {
      verblevel = 1;
      outFilePtr = NULL;
    };

    parallelprogram(int nargs,char **args) :
      ParallelProgramType(nargs,args)
    {
      verblevel = 1;
      outFilePtr = NULL;
    };

    parallelprogram(int nargs,char **args, MPI_Comm inMPICommunicator) :
      ParallelProgramType(nargs,args,inMPICommunicator)
    {
      verblevel = 1;
      outFilePtr = NULL;
    };

    parallelprogram(commandline &comline,CommunicatorType &incomm)
    {
      this->_command_line.Copy(comline);
      this->Init(_command_line.ProgramName(),incomm);
      verblevel = 1;
      outFilePtr = NULL;
    };

    virtual int Initialize()
    {
      if(ParallelProgramType::Initialize()){
        ErrOut("Failed to initialize.\n");
        ErrOut(CommandLine().ErrorReport()+std::string("\n"));
        ErrOut("Use -h,--help for usage help.\n\n");
        ErrOut(CommandLine().ShortUsage()+std::string("\n"));
        globalCommunicator.SetExit(1);
        if(globalCommunicator.Check())
          return(-1);
      }
      if(!CommandLine().GetOption('h').empty()){
        StdOut(CommandLine().LongUsage());
        globalCommunicator.SetExit(1);
        if(globalCommunicator.Check())
          return(1);
      }
      std::string applicationName(CommandLine().ProgramName());

      // Verbosity level processing intent:
      // 0 - be silent
      // 1 - normal verbosity
      // 2 - increased verbosity
      // 3 - debug mode engaged (debug stream engaged for root process)
      // 4+ - debug mode (with debugging logged on all processors)
      SetVerbLevel(1);
      std::string sverb(CommandLine().GetOption('v'));
      if(!sverb.empty()){
        if(sverb == ".true.")
          SetVerbLevel(1);
        else {
          int rank = Rank();
          int nproc = NProc();
          int nZeros = std::log10((double)nproc);
          std::istringstream Istr(sverb);
          int verbLevel;
          Istr >> verbLevel;
          SetVerbLevel(verbLevel);
          if(verbLevel > 9){
            if(rank > 0){
              SetVerbLevel(verbLevel - 9);
              outFilePtr = new std::ofstream;
              std::ostringstream outFileNameStream;
              outFileNameStream << applicationName << "_";
              for(int i = nZeros;i > 0;i--){
                int numRanks = std::pow((double)10,(double)i);
                if(rank < numRanks)
                  outFileNameStream << "0";
              }
              if(!ErrStreamReady())
                SetErrStream(std::cerr);
              outFileNameStream << rank;
              outFileNameStream << ".out";
              outFileName.assign(outFileNameStream.str());
              outFilePtr->open(outFileNameStream.str().c_str());
              if(!(*outFilePtr)){
                globalCommunicator.SetErr(1);
              }
            }

            if(globalCommunicator.Check()){
              if(!rank)
                ErrOut("Unable to open output on all processors.\n");
              return(-1);
            } else if(rank > 0) {
              SetOutStream(*outFilePtr);
            }
            SetDebugStream(OutStream());
            SetDebugLevel(verbLevel - 3);
            if(rank > 0)
              SetDebugLevel(verbLevel - 12);
          }
        }
      }
      // Process profiling control
      std::string sprof(CommandLine().GetOption('p'));
      Profiling(false);
      DisableProfilingBarriers();
      if(!sprof.empty()){
        if(sprof == ".true.")
          Profiling(true);
        else {
          std::istringstream Istr(sprof);
          int profLevel;
          Istr >> profLevel;
          if(profLevel == 0)
            Profiling(false);
          if(profLevel >= 1){
            Profiling(true);
            if(profLevel==2 || profLevel == 4)
              EnableProfilingBarriers();
            else
              DisableProfilingBarriers();
            if(profLevel > 2)
              WriteProfiles(true);
          }
        }
      }
      // Process profiling control
      std::string sdebug(CommandLine().GetOption('d'));
      if(!sdebug.empty()){
        if(sdebug == ".true.")
          SetDebugLevel(1);
        else {
          std::istringstream Istr(sdebug);
          int debugLevel;
          Istr >> debugLevel;
          if(debugLevel >= 1)
            SetDebugLevel(debugLevel);
        }
      }
      return(0);
    };

    virtual ~parallelprogram() {
      if(outFilePtr){
        outFilePtr->close();
        delete outFilePtr;
      }
      if(Rank() > 0)
        UnsetOutStream();
      SetOutStream(std::cout);
    };

    virtual int Run(){return(0);};
    virtual int Finalize() {
      if(OutStreamReady())
        Report(OutStream());
      if(ParallelProgramType::Finalize()){
        ErrOut("Failed to finalize.\n");
        if(ErrStreamReady())
          DumpErrors(ErrStream());
        return(1);
      }
      return(0);
    };
  };

  template<typename ProgramType>
  int MainDriver(int argc,char *argv[])
  {
    ProgramType mainProgram(argc,argv);
    if(mainProgram.Initialize()){
      return(1);
    }
    std::string programName(mainProgram.CommandLine().ProgramName());
    //  mainProgram.StdOut("Initialized\n");
    if(mainProgram.Run()){
      return(1);
    }
    //  mainProgram.StdOut("Ran\n");
    if(mainProgram.Finalize()){
      return(1);
    }
    //  mainProgram.StdOut("Finalized\n");
    return(0);
  }
}
#endif