logger.h

Go to the documentation of this file.

#pragma once

#include <sys/time.h>
#include <map>
#include <string>
#include <iostream>


typedef std::map<std::string, double> Event;


typedef std::map<std::string, double>::iterator E_iter;


class Logger
{
private:
    std::ofstream file,        
                  stepFile,    
                  legendFile;  
    Event tic,       
          timer,     
          timeStep,  
          memory;    

    double get_time()
    {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        return double(tv.tv_sec+tv.tv_usec*1e-6);
    } // get_time

public:
    bool printNow;  

    Logger(){}
    
    Logger(std::string folder)
    {
        file.open((folder + "/time").c_str());
        stepFile.open((folder + "/profiling").c_str());
        legendFile.open((folder + "/profiling_legend").c_str());
        printNow = false;
    }

    ~Logger()
    {
        writeLegend();
        file.close();
        stepFile.close();
    }

    void startTimer(std::string event)
    {
        tic[event] = get_time();
    } // startTimer

    void stopTimer(std::string event, bool print=false)
    {
        double toc = get_time();
        timeStep[event] += toc - tic[event];
        timer[event] += toc - tic[event];
        if(print) 
            std::cout << event << " : " << timer[event] << std::endl;
    } // stopTimer

    void eraseTimer(std::string event)
    {
        timer.erase(event);
    } // eraseTimer

    void resetTimer()
    {
        for( E_iter E=timer.begin(); E!=timer.end(); ++E )
            E->second = 0;
    } // resetTimer

    void resetTimeStep()
    {
        for (E_iter E=timeStep.begin(); E!=timeStep.end(); ++E )
            E->second = 0;
    } // resetTimeStep

    void allocMemory(std::string event, double bytes)
    {
        memory[event] += bytes;
    } // allocMemory

    void freeMemory(std::string event, double bytes)
    {
        memory[event] -= bytes;
    } // freeMemory

    void printTime(std::string event)
    {
        std::cout << event << " : " << timer[event] << std::endl;
    } // printTime

    void printMemory(std::string event)
    {
        std::cout << event << " : " << memory[event] << std::endl;
    } // printMemory

    void printAllTime()
    {
        double totalTime = 0.0;
        std::cout << std::endl;
        for( E_iter E=timer.begin(); E!=timer.end(); ++E )
        {
            totalTime += E->second;
            std::cout << std::setw(24) << E->first << std::setw(13) << std::fixed \
                      << std::setprecision(4) << E->second << std::endl;
        }
        std::cout << "-------------------------------------" << std::endl;
        std::cout << std::setw(24) << "TOTAL" << std::setw(13) << std::fixed \
                  << std::setprecision(4) << totalTime << std::endl;
    } // printAllTime

    void writeLegend()
    {
        for( E_iter E=timer.begin(); E!=timer.end(); ++E )
        {
            legendFile <<  E->first << std::endl;
        }
    } // writeLegend

    void writeTime()
    {
        for( E_iter E=timer.begin(); E!=timer.end(); ++E )
            file <<  E->first << " " << E->second << std::endl;
    } // writeTime
    
    void writeTimeStep(int n)
    {
        stepFile << n << "\t";
        for ( E_iter E=timeStep.begin(); E!=timeStep.end(); ++E )
            stepFile << E->second << "\t";
        stepFile << std::endl;
    } // writeTimeStep

}; // Logger