Skip to content

fix: improved HandleManager threading mgmt support #521

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
JeanPhilippeKernel wants to merge 1 commit into
base: develop
Choose a base branch
from
Open

fix: improved HandleManager threading mgmt support #521

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 7 additions & 3 deletions Tetragrama/Components/SceneViewportUIComponent.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,6 +32,8 @@ namespace Tetragrama::Components

void SceneViewportUIComponent::Update(ZEngine::Core::TimeStep dt)
{
auto app = reinterpret_cast<EditorPtr>(ParentLayer->CurrentApp);

if ((m_viewport_size.x != m_content_region_available_size.x) || (m_viewport_size.y != m_content_region_available_size.y))
{
if (!m_is_resizing)
Expand All @@ -45,14 +47,13 @@ namespace Tetragrama::Components
else if (m_is_resizing)
{
m_idle_frame_count++;
if (m_idle_frame_count >= m_idle_frame_threshold)
if (m_idle_frame_count >= app->RenderPipeline->Device->SwapchainPtr->IdleFrameThreshold)
{
m_is_resizing = false;
m_request_renderer_resize = true;
}
}

auto app = reinterpret_cast<EditorPtr>(ParentLayer->CurrentApp);
auto camera_controller = reinterpret_cast<Controllers::EditorCameraControllerPtr>(app->CameraController);

if (m_request_renderer_resize)
Expand Down Expand Up @@ -101,7 +102,10 @@ namespace Tetragrama::Components
m_refresh_texture_handle = false;
}

ImGui::Image((ImTextureID) m_scene_texture.Index, m_viewport_size, ImVec2(0, 1), ImVec2(1, 0));
if (m_scene_texture.Valid())
{
ImGui::Image((ImTextureID) m_scene_texture.Index, m_viewport_size, ImVec2(0, 1), ImVec2(1, 0));
}
// ViewPort bound computation
ImVec2 viewport_windows_size = ImGui::GetWindowSize();
ImVec2 minimum_bound = ImGui::GetWindowPos();
Expand Down
3 changes: 1 addition & 2 deletions Tetragrama/Components/SceneViewportUIComponent.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,8 +32,7 @@ namespace Tetragrama::Components
bool m_refresh_texture_handle{false};
bool m_request_renderer_resize{false};
bool m_is_resizing{false};
int m_idle_frame_count = 0;
int m_idle_frame_threshold = 9; // SwapchainImageCount * 3
int m_idle_frame_count = 0;
ImVec2 m_viewport_size{0.f, 0.f};
ImVec2 m_content_region_available_size{0.f, 0.f};
std::array<ImVec2, 2> m_viewport_bounds;
Expand Down
6 changes: 3 additions & 3 deletions ZEngine/ZEngine/Hardwares/DeviceSwapchain.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,7 +34,7 @@ namespace ZEngine::Hardwares
attachment_specification.ColorsMap[0].ReferenceLayout = ImageLayout::COLOR_ATTACHMENT_OPTIMAL;
SwapchainAttachment = ZPushStructCtorArgs(&Arena, RenderPasses::Attachment, Device, attachment_specification);

IdleFrameThreshold.store(BufferredFrameCount * 3 * 3 * 3, std::memory_order_release);
IdleFrameThreshold = (BufferredFrameCount * 3 * 3 * 3);
FrameContexts.init(&Arena, FrameContextPoolSize, FrameContextPoolSize);

for (uint32_t i = 0; i < FrameContextPoolSize; ++i)
Expand Down Expand Up @@ -268,7 +268,7 @@ namespace ZEngine::Hardwares
{
if (HasRecreationPending)
{
IdleFrameCount.fetch_add(1);
IdleFrameCount.value.fetch_add(1, std::memory_order_acq_rel);
Device->CommandBufferMgr->ResetEnqueuedBufferIndex();
return;
}
Expand Down Expand Up @@ -493,7 +493,7 @@ namespace ZEngine::Hardwares
};
VkResult present_result = vkQueuePresentKHR(queue.Handle, &present_info);

IdleFrameCount.fetch_add(1);
IdleFrameCount.value.fetch_add(1, std::memory_order_acq_rel);

if (present_result == VK_ERROR_OUT_OF_DATE_KHR || present_result == VK_SUBOPTIMAL_KHR)
{
Expand Down
5 changes: 2 additions & 3 deletions ZEngine/ZEngine/Hardwares/DeviceSwapchain.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,9 +36,8 @@ namespace ZEngine::Hardwares
uint32_t FrameContextOffset = 0;
uint32_t FrameContextPoolSize = 0;
const uint32_t FrameContextPoolSizeFactor = 4;
// Todo Convert atomic_uint as PaddedAtomic..
std::atomic_uint IdleFrameCount = 0;
std::atomic_uint IdleFrameThreshold = std::numeric_limits<uint32_t>::max();
uint64_t IdleFrameThreshold = 0;
PaddedAtomic<uint64_t> IdleFrameCount = {.value = 0};
uint64_t RenderTimelineNextValue = 0;
VkSwapchainKHR SwapchainHandle = VK_NULL_HANDLE;
FrameContextPtr CurrentFrame = nullptr;
Expand Down
220 changes: 107 additions & 113 deletions ZEngine/ZEngine/Hardwares/VulkanDevice.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -848,6 +848,7 @@ namespace ZEngine::Hardwares
{
auto ds = reinterpret_cast<VkDescriptorSet>(res_handle.Handle);
vkFreeDescriptorSets(LogicalDevice, reinterpret_cast<VkDescriptorPool>(res_handle.Data1), 1, &ds);
break;
}
case DeviceResourceType::RESOURCE_COUNT:
break;
Expand Down Expand Up @@ -1204,144 +1205,137 @@ namespace ZEngine::Hardwares
}

void VulkanDevice::DirtyCollector()
{
{
RunningDirtyCollector.store(true, std::memory_order_release);

ZENGINE_CORE_INFO("[*] Dirty Resource Collector started...")

while (RunningDirtyCollector.load(std::memory_order_acquire))
{
uint32_t idle_count = SwapchainPtr->IdleFrameCount.load(std::memory_order_acquire);
uint32_t threshold = SwapchainPtr->IdleFrameThreshold.load(std::memory_order_acquire);

if (idle_count < threshold)
uint32_t idle_count = SwapchainPtr->IdleFrameCount.value.load(std::memory_order_acquire);

if (idle_count < SwapchainPtr->IdleFrameThreshold)
{
std::this_thread::sleep_for(std::chrono::milliseconds(50));
continue;
}

if (DirtyResources.CanRemove())


uint32_t dirty_resource_count = DirtyResources.Size();
for (uint32_t i = 0; i < dirty_resource_count; ++i)
{
uint32_t dirty_resource_count = DirtyResources.Head();
for (uint32_t i = 0; i < dirty_resource_count; ++i)
auto handle = DirtyResources.ToHandle(i);

if (!handle)
{
auto handle = DirtyResources.ToHandle(i);

if (!handle)
{
continue;
}

DirtyResource& res_handle = DirtyResources[handle];
if (res_handle.FrameIndex == SwapchainPtr->CurrentFrame->Index)
continue;
}

DirtyResource& res_handle = DirtyResources[handle];
if (res_handle.FrameIndex == SwapchainPtr->CurrentFrame->Index)
{
switch (res_handle.Type)
{
switch (res_handle.Type)
case Rendering::DeviceResourceType::SAMPLER:
// vkDestroySampler(LogicalDevice, reinterpret_cast<VkSampler>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::FRAMEBUFFER:
vkDestroyFramebuffer(LogicalDevice, reinterpret_cast<VkFramebuffer>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::IMAGEVIEW:
vkDestroyImageView(LogicalDevice, reinterpret_cast<VkImageView>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::IMAGE:
vkDestroyImage(LogicalDevice, reinterpret_cast<VkImage>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::RENDERPASS:
vkDestroyRenderPass(LogicalDevice, reinterpret_cast<VkRenderPass>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::BUFFERMEMORY:
vkFreeMemory(LogicalDevice, reinterpret_cast<VkDeviceMemory>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::BUFFER:
vkDestroyBuffer(LogicalDevice, reinterpret_cast<VkBuffer>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::PIPELINE_LAYOUT:
vkDestroyPipelineLayout(LogicalDevice, reinterpret_cast<VkPipelineLayout>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::PIPELINE:
vkDestroyPipeline(LogicalDevice, reinterpret_cast<VkPipeline>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::DESCRIPTORSETLAYOUT:
vkDestroyDescriptorSetLayout(LogicalDevice, reinterpret_cast<VkDescriptorSetLayout>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::DESCRIPTORPOOL:
vkDestroyDescriptorPool(LogicalDevice, reinterpret_cast<VkDescriptorPool>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::SEMAPHORE:
vkDestroySemaphore(LogicalDevice, reinterpret_cast<VkSemaphore>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::FENCE:
vkDestroyFence(LogicalDevice, reinterpret_cast<VkFence>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::DESCRIPTORSET:
{
case Rendering::DeviceResourceType::SAMPLER:
// vkDestroySampler(LogicalDevice, reinterpret_cast<VkSampler>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::FRAMEBUFFER:
vkDestroyFramebuffer(LogicalDevice, reinterpret_cast<VkFramebuffer>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::IMAGEVIEW:
vkDestroyImageView(LogicalDevice, reinterpret_cast<VkImageView>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::IMAGE:
vkDestroyImage(LogicalDevice, reinterpret_cast<VkImage>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::RENDERPASS:
vkDestroyRenderPass(LogicalDevice, reinterpret_cast<VkRenderPass>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::BUFFERMEMORY:
vkFreeMemory(LogicalDevice, reinterpret_cast<VkDeviceMemory>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::BUFFER:
vkDestroyBuffer(LogicalDevice, reinterpret_cast<VkBuffer>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::PIPELINE_LAYOUT:
vkDestroyPipelineLayout(LogicalDevice, reinterpret_cast<VkPipelineLayout>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::PIPELINE:
vkDestroyPipeline(LogicalDevice, reinterpret_cast<VkPipeline>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::DESCRIPTORSETLAYOUT:
vkDestroyDescriptorSetLayout(LogicalDevice, reinterpret_cast<VkDescriptorSetLayout>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::DESCRIPTORPOOL:
vkDestroyDescriptorPool(LogicalDevice, reinterpret_cast<VkDescriptorPool>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::SEMAPHORE:
vkDestroySemaphore(LogicalDevice, reinterpret_cast<VkSemaphore>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::FENCE:
vkDestroyFence(LogicalDevice, reinterpret_cast<VkFence>(res_handle.Handle), nullptr);
break;
case Rendering::DeviceResourceType::DESCRIPTORSET:
{
auto ds = reinterpret_cast<VkDescriptorSet>(res_handle.Handle);
vkFreeDescriptorSets(LogicalDevice, reinterpret_cast<VkDescriptorPool>(res_handle.Data1), 1, &ds);
break;
}
case DeviceResourceType::RESOURCE_COUNT:
break;
auto ds = reinterpret_cast<VkDescriptorSet>(res_handle.Handle);
vkFreeDescriptorSets(LogicalDevice, reinterpret_cast<VkDescriptorPool>(res_handle.Data1), 1, &ds);
break;
}

DirtyResources.Remove(handle);
case DeviceResourceType::RESOURCE_COUNT:
break;
}

DirtyResources.Remove(handle);
}
}

if (DirtyBuffers.CanRemove())

uint32_t dirty_buffer_count = DirtyBuffers.Size();
for (uint32_t i = 0; i < dirty_buffer_count; ++i)
{
uint32_t dirty_buffer_count = DirtyBuffers.Head();
for (uint32_t i = 0; i < dirty_buffer_count; ++i)
auto handle = DirtyBuffers.ToHandle(i);

if (!handle)
{
auto handle = DirtyBuffers.ToHandle(i);

if (!handle)
{
continue;
}

BufferView& buffer = DirtyBuffers[handle];
if (buffer && buffer.FrameIndex == SwapchainPtr->CurrentFrame->Index)
{
vmaDestroyBuffer(VmaAllocatorValue, buffer.Handle, buffer.Allocation);
buffer.Handle = VK_NULL_HANDLE;
buffer.Allocation = VK_NULL_HANDLE;
DirtyBuffers.Remove(handle);
}
continue;
}

BufferView& buffer = DirtyBuffers[handle];
if (buffer && buffer.FrameIndex == SwapchainPtr->CurrentFrame->Index)
{
vmaDestroyBuffer(VmaAllocatorValue, buffer.Handle, buffer.Allocation);
buffer.Handle = VK_NULL_HANDLE;
buffer.Allocation = VK_NULL_HANDLE;
DirtyBuffers.Remove(handle);
}
}

if (DirtyBufferImages.CanRemove())


uint32_t dirty_buffer_image_count = DirtyBufferImages.Size();
for (uint32_t i = 0; i < dirty_buffer_image_count; ++i)
{
uint32_t dirty_buffer_image_count = DirtyBufferImages.Head();
for (uint32_t i = 0; i < dirty_buffer_image_count; ++i)
auto handle = DirtyBufferImages.ToHandle(i);

if (!handle)
{
auto handle = DirtyBufferImages.ToHandle(i);

if (!handle)
{
continue;
}

BufferImage& buffer = DirtyBufferImages[handle];

if (buffer && buffer.FrameIndex == SwapchainPtr->CurrentFrame->Index)
{
vkDestroyImageView(LogicalDevice, buffer.ViewHandle, nullptr);
// vkDestroySampler(LogicalDevice, buffer.Sampler, nullptr);
vmaDestroyImage(VmaAllocatorValue, buffer.Handle, buffer.Allocation);
buffer.Handle = VK_NULL_HANDLE;
buffer.Allocation = VK_NULL_HANDLE;
DirtyBufferImages.Remove(handle);
}
continue;
}

BufferImage& buffer = DirtyBufferImages[handle];

if (buffer && buffer.FrameIndex == SwapchainPtr->CurrentFrame->Index)
{
vkDestroyImageView(LogicalDevice, buffer.ViewHandle, nullptr);
// vkDestroySampler(LogicalDevice, buffer.Sampler, nullptr);
vmaDestroyImage(VmaAllocatorValue, buffer.Handle, buffer.Allocation);
buffer.Handle = VK_NULL_HANDLE;
buffer.Allocation = VK_NULL_HANDLE;
DirtyBufferImages.Remove(handle);
}
}
SwapchainPtr->IdleFrameCount.store(0, std::memory_order_release);

SwapchainPtr->IdleFrameCount.value.store(0, std::memory_order_release);
}

ZENGINE_CORE_INFO("[*] Dirty Resource Collector stopped...")
}

Expand Down
Loading
Loading