source/backends/vulkan/synchronizer.cpp

   1 #include <msp/core/algorithm.h>
   2 #include "buffer.h"
   3 #include "device.h"
   4 #include "error.h"
   5 #include "texture.h"
   6 #include "synchronizer.h"
   7 #include "vulkan.h"
   8
   9 using namespace std;
  10
  11 namespace Msp {
  12 namespace GL {
  13
  14 Synchronizer::Synchronizer(Device &d):
  15         device(d)
  16 { }
  17
  18 void Synchronizer::write_buffer(VkBuffer buffer, size_t offset, size_t size)
  19 {
  20         auto i = lower_bound_member(buffer_accesses, buffer, &BufferAccess::buffer);
  21         if(i==buffer_accesses.end() || i->buffer!=buffer)
  22         {
  23                 i = buffer_accesses.emplace(i);
  24                 i->buffer = buffer;
  25                 i->offset = offset;
  26                 i->size = size;
  27         }
  28         else
  29         {
  30                 size_t begin = min(offset, i->offset);
  31                 size_t end = max(offset+size, i->offset+i->size);
  32                 i->offset = begin;
  33                 i->size = end-begin;
  34         }
  35
  36         i->pending_write = true;
  37 }
  38
  39 void Synchronizer::split_image_mipmap(VkImage image, unsigned aspect, unsigned n_levels)
  40 {
  41         if(!n_levels)
  42                 throw invalid_argument("Synchronizer::split_image_mipmap");
  43
  44         auto i = lower_bound_member(image_accesses, image, &ImageAccess::image);
  45         if(i!=image_accesses.end() && i->image==image && i->level>=0)
  46                 return;
  47
  48         if(i!=image_accesses.end() && i->image==image && i->level==-1)
  49         {
  50                 i = image_accesses.insert(i, n_levels-1, *i);
  51                 for(unsigned j=0; j<n_levels; ++i, ++j)
  52                         i->level = j;
  53         }
  54         else
  55         {
  56                 ImageAccess access;
  57                 access.image = image;
  58                 access.aspect = aspect;
  59                 access.current_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
  60                 access.pending_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
  61
  62                 if(i->level==-2)
  63                         i = image_accesses.erase(i);
  64
  65                 for(unsigned j=0; j<n_levels; ++i, ++j)
  66                         if(i==image_accesses.end() || i->image!=image || i->level>static_cast<int>(j))
  67                         {
  68                                 i = image_accesses.insert(i, access);
  69                                 i->level = j;
  70                         }
  71         }
  72 }
  73
  74 void Synchronizer::change_image_layout(VkImage image, unsigned aspect, int level, unsigned layout, bool discard)
  75 {
  76         auto i = lower_bound_member(image_accesses, image, &ImageAccess::image);
  77
  78         if(level>=0)
  79         {
  80                 if(i==image_accesses.end() || i->image!=image)
  81                 {
  82                         i = image_accesses.emplace(i);
  83                         i->image = image;
  84                         i->level = -2;
  85                         ++i;
  86                 }
  87                 else if(i->level==-1)
  88                         throw invalid_operation("Synchronizer::change_image_layout");
  89                 else
  90                 {
  91                         for(; (i!=image_accesses.end() && i->image==image && i->level<level); ++i) ;
  92                 }
  93         }
  94         else if(i!=image_accesses.end() && i->image==image && i->level==-2)
  95                 throw invalid_operation("Synchronizer::change_image_layout");
  96
  97         if(i==image_accesses.end() || i->image!=image || (level>=0 && i->level!=level))
  98         {
  99                 i = image_accesses.emplace(i);
 100                 i->image = image;
 101                 i->aspect = aspect;
 102                 i->level = (level<0 ? -1 : level);
 103                 i->current_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 104         }
 105
 106         for(; (i!=image_accesses.end() && i->image==image && (level<0 || i->level==level)); ++i)
 107         {
 108                 if(discard)
 109                         i->current_layout = VK_IMAGE_LAYOUT_UNDEFINED;
 110                 i->pending_layout = layout;
 111         }
 112 }
 113
 114 void Synchronizer::reset()
 115 {
 116         for(BufferAccess &b: buffer_accesses)
 117                 b.pending_write = false;
 118         for(ImageAccess &i: image_accesses)
 119                 i.pending_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 120 }
 121
 122 void Synchronizer::barrier(VkCommandBuffer command_buffer)
 123 {
 124         const VulkanFunctions &vk = device.get_functions();
 125
 126         if(buffer_accesses.empty() && image_accesses.empty())
 127                 return;
 128
 129         VkPipelineStageFlags src_stage = 0;
 130         VkPipelineStageFlags dst_stage = 0;
 131
 132         static constexpr VkPipelineStageFlags buffer_read_stages = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT|
 133                 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT|VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 134         static constexpr VkPipelineStageFlags buffer_write_stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
 135
 136         vector<VkBufferMemoryBarrier> buffer_barriers;
 137         buffer_barriers.reserve(buffer_accesses.size());
 138         for(BufferAccess &b: buffer_accesses)
 139         {
 140                 if(b.pending_write==b.was_written)
 141                         continue;
 142
 143                 buffer_barriers.emplace_back(VkBufferMemoryBarrier{ });
 144                 VkBufferMemoryBarrier &barrier = buffer_barriers.back();
 145
 146                 barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
 147                 barrier.srcAccessMask = (b.was_written ? VK_ACCESS_MEMORY_WRITE_BIT : 0);
 148                 barrier.dstAccessMask = (b.pending_write ? VK_ACCESS_MEMORY_WRITE_BIT : VK_ACCESS_MEMORY_READ_BIT);
 149                 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
 150                 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
 151                 barrier.buffer = handle_cast<::VkBuffer>(b.buffer);
 152                 barrier.offset = b.offset;
 153                 barrier.size = b.size;
 154
 155                 src_stage |= (b.was_written ? buffer_write_stages : buffer_read_stages);
 156                 dst_stage |= (b.pending_write ? buffer_write_stages : buffer_read_stages);
 157         }
 158
 159         static constexpr VkPipelineStageFlags image_read_stages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT|VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT|
 160                 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
 161         static constexpr VkPipelineStageFlags image_write_stages = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT|
 162                 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT|VK_PIPELINE_STAGE_TRANSFER_BIT;
 163
 164         vector<VkImageMemoryBarrier> image_barriers;
 165         image_barriers.reserve(image_accesses.size());
 166         for(const ImageAccess &i: image_accesses)
 167         {
 168                 if(i.level==-2 || i.pending_layout==i.current_layout)
 169                         continue;
 170
 171                 image_barriers.emplace_back(VkImageMemoryBarrier{ });
 172                 VkImageMemoryBarrier &barrier = image_barriers.back();
 173
 174                 barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
 175                 barrier.srcAccessMask = (is_write_layout(i.current_layout) ? VK_ACCESS_MEMORY_WRITE_BIT : 0);
 176                 barrier.dstAccessMask = (is_write_layout(i.pending_layout) ? VK_ACCESS_MEMORY_WRITE_BIT : VK_ACCESS_MEMORY_READ_BIT);
 177                 barrier.oldLayout = static_cast<VkImageLayout>(i.current_layout);
 178                 barrier.newLayout = static_cast<VkImageLayout>(i.pending_layout);
 179                 barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
 180                 barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
 181                 barrier.image = handle_cast<::VkImage>(i.image);
 182                 barrier.subresourceRange.aspectMask = i.aspect;
 183                 barrier.subresourceRange.baseMipLevel = max(i.level, 0);
 184                 barrier.subresourceRange.levelCount = (i.level<0 ? VK_REMAINING_MIP_LEVELS : 1);
 185                 barrier.subresourceRange.baseArrayLayer = 0;
 186                 barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
 187
 188                 if(i.current_layout!=VK_IMAGE_LAYOUT_UNDEFINED)
 189                         src_stage |= (is_write_layout(i.current_layout) ? image_write_stages : image_read_stages);
 190                 dst_stage |= (is_write_layout(i.pending_layout) ? image_write_stages : image_read_stages);
 191         }
 192
 193         if(buffer_barriers.empty() && image_barriers.empty())
 194                 return;
 195
 196         if(!src_stage)
 197                 src_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 198         if(!dst_stage)
 199                 dst_stage = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 200
 201         vk.CmdPipelineBarrier(command_buffer, src_stage, dst_stage, 0, 0, 0,
 202                 buffer_barriers.size(), buffer_barriers.data(), image_barriers.size(), image_barriers.data());
 203
 204         for(auto i=buffer_accesses.begin(); i!=buffer_accesses.end(); )
 205         {
 206                 if(!i->pending_write)
 207                         i = buffer_accesses.erase(i);
 208                 else
 209                 {
 210                         i->was_written = i->pending_write;
 211                         ++i;
 212                 }
 213         }
 214
 215         bool sparse_levels = false;
 216         for(auto i=image_accesses.begin(); i!=image_accesses.end(); )
 217         {
 218                 if(i->level==-2)
 219                 {
 220                         sparse_levels = true;
 221                         ++i;
 222                 }
 223                 else if(i->pending_layout==VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
 224                 {
 225                         VkImage image = i->image;
 226                         i = image_accesses.erase(i);
 227                         if(i->image!=image)
 228                         {
 229                                 if(sparse_levels)
 230                                 {
 231                                         auto j = prev(i);
 232                                         if(j->level==-2)
 233                                                 i = image_accesses.erase(j);
 234                                 }
 235                                 sparse_levels = false;
 236                         }
 237                 }
 238                 else
 239                 {
 240                         i->current_layout = i->pending_layout;
 241                         ++i;
 242                 }
 243         }
 244 }
 245
 246 bool Synchronizer::is_write_layout(unsigned layout)
 247 {
 248         return layout==VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL || layout==VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ||
 249                 layout==VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 250 }
 251
 252 } // namespace GL
 253 } // namespace Msp