X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fbackends%2Fvulkan%2Fsynchronizer.cpp;h=3ec04026a09ae2e2617c3461e4a746544f0ab119;hb=8ab7589d65c4f8ca799f2a6886d128f4c36ff046;hp=85c813e261e79536910f468480db1ce74c969f7a;hpb=644b81d62660bafa702bfd7acedd3a0039aad993;p=libs%2Fgl.git

diff --git a/source/backends/vulkan/synchronizer.cpp b/source/backends/vulkan/synchronizer.cpp
index 85c813e2..3ec04026 100644
--- a/source/backends/vulkan/synchronizer.cpp
+++ b/source/backends/vulkan/synchronizer.cpp
@@ -1,6 +1,7 @@
 #include <msp/core/algorithm.h>
 #include "buffer.h"
 #include "device.h"
+#include "error.h"
 #include "texture.h"
 #include "synchronizer.h"
 #include "vulkan.h"
@@ -14,12 +15,12 @@ Synchronizer::Synchronizer(Device &d):
 	device(d)
 { }
 
-void Synchronizer::access(VkBuffer buffer, size_t offset, size_t size)
+void Synchronizer::write_buffer(VkBuffer buffer, size_t offset, size_t size)
 {
-	auto i = find_member(buffer_accesses, buffer, &BufferAccess::buffer);
-	if(i==buffer_accesses.end())
+	auto i = lower_bound_member(buffer_accesses, buffer, &BufferAccess::buffer);
+	if(i==buffer_accesses.end() || i->buffer!=buffer)
 	{
-		i = buffer_accesses.emplace(buffer_accesses.end());
+		i = buffer_accesses.emplace(i);
 		i->buffer = buffer;
 		i->offset = offset;
 		i->size = size;
@@ -35,17 +36,94 @@ void Synchronizer::access(VkBuffer buffer, size_t offset, size_t size)
 	i->pending_write = true;
 }
 
+void Synchronizer::split_image_mipmap(VkImage image, unsigned aspect, unsigned n_levels)
+{
+	if(!n_levels)
+		throw invalid_argument("Synchronizer::split_image_mipmap");
+
+	auto i = lower_bound_member(image_accesses, image, &ImageAccess::image);
+	if(i!=image_accesses.end() && i->image==image && i->level>=0)
+		return;
+
+	if(i!=image_accesses.end() && i->image==image && i->level==-1)
+	{
+		i = image_accesses.insert(i, n_levels-1, *i);
+		for(unsigned j=0; j<n_levels; ++i, ++j)
+			i->level = j;
+	}
+	else
+	{
+		ImageAccess access;
+		access.image = image;
+		access.aspect = aspect;
+		access.current_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+		access.pending_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+
+		if(i->level==-2)
+			i = image_accesses.erase(i);
+
+		for(unsigned j=0; j<n_levels; ++i, ++j)
+			if(i==image_accesses.end() || i->image!=image || i->level>static_cast<int>(j))
+			{
+				i = image_accesses.insert(i, access);
+				i->level = j;
+			}
+	}
+}
+
+void Synchronizer::change_image_layout(VkImage image, unsigned aspect, int level, unsigned layout, bool discard)
+{
+	auto i = lower_bound_member(image_accesses, image, &ImageAccess::image);
+
+	if(level>=0)
+	{
+		if(i==image_accesses.end() || i->image!=image)
+		{
+			i = image_accesses.emplace(i);
+			i->image = image;
+			i->level = -2;
+			++i;
+		}
+		else if(i->level==-1)
+			throw invalid_operation("Synchronizer::change_image_layout");
+		else
+		{
+			for(; (i!=image_accesses.end() && i->image==image && i->level<level); ++i) ;
+		}
+	}
+	else if(i!=image_accesses.end() && i->image==image && i->level==-2)
+		throw invalid_operation("Synchronizer::change_image_layout");
+
+	if(i==image_accesses.end() || i->image!=image || (level>=0 && i->level!=level))
+	{
+		i = image_accesses.emplace(i);
+		i->image = image;
+		i->aspect = aspect;
+		i->level = (level<0 ? -1 : level);
+		i->current_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+	}
+
+	for(; (i!=image_accesses.end() && i->image==image && (level<0 || i->level==level)); ++i)
+	{
+		if(discard)
+			i->current_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+		i->pending_layout = layout;
+	}
+}
+
 void Synchronizer::reset()
 {
 	for(BufferAccess &b: buffer_accesses)
 		b.pending_write = false;
+	for(ImageAccess &i: image_accesses)
+		i.pending_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 }
 
 void Synchronizer::barrier(VkCommandBuffer command_buffer)
 {
 	const VulkanFunctions &vk = device.get_functions();
 
-	if(buffer_accesses.empty())
+	if(buffer_accesses.empty() && image_accesses.empty())
 		return;
 
 	VkPipelineStageFlags src_stage = 0;
@@ -59,6 +137,9 @@ void Synchronizer::barrier(VkCommandBuffer command_buffer)
 	buffer_barriers.reserve(buffer_accesses.size());
 	for(BufferAccess &b: buffer_accesses)
 	{
+		if(b.pending_write==b.was_written)
+			continue;
+
 		buffer_barriers.emplace_back(VkBufferMemoryBarrier{ });
 		VkBufferMemoryBarrier &barrier = buffer_barriers.back();
 
@@ -75,13 +156,50 @@ void Synchronizer::barrier(VkCommandBuffer command_buffer)
 		dst_stage |= (b.pending_write ? buffer_write_stages : buffer_read_stages);
 	}
 
+	static constexpr VkPipelineStageFlags image_read_stages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT|VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT|
+		VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
+	static constexpr VkPipelineStageFlags image_write_stages = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT|
+		VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT|VK_PIPELINE_STAGE_TRANSFER_BIT;
+
+	vector<VkImageMemoryBarrier> image_barriers;
+	image_barriers.reserve(image_accesses.size());
+	for(const ImageAccess &i: image_accesses)
+	{
+		if(i.level==-2 || i.pending_layout==i.current_layout)
+			continue;
+
+		image_barriers.emplace_back(VkImageMemoryBarrier{ });
+		VkImageMemoryBarrier &barrier = image_barriers.back();
+
+		barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+		barrier.srcAccessMask = (is_write_layout(i.current_layout) ? VK_ACCESS_MEMORY_WRITE_BIT : 0);
+		barrier.dstAccessMask = (is_write_layout(i.pending_layout) ? VK_ACCESS_MEMORY_WRITE_BIT : VK_ACCESS_MEMORY_READ_BIT);
+		barrier.oldLayout = static_cast<VkImageLayout>(i.current_layout);
+		barrier.newLayout = static_cast<VkImageLayout>(i.pending_layout);
+		barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		barrier.image = handle_cast<::VkImage>(i.image);
+		barrier.subresourceRange.aspectMask = i.aspect;
+		barrier.subresourceRange.baseMipLevel = max(i.level, 0);
+		barrier.subresourceRange.levelCount = (i.level<0 ? VK_REMAINING_MIP_LEVELS : 1);
+		barrier.subresourceRange.baseArrayLayer = 0;
+		barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
+
+		if(i.current_layout!=VK_IMAGE_LAYOUT_UNDEFINED)
+			src_stage |= (is_write_layout(i.current_layout) ? image_write_stages : image_read_stages);
+		dst_stage |= (is_write_layout(i.pending_layout) ? image_write_stages : image_read_stages);
+	}
+
+	if(buffer_barriers.empty() && image_barriers.empty())
+		return;
+
 	if(!src_stage)
 		src_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 	if(!dst_stage)
 		dst_stage = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 
 	vk.CmdPipelineBarrier(command_buffer, src_stage, dst_stage, 0, 0, 0,
-		buffer_barriers.size(), buffer_barriers.data(), 0, 0);
+		buffer_barriers.size(), buffer_barriers.data(), image_barriers.size(), image_barriers.data());
 
 	for(auto i=buffer_accesses.begin(); i!=buffer_accesses.end(); )
 	{
@@ -93,6 +211,42 @@ void Synchronizer::barrier(VkCommandBuffer command_buffer)
 			++i;
 		}
 	}
+
+	bool sparse_levels = false;
+	for(auto i=image_accesses.begin(); i!=image_accesses.end(); )
+	{
+		if(i->level==-2)
+		{
+			sparse_levels = true;
+			++i;
+		}
+		else if(i->pending_layout==VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
+		{
+			VkImage image = i->image;
+			i = image_accesses.erase(i);
+			if(i->image!=image)
+			{
+				if(sparse_levels)
+				{
+					auto j = prev(i);
+					if(j->level==-2)
+						i = image_accesses.erase(j);
+				}
+				sparse_levels = false;
+			}
+		}
+		else
+		{
+			i->current_layout = i->pending_layout;
+			++i;
+		}
+	}
+}
+
+bool Synchronizer::is_write_layout(unsigned layout)
+{
+	return layout==VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL || layout==VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ||
+		layout==VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 }
 
 } // namespace GL