CORE_Profiler.h

#ifndef CORE_Profiler_H
#define CORE_Profiler_H
 
#include "types.h"
#include "functions_type.h"
 
//list headers
#include <map>
#include <vector>
#include <tuple>
 
//std::cout header
#include <iostream>
 
//type of routine
typedef std::tuple<tInteger,tReal,std::vector<tWallTime>> tRoutineCall;
 
 
class CORE_Profiler   { 
    
    // ATTRIBUTES
 
public:
    static tBoolean IS_PROFILING_ROUTINE_PRINTED;
  
private:
 
#ifdef USE_PROFILER
    //routine name -> (n,total called time,vector<recursive call timers>)
    static std::map<tString,tRoutineCall> mProfiledRoutines;
#endif
    
public:
    // CONSTRUCTORS
    CORE_Profiler() {
    }
    
    // DESTRUCTORS
    virtual ~CORE_Profiler() {
    }
    
    
    
    
    inline static void StartCallRoutine(const tString& routineName) {
#ifdef USE_PROFILER
        auto iter=mProfiledRoutines.find(routineName);
        if (iter==mProfiledRoutines.end()) {
            tRoutineCall call;
            //number of call
            std::get<0>(call)=1;
            //timer
            std::get<1>(call)=0;
            //start time of the call
            std::get<2>(call).push_back(std::chrono::high_resolution_clock::now());
            if (IS_PROFILING_ROUTINE_PRINTED) {
                std::cout<<routineName<<" start called :"<<std::get<0>(call)<<" calls \n";
            }
            mProfiledRoutines[routineName]=call;
        } else {
            tRoutineCall &call=iter->second;
            std::get<0>(call)++;
            //start time of the call
            std::get<2>(call).push_back(std::chrono::high_resolution_clock::now());
            if (IS_PROFILING_ROUTINE_PRINTED) {
                std::cout<<routineName<<" start called :"<<std::get<0>(call)<<" calls \n";
            }
        }
#endif
    }//end StartCallRoutine(routineName) method
    
    inline static void EndCallRoutine(const tString& routineName) {
#ifdef USE_PROFILER
        auto iter=mProfiledRoutines.find(routineName);
        if (iter!=mProfiledRoutines.end()) {
            tRoutineCall &call=iter->second;
            //time of the end  call
            tWallTime timer=std::chrono::high_resolution_clock::now();
            tWallTime& start=std::get<2>(call).back();
            //duration of the call
            std::chrono::duration<tReal,std::milli> duration=(timer-start);
            //add the duration
            std::get<1>(call)+=duration.count();
            //remove the last calls
            std::get<2>(call).pop_back();
            if (IS_PROFILING_ROUTINE_PRINTED) {
                std::cout<<routineName<<" end called :"<<std::get<0>(call)<<" calls, duration:"<<(std::get<1>(call)/1000.0L)<<" (s) \n";
            }
        }
        
#endif
    }//end EndCallRoutine(routineName) method
    
    inline static void PrintCallRoutines(std::ostream& out) {
#ifdef USE_PROFILER
        
        out<<"Called profiles Routines : \n";
        for(const auto& routines: mProfiledRoutines) {
            out<<"\t"<<routines.first<<" : ";
            const tRoutineCall &call=routines.second;
            out<<"\t nCalls:"<<std::get<0>(call);
            out<<"\t time:"<<(std::get<1>(call)/1000.0L)<<" (s)";
            out<<"\t number of not ended calls:"<<(std::get<2>(call).size())<<"\n";
        }
        
#endif
    }//end  PrintCallRoutine(out)
 
};
#endif