ScopedTimers.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/UnrealString.h"
#include "Containers/StringFwd.h"
#include "CoreGlobals.h"
#include "HAL/PlatformTime.h"
#include "HAL/ThreadSafeCounter.h"
#include "Misc/OutputDeviceRedirector.h"
#include "HAL/ThreadSafeCounter64.h"
 
#include <atomic>
 
double AtomicDoubleFetchAdd(std::atomic<double>& Value, double Delta,
    std::memory_order MemoryOrder = std::memory_order_seq_cst);
 
class FDurationTimer
{
public:
    explicit FDurationTimer(double& AccumulatorIn)
        : StartTime(FPlatformTime::Seconds())
        , Accumulator(AccumulatorIn)
    {}
 
    double Start()
    {
        StartTime = FPlatformTime::Seconds();
        return StartTime;
    }
 
    double Stop()
    {
        double StopTime = FPlatformTime::Seconds();
        Accumulator += (StopTime - StartTime);
        StartTime = StopTime;
            
        return StopTime;
    }
 
protected:
    double StartTime;
    double& Accumulator;
};
 
class FScopedDurationTimer : public FDurationTimer
{
public:
    explicit FScopedDurationTimer(double& AccumulatorIn)
        : FDurationTimer(AccumulatorIn)
    {
    }
 
    ~FScopedDurationTimer()
    {
        Stop();
    }
};
 
class FAutoScopedDurationTimer : public FScopedDurationTimer
{
public:
    FAutoScopedDurationTimer()
        : FScopedDurationTimer(AccumulatorValue)
        , AccumulatorValue(0)
    {
    }
 
    double GetTime()
    {
        Stop();
        return AccumulatorValue;
    }
 
private:
    double AccumulatorValue;
};
 
 
class FDurationAtomicTimer
{
public:
    explicit FDurationAtomicTimer(std::atomic<double>& AccumulatorIn,
        std::memory_order InMemoryOrder = std::memory_order_relaxed)
        : StartTime(FPlatformTime::Seconds())
        , Accumulator(AccumulatorIn)
        , MemoryOrder(InMemoryOrder)
    {}
 
    double Start()
    {
        StartTime = FPlatformTime::Seconds();
        return StartTime;
    }
 
    double Stop()
    {
        double StopTime = FPlatformTime::Seconds();
        AtomicDoubleFetchAdd(Accumulator, StopTime - StartTime, MemoryOrder);
        StartTime = StopTime;
 
        return StopTime;
    }
 
protected:
    double StartTime;
    std::atomic<double>& Accumulator;
    std::memory_order MemoryOrder;
};
 
class FScopedDurationAtomicTimer : public FDurationAtomicTimer
{
public:
    explicit FScopedDurationAtomicTimer(std::atomic<double>& AccumulatorIn,
        std::memory_order InMemoryOrder = std::memory_order_relaxed)
        : FDurationAtomicTimer(AccumulatorIn, InMemoryOrder)
    {
    }
 
    ~FScopedDurationAtomicTimer()
    {
        Stop();
    }
};
 
template <typename ThreadSafeCounterClass>
class TScopedDurationThreadSafeTimer
{
public:
    explicit TScopedDurationThreadSafeTimer(ThreadSafeCounterClass& InCounter)
        :Counter(InCounter)
        , StartCycles(FPlatformTime::Cycles())
    {
    }
    ~TScopedDurationThreadSafeTimer()
    {
        Counter.Add(FPlatformTime::Cycles() - StartCycles);
    }
private:
    ThreadSafeCounterClass& Counter;
    int32 StartCycles;
};
 
typedef TScopedDurationThreadSafeTimer<FThreadSafeCounter>   FScopedDurationThreadSafeTimer;
typedef TScopedDurationThreadSafeTimer<FThreadSafeCounter64> FScopedDurationThreadSafeTimer64;
 
class FScopedDurationTimeLogger
{
public:
    explicit FScopedDurationTimeLogger(FString InMsg = TEXT("Scoped action"), FOutputDevice* InDevice = GLog)
        : Msg        (MoveTemp(InMsg))
        , Device     (InDevice)
        , Accumulator(0.0)
        , Timer      (Accumulator)
    {
        Timer.Start();
    }
 
    ~FScopedDurationTimeLogger()
    {
        Timer.Stop();
        Device->Logf(TEXT("%s: %f secs"), *Msg, Accumulator);
    }
 
private:
    FString        Msg;
    FOutputDevice* Device;
    double         Accumulator;
    FDurationTimer Timer;
};
 
class FScopedSwitchedDurationTimer
{
public:
    explicit FScopedSwitchedDurationTimer(double& AccumulatorIn, bool bDoFunctionalityIn)
        : StartTime(bDoFunctionalityIn ? FPlatformTime::Seconds() : 0)
        , Accumulator(AccumulatorIn)
        , bDoFunctionality(bDoFunctionalityIn)
    {
    }
 
    ~FScopedSwitchedDurationTimer()
    {
        if (bDoFunctionality)
        {
            Accumulator += (FPlatformTime::Seconds() - StartTime);
        }
    }
 
    double Start()
    {
        StartTime = FPlatformTime::Seconds();
        return StartTime;
    }
 
protected:
    double StartTime;
    double& Accumulator;
    const bool bDoFunctionality;
};
 
class FScopedSwitchedCountedDurationTimer : FScopedSwitchedDurationTimer
{
public:
    explicit FScopedSwitchedCountedDurationTimer(double& TimeAccumulatorIn, int32& CountAccumlatorIn, bool bDoFunctionalityIn)
        : FScopedSwitchedDurationTimer(TimeAccumulatorIn, bDoFunctionalityIn)
    {
        if (bDoFunctionalityIn)
        {
            ++CountAccumlatorIn;
        }
    }
};
 
template<class Func>
class FScopedDurationTimeCustomLogger
{
public:
    explicit FScopedDurationTimeCustomLogger(const TCHAR* InTitle, double& InTotalTime, Func InLogFunc)
        : Title(InTitle)
        , LogFunc(InLogFunc)
        , LocalTime(-FPlatformTime::Seconds())
        , TotalTime(InTotalTime)
    {
        LogFunc(*FString::Printf(TEXT("%s started..."), InTitle));
    }
 
    ~FScopedDurationTimeCustomLogger()
    {
        LocalTime += FPlatformTime::Seconds();
        TotalTime += LocalTime;
 
        TStringBuilder<1024> Msg;
        Msg.Appendf(TEXT("%s took %s"), *Title, *FPlatformTime::PrettyTime(LocalTime));
 
        if (TotalTime > LocalTime)
        {
            Msg.Appendf(TEXT(" (total: %s)"), *FPlatformTime::PrettyTime(TotalTime));
        }
 
        LogFunc(*Msg);
    }
 
private:
    FString Title;
    Func LogFunc;
    double LocalTime;
    double& TotalTime;
};
 
 
inline double AtomicDoubleFetchAdd(std::atomic<double>& Value, double Delta,
    std::memory_order MemoryOrder)
{
    double Expected = Value.load(std::memory_order_relaxed);
    double Desired;
    std::memory_order ReadModifyWriteMemoryOrder =
        MemoryOrder == std::memory_order_relaxed ? std::memory_order_relaxed
        : MemoryOrder == std::memory_order_acq_rel ? std::memory_order_acq_rel
        : std::memory_order_seq_cst;
 
    bool bExchangeSucceeded = false;
    do
    {
        Desired = Expected + Delta;
        bExchangeSucceeded = Value.compare_exchange_weak(Expected, Desired,
            /* success order */ ReadModifyWriteMemoryOrder,
            /* failure order */ std::memory_order_relaxed);
    } while (!bExchangeSucceeded);
 
    return Expected;
}
 
#if NO_LOGGING
#define UE_SCOPED_TIMER(Title, Category, Verbosity)
#else
#define UE_SCOPED_TIMER(Title, Category, Verbosity) \
    static double UE_SCOPED_TIMER_COMBINE(ScopedTimerTotal_,__LINE__) = 0.0; FScopedDurationTimeCustomLogger UE_SCOPED_TIMER_COMBINE(ScopedTimer_,__LINE__)(Title, UE_SCOPED_TIMER_COMBINE(ScopedTimerTotal_,__LINE__), [](const TCHAR* Msg) { UE_LOG(Category, Verbosity, TEXT("%s"), Msg) })
 
#define UE_SCOPED_TIMER_COMBINE_INNER(A,B) A##B
#define UE_SCOPED_TIMER_COMBINE(A,B) UE_SCOPED_TIMER_COMBINE_INNER(A,B)
#endif