timer.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                   Riccardo Rossi
//                   Vicente Mataix Ferrandiz
//
//
 
#if !defined(KRATOS_TIMER_H_INCLUDED )
#define  KRATOS_TIMER_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
#include <fstream>
#include <map>
#include <unordered_map>
#include <chrono>
 
// External includes
 
// Project includes
#include "includes/define.h"
 
namespace Kratos
{
 
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) Timer
{
    class TimerData
    {
        int mRepeatNumber;
        double mStartTime;
        double mTotalElapsedTime;
        double mMaximumTime;
        double mMinimumTime;
    public:
        TimerData() : mRepeatNumber(int()), mStartTime(double()), mTotalElapsedTime(double()), mMaximumTime(double()), mMinimumTime(double()) {}
        double GetStartTime()
        {
            return mStartTime;
        }
        void SetStartTime(double StartTime)
        {
            mStartTime = StartTime;
        }
        double GetTotalElapsedTime()
        {
            return mTotalElapsedTime;
        }
        void SetTotalElapsedTime(double TotalElapsedTime)
        {
            mTotalElapsedTime = TotalElapsedTime;
        }
        void Update(double StopTime)
        {
            double elapsed = StopTime - mStartTime;
            if(mRepeatNumber == 0)
                mMinimumTime = elapsed;
            mTotalElapsedTime += elapsed;
            if(mMaximumTime < elapsed)
                mMaximumTime = elapsed;
 
            if((mMinimumTime > elapsed))
                mMinimumTime = elapsed;
 
            mRepeatNumber++;
 
        }
        void PrintData(std::ostream& rOStream, double GlobalElapsedTime = -1.00) const;
    };
 
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(Timer);
 
    typedef double TimeType;
 
    typedef std::map<std::string, TimerData> ContainerType;
 
    typedef std::unordered_map<std::string, std::string> InternalNameDatabaseType;
 
    static constexpr std::size_t NumberOfZeros = 3;
 
 
    Timer();
 
    virtual ~Timer()
    {
 
    }
 
 
 
    static void Start(std::string const& rIntervalName);
 
    static void Stop(std::string const& rIntervalName);
 
    static inline double GetTime()
    {
        const auto current_time = std::chrono::steady_clock::now();
        return std::chrono::duration_cast<std::chrono::duration<double>>(current_time.time_since_epoch()).count();
    }
 
    static inline double ElapsedSeconds(const std::chrono::steady_clock::time_point StartTime)
    {
        const auto current_time = std::chrono::steady_clock::now();
        return std::chrono::duration_cast<std::chrono::duration<double>>(current_time - StartTime).count();
    }
 
 
    static int SetOuputFile(std::string const& rOutputFileName);
 
    static int CloseOuputFile();
 
    static bool GetPrintOnScreen();
 
    static void SetPrintOnScreen(bool const PrintOnScreen);
 
    static bool GetPrintIntervalInformation();
 
    static void SetPrintIntervalInformation(bool const PrintIntervalInformation);
 
 
 
    static void PrintIntervalInformation(
        std::ostream& rOStream,
        std::string const& rIntervalName,
        const double StartTime,
        const double StopTime
        );
 
    static void PrintIntervalInformation(
        std::string const& rIntervalName,
        const double StartTime,
        const double StopTime
        );
 
    static void PrintTimingInformation();
 
    static void PrintTimingInformation(std::ostream& rOStream);
 
    virtual std::string Info() const
    {
        return "Timer";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        PrintTimingInformation(rOStream);
    }
 
 
 
protected:
 
 
 
 
 
 
 
private:
 
 
    static InternalNameDatabaseType msInternalNameDatabase;        
 
    static ContainerType msTimeTable;                              
 
    static std::ofstream msOutputFile;                             
 
    static std::size_t msCounter;                                  
 
    static bool msPrintOnScreen;                                   
 
    static bool msPrintIntervalInformation;                        
 
    static const std::chrono::steady_clock::time_point mStartTime; 
 
 
 
    static std::string GetInternalName(const std::string& rName);
 
    static std::vector<std::string>& GetLabelsStackInstance()
    {
      static std::vector<std::string> instance;
      return instance;
    }
 
    static std::string CreateFullLabel(){
        const auto& r_labels_stack = GetLabelsStackInstance();
        std::string result;
        for(const auto& r_label : r_labels_stack){
        result += "/" + r_label;
        }
        return result;
    }
 
 
 
 
 
    Timer& operator=(Timer const& rOther)
    {
        return *this;
    }
 
    /*       Timer(Timer const& rOther); */
 
 
}; // Class Timer
 
 
 
 
 
//   inline std::istream& operator >> (std::istream& rIStream,
//                  Timer& rThis){}
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const Timer& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}  // namespace Kratos.
 
#endif // KRATOS_TIMER_H_INCLUDED  defined