VulkanGPUProfiler.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    VulkanGPUProfiler.h: Vulkan Utility definitions.
=============================================================================*/
 
#pragma once
 
#include "Containers/Queue.h"
#include "GPUProfiler.h"
#include "VulkanConfiguration.h"
 
class FVulkanCommandBuffer;
class FVulkanContextCommon;
class FVulkanDevice;
 
#if (RHI_NEW_GPU_PROFILER == 0)
 
class FVulkanSyncPoint;
using FVulkanSyncPointRef = TRefCountPtr<FVulkanSyncPoint>;
 
class FVulkanGPUTiming : public FGPUTiming
{
public:
    FVulkanGPUTiming(FVulkanContextCommon* InContext, FVulkanDevice* InDevice)
        : Device(InDevice)
        , Context(InContext)
        , bIsTiming(false)
        , bEndTimestampIssued(false)
    {
    }
 
    ~FVulkanGPUTiming();
 
    void StartTiming(FVulkanContextCommon* InContext = nullptr);
 
    void EndTiming(FVulkanContextCommon* InContext = nullptr);
 
    uint64 GetTiming(bool bGetCurrentResultsAndBlock = false);
 
    void Initialize(uint32 PoolSize = 8);
 
    void Release();
 
    bool IsComplete() const
    {
        check(bEndTimestampIssued);
        return true;
    }
 
    bool IsTiming() const
    {
        return bIsTiming;
    }
 
    static void CalibrateTimers(FVulkanDevice& Device);
 
private:
 
    void DiscardOldestQuery();
 
    static void PlatformStaticInitialize(void* UserData);
 
    FVulkanDevice* Device = nullptr;
    FVulkanContextCommon* Context = nullptr;
 
    bool bIsTiming;
    bool bEndTimestampIssued;
    uint64 LastTime = 0;
 
    struct FPendingQuery
    {
        FVulkanSyncPointRef StartSyncPoint;
        uint64 StartResult = 0;
        FVulkanSyncPointRef EndSyncPoint;
        uint64 EndResult = 0;
    };
    const uint32 MaxPendingQueries = 4;
    uint32 NumPendingQueries = 0;
    TQueue<FPendingQuery*> PendingQueries;
    FPendingQuery* ActiveQuery = nullptr;
};
 
class FVulkanEventNode : public FGPUProfilerEventNode
{
public:
    FVulkanEventNode(const TCHAR* InName, FGPUProfilerEventNode* InParent, FVulkanContextCommon* InContext, FVulkanDevice* InDevice) :
        FGPUProfilerEventNode(InName, InParent),
        Timing(InContext, InDevice)
    {
        // Initialize Buffered timestamp queries 
        Timing.Initialize();
    }
 
    virtual ~FVulkanEventNode()
    {
        Timing.Release(); 
    }
 
    virtual float GetTiming() override final;
 
 
    virtual void StartTiming() override final
    {
        Timing.StartTiming();
    }
 
    virtual void StopTiming() override final
    {
        Timing.EndTiming();
    }
 
    FVulkanGPUTiming Timing;
};
 
class FVulkanEventNodeFrame : public FGPUProfilerEventNodeFrame
{
public:
 
    FVulkanEventNodeFrame(FVulkanContextCommon* InContext, FVulkanDevice* InDevice)
        : RootEventTiming(InContext, InDevice)
    {
        RootEventTiming.Initialize();
    }
 
    ~FVulkanEventNodeFrame()
    {
        RootEventTiming.Release();
    }
 
    virtual void StartFrame() override final;
 
    virtual void EndFrame() override final;
 
    virtual float GetRootTimingResults() override final;
 
    virtual bool PlatformDisablesVSync() const { return true; }
 
    FVulkanGPUTiming RootEventTiming;
};
 
struct FVulkanGPUProfiler : public FGPUProfiler
{
    TIndirectArray<FVulkanEventNodeFrame> GPUHitchEventNodeFrames;
 
    FVulkanGPUProfiler(FVulkanContextCommon* InContext, FVulkanDevice* InDevice);
 
    virtual ~FVulkanGPUProfiler();
 
    virtual FGPUProfilerEventNode* CreateEventNode(const TCHAR* InName, FGPUProfilerEventNode* InParent) override final
    {
        FVulkanEventNode* EventNode = new FVulkanEventNode(InName, InParent, CmdContext, Device);
        return EventNode;
    }
 
    void BeginFrame();
 
    void EndFrameBeforeSubmit();
    void EndFrame();
 
    bool bCommandlistSubmitted;
    FVulkanDevice* Device;
    FVulkanContextCommon* CmdContext;
 
    bool bBeginFrame;
};
 
#endif // (RHI_NEW_GPU_PROFILER == 0)