VulkanSynchronization.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once 
 
#include "Containers/Array.h"
#include "HAL/CriticalSection.h"
#include "Templates/RefCounting.h"
#include "VulkanConfiguration.h"
#include "VulkanThirdParty.h"
 
class FVulkanDevice;
class FVulkanFenceManager;
 
// Internal Vulkan Fence class that wrap VkFence management
// (not to be confused with FVulkanGPUFence class that maps to RHI's FRHIFence) 
class FVulkanFence
{
public:
    FVulkanFence(FVulkanDevice& InDevice, FVulkanFenceManager& InOwner, bool bCreateSignaled);
 
    inline VkFence GetHandle() const
    {
        return Handle;
    }
 
    inline bool IsSignaled() const
    {
        return State == EState::Signaled;
    }
 
    FVulkanFenceManager& GetOwner()
    {
        return Owner;
    }
 
protected:
    VkFence Handle;
 
    enum class EState
    {
        // Initial state
        NotReady,
 
        // After GPU processed it
        Signaled,
    };
 
    EState State;
 
    FVulkanFenceManager& Owner;
 
    // Only owner can delete!
    ~FVulkanFence();
    friend FVulkanFenceManager;
};
 
class FVulkanFenceManager
{
public:
    FVulkanFenceManager(FVulkanDevice& InDevice)
        : Device(InDevice)
    {
    }
    ~FVulkanFenceManager();
 
    void Deinit();
 
    FVulkanFence* AllocateFence(bool bCreateSignaled = false);
 
    inline bool IsFenceSignaled(FVulkanFence* Fence)
    {
        if (Fence->IsSignaled())
        {
            return true;
        }
 
        return CheckFenceState(Fence);
    }
 
    // Returns false if it timed out
    bool WaitForAnyFence(TArrayView<FVulkanFence*> Fences, uint64 TimeInNanoseconds);
    bool WaitForFence(FVulkanFence* Fence, uint64 TimeInNanoseconds);
 
    void ResetFence(FVulkanFence* Fence);
 
    // Sets it to nullptr
    void ReleaseFence(FVulkanFence*& Fence);
 
    // Sets it to nullptr
    void WaitAndReleaseFence(FVulkanFence*& Fence, uint64 TimeInNanoseconds);
 
protected:
    FVulkanDevice& Device;
    FCriticalSection FenceLock;
    TArray<FVulkanFence*> FreeFences;
    TArray<FVulkanFence*> UsedFences;
 
    // Returns true if signaled
    bool CheckFenceState(FVulkanFence* Fence);
 
    void DestroyFence(FVulkanFence* Fence);
};
 
 
 
enum class EVulkanSemaphoreFlags : uint8
{
    None = 0,
 
    // Will not delete handle on destruction
    ExternallyOwned    = 1 << 1,    
 
    // Inform submission pipeline that the signal will not come from a payload (acquired image semaphore for example)
    ExternallySignaled = 1 << 2,
 
    // Create a timeline semaphore (must be supported)
    Timeline           = 1 << 3,
 
    // Will not be queued for deferred deletion
    ImmediateDeletion  = 1 << 4
};
ENUM_CLASS_FLAGS(EVulkanSemaphoreFlags);
 
 
// Internal Vulkan Semaphore class that wrap VkSemaphore management (binary or timeline)
class FVulkanSemaphore : public FThreadSafeRefCountedObject
{
public:
    FVulkanSemaphore(FVulkanDevice& InDevice, EVulkanSemaphoreFlags InFlags=EVulkanSemaphoreFlags::None, uint64 InInitialTimelineValue=0);
    FVulkanSemaphore(FVulkanDevice& InDevice, const VkSemaphore& InExternalSemaphore);
    virtual ~FVulkanSemaphore();
 
    VkSemaphore GetHandle() const
    {
        return SemaphoreHandle;
    }
 
    bool IsExternallyOwned() const
    {
        return EnumHasAnyFlags(Flags, EVulkanSemaphoreFlags::ExternallyOwned);
    }
 
    bool IsExternallySignaled() const
    {
        return EnumHasAnyFlags(Flags, EVulkanSemaphoreFlags::ExternallySignaled);
    }
 
    bool IsTimeline() const
    {
        return EnumHasAnyFlags(Flags, EVulkanSemaphoreFlags::Timeline);
    }
 
    uint64 GetTimelineSemaphoreValue();
    bool WaitForTimelineSemaphoreValue(uint64 Value, uint64 Timeout);
 
private:
    FVulkanDevice& Device;
    VkSemaphore SemaphoreHandle;
    const EVulkanSemaphoreFlags Flags;
};