GenericPlatformTime.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
 
#if PLATFORM_HAS_BSD_TIME 
    #include <sys/time.h> // IWYU pragma: export
#endif
 
 
struct FCPUTime
{
    FCPUTime( float InCPUTimePct, float InCPUTimePctRelative ) 
        : CPUTimePct( InCPUTimePct )
        , CPUTimePctRelative( InCPUTimePctRelative )
    {}
 
    FCPUTime& operator+=( const FCPUTime& Other )
    {
        CPUTimePct += Other.CPUTimePct;
        CPUTimePctRelative += Other.CPUTimePctRelative;
        return *this;
    }
 
    float CPUTimePct;
 
    float CPUTimePctRelative;
};
 
 
struct FGenericPlatformTime
{
#if PLATFORM_HAS_BSD_TIME 
    static CORE_API double InitTiming();
 
    static inline double Seconds()
    {
        struct timeval tv;
        gettimeofday( &tv, NULL );
        return ((double) tv.tv_sec) + (((double) tv.tv_usec) / 1000000.0);
    }
 
    static inline uint32 Cycles()
    {
        struct timeval tv;
        gettimeofday( &tv, NULL );
        return (uint32) ((((uint64)tv.tv_sec) * 1000000ULL) + (((uint64)tv.tv_usec)));
    }
    static inline uint64 Cycles64()
    {
        struct timeval tv;
        gettimeofday( &tv, NULL );
        return ((((uint64)tv.tv_sec) * 1000000ULL) + (((uint64)tv.tv_usec)));
    }
 
    static CORE_API void SystemTime( int32& Year, int32& Month, int32& DayOfWeek, int32& Day, int32& Hour, int32& Min, int32& Sec, int32& MSec );
 
    static CORE_API void UtcTime( int32& Year, int32& Month, int32& DayOfWeek, int32& Day, int32& Hour, int32& Min, int32& Sec, int32& MSec );
#endif
 
    static CORE_API TCHAR* StrDate( TCHAR* Dest, SIZE_T DestSize );
    static CORE_API TCHAR* StrTime( TCHAR* Dest, SIZE_T DestSize );
 
    static CORE_API const TCHAR* StrTimestamp();
 
    static CORE_API FString PrettyTime( double Seconds );
 
    static bool UpdateCPUTime( float DeltaTime )
    {
        return false;
    }
 
    static bool UpdateThreadCPUTime(float = 0.0)
    {
        return false;
    }
 
    static void AutoUpdateGameThreadCPUTime(double UpdateInterval)
    {
    }
 
    static FCPUTime GetCPUTime()
    {
        return FCPUTime( 0.0f, 0.0f );
    }
 
    static FCPUTime GetThreadCPUTime()
    {
        return FCPUTime(0.0f, 0.0f);
    }
 
    static double GetLastIntervalCPUTimeInSeconds()
    {
        return LastIntervalCPUTimeInSeconds;
    }
 
    static double GetLastIntervalThreadCPUTimeInSeconds()
    {
        return 0.0;
    }
 
    static double GetSecondsPerCycle()
    {
        return SecondsPerCycle;
    }
 
    static float ToMilliseconds( const uint32 Cycles )
    {
        return (float)double( SecondsPerCycle * 1000.0 * Cycles );
    }
 
    static float ToSeconds( const uint32 Cycles )
    {
        return (float)double( SecondsPerCycle * Cycles );
    }
 
 
    static double GetSecondsPerCycle64()
    {
        return SecondsPerCycle64;
    }
 
    static double ToMilliseconds64(const uint64 Cycles)
    {
        return ToSeconds64(Cycles) * 1000.0;
    }
 
    static double ToSeconds64(const uint64 Cycles)
    {
        return GetSecondsPerCycle64() * double(Cycles);
    }
 
    static uint64 SecondsToCycles64(double Seconds)
    {
        return static_cast<uint64>(Seconds / GetSecondsPerCycle64());
    }
 
protected:
 
    static CORE_API double SecondsPerCycle;
    static CORE_API double SecondsPerCycle64;
    static CORE_API double LastIntervalCPUTimeInSeconds;
};