Vulkan: Implement shader buffers descriptor cache.

src/common/bitset_utils.h

@@ -486,20 +486,9 @@ using BitSet = typename priv::GetBitSet<N>::Type;
 template <std::size_t N>
 class BitSetArray final
 {
-  private:
-    static constexpr std::size_t kDefaultBitSetSizeMinusOne = priv::kDefaultBitSetSize - 1;
-    static constexpr std::size_t kShiftForDivision =
-        static_cast<std::size_t>(rx::Log2(static_cast<unsigned int>(priv::kDefaultBitSetSize)));
-    static constexpr std::size_t kArraySize =
-        ((N + kDefaultBitSetSizeMinusOne) >> kShiftForDivision);
-    constexpr static std::size_t kLastElementCount = (N & kDefaultBitSetSizeMinusOne);
-    constexpr static std::size_t kLastElementMask  = priv::BaseBitSetType::Mask(
-        kLastElementCount == 0 ? priv::kDefaultBitSetSize : kLastElementCount);
-
+  public:
     using BaseBitSet = priv::BaseBitSetType;
-    std::array<BaseBitSet, kArraySize> mBaseBitSetArray;
 
-  public:
     BitSetArray();
     BitSetArray(const BitSetArray<N> &other);
 
@@ -671,6 +660,20 @@ class BitSetArray final
     std::size_t count() const;
     bool intersects(const BitSetArray &other) const;
     BitSetArray<N> &flip();
+
+    BaseBitSet::value_type bits(size_t index) const;
+
+  private:
+    static constexpr std::size_t kDefaultBitSetSizeMinusOne = priv::kDefaultBitSetSize - 1;
+    static constexpr std::size_t kShiftForDivision =
+        static_cast<std::size_t>(rx::Log2(static_cast<unsigned int>(priv::kDefaultBitSetSize)));
+    static constexpr std::size_t kArraySize =
+        ((N + kDefaultBitSetSizeMinusOne) >> kShiftForDivision);
+    constexpr static std::size_t kLastElementCount = (N & kDefaultBitSetSizeMinusOne);
+    constexpr static std::size_t kLastElementMask  = priv::BaseBitSetType::Mask(
+        kLastElementCount == 0 ? priv::kDefaultBitSetSize : kLastElementCount);
+
+    std::array<BaseBitSet, kArraySize> mBaseBitSetArray;
 };
 
 template <std::size_t N>
@@ -982,6 +985,12 @@ BitSetArray<N> &BitSetArray<N>::flip()
     mBaseBitSetArray[kArraySize - 1] &= kLastElementMask;
     return *this;
 }
+
+template <std::size_t N>
+typename BitSetArray<N>::BaseBitSet::value_type BitSetArray<N>::bits(size_t index) const
+{
+    return mBaseBitSetArray[index].bits();
+}
 }  // namespace angle
 
 template <size_t N, typename BitsT, typename ParamT>

src/common/bitset_utils_unittest.cpp

@@ -403,6 +403,7 @@ TYPED_TEST(BitSetArrayTest, BasicTest)
     EXPECT_FALSE(mBits.any());
     EXPECT_TRUE(mBits.none());
     EXPECT_EQ(mBits.count(), 0u);
+    EXPECT_EQ(mBits.bits(0), 0u);
 
     // Verify set on a single bit
     mBits.set(45);
@@ -452,8 +453,11 @@ TYPED_TEST(BitSetArrayTest, BasicTest)
     // Test intersection logic
     TypeParam testBitSet;
     testBitSet.set(1);
+    EXPECT_EQ(testBitSet.bits(0), (1ul << 1ul));
     testBitSet.set(3);
+    EXPECT_EQ(testBitSet.bits(0), (1ul << 1ul) | (1ul << 3ul));
     testBitSet.set(5);
+    EXPECT_EQ(testBitSet.bits(0), (1ul << 1ul) | (1ul << 3ul) | (1ul << 5ul));
     EXPECT_FALSE(mBits.intersects(testBitSet));
     mBits.set(3);
     EXPECT_TRUE(mBits.intersects(testBitSet));

src/libANGLE/State.h

@@ -453,6 +453,22 @@ class State : angle::NonCopyable
     const OffsetBindingPointer<Buffer> &getIndexedAtomicCounterBuffer(size_t index) const;
     const OffsetBindingPointer<Buffer> &getIndexedShaderStorageBuffer(size_t index) const;
 
+    const angle::BitSet<gl::IMPLEMENTATION_MAX_UNIFORM_BUFFER_BINDINGS> &getUniformBuffersMask()
+        const
+    {
+        return mBoundUniformBuffersMask;
+    }
+    const angle::BitSet<gl::IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS>
+        &getAtomicCounterBuffersMask() const
+    {
+        return mBoundAtomicCounterBuffersMask;
+    }
+    const angle::BitSet<gl::IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS>
+        &getShaderStorageBuffersMask() const
+    {
+        return mBoundShaderStorageBuffersMask;
+    }
+
     // Detach a buffer from all bindings
     angle::Result detachBuffer(Context *context, const Buffer *buffer);
 

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -440,12 +440,6 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
     vk::DescriptorSetLayoutDesc getDriverUniformsDescriptorSetDesc(
         VkShaderStageFlags shaderStages) const;
 
-    // We use textureSerial to optimize texture binding updates. Each permutation of a
-    // {VkImage/VkSampler} generates a unique serial. These object ids are combined to form a unique
-    // signature for each descriptor set. This allows us to keep a cache of descriptor sets and
-    // avoid calling vkAllocateDesctiporSets each texture update.
-    const vk::TextureDescriptorDesc &getActiveTexturesDesc() const { return mActiveTexturesDesc; }
-
     void updateScissor(const gl::State &glState);
 
     bool emulateSeamfulCubeMapSampling() const { return mEmulateSeamfulCubeMapSampling; }
@@ -867,7 +861,6 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
     void writeAtomicCounterBufferDriverUniformOffsets(uint32_t *offsetsOut, size_t offsetsSize);
 
     angle::Result submitFrame(const vk::Semaphore *signalSemaphore);
-    angle::Result memoryBarrierImpl(GLbitfield barriers, VkPipelineStageFlags stageMask);
 
     angle::Result synchronizeCpuGpuTime();
     angle::Result traceGpuEventImpl(vk::CommandBuffer *commandBuffer,
@@ -1037,8 +1030,15 @@ class ContextVk : public ContextImpl, public vk::Context, public MultisampleText
     // This cache should also probably include the texture index (shader location) and array
     // index (also in the shader). This info is used in the descriptor update step.
     gl::ActiveTextureArray<vk::TextureUnit> mActiveTextures;
+
+    // We use textureSerial to optimize texture binding updates. Each permutation of a
+    // {VkImage/VkSampler} generates a unique serial. These object ids are combined to form a unique
+    // signature for each descriptor set. This allows us to keep a cache of descriptor sets and
+    // avoid calling vkAllocateDesctiporSets each texture update.
     vk::TextureDescriptorDesc mActiveTexturesDesc;
 
+    vk::ShaderBuffersDescriptorDesc mShaderBuffersDescriptorDesc;
+
     gl::ActiveTextureArray<TextureVk *> mActiveImages;
 
     // "Current Value" aka default vertex attribute state.

src/libANGLE/renderer/vulkan/ProgramExecutableVk.h

@@ -152,10 +152,13 @@ class ProgramExecutableVk
     angle::Result createPipelineLayout(const gl::Context *glContext,
                                        gl::ActiveTextureArray<vk::TextureUnit> *activeTextures);
 
-    angle::Result updateTexturesDescriptorSet(ContextVk *contextVk);
-    angle::Result updateShaderResourcesDescriptorSet(ContextVk *contextVk,
-                                                     FramebufferVk *framebufferVk,
-                                                     vk::CommandBufferHelper *commandBufferHelper);
+    angle::Result updateTexturesDescriptorSet(ContextVk *contextVk,
+                                              const vk::TextureDescriptorDesc &texturesDesc);
+    angle::Result updateShaderResourcesDescriptorSet(
+        ContextVk *contextVk,
+        FramebufferVk *framebufferVk,
+        const vk::ShaderBuffersDescriptorDesc &shaderBuffersDesc,
+        vk::CommandBufferHelper *commandBufferHelper);
     angle::Result updateTransformFeedbackDescriptorSet(
         const gl::ProgramState &programState,
         gl::ShaderMap<DefaultUniformBlock> &defaultUniformBlocks,
@@ -182,6 +185,11 @@ class ProgramExecutableVk
         mProgramPipeline = pipeline;
     }
 
+    bool usesDynamicUniformBufferDescriptors() const
+    {
+        return mUniformBufferDescriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
+    }
+
     ProgramExecutablePerfCounters getAndResetObjectPerfCounters();
 
   private:
@@ -222,18 +230,23 @@ class ProgramExecutableVk
                                             ContextVk *contextVk);
     void updateTransformFeedbackDescriptorSetImpl(const gl::ProgramState &programState,
                                                   ContextVk *contextVk);
-    angle::Result getOrAllocateShaderResourcesDescriptorSet(ContextVk *contextVk,
-                                                            VkDescriptorSet *descriptorSetOut);
-    angle::Result updateBuffersDescriptorSet(ContextVk *contextVk,
-                                             const gl::ShaderType shaderType,
-                                             vk::CommandBufferHelper *commandBufferHelper,
-                                             const std::vector<gl::InterfaceBlock> &blocks,
-                                             VkDescriptorType descriptorType);
+    angle::Result getOrAllocateShaderResourcesDescriptorSet(
+        ContextVk *contextVk,
+        const vk::ShaderBuffersDescriptorDesc *shaderBuffersDesc,
+        VkDescriptorSet *descriptorSetOut);
+    angle::Result updateBuffersDescriptorSet(
+        ContextVk *contextVk,
+        const gl::ShaderType shaderType,
+        const vk::ShaderBuffersDescriptorDesc &shaderBuffersDesc,
+        const std::vector<gl::InterfaceBlock> &blocks,
+        VkDescriptorType descriptorType,
+        bool cacheHit);
     angle::Result updateAtomicCounterBuffersDescriptorSet(
+        ContextVk *contextVk,
         const gl::ProgramState &programState,
         const gl::ShaderType shaderType,
-        ContextVk *contextVk,
-        vk::CommandBufferHelper *commandBufferHelper);
+        const vk::ShaderBuffersDescriptorDesc &shaderBuffersDesc,
+        bool cacheHit);
     angle::Result updateImagesDescriptorSet(ContextVk *contextVk,
                                             const gl::ProgramExecutable &executable,
                                             const gl::ShaderType shaderType);
@@ -247,13 +260,15 @@ class ProgramExecutableVk
     // Descriptor sets for uniform blocks and textures for this program.
     vk::DescriptorSetArray<VkDescriptorSet> mDescriptorSets;
     vk::DescriptorSetArray<VkDescriptorSet> mEmptyDescriptorSets;
-    size_t mNumDefaultUniformDescriptors;
+    uint32_t mNumDefaultUniformDescriptors;
     vk::BufferSerial mCurrentDefaultUniformBufferSerial;
 
     DescriptorSetCache<vk::UniformsAndXfbDescriptorDesc, VulkanCacheType::UniformsAndXfbDescriptors>
         mUniformsAndXfbDescriptorsCache;
     DescriptorSetCache<vk::TextureDescriptorDesc, VulkanCacheType::TextureDescriptors>
         mTextureDescriptorsCache;
+    DescriptorSetCache<vk::ShaderBuffersDescriptorDesc, VulkanCacheType::ShaderBuffersDescriptors>
+        mShaderBufferDescriptorsCache;
 
     // We keep a reference to the pipeline and descriptor set layouts. This ensures they don't get
     // deleted while this program is in use.
@@ -270,7 +285,9 @@ class ProgramExecutableVk
     vk::DescriptorSetArray<vk::DynamicDescriptorPool> mDynamicDescriptorPools;
 
     // A set of dynamic offsets used with vkCmdBindDescriptorSets for the default uniform buffers.
-    gl::ShaderVector<uint32_t> mDynamicDescriptorOffsets;
+    VkDescriptorType mUniformBufferDescriptorType;
+    gl::ShaderVector<uint32_t> mDynamicUniformDescriptorOffsets;
+    std::vector<uint32_t> mDynamicShaderBufferDescriptorOffsets;
 
     // TODO: http://anglebug.com/4524: Need a different hash key than a string,
     // since that's slow to calculate.

src/libANGLE/renderer/vulkan/ProgramPipelineVk.cpp

@@ -179,7 +179,7 @@ angle::Result ProgramPipelineVk::updateUniforms(ContextVk *contextVk)
             const angle::MemoryBuffer &uniformData =
                 programVk->getDefaultUniformBlocks()[shaderType].uniformData;
             memcpy(&bufferData[offsets[shaderType]], uniformData.data(), uniformData.size());
-            mExecutable.mDynamicDescriptorOffsets[offsetIndex] =
+            mExecutable.mDynamicUniformDescriptorOffsets[offsetIndex] =
                 static_cast<uint32_t>(bufferOffset + offsets[shaderType]);
             programVk->clearShaderUniformDirtyBit(shaderType);
         }

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -758,7 +758,7 @@ angle::Result ProgramVk::updateUniforms(ContextVk *contextVk)
         {
             const angle::MemoryBuffer &uniformData = mDefaultUniformBlocks[shaderType].uniformData;
             memcpy(&bufferData[offsets[shaderType]], uniformData.data(), uniformData.size());
-            mExecutable.mDynamicDescriptorOffsets[offsetIndex] =
+            mExecutable.mDynamicUniformDescriptorOffsets[offsetIndex] =
                 static_cast<uint32_t>(bufferOffset + offsets[shaderType]);
             mDefaultUniformBlocksDirty.reset(shaderType);
         }

src/libANGLE/renderer/vulkan/vk_cache_utils.cpp

@@ -3024,6 +3024,41 @@ bool UniformsAndXfbDescriptorDesc::operator==(const UniformsAndXfbDescriptorDesc
     return memcmp(&mBufferSerials, &other.mBufferSerials, sizeof(BufferSerial) * mBufferCount) == 0;
 }
 
+// ShaderBuffersDescriptorDesc implementation.
+ShaderBuffersDescriptorDesc::ShaderBuffersDescriptorDesc()
+{
+    reset();
+}
+
+ShaderBuffersDescriptorDesc::~ShaderBuffersDescriptorDesc() = default;
+
+ShaderBuffersDescriptorDesc::ShaderBuffersDescriptorDesc(const ShaderBuffersDescriptorDesc &other) =
+    default;
+
+ShaderBuffersDescriptorDesc &ShaderBuffersDescriptorDesc::operator=(
+    const ShaderBuffersDescriptorDesc &other) = default;
+
+size_t ShaderBuffersDescriptorDesc::hash() const
+{
+    return angle::ComputeGenericHash(mPayload.data(), sizeof(mPayload[0]) * mPayload.size());
+}
+
+void ShaderBuffersDescriptorDesc::reset()
+{
+    mPayload.clear();
+}
+
+bool ShaderBuffersDescriptorDesc::operator==(const ShaderBuffersDescriptorDesc &other) const
+{
+    return mPayload == other.mPayload;
+}
+
+void ShaderBuffersDescriptorDesc::append64BitValue(uint64_t value)
+{
+    mPayload.push_back(static_cast<uint32_t>(value & (angle::Bit<uint64_t>(32u) - 1u)));
+    mPayload.push_back(value >> 32);
+}
+
 // FramebufferDesc implementation.
 
 FramebufferDesc::FramebufferDesc()
@@ -3886,4 +3921,7 @@ template class DescriptorSetCache<vk::TextureDescriptorDesc, VulkanCacheType::Te
 
 template class DescriptorSetCache<vk::UniformsAndXfbDescriptorDesc,
                                   VulkanCacheType::UniformsAndXfbDescriptors>;
+
+template class DescriptorSetCache<vk::ShaderBuffersDescriptorDesc,
+                                  VulkanCacheType::ShaderBuffersDescriptors>;
 }  // namespace rx

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -1128,6 +1128,34 @@ class UniformsAndXfbDescriptorDesc
     std::array<BufferSerial, kMaxBufferCount> mBufferSerials;
 };
 
+class ShaderBuffersDescriptorDesc
+{
+  public:
+    ShaderBuffersDescriptorDesc();
+    ~ShaderBuffersDescriptorDesc();
+
+    ShaderBuffersDescriptorDesc(const ShaderBuffersDescriptorDesc &other);
+    ShaderBuffersDescriptorDesc &operator=(const ShaderBuffersDescriptorDesc &other);
+
+    size_t hash() const;
+    void reset();
+
+    bool operator==(const ShaderBuffersDescriptorDesc &other) const;
+
+    ANGLE_INLINE void appendBufferSerial(BufferSerial bufferSerial)
+    {
+        mPayload.push_back(bufferSerial.getValue());
+    }
+    ANGLE_INLINE void append32BitValue(uint32_t value) { mPayload.push_back(value); }
+
+    void append64BitValue(uint64_t value);
+
+  private:
+    // After a preliminary minimum size, use heap memory.
+    static constexpr size_t kFastBufferWordLimit = 32;
+    angle::FastVector<uint32_t, kFastBufferWordLimit> mPayload;
+};
+
 // In the FramebufferDesc object:
 //  - Depth/stencil serial is at index 0
 //  - Color serials are at indices [1, gl::IMPLEMENTATION_MAX_DRAW_BUFFERS]
@@ -1314,6 +1342,12 @@ struct hash<rx::vk::UniformsAndXfbDescriptorDesc>
 };
 
 template <>
+struct hash<rx::vk::ShaderBuffersDescriptorDesc>
+{
+    size_t operator()(const rx::vk::ShaderBuffersDescriptorDesc &key) const { return key.hash(); }
+};
+
+template <>
 struct hash<rx::vk::FramebufferDesc>
 {
     size_t operator()(const rx::vk::FramebufferDesc &key) const { return key.hash(); }
@@ -1352,6 +1386,7 @@ enum class VulkanCacheType
     DescriptorSetLayout,
     TextureDescriptors,
     UniformsAndXfbDescriptors,
+    ShaderBuffersDescriptors,
     Framebuffer,
     EnumCount
 };

src/tests/gl_tests/ComputeShaderTest.cpp

@@ -394,8 +394,7 @@ void main()
     EXPECT_GL_NO_ERROR();
 }
 
-// Test that binds UAV with type buffer to slot 0, then binds UAV with type image to slot 0, then
-// buffer again.
+// Binds a storage buffer to slot 0, then binds a storage image to slot 0, then buffer again.
 TEST_P(ComputeShaderTest, BufferImageBuffer)
 {
     // See http://anglebug.com/3536

src/tests/gl_tests/UniformBufferTest.cpp

@@ -799,6 +799,9 @@ TEST_P(UniformBufferTest31, UseAsUBOThenUpdateThenDrawIndirect)
     // http://anglebug.com/5826
     ANGLE_SKIP_TEST_IF(IsD3D11());
 
+    // http://anglebug.com/5871
+    ANGLE_SKIP_TEST_IF(IsVulkan() && IsPixel2());
+
     const std::array<uint32_t, 4> kInitialData = {100, 200, 300, 400};
     const std::array<uint32_t, 4> kUpdateData  = {4, 1, 0, 0};
 

src/tests/gl_tests/VulkanPerformanceCounterTest.cpp

@@ -3040,9 +3040,7 @@ void main()
 
     // Check for unnecessary descriptor set allocations.
     uint32_t descriptorSetAllocationsAfter = hackANGLE().descriptorSetAllocations;
-
-    // TODO(jmadill): http://anglebug.com/5736 change to EXPECT_EQ.
-    EXPECT_NE(descriptorSetAllocationsBefore, descriptorSetAllocationsAfter);
+    EXPECT_EQ(descriptorSetAllocationsAfter, 0u);
 }
 
 ANGLE_INSTANTIATE_TEST(VulkanPerformanceCounterTest, ES3_VULKAN());