Global.H

Go to the documentation of this file.

#ifndef _GLOBAL_H_
#define _GLOBAL_H_

#include "ComLine.H"
#include "UnixUtils.H"
#include "primitive_utilities.H"

namespace ix {

  namespace global {
    template<typename StackType,typename ErrorType,typename ProfilerType>
    class GlobalObj {
    private:

      unsigned char _debug_level;

      unsigned char _log_level;

      unsigned char _verb_level;

      std::list< StackType > _Stack;

      std::list< ErrorType > _Errors;
    
      bool _initd;

    protected:
      std::ostream          *_DebugStream;
      std::ostream          *_OutStream;
      std::ostream          *_LogStream;
      std::ostream          *_ErrStream;
      ProfilerType           *_Profiler;
    private:
      bool                   _profiling_enabled;
      bool                   _profiler_mine;
      bool                   _write_profiles;
      std::string            _name;
      std::ostream          *_OutStreamSave;
      std::ostream          *_ErrStreamSave;
      std::ostream          *_DebugStreamSave;
    public:

      GlobalObj() : _debug_level(0), _log_level(0), _verb_level(1),
                    _DebugStream(NULL), 
                    _OutStream(&std::cout), _LogStream(NULL),
                    _ErrStream(&std::cerr),_Profiler(NULL),
                    _profiling_enabled(false),_profiler_mine(false),_write_profiles(true), 
                    _name(""), _OutStreamSave(NULL), _ErrStreamSave(NULL),
                    _DebugStreamSave(NULL)
      {
        //      _Stack.push_back("main");
        //      std::cout << "default constr" << std::endl;
      };
    
      GlobalObj(int narg,char **args) :
        _debug_level(0), _log_level(0), _verb_level(1),
        _DebugStream(NULL), 
        _OutStream(&std::cout), _LogStream(NULL),
        _ErrStream(&std::cerr),_Profiler(NULL),
        _profiling_enabled(false),_profiler_mine(false),_write_profiles(true),
        _name(""), _OutStreamSave(NULL), _ErrStreamSave(NULL),
        _DebugStreamSave(NULL)
      {
        //      std::cout << "std args constr" << std::endl;
        assert(narg > 0); // lame effort to validate command line on all procs
        Init(util::stripdirs(args[0]));
      };

      GlobalObj(GlobalObj<StackType,ErrorType,ProfilerType> &globin) :
        _debug_level(globin._debug_level), _log_level(globin._log_level),_verb_level(globin._verb_level),
        _DebugStream(globin._DebugStream), _OutStream(globin._OutStream), 
        _LogStream(globin._LogStream), _ErrStream(globin._ErrStream),
        _Profiler(globin._Profiler),_profiling_enabled(globin._profiling_enabled),
        _profiler_mine(false), _write_profiles(true),_name(globin._name), _OutStreamSave(globin._OutStreamSave),
        _ErrStreamSave(globin._ErrStreamSave), _DebugStreamSave(globin._DebugStreamSave)
      {
        //      std::cout << "copy constr" << std::endl;
        if(!globin._Stack.empty()){
          typename std::list<StackType>::iterator si = globin._Stack.begin();
          while(si != globin._Stack.end())
            _Stack.push_back(*si++);
        }
        _initd = false;
      };
    

    
      GlobalObj(const StackType &name) : _debug_level(0) , _log_level(0), _verb_level(1)
      {
        //      std::cout << "named constr" << std::endl;

        Init(name);
      };

      GlobalObj(const StackType &name,int id) : _debug_level(0), _log_level(0), _verb_level(1)
      {
        //      std::cout << "named&&numbered constr" << std::endl;
        Init(name,id);
      };

      virtual inline int Init(const StackType &name)
      {
        unsigned int id = 0;
        _debug_level = 0;
        _log_level = 0;
        _verb_level = 1;
        _name = name;
        //      _profiling_enabled = true;
        if(_Profiler && _profiler_mine)
          delete _Profiler;
        _Profiler = new ProfilerType;
        _Profiler->Init(name,id);
        _profiler_mine = true;
        _profiling_enabled = false;
        _write_profiles = true;
        //      _DebugStream = &std::cout;
        _DebugStream = &std::cout;
        _ErrStream = &std::cerr;
        _OutStream = &std::cout;
        _LogStream = NULL;
        _OutStreamSave =   _OutStream;
        _ErrStreamSave =   _ErrStream;
        _DebugStreamSave = _DebugStream;
        //      _Stack.clear();
        _Stack.push_front(name);
        _Errors.clear();
        _initd = true;
        return(0);
      };

      virtual inline int Init(const StackType &name,unsigned int id)
      {
        _name = name;
        _verb_level = 1;
        _debug_level = 0;
        _log_level = 0;
        _profiling_enabled = false;
        _write_profiles = false;
        if(_Profiler && _profiler_mine)
          delete _Profiler;
        _Profiler = new ProfilerType;
        _Profiler->Init(name,id);
        _profiler_mine = true;
        //      _DebugStream = &std::cout;
        _DebugStream = NULL;
        _OutStream = NULL;
        _ErrStream = NULL;
        _LogStream = NULL;
        if(id == 0){
          _DebugStream = &std::cout;
          _ErrStream   = &std::cerr;
          _OutStream   = &std::cout;
        }
        _OutStreamSave =   _OutStream;
        _ErrStreamSave =   _ErrStream;
        _DebugStreamSave = _DebugStream;
        //      _Stack.clear();
        _Stack.push_front(name);
        _Errors.clear();
        _initd = true;
        return(0);
      };

      virtual inline int Finalize()
      {
        int errcode = 0;
        if(_initd){
          if(_profiler_mine){
            if(_Profiler->FinalizeReady() && _Profiler)
              _Profiler->Finalize(_write_profiles);
            else if(_profiling_enabled)
              errcode = 1;
          }
          _profiling_enabled = false;
          _initd = false;
        }
        return(errcode);
      };

      virtual inline bool WriteProfiles(){
        return(_write_profiles);
      };

      virtual inline bool WriteProfiles(bool yn){
        return(_write_profiles = yn);
      };

      virtual inline bool Profiling(){
        return(_profiling_enabled);
      };

      virtual inline bool Profiling(bool yn){
        _profiling_enabled = yn;
        return(_profiling_enabled);
      };

      virtual inline void Report(std::ostream &ReportStream)
      {
        if(_Profiler){
          _Profiler->Finalize(_write_profiles);
          if(_profiling_enabled)
            _Profiler->SummarizeSerialExecution(ReportStream);
        }
      };

      virtual inline void Register(const StackType &stackentry){
        _Stack.push_front(FName()+stackentry);
        if(_debug_level > 1 && _DebugStream)
          *_DebugStream << "GlobalDebugging:Register(" << FName()+stackentry << ")" << std::endl;
      }

      virtual inline void DeRegister(const StackType &stackentry){
        _Stack.pop_front();
        if(_debug_level > 1 && _DebugStream)
          *_DebugStream << "GlobalDebugging:DeRegister(" << FName() + stackentry << ")" << std::endl;
      }

      virtual inline void FunctionEntry(const StackType &stackentry){
        _Stack.push_front(FName()+stackentry);
        if(_profiling_enabled && _Profiler)
          _Profiler->FunctionEntry(FName()+stackentry);
        if(_debug_level > 1 && _DebugStream)
          *_DebugStream << "GlobalDebugging:FunctionEntry(" << FName() + stackentry << ")" << std::endl;
      };

      virtual inline void FunctionExit(const StackType &stackentry){
        _Stack.pop_front();
        if(_profiling_enabled && _Profiler)
          _Profiler->FunctionExit(FName()+stackentry);
        if(_debug_level > 1 && _DebugStream)
          *_DebugStream << "GlobalDebugging:FunctionExit(" << FName() + stackentry << ")" << std::endl;
      };

      virtual inline void FunctionExitAll(){
    if(_Profiler)
          _Profiler->FunctionExitAll();
      };

      virtual inline void Error(const ErrorType &error){
        _Errors.push_front(error);
      };

      virtual inline void DumpErrors(std::ostream &Ostr){
        util::DumpContents(Ostr,_Errors);
      };

      virtual inline void DumpStack(std::ostream &Ostr){
        util::DumpContents(Ostr,_Stack);
      };

      virtual inline void DumpProfile(std::ostream &Ostr){
        if(_Profiler)
          _Profiler->Dump(Ostr);
      };
    
      bool DebugStreamReady() { return (_DebugStream != NULL); };

      void SetDebugStream(std::ostream &dbstream){
        _DebugStream = &dbstream;
      };

      std::ostream &DebugStream(){ assert(_DebugStream); return(*_DebugStream); };

      std::ostream *DebugStreamPtr(){ return(_DebugStream); };

      bool ErrStreamReady() { return (_ErrStream != NULL); };

      void SetErrStream(std::ostream &dbstream){
        _ErrStream = &dbstream;
      };

      std::ostream &ErrStream(){ assert(_ErrStream); return(*_ErrStream); };

      std::ostream *ErrStreamPtr(){ return(_ErrStream); };

      bool OutStreamReady() { return (_OutStream != NULL); };

      void SetOutStream(std::ostream &outstream){
        _OutStream = &outstream;
      };

      std::ostream &OutStream(){ assert(_OutStream); return(*_OutStream); };

      std::ostream *OutStreamPtr(){ return(_OutStream); };
      
      void UnsetOutStream(){ _OutStream = NULL; }; 

      bool LogStreamReady() { return (_LogStream != NULL); };

      void SetLogStream(std::ostream &logstream){
        _LogStream = &logstream;
      };

      std::ostream &LogStream(){ assert(_LogStream); return(*_LogStream); };

      std::ostream *LogStreamPtr(){ return(_LogStream); };

      void SetProfiler(ProfilerType &profiler){
        if(_profiler_mine){
          if(_profiling_enabled && _Profiler && _Profiler->FinalizeReady())
            _Profiler->Finalize();
          if(_Profiler)
            delete _Profiler;
        }
        _Profiler = &profiler;
      };
    
      virtual inline void SetName(const std::string &name) { _name = FName()+name; };
      virtual inline void ReName(const std::string &name) { _name = name; };
      virtual inline const std::string &Name(){return(_name);};
      ProfilerType &Profiler(){ assert(_Profiler); return(*_Profiler); };
    
      void SetDebugLevel(unsigned char l){  _debug_level = l; };

      unsigned char DebugLevel(){ return(_debug_level); };

      void SetVerbLevel(unsigned char l) { _verb_level = l; };

      unsigned char VerbLevel(){ return (_verb_level); };

      void SetLogLevel(unsigned char l) { _log_level = l; };

      unsigned char LogLevel(){ return (_log_level); };
    
      void DeSyncIO()
      {
        _OutStreamSave   = _OutStream;
        _ErrStreamSave   = _ErrStream;
        _DebugStreamSave = _DebugStream;
        _OutStream   = &std::cout;
        _ErrStream   = &std::cerr;
        _DebugStream = &std::cout;
      };

      void SyncIO()
      {
        _OutStream   = _OutStreamSave;      
        _ErrStream   = _ErrStreamSave;
        _DebugStream = _DebugStreamSave;
      };

      virtual inline int ForceOut(const std::string &outstr,unsigned char inlev = 1)
      {
        if(_verb_level >= inlev){
          std::string line;
          std::istringstream Istr(outstr);
          while(std::getline(Istr,line)){
            std::cout << (Name().empty() ? "" : std::string(Name()+std::string(": "))) 
                      << line;
            std::cout << (Istr.good() ? "\n" : "");
          }
          std::flush(std::cout);
        }
        else
          return(1);
        return(0);
      };

      virtual inline int StdOut(const std::string &outstr,unsigned char inlev = 1)
      {
        if(_OutStream && _verb_level >= inlev){
          std::string line;
          std::istringstream Istr(outstr);
          while(std::getline(Istr,line)){
            *_OutStream << (Name().empty() ? "" : std::string(Name()+std::string(": "))) 
                        << line;
            *_OutStream << (Istr.good() ? "\n" : "");
          }
          std::flush(*_OutStream);
        }
        else
          return(1);
        return(0);
      };

      virtual inline int ErrOut(const std::string &outstr)
      {
        if(_ErrStream){
          std::string line;
          std::istringstream Istr(outstr);
          while(std::getline(Istr,line)){
            *_ErrStream << (Name().empty() ? "" : std::string(Name()+std::string(":"))) 
                        << "Error: " << line;
            *_ErrStream << (Istr.good() ? "\n" : "");
          }
          std::flush(*_ErrStream);
        }
        else
          return(1);
        return(0);
      };
    
      virtual inline int DebugOut(const std::string &outstr,int inlev=1)
      {
        if(_DebugStream && _debug_level >= inlev){
          std::string line;
          std::istringstream Istr(outstr);
          while(std::getline(Istr,line)){
            *_DebugStream << (Name().empty() ? "" : std::string(Name()+std::string(":")))
                          << "db: " << line;
            *_DebugStream << (Istr.good() ? "\n" : "");
          }
          std::flush(*_DebugStream);
        }
        else
          return(1);
        return(0);
      };

      virtual inline int LogOut(const std::string &outstr,int inlev=0)
      {
        std::string timestring(sys::LogTime());
        if((_LogStream != NULL) && (_log_level >= inlev)){
          std::string line;
          std::istringstream Istr(outstr);
          while(std::getline(Istr,line)){
            *_LogStream << timestring 
                        << (Name().empty() ? "" : std::string(Name()+std::string(": ")))
                        << line;
            *_LogStream << (Istr.good() ? "\n" : "");
          }
          std::flush(*_LogStream);
        }
        else
          return(1);
        return(0);
      };

      virtual inline ~GlobalObj()
      { 
        if(_initd) 
          Finalize(); 
        if(_profiler_mine && _Profiler){
          delete _Profiler;
        }
      };
    private:
      std::string FName() { return((Name().empty() ? 
                                    std::string("") :
                                    std::string(Name()+std::string(":")))); };
    };
  
    template<typename CommunicatorType,typename StackType,
             typename ErrorType,typename ProfilerType>
    class ParallelGlobalObj : public GlobalObj<StackType,ErrorType,ProfilerType> 
    {
      typedef GlobalObj<StackType,ErrorType,ProfilerType> GlobalType;
    protected:
      bool profilingBarrier;
      CommunicatorType globalCommunicator;
    public:
      ParallelGlobalObj() :
        GlobalType()
      {
        profilingBarrier = false;
      };
      ParallelGlobalObj(GlobalType &inglob) :
        GlobalType(inglob)
      {
        profilingBarrier = false;
      };
      ParallelGlobalObj(ParallelGlobalObj<CommunicatorType,StackType,ErrorType,ProfilerType> &pglobin) :
        GlobalObj<StackType,ErrorType,ProfilerType>(pglobin)
      {
        globalCommunicator.Initialize(pglobin.globalCommunicator);
        profilingBarrier = false;

      };
      ParallelGlobalObj(const std::string &name) :
        GlobalObj<StackType,ErrorType,ProfilerType>(name)
      {
        //      Init(name);
        profilingBarrier = false;
        
      };
      ParallelGlobalObj(const std::string &name,unsigned int id) :
        GlobalObj<StackType,ErrorType,ProfilerType>(name,id)
      {
        //      Init(name);
        profilingBarrier = false; 
      };
      ParallelGlobalObj(int narg,char **args) :
        GlobalObj<StackType,ErrorType,ProfilerType>(narg,args)
      {
        int result = Init(narg,args);
        assert(result == 0);
        profilingBarrier = false;
        
      };
      ParallelGlobalObj(int narg,char **args,CommunicatorType &incomm) :
        GlobalObj<StackType,ErrorType,ProfilerType>(narg,args)
      {
        int result = Init(util::stripdirs(args[0]),incomm);
        assert(result == 0);
        profilingBarrier = false;
      };
      virtual inline int Init(const std::string &name,CommunicatorType &incomm)
      {
        int retval = globalCommunicator.Initialize(incomm);
        if(retval)
          return(retval);
        return(GlobalObj<StackType,ErrorType,ProfilerType>::Init(name,globalCommunicator.Rank()));
      };
      virtual inline int Init(const std::string &name)
      {
        return(GlobalObj<StackType,ErrorType,ProfilerType>::Init(name));
      };
      virtual inline int Init(const std::string &name,unsigned int id) 
      {
        return(GlobalObj<StackType,ErrorType,ProfilerType>::Init(name,id));
      };
      virtual inline int Init(int narg,char **args)
      {
        int retval = globalCommunicator.Initialize(&narg,&args);
        if(retval){
          return(retval);
        }
        return(GlobalObj<StackType,ErrorType,ProfilerType>::Init(util::stripdirs(args[0]),globalCommunicator.Rank()));
      };
      bool ProfilingBarriers(){return(profilingBarrier);};
      void EnableProfilingBarriers(){profilingBarrier = true;};
      void DisableProfilingBarriers(){profilingBarrier = false;};
      virtual inline void FunctionEntry(const StackType &stackentry){
        if(profilingBarrier)
          globalCommunicator.Barrier();
        GlobalObj<StackType,ErrorType,ProfilerType>::FunctionEntry(stackentry);
      };
      virtual inline void FunctionExit(const StackType &stackentry){
        if(profilingBarrier)
          globalCommunicator.Barrier();
        GlobalObj<StackType,ErrorType,ProfilerType>::FunctionExit(stackentry);
      };
      virtual inline int Rank()
      {
        return(globalCommunicator.Rank());
      };
      virtual inline int NProc()
      {
        return(globalCommunicator.Size());
      };
      virtual inline int Finalize()
      {
        int retval = GlobalObj<StackType,ErrorType,ProfilerType>::Finalize();
        if(retval)
          return(retval);
        return(globalCommunicator.Finalize());
      };
      virtual inline CommunicatorType &Communicator(){return globalCommunicator; };
      virtual ~ParallelGlobalObj(){ Finalize();};
    };

    template<typename GlobalType,typename ComLineType>
    class Program : public GlobalType
    {
    protected:
      ComLineType _command_line;
    public:
      Program() :
        GlobalType()
      {};
      Program(GlobalType &inglob) :
        GlobalType(inglob){};
      Program(ComLineType &incom) :
        GlobalType(),_command_line(incom)
      {};
      Program(int narg,char **args) :
        GlobalType(narg,args)
      {
        _command_line.Record((const char **)args);
        //      SetName(_command_line.ProgramName());
      };
      Program(ComLineType &incom,GlobalType &inglob) :
        GlobalType(inglob), _command_line(incom) {};
      Program(int narg,char **args,GlobalType &inglob) :
        GlobalType(inglob)
      {
        _command_line.Record((const char **)args);
        //      SetName(_command_line.ProgramName());
      };
      virtual inline int Initialize()
      {
        _command_line.Initialize();
        return(_command_line.ProcessOptions());
      };
      ComLineType &CommandLine() {return _command_line; };
      virtual inline int Run(){return(0);};
      virtual inline int Finalize(){return(GlobalType::Finalize());};
      virtual ~Program(){};
    };
  };
};
#endif