From 7ec394db8961009e6ac23fea909f8353d865f7a3 Mon Sep 17 00:00:00 2001 From: Steven Le Rouzic Date: Fri, 9 May 2025 00:32:33 +0200 Subject: Add and use Vulkan synchronization library --- hk21/vulkan/sync/BUILD.bazel | 33 ++++++ hk21/vulkan/sync/sync.cpp | 252 ++++++++++++++++++++++++++++++++++++++++ hk21/vulkan/sync/sync.hpp | 64 ++++++++++ hk21/vulkan/sync/sync_tests.cpp | 162 ++++++++++++++++++++++++++ 4 files changed, 511 insertions(+) create mode 100644 hk21/vulkan/sync/BUILD.bazel create mode 100644 hk21/vulkan/sync/sync.cpp create mode 100644 hk21/vulkan/sync/sync.hpp create mode 100644 hk21/vulkan/sync/sync_tests.cpp (limited to 'hk21/vulkan/sync') diff --git a/hk21/vulkan/sync/BUILD.bazel b/hk21/vulkan/sync/BUILD.bazel new file mode 100644 index 0000000..fc74cad --- /dev/null +++ b/hk21/vulkan/sync/BUILD.bazel @@ -0,0 +1,33 @@ +# Copyright 2025 Steven Le Rouzic +# +# SPDX-License-Identifier: BSD-3-Clause + +cc_library( + name = "sync", + hdrs = [ + "sync.hpp", + ], + srcs = [ + "sync.cpp", + ], + deps = [ + "//vendor/vulkan", + "@asl//asl/base", + "@asl//asl/types:option", + "@asl//asl/types:span", + ], + visibility = ["//:__subpackages__"], + applicable_licenses = ["//:license"], +) + +cc_test( + name = "tests", + srcs = [ + "sync_tests.cpp", + ], + deps = [ + ":sync", + "@asl//asl/containers:buffer", + "@asl//asl/testing", + ], +) diff --git a/hk21/vulkan/sync/sync.cpp b/hk21/vulkan/sync/sync.cpp new file mode 100644 index 0000000..1c81ce3 --- /dev/null +++ b/hk21/vulkan/sync/sync.cpp @@ -0,0 +1,252 @@ +// Copyright 2025 Steven Le Rouzic +// +// SPDX-License-Identifier: BSD-3-Clause + +#include "hk21/vulkan/sync/sync.hpp" + +#include + +// All of this is largely inspired by nicegraf's synchronization utility. +// See https://github.com/nicebyte/nicegraf/blob/3a291433fdb4fd9cf38356f297ff1d851617f0f5/source/ngf-vk/impl.c#L2718 + +namespace +{ + +enum StageAccess : uint32_t +{ + kClearStageTransferWrite = 0x0000'0001U, + kFragmentStageShaderSampled = 0x0000'0002U, + kVertexStageShaderSampled = 0x0000'0004U, + kColorAttachmentWrite = 0x0000'0008U, +}; + +constexpr VkAccessFlags kWriteAccessMask = + VK_ACCESS_2_SHADER_WRITE_BIT + | VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT + | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT + | VK_ACCESS_2_TRANSFER_WRITE_BIT + | VK_ACCESS_2_HOST_WRITE_BIT + | VK_ACCESS_2_MEMORY_WRITE_BIT + | VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT; + +struct UsageInfo +{ + uint32_t stage_access_mask{}; + VkAccessFlags2 access_flags{}; + VkPipelineStageFlags2 pipeline_stage_flags{}; + VkImageLayout image_layout{}; +}; + +const auto kUsageInfos = ([]() static { + using namespace vulkan_sync; + + static UsageInfo info[asl::to_underlying(Usage::kCount_)]{}; + + info[asl::to_underlying(Usage::kImageClear)] = UsageInfo{ + .stage_access_mask = StageAccess::kClearStageTransferWrite, + .access_flags = VK_ACCESS_2_TRANSFER_WRITE_BIT, + .pipeline_stage_flags = VK_PIPELINE_STAGE_2_CLEAR_BIT, + .image_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + }; + + info[asl::to_underlying(Usage::kImagePresent)] = UsageInfo{ + .stage_access_mask = 0, + .access_flags = VK_ACCESS_2_NONE, + .pipeline_stage_flags = VK_PIPELINE_STAGE_2_NONE, + .image_layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + }; + + info[asl::to_underlying(Usage::kImageSampledInFragmentShader)] = UsageInfo{ + .stage_access_mask = StageAccess::kFragmentStageShaderSampled, + .access_flags = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, + .pipeline_stage_flags = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, + .image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + }; + + info[asl::to_underlying(Usage::kImageSampledInVertexShader)] = UsageInfo{ + .stage_access_mask = StageAccess::kVertexStageShaderSampled, + .access_flags = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, + .pipeline_stage_flags = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT, + .image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + }; + + info[asl::to_underlying(Usage::kImageColorWriteAttachment)] = UsageInfo{ + .stage_access_mask = StageAccess::kColorAttachmentWrite, + .access_flags = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, + .pipeline_stage_flags = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, + .image_layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + }; + + return asl::span(info); +})(); + + + +// We use an image barrier as a common structure for image and buffer barriers. +// The only differences are the resource, the subresource range, and the image layouts. +// We just discard whatever we don't need and fill the more specific fields outside. +asl::option synchronize_resource_( + vulkan_sync::ResourceState* state, + VkImageLayout* state_layout, + vulkan_sync::Usage new_usage) +{ + const UsageInfo& usage_info = kUsageInfos[asl::to_underlying(new_usage)]; + + const bool is_read_only_access = (usage_info.access_flags & kWriteAccessMask) == 0U; + + const bool needs_layout_transition = *state_layout != usage_info.image_layout; + + const bool needs_write = needs_layout_transition || !is_read_only_access; + + VkImageMemoryBarrier2 barrier{ + .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + .pNext = nullptr, + .srcStageMask = 0, + .srcAccessMask = 0, + .dstStageMask = 0, + .dstAccessMask = 0, + .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .newLayout = VK_IMAGE_LAYOUT_UNDEFINED, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .image = VK_NULL_HANDLE, + .subresourceRange = {}, + }; + + if (needs_write) + { + barrier.srcStageMask |= asl::exchange(state->active_readers_pipeline_stage_mask, VK_PIPELINE_STAGE_2_NONE); + barrier.srcAccessMask |= asl::exchange(state->active_readers_access_mask, VK_ACCESS_2_NONE); + state->has_seen_last_write = 0; + + // If there was to read since last write, but there was a write, + // synchronize with last write instead. + if (barrier.srcStageMask == VK_PIPELINE_STAGE_2_NONE && + state->last_writer_pipeline_stage_mask != VK_PIPELINE_STAGE_2_NONE) + { + barrier.srcStageMask |= state->last_writer_pipeline_stage_mask; + barrier.srcAccessMask |= state->last_writer_access_mask; + } + + // Last write is now the new usage. + state->last_writer_pipeline_stage_mask = usage_info.pipeline_stage_flags; + state->last_writer_access_mask = usage_info.access_flags; + + // If this is a read-only that is considered a write (layout transition) + // we also record the reader info, because it acts as if this read has been + // synchronized. + if (is_read_only_access) + { + state->has_seen_last_write |= usage_info.stage_access_mask; + state->active_readers_access_mask |= usage_info.access_flags; + state->active_readers_pipeline_stage_mask |= usage_info.pipeline_stage_flags; + } + } + else + { + // If there was a previous write we need to synchronize with, and this + // access has not been synchronized with it yet, synchronize. + if (state->last_writer_pipeline_stage_mask != VK_PIPELINE_STAGE_2_NONE + && (state->has_seen_last_write & usage_info.stage_access_mask) != usage_info.stage_access_mask) + { + barrier.srcStageMask |= state->last_writer_pipeline_stage_mask; + barrier.srcAccessMask |= state->last_writer_access_mask; + } + + // Record this reader info. + state->has_seen_last_write |= usage_info.stage_access_mask; + state->active_readers_access_mask |= usage_info.access_flags; + state->active_readers_pipeline_stage_mask |= usage_info.pipeline_stage_flags; + } + + // If the barrier has been filled or we need a layout transition, emit a barrier. + if (barrier.srcStageMask != VK_PIPELINE_STAGE_2_NONE || needs_layout_transition) + { + barrier.dstStageMask |= usage_info.pipeline_stage_flags; + barrier.dstAccessMask |= usage_info.access_flags; + + if (barrier.dstStageMask == VK_PIPELINE_STAGE_2_NONE) + { + barrier.dstStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT; + } + + if (barrier.srcStageMask == VK_PIPELINE_STAGE_2_NONE) + { + barrier.srcStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT; + } + + if (needs_layout_transition) + { + barrier.oldLayout = asl::exchange(*state_layout, usage_info.image_layout); + barrier.newLayout = usage_info.image_layout; + } + + return barrier; + } + + return asl::nullopt; +} + +} // anonymous namespace + +namespace vulkan_sync +{ + +void synchronize_resource( + VkImage image, VkImageAspectFlags aspects, + ImageState* state, Usage new_usage, DependencyInfoBuilder* builder) +{ + const UsageInfo& usage_info = kUsageInfos[asl::to_underlying(new_usage)]; + ASL_ASSERT(usage_info.image_layout != VK_IMAGE_LAYOUT_UNDEFINED); + + auto barrier_opt = synchronize_resource_(state, &state->current_layout, new_usage); + if (barrier_opt.has_value()) + { + auto& barrier = barrier_opt.value(); + + barrier.image = image; + barrier.subresourceRange = { + .aspectMask = aspects, + .baseMipLevel = 0, + .levelCount = VK_REMAINING_MIP_LEVELS, + .baseArrayLayer = 0, + .layerCount = VK_REMAINING_ARRAY_LAYERS, + }; + + builder->add_image_barrier(barrier); + } +} + +void synchronize_resource( + VkBuffer buffer, BufferState* state, + Usage new_usage, DependencyInfoBuilder* builder) +{ + const UsageInfo& usage_info = kUsageInfos[asl::to_underlying(new_usage)]; + ASL_ASSERT(usage_info.image_layout == VK_IMAGE_LAYOUT_UNDEFINED); + + VkImageLayout dummy_layout = VK_IMAGE_LAYOUT_UNDEFINED; + auto barrier_opt = synchronize_resource_(state, &dummy_layout, new_usage); + if (barrier_opt.has_value()) + { + const auto& image_barrier = barrier_opt.value(); + + VkBufferMemoryBarrier2 barrier{ + .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, + .pNext = nullptr, + .srcStageMask = image_barrier.srcStageMask, + .srcAccessMask = image_barrier.srcAccessMask, + .dstStageMask = image_barrier.dstStageMask, + .dstAccessMask = image_barrier.dstAccessMask, + .srcQueueFamilyIndex = image_barrier.srcQueueFamilyIndex, + .dstQueueFamilyIndex = image_barrier.dstQueueFamilyIndex, + .buffer = buffer, + .offset = 0, + .size = VK_WHOLE_SIZE, + }; + + builder->add_buffer_barrier(barrier); + } +} + +} // namespace vulkan_sync + diff --git a/hk21/vulkan/sync/sync.hpp b/hk21/vulkan/sync/sync.hpp new file mode 100644 index 0000000..b89b625 --- /dev/null +++ b/hk21/vulkan/sync/sync.hpp @@ -0,0 +1,64 @@ +// Copyright 2025 Steven Le Rouzic +// +// SPDX-License-Identifier: BSD-3-Clause + +#pragma once + +#include +#include +#include +#include + +namespace vulkan_sync +{ + +class DependencyInfoBuilder +{ +public: + DependencyInfoBuilder() = default; + ASL_DEFAULT_COPY_MOVE(DependencyInfoBuilder); + virtual ~DependencyInfoBuilder() = default; + + virtual void add_image_barrier(const VkImageMemoryBarrier2&) = 0; + virtual void add_buffer_barrier(const VkBufferMemoryBarrier2&) = 0; +}; + +struct ResourceState +{ + VkAccessFlags2 last_writer_access_mask{}; + VkPipelineStageFlags2 last_writer_pipeline_stage_mask{}; + + VkAccessFlags2 active_readers_access_mask{}; + VkPipelineStageFlags2 active_readers_pipeline_stage_mask{}; + + // Which StageAccess-es have seen the previous write. + uint32_t has_seen_last_write{}; +}; + +struct BufferState : public ResourceState {}; + +struct ImageState : public ResourceState +{ + VkImageLayout current_layout = VK_IMAGE_LAYOUT_UNDEFINED; +}; + +enum class Usage : uint32_t +{ + kImageClear, + kImagePresent, + kImageSampledInFragmentShader, + kImageSampledInVertexShader, + kImageColorWriteAttachment, + + kCount_, +}; + +void synchronize_resource( + VkImage, VkImageAspectFlags, + ImageState*, Usage new_usage, DependencyInfoBuilder*); + +void synchronize_resource( + VkBuffer, BufferState*, + Usage new_usage, DependencyInfoBuilder*); + +} // namespace vulkan_sync diff --git a/hk21/vulkan/sync/sync_tests.cpp b/hk21/vulkan/sync/sync_tests.cpp new file mode 100644 index 0000000..ff6bfd0 --- /dev/null +++ b/hk21/vulkan/sync/sync_tests.cpp @@ -0,0 +1,162 @@ +// Copyright 2025 Steven Le Rouzic +// +// SPDX-License-Identifier: BSD-3-Clause + +#include "hk21/vulkan/sync/sync.hpp" + +#include +#include + +class DependencyInfoBuilder : public vulkan_sync::DependencyInfoBuilder +{ + asl::buffer m_image_barriers; + asl::buffer m_buffer_barriers; + +public: + void add_image_barrier(const VkImageMemoryBarrier2& barrier) override + { + m_image_barriers.push(barrier); + } + + void add_buffer_barrier(const VkBufferMemoryBarrier2& barrier) override + { + m_buffer_barriers.push(barrier); + } + + void reset() + { + m_image_barriers.clear(); + m_buffer_barriers.clear(); + } + + asl::span image_barriers() const + { + return m_image_barriers; + } + + asl::span buffer_barriers() const + { + return m_buffer_barriers; + } +}; + +ASL_TEST(clear_and_present) +{ + DependencyInfoBuilder builder; + vulkan_sync::ImageState state{}; + + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageClear, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + auto barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_NONE); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_CLEAR_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_TRANSFER_WRITE_BIT); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + + builder.reset(); + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageClear, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == VK_PIPELINE_STAGE_2_CLEAR_BIT); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_TRANSFER_WRITE_BIT); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_CLEAR_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_TRANSFER_WRITE_BIT); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_UNDEFINED); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + + builder.reset(); + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImagePresent, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == VK_PIPELINE_STAGE_2_CLEAR_BIT); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_TRANSFER_WRITE_BIT); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_NONE); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); + + builder.reset(); + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageClear, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_NONE); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_CLEAR_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_TRANSFER_WRITE_BIT); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); +} + +ASL_TEST(clear_and_draw) +{ + DependencyInfoBuilder builder; + vulkan_sync::ImageState state{}; + + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageColorWriteAttachment, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + auto barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_NONE); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + + builder.reset(); + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageSampledInVertexShader, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_SHADER_SAMPLED_READ_BIT); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + + builder.reset(); + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageSampledInFragmentShader, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_SHADER_SAMPLED_READ_BIT); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_SHADER_SAMPLED_READ_BIT); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_UNDEFINED); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + + builder.reset(); + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageSampledInVertexShader, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 0); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + + builder.reset(); + synchronize_resource(VK_NULL_HANDLE, {}, &state, vulkan_sync::Usage::kImageClear, &builder); + ASL_TEST_ASSERT(builder.buffer_barriers().size() == 0); + ASL_TEST_ASSERT(builder.image_barriers().size() == 1); + barrier = builder.image_barriers()[0]; + ASL_TEST_EXPECT(barrier.srcStageMask == (VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT)); + ASL_TEST_EXPECT(barrier.srcAccessMask == VK_ACCESS_2_SHADER_SAMPLED_READ_BIT); + ASL_TEST_EXPECT(barrier.dstStageMask == VK_PIPELINE_STAGE_2_CLEAR_BIT); + ASL_TEST_EXPECT(barrier.dstAccessMask == VK_ACCESS_2_TRANSFER_WRITE_BIT); + ASL_TEST_EXPECT(barrier.oldLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + ASL_TEST_EXPECT(barrier.newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + ASL_TEST_EXPECT(state.current_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); +} + -- cgit