Resolve read after write hazard in api samples [hpp_]oit_linked_lists.

asuessenbach · asuessenbach · commit 76310c34aebc · 2026-04-08T11:30:24.000+02:00
diff --git a/samples/api/hpp_oit_linked_lists/hpp_oit_linked_lists.cpp b/samples/api/hpp_oit_linked_lists/hpp_oit_linked_lists.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2023-2025, NVIDIA
+/* Copyright (c) 2023-2026, NVIDIA
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -20,6 +20,8 @@
 HPPOITLinkedLists::HPPOITLinkedLists()
 {
 	title = "HPP OIT linked lists";
+
+	add_device_extension(vk::KHRSynchronization2ExtensionName);
 }
 
 HPPOITLinkedLists::~HPPOITLinkedLists()
@@ -94,6 +96,8 @@ void HPPOITLinkedLists::request_gpu_features(vkb::core::PhysicalDeviceCpp &gpu)
 	{
 		requested_features.samplerAnisotropy = true;
 	}
+
+	REQUEST_REQUIRED_FEATURE(gpu, vk::PhysicalDeviceSynchronization2FeaturesKHR, synchronization2);
 }
 
 void HPPOITLinkedLists::build_command_buffers()
@@ -132,15 +136,18 @@ void HPPOITLinkedLists::build_command_buffers()
 			}
 			command_buffer.endRenderPass();
 
-			vkb::common::image_layout_transition(command_buffer,
-			                                     linked_list_head_image->get_handle(),
-			                                     vk::PipelineStageFlagBits::eFragmentShader,
-			                                     vk::PipelineStageFlagBits::eFragmentShader,
-			                                     vk::AccessFlagBits::eShaderWrite,
-			                                     vk::AccessFlagBits::eShaderRead,
-			                                     vk::ImageLayout::eGeneral,
-			                                     vk::ImageLayout::eGeneral,
-			                                     {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1});
+			// Insert a pipeline barrier to ensure that all writes to the fragment buffer performed in the gather pass are made available before reading from it in the combine pass
+			vk::BufferMemoryBarrier2 buffer_barrier{.srcStageMask        = vk::PipelineStageFlagBits2::eFragmentShader,
+			                                        .srcAccessMask       = vk::AccessFlagBits2::eShaderStorageWrite,
+			                                        .dstStageMask        = vk::PipelineStageFlagBits2::eFragmentShader,
+			                                        .dstAccessMask       = vk::AccessFlagBits2::eShaderStorageRead,
+			                                        .srcQueueFamilyIndex = vk::QueueFamilyIgnored,
+			                                        .dstQueueFamilyIndex = vk::QueueFamilyIgnored,
+			                                        .buffer              = fragment_buffer->get_handle(),
+			                                        .offset              = 0,
+			                                        .size                = vk::WholeSize};
+			vk::DependencyInfo       dependency_info{.dependencyFlags = vk::DependencyFlagBits::eByRegion, .bufferMemoryBarrierCount = 1, .pBufferMemoryBarriers = &buffer_barrier};
+			command_buffer.pipelineBarrier2(dependency_info);
 
 			// Combine pass
 			combine_render_pass_begin_info.framebuffer = framebuffers[i];
@@ -270,21 +277,26 @@ void HPPOITLinkedLists::create_fragment_resources(vk::Extent2D const &extent)
 {
 	const vk::Extent3D image_extent{extent.width, extent.height, 1};
 	const vk::Format   image_format{vk::Format::eR32Uint};
-	linked_list_head_image      = std::make_unique<vkb::core::HPPImage>(get_device(),
-                                                                   image_extent,
-                                                                   image_format,
-                                                                   vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferDst,
-                                                                   VMA_MEMORY_USAGE_GPU_ONLY,
-                                                                   vk::SampleCountFlagBits::e1);
+	linked_list_head_image = std::make_unique<vkb::core::HPPImage>(get_device(),
+	                                                               image_extent,
+	                                                               image_format,
+	                                                               vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferDst,
+	                                                               VMA_MEMORY_USAGE_GPU_ONLY,
+	                                                               vk::SampleCountFlagBits::e1);
+	linked_list_head_image->set_debug_name("linked_list_head_image");
+
 	linked_list_head_image_view = std::make_unique<vkb::core::HPPImageView>(*linked_list_head_image, vk::ImageViewType::e2D, image_format);
+	linked_list_head_image_view->set_debug_name("linked_list_head_image_view");
 
 	fragment_max_count                  = extent.width * extent.height * kFragmentsPerPixelAverage;
 	const uint32_t fragment_buffer_size = sizeof(glm::uvec3) * fragment_max_count;
 	fragment_buffer =
 	    std::make_unique<vkb::core::BufferCpp>(get_device(), fragment_buffer_size, vk::BufferUsageFlagBits::eStorageBuffer, VMA_MEMORY_USAGE_GPU_ONLY);
+	fragment_buffer->set_debug_name("fragment_buffer");
 
 	fragment_counter = std::make_unique<vkb::core::BufferCpp>(
 	    get_device(), sizeof(glm::uint), vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eTransferDst, VMA_MEMORY_USAGE_GPU_ONLY);
+	fragment_counter->set_debug_name("fragment_counter");
 }
 
 void HPPOITLinkedLists::create_gather_pass_objects(vk::Extent2D const &extent)
@@ -448,8 +460,8 @@ void HPPOITLinkedLists::update_descriptors()
 	vk::DescriptorBufferInfo fragment_buffer_descriptor{fragment_buffer->get_handle(), 0, vk::WholeSize};
 	vk::DescriptorBufferInfo fragment_counter_descriptor{fragment_counter->get_handle(), 0, vk::WholeSize};
 	vk::DescriptorImageInfo  background_texture_descriptor{background_texture.sampler,
-                                                          background_texture.image->get_vk_image_view().get_handle(),
-                                                          descriptor_type_to_image_layout(vk::DescriptorType::eCombinedImageSampler,
+	                                                       background_texture.image->get_vk_image_view().get_handle(),
+	                                                       descriptor_type_to_image_layout(vk::DescriptorType::eCombinedImageSampler,
 	                                                                                       background_texture.image->get_vk_image_view().get_format())};
 
 	std::array<vk::WriteDescriptorSet, 6> write_descriptor_sets = {{{.dstSet          = descriptor_set,
diff --git a/samples/api/oit_linked_lists/oit_linked_lists.cpp b/samples/api/oit_linked_lists/oit_linked_lists.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2023-2025, Google
+/* Copyright (c) 2023-2026, Google
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -20,6 +20,9 @@
 
 OITLinkedLists::OITLinkedLists()
 {
+	title = "OIT linked lists";
+
+	add_device_extension(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
 }
 
 OITLinkedLists::~OITLinkedLists()
@@ -115,6 +118,8 @@ void OITLinkedLists::request_gpu_features(vkb::core::PhysicalDeviceC &gpu)
 	{
 		throw std::runtime_error("This sample requires support for buffers and images stores and atomic operations in the fragment shader stage");
 	}
+
+	REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceSynchronization2FeaturesKHR, synchronization2);
 }
 
 void OITLinkedLists::on_update_ui_overlay(vkb::Drawer &drawer)
@@ -161,13 +166,19 @@ void OITLinkedLists::build_command_buffers()
 				vkCmdEndRenderPass(draw_cmd_buffers[i]);
 			}
 
-			VkImageSubresourceRange subresource_range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
-			vkb::image_layout_transition(
-			    draw_cmd_buffers[i], linked_list_head_image->get_handle(),
-			    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-			    VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
-			    VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
-			    subresource_range);
+			// Insert a pipeline barrier to ensure that all writes to the fragment buffer performed in the gather pass are made available before reading from it in the combine pass
+			VkBufferMemoryBarrier2 buffer_barrier{.sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
+			                                      .srcStageMask        = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
+			                                      .srcAccessMask       = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
+			                                      .dstStageMask        = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
+			                                      .dstAccessMask       = VK_ACCESS_2_SHADER_STORAGE_READ_BIT,
+			                                      .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+			                                      .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+			                                      .buffer              = fragment_buffer->get_handle(),
+			                                      .offset              = 0,
+			                                      .size                = VK_WHOLE_SIZE};
+			VkDependencyInfo       dependency_info{.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT, .bufferMemoryBarrierCount = 1, .pBufferMemoryBarriers = &buffer_barrier};
+			vkCmdPipelineBarrier2KHR(draw_cmd_buffers[i], &dependency_info);
 
 			// Combine pass
 			{
@@ -252,17 +263,22 @@ void OITLinkedLists::create_fragment_resources(const uint32_t width, const uint3
 	{
 		const VkExtent3D image_extent = {width, height, 1};
 		linked_list_head_image        = std::make_unique<vkb::core::Image>(get_device(), image_extent, VK_FORMAT_R32_UINT, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY, VK_SAMPLE_COUNT_1_BIT);
-		linked_list_head_image_view   = std::make_unique<vkb::core::ImageView>(*linked_list_head_image, VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R32_UINT);
+		linked_list_head_image->set_debug_name("linked_list_head_image");
+
+		linked_list_head_image_view = std::make_unique<vkb::core::ImageView>(*linked_list_head_image, VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R32_UINT);
+		linked_list_head_image_view->set_debug_name("linked_list_head_image_view");
 	}
 
 	{
 		fragment_max_count                  = width * height * kFragmentsPerPixelAverage;
 		const uint32_t fragment_buffer_size = sizeof(glm::uvec3) * fragment_max_count;
 		fragment_buffer                     = std::make_unique<vkb::core::BufferC>(get_device(), fragment_buffer_size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_GPU_ONLY);
+		fragment_buffer->set_debug_name("fragment_buffer");
 	}
 
 	{
 		fragment_counter = std::make_unique<vkb::core::BufferC>(get_device(), sizeof(glm::uint), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY);
+		fragment_counter->set_debug_name("fragment_counter");
 	}
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-/* Copyright (c) 2023-2025, Google`
	`1`	`+/* Copyright (c) 2023-2026, Google`
`2`	`2`	`*`
`3`	`3`	`* SPDX-License-Identifier: Apache-2.0`
`4`	`4`	`*`
`@@ -20,6 +20,9 @@`
`20`	`20`
`21`	`21`	`OITLinkedLists::OITLinkedLists()`
`22`	`22`	`{`
	`23`	`+ title = "OIT linked lists";`
	`24`	`+`
	`25`	`+ add_device_extension(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);`
`23`	`26`	`}`
`24`	`27`
`25`	`28`	`OITLinkedLists::~OITLinkedLists()`
`@@ -115,6 +118,8 @@ void OITLinkedLists::request_gpu_features(vkb::core::PhysicalDeviceC &gpu)`
`115`	`118`	`{`
`116`	`119`	`throw std::runtime_error("This sample requires support for buffers and images stores and atomic operations in the fragment shader stage");`
`117`	`120`	`}`
	`121`	`+`
	`122`	`+ REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceSynchronization2FeaturesKHR, synchronization2);`
`118`	`123`	`}`
`119`	`124`
`120`	`125`	`void OITLinkedLists::on_update_ui_overlay(vkb::Drawer &drawer)`
`@@ -161,13 +166,19 @@ void OITLinkedLists::build_command_buffers()`
`161`	`166`	`vkCmdEndRenderPass(draw_cmd_buffers[i]);`
`162`	`167`	`}`
`163`	`168`
`164`		`- VkImageSubresourceRange subresource_range = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};`
`165`		`- vkb::image_layout_transition(`
`166`		`- draw_cmd_buffers[i], linked_list_head_image->get_handle(),`
`167`		`- VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,`
`168`		`- VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,`
`169`		`- VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,`
`170`		`- subresource_range);`
	`169`	`+ // Insert a pipeline barrier to ensure that all writes to the fragment buffer performed in the gather pass are made available before reading from it in the combine pass`
	`170`	`+ VkBufferMemoryBarrier2 buffer_barrier{.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,`
	`171`	`+ .srcStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,`
	`172`	`+ .srcAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,`
	`173`	`+ .dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,`
	`174`	`+ .dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_READ_BIT,`
	`175`	`+ .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,`
	`176`	`+ .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,`
	`177`	`+ .buffer = fragment_buffer->get_handle(),`
	`178`	`+ .offset = 0,`
	`179`	`+ .size = VK_WHOLE_SIZE};`
	`180`	`+ VkDependencyInfo dependency_info{.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT, .bufferMemoryBarrierCount = 1, .pBufferMemoryBarriers = &buffer_barrier};`
	`181`	`+ vkCmdPipelineBarrier2KHR(draw_cmd_buffers[i], &dependency_info);`
`171`	`182`
`172`	`183`	`// Combine pass`
`173`	`184`	`{`
`@@ -252,17 +263,22 @@ void OITLinkedLists::create_fragment_resources(const uint32_t width, const uint3`
`252`	`263`	`{`
`253`	`264`	`const VkExtent3D image_extent = {width, height, 1};`
`254`	`265`	`linked_list_head_image = std::make_unique<vkb::core::Image>(get_device(), image_extent, VK_FORMAT_R32_UINT, VK_IMAGE_USAGE_STORAGE_BIT \| VK_IMAGE_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY, VK_SAMPLE_COUNT_1_BIT);`
`255`		`- linked_list_head_image_view = std::make_unique<vkb::core::ImageView>(*linked_list_head_image, VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R32_UINT);`
	`266`	`+ linked_list_head_image->set_debug_name("linked_list_head_image");`
	`267`	`+`
	`268`	`+ linked_list_head_image_view = std::make_unique<vkb::core::ImageView>(*linked_list_head_image, VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R32_UINT);`
	`269`	`+ linked_list_head_image_view->set_debug_name("linked_list_head_image_view");`
`256`	`270`	`}`
`257`	`271`
`258`	`272`	`{`
`259`	`273`	`fragment_max_count = width * height * kFragmentsPerPixelAverage;`
`260`	`274`	`const uint32_t fragment_buffer_size = sizeof(glm::uvec3) * fragment_max_count;`
`261`	`275`	`fragment_buffer = std::make_unique<vkb::core::BufferC>(get_device(), fragment_buffer_size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_GPU_ONLY);`
	`276`	`+ fragment_buffer->set_debug_name("fragment_buffer");`
`262`	`277`	`}`
`263`	`278`
`264`	`279`	`{`
`265`	`280`	`fragment_counter = std::make_unique<vkb::core::BufferC>(get_device(), sizeof(glm::uint), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT \| VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY);`
	`281`	`+ fragment_counter->set_debug_name("fragment_counter");`
`266`	`282`	`}`
`267`	`283`	`}`
`268`	`284`