EscalationStates.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Math/UnrealMathSSE.h"
#include "Misc/AssertionMacros.h"
#include "Net/Core/Connection/StateStruct.h"
#include "Templates/EnableIf.h"
#include "Templates/Function.h"
#include "Templates/IsEnum.h"
#include "Templates/Models.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/Class.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/StructOnScope.h"
#include "UObject/UObjectGlobals.h"
 
#include "EscalationStates.generated.h"
 
class UObject;
 
 
// Defines
 
#define ESCALATION_QUOTA_DEBUG 0
 
 
// Forward declarations
class UEscalationManagerConfig;
 
namespace UE
{
    namespace Net
    {
        class FEscalationManager;
        struct FEscalationCounter;
    }
}
 
 
enum class EQuotaType : uint8
{
    EscalateQuota,      // Check quota for escalating to a higher state
    DeescalateQuota     // Check quota for de-escalating to a lower state
};
 
struct FHasHitAnyQuotaParms
{
    using FEscalationCounter = UE::Net::FEscalationCounter;
 
    const TArrayView<TArrayView<int32>>& RegisteredCounters;
 
    const TArrayView<FEscalationCounter>(&PerPeriodHistory)[16];
 
    const TArrayView<FEscalationCounter>& SecondCounters;
 
    const TArrayView<FEscalationCounter>& FrameCounters;
 
    EQuotaType QuotaType;
};
 
 
USTRUCT()
struct FEscalationState : public FStateStruct
{
    friend UE::Net::FEscalationManager;
    friend UEscalationManagerConfig;
 
    GENERATED_BODY()
 
 
protected:
    enum class EValidateTime : uint8
    {
        Optional,
        MustBeSet
    };
 
 
public:
    UPROPERTY(config)
    bool bLogEscalate               = false;
 
    UPROPERTY(config)
    bool bDormant                   = false;
 
    UPROPERTY(config)
    int16 CooloffTime               = -1;
 
    UPROPERTY(config)
    int16 AutoEscalateTime          = -1;
 
 
protected:
    UPROPERTY()
    int8 HighestTimePeriod = 0;
 
    UPROPERTY()
    TArray<int8> AllTimePeriods;
 
 
public:
    NETCORE_API bool IsDormant() const;
 
    NETCORE_API int8 GetHighestTimePeriod() const;
 
    NETCORE_API const TArray<int8>& GetAllTimePeriods() const;
 
 
protected:
    NETCORE_API virtual void ValidateConfigInternal() override;
 
    NETCORE_API void ValidateTimePeriod(int8& Value, const TCHAR* PropertyName, EValidateTime Requirement=EValidateTime::Optional);
 
 
private:
    virtual bool HasHitAnyQuota(FHasHitAnyQuotaParms Parms) const
    {
        return false;
    }
};
 
template<class T>
struct TEscalationStateStatics
{
    static inline const TCHAR* GetConfigSection()
    {
        return T::GetConfigSection();
    }
 
    static inline UClass* GetBaseConfigClass()
    {
        return T::GetBaseConfigClass();
    }
};
 
 
namespace UE
{
namespace Net
{
// Forward declarations
enum class ESeverityUpdate : uint8;
 
 
// Typedefs
 
using FNotifySeverityUpdate = TUniqueFunction<void(const FEscalationState& OldState, const FEscalationState& NewState, ESeverityUpdate UpdateType)>;
 
 
struct FEscalationCounter
{
    int32 Counter           = 0;
 
    double AccumTime        = 0.0;
 
#if ESCALATION_QUOTA_DEBUG
    double DebugAccumTime   = 0.0;
#endif
 
 
public:
    void ResetCounters()
    {
        Counter = 0;
        AccumTime = 0.0;
 
#if ESCALATION_QUOTA_DEBUG
        DebugAccumTime = 0.0;
#endif
    }
 
    void AccumulateCounter(const FEscalationCounter& InCounter)
    {
        Counter += InCounter.Counter;
        AccumTime += InCounter.AccumTime;
 
#if ESCALATION_QUOTA_DEBUG
        DebugAccumTime += InCounter.DebugAccumTime;
#endif
    }
};
 
enum class ESeverityUpdate : uint8
{
    Escalate,       // Escalating to a higher escalation state
    AutoEscalate,   // Automatic/non-quota escalation to a higher escalation state, e.g. when too much time was spent in a lower state
    Deescalate      // Deescalating to a lower escalation state
};
 
enum class EEscalateReason : uint8
{
    QuotaLimit,     // Escalation quota's were hit (followed by additional ReasonContext)
    AutoEscalate,   // Automatic escalation from a lower state, e.g. after spending too much time in a lower state
    Deescalate      // Deescalation to a lower state
};
 
enum class EEscalateResult : uint8
{
    Escalated,      // Escalated to a higher/more-severe state
    Deescalated,    // De-escalated to a lower/less-severe state
    NoChange        // No state change occurred
};
 
 
class FEscalationManager
{
    template<typename, typename, typename> friend class TEscalationManager;
    friend UEscalationManagerConfig;
 
private:
    template<typename T, typename = decltype(TBaseStructure<T>::Get())>
    class TStructOnScopeLite final : public FStructOnScope
    {
    public:
        TStructOnScopeLite(const UStruct* InScriptStruct, uint8* Data)
            : FStructOnScope(InScriptStruct, Data)
        {
            check(InScriptStruct->IsChildOf(TBaseStructure<T>::Get()));
        }
 
        T* Get() const
        {
            return reinterpret_cast<T*>(SampleStructMemory);
        }
 
        T* operator->() const
        {
            return Get();
        }
 
        explicit operator bool() const
        {
            return IsValid();
        }
 
        template<typename U>
        U* Cast()
        {
            if (GetStruct()->IsChildOf(TBaseStructure<U>::Get()))
            {
                return reinterpret_cast<U*>(SampleStructMemory);
            }
            return nullptr;
        }
 
        template<typename U>
        const U* Cast() const
        {
            return const_cast<TStructOnScopeLite*>(this)->Cast<U>();
        }
    };
 
 
    struct FEscalationManagerParms
    {
        int32 NumCounters                                                                       = 0;
        const TArrayView<TArrayView<int32>> RegisteredCountersCache                             = {};
        const UStruct* StateStruct                                                              = nullptr;
        uint8* StateMemory                                                                      = nullptr;
    };
 
    struct FEscalationManagerInitParms
    {
        const TArrayView<FEscalationCounter> FrameCounters                                      = {};
        const TArrayView<FEscalationCounter> SecondCounters                                     = {};
        const TArrayView<FEscalationCounter> CountersPerPeriodHistoryAlloc                      = {};
    };
 
 
private:
    NETCORE_API FEscalationManager(FEscalationManagerParms Parms);
 
    NETCORE_API void InitParms(FEscalationManagerInitParms Parms);
 
    FEscalationManager() = delete;
 
    NETCORE_API void InitConfig(FStateConfigParms ConfigParms);
 
    NETCORE_API EEscalateResult UpdateSeverity(ESeverityUpdate Update, EEscalateReason Reason, FString ReasonContext=TEXT(""));
 
    NETCORE_API void RecalculatePeriodHistory(const TArray<int8>& InTimePeriods, TArrayView<FEscalationCounter>(&OutPerPeriodHistory)[16],
                                    int32 StartPerSecHistoryIdx=INDEX_NONE);
 
    NETCORE_API int32 GetHighestHistoryRequirement() const;
 
    NETCORE_API void ResetAllCounters();
 
    NETCORE_API int32 AddNewCounter_Internal(int32 Count, const TArrayView<FEscalationCounter>& CountersPerPeriodAlloc);
 
public:
    FEscalationCounter& GetFrameCounter(int32 CounterIndex)
    {
        check(CounterIndex < NumCounters);
 
        return FrameCounters[CounterIndex];
    }
 
    NETCORE_API void CheckQuotas();
 
    NETCORE_API void TickRealtime(double TimeSeconds);
 
    bool DoesRequireTick() const
    {
        return !IsDormant();
    }
 
 
    // Accessors
 
    NETCORE_API bool IsDormant() const;
 
    NETCORE_API const UEscalationManagerConfig* GetBaseConfig() const;
 
    NETCORE_API void SetManagerContext(FString InManagerContext);
 
    NETCORE_API void SetNotifySeverityUpdate(FNotifySeverityUpdate&& InNotifySeverityUpdate);
 
 
private:
    const UEscalationManagerConfig* BaseConfig                                                  = nullptr;
 
    FString ManagerContext;
 
    FNotifySeverityUpdate NotifySeverityUpdate;
 
    int32 NumCounters                                                                           = 0;
 
    bool bEnabled                                                                               = false;
 
 
    TStructOnScopeLite<FEscalationState> State;
 
    int8 ActiveState                                                                            = 0;
 
    double LastMetEscalationConditions                                                          = 0.0;
 
 
    TArrayView<FEscalationCounter> FrameCounters;
 
    TArrayView<FEscalationCounter> SecondCounters;
 
    double LastPerSecQuotaBegin                                                                 = 0.0;
 
    TArray<TArrayView<FEscalationCounter>> CountersPerSecHistory;
 
    TArray<FEscalationCounter> CountersPerSecHistoryAlloc;
 
    int32 LastCountersPerSecHistoryIdx                                                          = 0;
 
    TArrayView<FEscalationCounter> CountersPerPeriodHistory[16]                                 = {};
 
 
    const TArrayView<TArrayView<int32>> RegisteredCounters;
};
 
enum EEmptyCategories : uint32
{
    Max
};
 
 
template<typename CountersEnum, typename EscalationStateType, typename CounterCategoriesEnum=EEmptyCategories>
class TEscalationManager final : public FEscalationManager
{
    static_assert(TIsEnum<CountersEnum>::Value, "CountersEnum must be an enum");
    static_assert(TIsEnum<CounterCategoriesEnum>::Value, "CounterCategoriesEnum must be an enum");
    static_assert(TIsDerivedFrom<EscalationStateType, FEscalationState>::Value, "EscalationStateType must be a subclass of FEscalationState");
 
 
    struct CHasEnumPreallocNum
    {
        template<typename T>
        auto Requires() -> decltype(
            T::NumPrealloc
        );
    };
 
    // 'typename = typename TEnableIf' does not work here, unusually
    template<typename T, typename TEnableIf<TModels_V<CHasEnumPreallocNum, T>>::Type* = nullptr>
    inline static constexpr int32 GetCounterNumPrealloc()
    {
        return FMath::Max((int32)T::NumPrealloc, (int32)T::Max);
    }
 
    template<typename T, typename TEnableIf<!TModels_V<CHasEnumPreallocNum, T>>::Type* = nullptr>
    inline static constexpr int32 GetCounterNumPrealloc()
    {
        return (int32)T::Max;
    }
 
    static constexpr int32 TNum = (int32)CountersEnum::Max;
 
    static constexpr int32 TNumPrealloc = GetCounterNumPrealloc<CountersEnum>();
 
    static constexpr int32 TNumCategories = (int32)CounterCategoriesEnum::Max;
 
 
public:
    TEscalationManager()
        : FEscalationManager(
            FEscalationManagerParms
            {
                TNum, MakeArrayView(RegisteredCountersCacheAlloc, TNumCategories),
                EscalationStateType::StaticStruct(), (uint8*)&StateAlloc //-V1050
            })
    {
        static_assert(UE_ARRAY_COUNT(CountersPerPeriodHistory) == 16,
                        "CountersPerPeriodAlloc initialization must match CountersPerPeriodHistory length");
 
        FrameCountersAlloc.SetNum(TNumPrealloc);
        SecondCountersAlloc.SetNum(TNumPrealloc);
        CountersPerPeriodAlloc.SetNum(TNumPrealloc * UE_ARRAY_COUNT(CountersPerPeriodHistory));
 
        InitParms(
            FEscalationManagerInitParms
            {
                MakeArrayView(FrameCountersAlloc.GetData(), TNum), MakeArrayView(SecondCountersAlloc.GetData(), TNum),
                MakeArrayView(CountersPerPeriodAlloc.GetData(), TNum * UE_ARRAY_COUNT(CountersPerPeriodHistory))
            });
    }
 
    void Init(FString ConfigContext)
    {
        FEscalationManager::InitConfig({TEscalationStateStatics<EscalationStateType>::GetConfigSection(), ConfigContext,
                                            TEscalationStateStatics<EscalationStateType>::GetBaseConfigClass(),
                                            EscalationStateType::StaticStruct()
                                        });
    }
 
    int32 AddNewCounter(int32 Count=1)
    {
        FrameCountersAlloc.AddDefaulted(Count);
        SecondCountersAlloc.AddDefaulted(Count);
        CountersPerPeriodAlloc.AddDefaulted(Count * UE_ARRAY_COUNT(CountersPerPeriodHistory));
 
        FrameCounters = MakeArrayView(FrameCountersAlloc);
        SecondCounters = MakeArrayView(SecondCountersAlloc);
 
        return AddNewCounter_Internal(Count, MakeArrayView(CountersPerPeriodAlloc));
    }
 
    void RegisterCounterCategory(int32 CategoryIndex, int32 CounterIndex)
    {
        check(CategoryIndex < UE_ARRAY_COUNT(RegisteredCountersAlloc));
        check(CounterIndex >= 0);
 
        TArray<int32, TInlineAllocator<TNumPrealloc>>& CurRegisteredCounters = RegisteredCountersAlloc[CategoryIndex];
    
        CurRegisteredCounters.AddUnique(CounterIndex);
        RegisteredCounters[CategoryIndex] = MakeArrayView(CurRegisteredCounters);
    }
 
private:
    EscalationStateType StateAlloc;
 
    TArray<FEscalationCounter, TInlineAllocator<TNumPrealloc>> FrameCountersAlloc;
    TArray<FEscalationCounter, TInlineAllocator<TNumPrealloc>> SecondCountersAlloc;
    TArray<FEscalationCounter, TInlineAllocator<TNumPrealloc * UE_ARRAY_COUNT(CountersPerPeriodHistory)>> CountersPerPeriodAlloc;
    TArray<int32, TInlineAllocator<TNumPrealloc>> RegisteredCountersAlloc[FMath::Max(TNumCategories, 1)];
    TArrayView<int32> RegisteredCountersCacheAlloc[FMath::Max(TNumCategories, 1)];
};
 
}
}
 
 
UCLASS(config=Engine, PerObjectConfig, MinimalAPI)
class UEscalationManagerConfig : public UStatePerObjectConfig
{
    GENERATED_BODY()
 
private:
    NETCORE_API virtual void LoadStateConfig() override;
 
 
public:
    UPROPERTY(config)
    TArray<FString> EscalationSeverity;
 
    TArray<TStructOnScope<FEscalationState>> EscalationSeverityState;
};