[Graphite] Use mappable buffers for Vulkan instrinsic uniforms.

Change-Id: Ic5dcec4a346c5093c64f4010c084ed4028e0086d
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/912216
Commit-Queue: Greg Daniel <[email protected]>
Reviewed-by: Michael Ludwig <[email protected]>

Author: egdaniel

src/gpu/graphite/vk/VulkanCommandBuffer.cpp

@@ -21,6 +21,7 @@
 #include "src/gpu/graphite/TextureProxy.h"
 #include "src/gpu/graphite/UniformManager.h"
 #include "src/gpu/graphite/vk/VulkanBuffer.h"
+#include "src/gpu/graphite/vk/VulkanCaps.h"
 #include "src/gpu/graphite/vk/VulkanDescriptorSet.h"
 #include "src/gpu/graphite/vk/VulkanFramebuffer.h"
 #include "src/gpu/graphite/vk/VulkanGraphiteUtilsPriv.h"
@@ -36,6 +37,82 @@ namespace skgpu::graphite {
 
 class VulkanDescriptorSet;
 
+/**
+ * Since intrinsic uniforms need to be read in the vertex shader, we cannot use protected buffers
+ * for them when submitting protected work. Thus in order to upload data to them, we need to make
+ * them mappable instead of using commands to copy data to them (would require them to be
+ * protected if we did). This helper class manages rotating through buffers and writing each new
+ * occurrence of a set of intrinsic uniforms into the current buffer.
+ *
+ * Ideally we would remove this class and instead use push constants for all intrinsic uniforms.
+ */
+class VulkanCommandBuffer::IntrinsicConstantsManager {
+public:
+    BindBufferInfo add(VulkanCommandBuffer* cb, UniformDataBlock intrinsicValues) {
+        static constexpr int kNumSlots = 8;
+
+        BindBufferInfo* existing = fCachedIntrinsicValues.find(intrinsicValues);
+        if (existing) {
+            return *existing;
+        }
+
+        SkASSERT(!cb->fActiveRenderPass);
+
+        const Caps* caps = cb->fSharedContext->caps();
+        const uint32_t stride =
+                SkAlignTo(intrinsicValues.size(), caps->requiredUniformBufferAlignment());
+        if (!fCurrentBuffer || fSlotsUsed == kNumSlots) {
+            VulkanResourceProvider* resourceProvider = cb->fResourceProvider;
+            sk_sp<Buffer> buffer = resourceProvider->findOrCreateBuffer(stride * kNumSlots,
+                                                                        BufferType::kUniform,
+                                                                        AccessPattern::kHostVisible,
+                                                                        "IntrinsicConstantBuffer");
+            if (!buffer) {
+                return {};
+            }
+            VulkanBuffer* ptr = static_cast<VulkanBuffer*>(buffer.release());
+            fCurrentBuffer = sk_sp<VulkanBuffer>(ptr);
+
+            fSlotsUsed = 0;
+
+            if (!fCurrentBuffer) {
+                // If we failed to create a GPU buffer to hold the intrinsic uniforms, we will fail
+                // the Recording being inserted, so return an empty bind info.
+                return {};
+            }
+            cb->trackResource(fCurrentBuffer);
+        }
+
+        SkASSERT(fCurrentBuffer && fSlotsUsed < kNumSlots);
+        void* mapPtr = fCurrentBuffer->map();
+        if (!mapPtr) {
+            return {};
+        }
+        uint32_t offset = (fSlotsUsed++) * stride;
+        mapPtr = SkTAddOffset<void>(mapPtr, static_cast<ptrdiff_t>(offset));
+        memcpy(mapPtr, intrinsicValues.data(), intrinsicValues.size());
+
+        BindBufferInfo binding{
+                fCurrentBuffer.get(), offset, SkTo<uint32_t>(intrinsicValues.size())};
+        fCachedIntrinsicValues.set(UniformDataBlock::Make(intrinsicValues, &fUniformData), binding);
+        return binding;
+    }
+
+private:
+    // The current buffer being filled up, as well as the how much of it has been written to.
+    sk_sp<VulkanBuffer> fCurrentBuffer;
+    int fSlotsUsed = 0;  // in multiples of the intrinsic uniform size and UBO binding requirement
+
+    // All uploaded intrinsic uniform sets and where they are on the GPU. All uniform sets are
+    // cached for the duration of a CommandBuffer since the maximum number of elements in this
+    // collection will equal the number of render passes and the intrinsic constants aren't that
+    // large. This maximizes the chance for reuse between passes.
+    skia_private::THashMap<UniformDataBlock, BindBufferInfo, UniformDataBlock::Hash>
+            fCachedIntrinsicValues;
+    SkArenaAlloc fUniformData{0};
+};
+
+
 std::unique_ptr<VulkanCommandBuffer> VulkanCommandBuffer::Make(
         const VulkanSharedContext* sharedContext,
         VulkanResourceProvider* resourceProvider,
@@ -121,6 +198,7 @@ void VulkanCommandBuffer::onResetCommandBuffer() {
     SkASSERT(!fActive);
     VULKAN_CALL_ERRCHECK(fSharedContext, ResetCommandPool(fSharedContext->device(), fPool, 0));
     fActiveGraphicsPipeline = nullptr;
+    fIntrinsicConstants = nullptr;
     fBindUniformBuffers = true;
     fBoundIndexBuffer = VK_NULL_HANDLE;
     fBoundIndexBufferOffset = 0;
@@ -156,6 +234,7 @@ void VulkanCommandBuffer::begin() {
 
     VULKAN_CALL_ERRCHECK(fSharedContext,
                          BeginCommandBuffer(fPrimaryCommandBuffer, &cmdBufferBeginInfo));
+    fIntrinsicConstants = std::make_unique<IntrinsicConstantsManager>();
     fActive = true;
 }
 
@@ -369,33 +448,24 @@ void VulkanCommandBuffer::waitUntilFinished() {
                                        /*timeout=*/UINT64_MAX));
 }
 
-void VulkanCommandBuffer::updateIntrinsicUniforms(SkIRect viewport) {
+bool VulkanCommandBuffer::updateIntrinsicUniforms(SkIRect viewport) {
     SkASSERT(fActive && !fActiveRenderPass);
 
     // The SkSL has declared these as a top-level interface block, which will use std140 in Vulkan.
     // If we switch to supporting push constants here, it would be std430 instead.
     UniformManager intrinsicValues{Layout::kStd140};
     CollectIntrinsicUniforms(fSharedContext->caps(), viewport, fDstCopyBounds, &intrinsicValues);
-    SkSpan<const char> bytes = intrinsicValues.finish();
-    SkASSERT(bytes.size_bytes() == VulkanResourceProvider::kIntrinsicConstantSize);
-
-    sk_sp<Buffer> intrinsicUniformBuffer = fResourceProvider->refIntrinsicConstantBuffer();
-    const VulkanBuffer* intrinsicVulkanBuffer =
-            static_cast<VulkanBuffer*>(intrinsicUniformBuffer.get());
-    SkASSERT(intrinsicVulkanBuffer && intrinsicVulkanBuffer->size() >= bytes.size_bytes());
-
-    fUniformBuffersToBind[VulkanGraphicsPipeline::kIntrinsicUniformBufferIndex] = {
-            intrinsicUniformBuffer.get(),
-            /*offset=*/0,
-            SkTo<uint32_t>(bytes.size_bytes())
-        };
-
-    this->updateBuffer(intrinsicVulkanBuffer, bytes.data(), bytes.size_bytes());
+    BindBufferInfo binding =
+            fIntrinsicConstants->add(this, UniformDataBlock::Wrap(&intrinsicValues));
+    if (!binding) {
+        return false;
+    } else if (binding ==
+               fUniformBuffersToBind[VulkanGraphicsPipeline::kIntrinsicUniformBufferIndex]) {
+        return true;  // no binding change needed
+    }
 
-    // Ensure the buffer update is completed and made visible before reading
-    intrinsicVulkanBuffer->setBufferAccess(this, VK_ACCESS_UNIFORM_READ_BIT,
-                                           VK_PIPELINE_STAGE_VERTEX_SHADER_BIT);
-    this->trackResource(std::move(intrinsicUniformBuffer));
+    fUniformBuffersToBind[VulkanGraphicsPipeline::kIntrinsicUniformBufferIndex] = binding;
+    return true;
 }
 
 bool VulkanCommandBuffer::onAddRenderPass(const RenderPassDesc& renderPassDesc,
@@ -424,7 +494,9 @@ bool VulkanCommandBuffer::onAddRenderPass(const RenderPassDesc& renderPassDesc,
         }
     }
 
-    this->updateIntrinsicUniforms(viewport);
+    if (!this->updateIntrinsicUniforms(viewport)) {
+        return false;
+    }
     this->setViewport(viewport);
 
     if (!this->beginRenderPass(renderPassDesc,

src/gpu/graphite/vk/VulkanCommandBuffer.h

@@ -167,7 +167,7 @@ class VulkanCommandBuffer final : public CommandBuffer {
 
     // Update the intrinsic constant uniform buffer and binding to reflect the updated viewport.
     // The resource provider is responsible for finding a suitable buffer and managing its lifetime.
-    void updateIntrinsicUniforms(SkIRect viewport);
+    bool updateIntrinsicUniforms(SkIRect viewport);
 
     bool updateLoadMSAAVertexBuffer();
     bool loadMSAAFromResolve(const RenderPassDesc&,
@@ -225,6 +225,9 @@ class VulkanCommandBuffer final : public CommandBuffer {
     size_t fBoundIndirectBufferOffset = 0;
 
     float fCachedBlendConstant[4];
+
+    class IntrinsicConstantsManager;
+    std::unique_ptr<IntrinsicConstantsManager> fIntrinsicConstants;
 };
 
 } // namespace skgpu::graphite