RHIGPUReadback.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
  RHIGPUReadback.h: classes for managing fences and staging buffers for
  asynchronous GPU memory updates and readbacks with minimal stalls and no
  RHI thread flushes
=============================================================================*/
 
#pragma once
 
#include "RHI.h"
#include "DynamicRHI.h"
#include "RHICommandList.h"
 
class FRHIGPUMemoryReadback
{
public:
 
    FRHIGPUMemoryReadback(FName RequestName)
    {
        Fence = RHICreateGPUFence(RequestName);
        LastLockGPUIndex = 0;
    }
 
    virtual ~FRHIGPUMemoryReadback() {}
 
    inline bool IsReady()
    {
        return !Fence || (Fence->NumPendingWriteCommands.GetValue() == 0 && Fence->Poll());
    }
 
    inline bool IsReady(FRHIGPUMask GPUMask)
    {
        return !Fence || Fence->Poll(GPUMask);
    }
 
    void Wait(FRHICommandListImmediate& RHICmdList, FRHIGPUMask GPUMask) const
    {
        if (Fence)
        {
            Fence->Wait(RHICmdList, GPUMask);
        }
    }
 
    virtual void EnqueueCopy(FRHICommandList& RHICmdList, FRHIBuffer* SourceBuffer, uint32 NumBytes = 0)
    {
        unimplemented();
    }
 
    virtual void EnqueueCopy(FRHICommandList& RHICmdList, FRHITexture* SourceTexture, const FIntVector& SourcePosition, uint32 SourceSlice, const FIntVector& Size)
    {
        unimplemented();
    }
 
    void EnqueueCopy(FRHICommandList& RHICmdList, FRHITexture* SourceTexture, FResolveRect Rect = FResolveRect(), uint32 SourceSlice = 0)
    {
        FIntVector SourcePosition, Size;
 
        if (Rect.IsValid())
        {
            SourcePosition = FIntVector(Rect.X1, Rect.Y1, 0);
            Size = FIntVector(Rect.X2 - Rect.X1, Rect.Y2 - Rect.Y1, 1);
        }
        else
        {
            SourcePosition = FIntVector::ZeroValue;
            Size = FIntVector::ZeroValue;
        }
        
        EnqueueCopy(RHICmdList, SourceTexture, SourcePosition, SourceSlice, Size);
    }
 
    virtual void* Lock(uint32 NumBytes) = 0;
 
    virtual void Unlock() = 0;
 
    inline const FRHIGPUMask& GetLastCopyGPUMask() const { return LastCopyGPUMask; }
 
    FName GetName() const { return Fence->GetFName(); }
 
protected:
 
    FGPUFenceRHIRef Fence;
    FRHIGPUMask LastCopyGPUMask;
 
    // We need to separately track which GPU buffer was last locked.  It's possible for a new copy operation to
    // be enqueued (writing to LastCopyGPUMask) while the buffer is technically locked, with the unlock and enqueued
    // copy on the GPU itself happening later, during pass execution in FRDGBuilder::Execute (for example, this
    // happens with Nanite streaming).  It's not unsafe, because the operations are occurring in order on both the
    // render thread and later pass Execute, but our locking logic needs to handle that scenario.
    uint32 LastLockGPUIndex;
};
 
class FRHIGPUBufferReadback final : public FRHIGPUMemoryReadback
{
public:
 
    RHI_API FRHIGPUBufferReadback(FName RequestName);
     
    RHI_API void EnqueueCopy(FRHICommandList& RHICmdList, FRHIBuffer* SourceBuffer, uint32 NumBytes = 0) override;
    RHI_API void* Lock(uint32 NumBytes) override;
    RHI_API void Unlock() override;
    RHI_API uint64 GetGPUSizeBytes() const;
 
private:
 
    // RHI staging buffers are single GPU -- need to be branched when using multiple GPUs
#if WITH_MGPU
    FStagingBufferRHIRef DestinationStagingBuffers[MAX_NUM_GPUS];
#else
    FStagingBufferRHIRef DestinationStagingBuffers[1];
#endif
};
 
 
class FRHIGPUTextureReadback final : public FRHIGPUMemoryReadback
{
public:
    RHI_API FRHIGPUTextureReadback(FName RequestName);
 
    using FRHIGPUMemoryReadback::EnqueueCopy;
 
    RHI_API void EnqueueCopy(FRHICommandList& RHICmdList, FRHITexture* SourceTexture, const FIntVector& SourcePosition, uint32 SourceSlice, const FIntVector& Size) override;
 
    UE_DEPRECATED(5.0, "Use FRHIGPUTextureReadback::Lock( int32& OutRowPitchInPixels) instead.")
    RHI_API void* Lock(uint32 NumBytes) override;
 
    RHI_API void* Lock(int32& OutRowPitchInPixels, int32* OutBufferHeight = nullptr);
    RHI_API void Unlock() override;
 
    UE_DEPRECATED(5.0, "Use FRHIGPUTextureReadback::Lock( int32& OutRowPitchInPixels) instead.")
    RHI_API void LockTexture(FRHICommandListImmediate& RHICmdList, void*& OutBufferPtr, int32& OutRowPitchInPixels);
 
    RHI_API uint64 GetGPUSizeBytes() const;
 
#if WITH_MGPU
    FTextureRHIRef DestinationStagingTextures[MAX_NUM_GPUS];
#else
    FTextureRHIRef DestinationStagingTextures[1];
#endif
};