TimelineSynchronizer.cpp

Go to the documentation of this file.

#include "Engine/Renderer/TimelineSynchronizer.h"
#include "Engine/Core/ApplicationContext.h"
 
#include <stdexcept>
#include <utility>
 
namespace EngineCore
{
 
TimelineSynchronizer::TimelineSynchronizer(ApplicationContext* context, uint32_t framesInFlight)
    : context_(context)
    , framesInFlight_(framesInFlight)
{
    if (!context_)
    {
        throw std::runtime_error("TimelineSynchronizer requires a valid ApplicationContext");
    }
 
    VkSemaphoreTypeCreateInfo typeInfo{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
        .pNext = nullptr,
        .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
        .initialValue = 0,
    };
 
    VkSemaphoreCreateInfo createInfo{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
        .pNext = &typeInfo,
        .flags = 0,
    };
 
    VkResult result = vkCreateSemaphore(context_->getVkDevice(), &createInfo, nullptr, &timelineSemaphore_);
    if (result != VK_SUCCESS)
    {
        throw std::runtime_error("Failed to create timeline semaphore");
    }
}
 
TimelineSynchronizer::~TimelineSynchronizer()
{
    if (timelineSemaphore_ != VK_NULL_HANDLE && context_)
    {
        vkDestroySemaphore(context_->getVkDevice(), timelineSemaphore_, nullptr);
        timelineSemaphore_ = VK_NULL_HANDLE;
    }
}
 
TimelineSynchronizer::TimelineSynchronizer(TimelineSynchronizer&& other) noexcept
    : context_(other.context_)
    , timelineSemaphore_(other.timelineSemaphore_)
    , framesInFlight_(other.framesInFlight_)
{
    other.context_ = nullptr;
    other.timelineSemaphore_ = VK_NULL_HANDLE;
    other.framesInFlight_ = 0;
}
 
TimelineSynchronizer& TimelineSynchronizer::operator=(TimelineSynchronizer&& other) noexcept
{
    if (this != &other)
    {
        // Clean up existing resources
        if (timelineSemaphore_ != VK_NULL_HANDLE && context_)
        {
            vkDestroySemaphore(context_->getVkDevice(), timelineSemaphore_, nullptr);
        }
 
        // Move from other
        context_ = other.context_;
        timelineSemaphore_ = other.timelineSemaphore_;
        framesInFlight_ = other.framesInFlight_;
 
        // Clear other
        other.context_ = nullptr;
        other.timelineSemaphore_ = VK_NULL_HANDLE;
        other.framesInFlight_ = 0;
    }
    return *this;
}
 
uint64_t TimelineSynchronizer::getCurrentValue() const
{
    uint64_t value = 0;
    vkGetSemaphoreCounterValue(context_->getVkDevice(), timelineSemaphore_, &value);
    return value;
}
 
void TimelineSynchronizer::waitForValue(uint64_t value, uint64_t timeout) const
{
    VkSemaphoreWaitInfo waitInfo{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
        .pNext = nullptr,
        .flags = 0,
        .semaphoreCount = 1,
        .pSemaphores = &timelineSemaphore_,
        .pValues = &value,
    };
 
    VkResult result = vkWaitSemaphores(context_->getVkDevice(), &waitInfo, timeout);
    if (result != VK_SUCCESS && result != VK_TIMEOUT)
    {
        throw std::runtime_error("Failed to wait on timeline semaphore");
    }
}
 
void TimelineSynchronizer::signalValue(uint64_t value) const
{
    VkSemaphoreSignalInfo signalInfo{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
        .pNext = nullptr,
        .semaphore = timelineSemaphore_,
        .value = value,
    };
 
    VkResult result = vkSignalSemaphore(context_->getVkDevice(), &signalInfo);
    if (result != VK_SUCCESS)
    {
        throw std::runtime_error("Failed to signal timeline semaphore from CPU");
    }
}
 
} // namespace EngineCore