MetalCommandQueue.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MetalRHIPrivate.h"
#include "MetalSubmission.h"
#include "RHI.h"
#include "RHIFeatureLevel.h"
#include "Containers/LockFreeList.h"
 
class FMetalCommandBuffer;
class FMetalCommandList;
class FMetalFence;
class FMetalDevice;
struct FMetalCounterSample;
struct FMetalBreadcrumbEvent;
class FMetalEventNode;
 
#if RHI_NEW_GPU_PROFILER
class FMetalTiming
{
public:
    FMetalCommandQueue& Queue;
 
    // Timer calibration data
    uint64 GPUFrequency = 0, GPUTimestamp = 0;
    uint64 CPUFrequency = 0, CPUTimestamp = 0;
 
    UE::RHI::GPUProfiler::FEventStream EventStream;
 
    FMetalTiming(FMetalCommandQueue& Queue);
};
#endif
 
class FMetalCommandQueue
{
public:
#pragma mark - Public C++ Boilerplate -
 
    FMetalCommandQueue(FMetalDevice& Device, uint32 const MaxNumCommandBuffers = 0);
    
    ~FMetalCommandQueue(void);
    
#pragma mark - Public Command Buffer Mutators -
 
    FMetalCommandBuffer* CreateCommandBuffer(void);
    
    void CommitCommandBuffer(FMetalCommandBuffer* CommandBuffer);
 
    FMetalFence* CreateFence(NS::String* Label) const;
    
#pragma mark - Public Command Queue Accessors -
    
    FMetalDevice& GetDevice(void);
    
    MTL::CommandQueue* GetQueue(void) { return CommandQueue; }
 
    static MTL::ResourceOptions GetCompatibleResourceOptions(MTL::ResourceOptions Options);
    
    static inline bool SupportsSeparateMSAAAndResolveTarget() { return (PLATFORM_MAC != 0 || GMaxRHIFeatureLevel >= ERHIFeatureLevel::SM5); }
 
    static inline bool IsUMASystem() { return IsRHIDeviceApple(); }
 
#pragma mark - Public Debug Support -
 
    void InsertDebugCaptureBoundary(void);
    
    struct : public TQueue<FMetalPayload*, EQueueMode::Mpsc>
    {
        FMetalPayload* Peek()
        {
            if (FMetalPayload** Result = TQueue::Peek())
            {
                return *Result;
            }
 
            return nullptr;
        }       
    } PendingSubmission, PendingInterrupt;
 
    FMetalPayload* PayloadToSubmit  = nullptr;
    
    using FPayloadArray = TArray<FMetalPayload*>;
 
    // Batches the current payload's command lists, returning the latest fence value signaled for this queue.
    uint64 FinalizePayload(bool bRequiresSignal, FPayloadArray& PayloadsToHandDown);
    
    FMetalSignalEvent& GetSignalEvent()
    {
        return SignalEvent;
    }
 
    TArray<FMetalRHIRenderQuery*> TimestampQueries;
    TArray<FMetalRHIRenderQuery*> OcclusionQueries;
    TArray<FMetalCounterSamplePtr> CounterSamples;
    
#if RHI_NEW_GPU_PROFILER == 0
    TMap<FMetalEventNode*, TArray<FMetalCounterSamplePtr>> EventSampleCounters;
#endif
    
#if RHI_NEW_GPU_PROFILER
    UE::RHI::GPUProfiler::FQueue GetProfilerQueue() const;
    FMetalTiming* Timing = nullptr;
#endif
    
private:
#pragma mark - Private Member Variables -
    FMetalDevice& Device;
    MTL::CommandQueue* CommandQueue;
    int32 RuntimeDebuggingLevel;
    static NS::UInteger PermittedOptions;
    
    FMetalSignalEvent SignalEvent;
};