aboutsummaryrefslogblamecommitdiffstats
path: root/util/datetime/cputimer.h
blob: 7d38d5bdb38b42bd990f2f877bc8318e82acdcc8 (plain) (tree)
1
2
3
4
5
6
7
8
9
            
 
                 
                               
                                
                            
 
              
        
                           
 



                                                             
                    
               
 
       
                    



                                   
                  


                            
                     
                
 
       
                     



                                        
                      




                                  
                  











                                                                                               
                       







                               
                                  
 
                                

                        
                       
       
                                                                                        

                                
                  
                                 
                  
        
                          



                      
                                                       





                                  
      
                   
        
                    
                 
            
                     
 
       
                                                             
                   
 
                 
                               
  
#pragma once

#include "base.h"

#include <util/system/rusage.h>
#include <util/generic/string.h>
#include <util/stream/str.h>

class TTimer {
private:
    TInstant Start_;
    TStringStream Message_;

public:
    TTimer(const TStringBuf message = TStringBuf(" took: "));
    ~TTimer();
};

class TSimpleTimer {
    TInstant T;

public:
    TSimpleTimer() {
        Reset();
    }
    TDuration Get() const {
        return TInstant::Now() - T;
    }
    void Reset() {
        T = TInstant::Now();
    }
};

class TProfileTimer {
    TDuration T;

public:
    TProfileTimer() {
        Reset();
    }
    TDuration Get() const {
        return TRusage::Get().Utime - T;
    }
    TDuration Step() {
        TRusage r;
        r.Fill();
        TDuration d = r.Utime - T;
        T = r.Utime;
        return d;
    }
    void Reset() {
        T = TRusage::Get().Utime;
    }
};

/// Return cached processor cycle count per second. Method takes 1 second at first invocation.
/// Note, on older systems cycle rate may change during program lifetime,
/// so returned value may be incorrect. Modern Intel and AMD processors keep constant TSC rate.
ui64 GetCyclesPerMillisecond();
void SetCyclesPerSecond(ui64 cycles);

TDuration CyclesToDuration(ui64 cycles);
ui64 DurationToCycles(TDuration duration);

class TPrecisionTimer {
private:
    ui64 Start = 0;

public:
    TPrecisionTimer();

    ui64 GetCycleCount() const;
};

TString FormatCycles(ui64 cycles);

class TFormattedPrecisionTimer {
private:
    ui64 Start;
    const char* Message;
    IOutputStream* Out;

public:
    TFormattedPrecisionTimer(const char* message = "took ", IOutputStream* out = &Cout);
    ~TFormattedPrecisionTimer();
};

class TFuncTimer {
public:
    TFuncTimer(const char* func);
    ~TFuncTimer();

private:
    const TInstant Start_;
    const char* Func_;
};

class TFakeTimer {
public:
    inline TFakeTimer(const char* = nullptr) noexcept {
    }
};

#if defined(WITH_DEBUG)
    #define TDebugTimer TFuncTimer
#else
    #define TDebugTimer TFakeTimer
#endif

class TTimeLogger {
private:
    TString Message;
    bool Verbose;
    bool OK;
    time_t Begin;
    ui64 BeginCycles;

public:
    TTimeLogger(const TString& message, bool verbose = true);
    ~TTimeLogger();

    void SetOK();
    double ElapsedTime() const;
};