MetalDevice.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "MetalViewport.h"
#include "MetalCommandQueue.h"
#include "MetalBuffer.h"
#include "MetalCaptureManager.h"
#include "MetalTempAllocator.h"
#include "MetalStateCache.h"
#include "MetalCounterSampler.h"
 
#if PLATFORM_IOS
#include "IOS/IOSView.h"
#endif
#include "Containers/LockFreeList.h"
 
// Defines a unique command queue type within a Metal Device (owner by the command list managers).
// Currently only implements direct
enum class EMetalQueueType
{
    Direct = 0,
    Count,
};
 
typedef NS_OPTIONS(uint32, EMetalFeatures)
{
    EMetalFeaturesCountingQueries = 1 << 1,
    EMetalFeaturesBaseVertexInstance = 1 << 2,
    EMetalFeaturesIndirectBuffer = 1 << 3,
    EMetalFeaturesLayeredRendering = 1 << 4,
    EMetalFeaturesValidation = 1 << 5,
    EMetalFeaturesHeaps = 1 << 6,
    EMetalFeaturesFences = 1 << 7,
    EMetalFeaturesMSAADepthResolve = 1 << 8,
    EMetalFeaturesMSAAStoreAndResolve = 1 << 9,
    EMetalFeaturesCubemapArrays = 1 << 10,
    EMetalFeaturesMultipleViewports = 1 << 11,
    EMetalFeaturesPresentMinDuration = 1 << 12,
    EMetalFeaturesEfficientBufferBlits = 1 << 13,
    EMetalFeaturesBufferSubAllocation = 1 << 14,
    EMetalFeaturesPrivateBufferSubAllocation = 1 << 15,
    EMetalFeaturesTileShaders = 1 << 16,
    EMetalFeaturesStageCounterSampling = 1 << 17,
    EMetalFeaturesBoundaryCounterSampling = 1 << 18,
    EMetalFeaturesRayTracing = 1 << 19,
};
 
enum EMetalDebugLevel
{
    EMetalDebugLevelOff,
    EMetalDebugLevelFastValidation,
    EMetalDebugLevelResetOnBind,
    EMetalDebugLevelConditionalSubmit,
    EMetalDebugLevelValidation,
    EMetalDebugLevelWaitForComplete,
};
 
enum class EMetalShaderValidationType
{
    All,
    ComputeOnly,
    RenderPipelineOnly,
    ShaderName,
};
 
class FMetalBindlessDescriptorManager;
 
class FMetalRayTracingCompactionRequestHandler;
 
class FMetalDevice
{
public:
    static FMetalDevice* CreateDevice();
    virtual ~FMetalDevice();
    
    void EnumerateFeatureSupport();
    inline bool SupportsFeature(EMetalFeatures InFeature) { return ((Features & InFeature) != 0); }
    
    inline FMetalResourceHeap& GetResourceHeap(void) { return Heap; }
    
    void EndDrawingViewport(bool bPresent);
    
    MTLTexturePtr CreateTexture(FMetalSurface* Surface, MTL::TextureDescriptor* Descriptor);
    FMetalBufferPtr CreatePooledBuffer(FMetalPooledBufferArgs const& Args);
    MTLEventPtr CreateEvent();
    
    void DrainHeap();
    void GarbageCollect();
    
    uint32 GetDeviceIndex(void) const;
    
    FMetalTempAllocator* GetTransferAllocator()
    {
        return TransferBufferAllocator;
    }
    
    FMetalTempAllocator* GetUniformAllocator()
    {
        return UniformBufferAllocator;
    }
    
    uint32 GetFrameNumberRHIThread()
    {
        return FrameNumberRHIThread;
    }
    
    FMetalCommandQueue& GetCommandQueue(EMetalQueueType QueueType)
    {
        check(QueueType < EMetalQueueType::Count);
        return *CommandQueues[(uint32_t)QueueType];
    }
    
#if PLATFORM_SUPPORTS_BINDLESS_RENDERING
    FMetalBindlessDescriptorManager* GetBindlessDescriptorManager()
    {
        return BindlessDescriptorManager;
    }
#endif
    
#if METAL_DEBUG_OPTIONS
    void AddActiveBuffer(MTL::Buffer* Buffer, const NS::Range& Range);
    void RemoveActiveBuffer(MTL::Buffer* Buffer, const NS::Range& Range);
    bool ValidateIsInactiveBuffer(MTL::Buffer* Buffer, const NS::Range& Range);
#endif
    
    MTL::Device* GetDevice()
    {
        return Device;
    }
    
    inline int32 GetRuntimeDebuggingLevel(void) const
    {
        return RuntimeDebuggingLevel;
    }
    
    void IncrementFrameRHIThread()
    {
        FrameNumberRHIThread++;
    }
    
    dispatch_semaphore_t& GetFrameSemaphore()
    {
        return FrameSemaphore;
    }
    
    FMetalCounterSampler* GetCounterSampler()
    {
        return CounterSampler;
    }
    
    bool IsShaderValidationEnabled()
    {
        return bShaderValidationEnabled;
    }
    
private:
    FMetalDevice(MTL::Device* MetalDevice, uint32 DeviceIndex);
    
    void FlushFreeList(bool const bFlushFences = true);
    
private:
    MTL::Device* Device;
    
    TArray<FMetalCommandQueue*, TInlineAllocator<(uint32)EMetalQueueType::Count>> CommandQueues;
    
    dispatch_semaphore_t FrameSemaphore;
    
    uint32 DeviceIndex;
    
    FMetalResourceHeap Heap;
    
    FMetalCaptureManager* CaptureManager;
    
    FMetalTempAllocator* UniformBufferAllocator;
    FMetalTempAllocator* TransferBufferAllocator;
    
#if METAL_DEBUG_OPTIONS
    TArray<FMetalFence*> FrameFences;
    
    FCriticalSection ActiveBuffersMutex;
    
    TMap<MTL::Buffer*, TArray<NS::Range>> ActiveBuffers;
#endif
    
    FCriticalSection FreeListMutex;
    
    FEvent* FrameReadyEvent;
    
    uint32 FrameCounter = 0;
    
    uint64 Features = 0;
    
    FMetalPipelineStateCacheManager* PSOManager;
 
    uint32 FrameNumberRHIThread = 0;
 
    int32 RuntimeDebuggingLevel = 0;
    
    FMetalCounterSampler* CounterSampler = nullptr;
    
    bool bShaderValidationEnabled = false;
    
#if PLATFORM_SUPPORTS_BINDLESS_RENDERING
    FMetalBindlessDescriptorManager* BindlessDescriptorManager;
#endif
 
#if METAL_RHI_RAYTRACING
    FMetalRayTracingCompactionRequestHandler* RayTracingCompactionRequestHandler;
 
    void InitializeRayTracing();
    void CleanUpRayTracing();
    
public:
    void UpdateRayTracing(FMetalRHICommandContext& Context);
 
    inline FMetalRayTracingCompactionRequestHandler* GetRayTracingCompactionRequestHandler() const { return RayTracingCompactionRequestHandler; }
    
    // Dummy Index buffer used when creating descriptors
    FMetalBufferPtr DummyIndexBuffer;
#endif // METAL_RHI_RAYTRACING
};