Vulkan: Only calculate variable locations once

src/libANGLE/renderer/glslang_wrapper_utils.h

@@ -21,20 +21,27 @@ enum class GlslangError
     InvalidSpirv,
 };
 
+constexpr gl::ShaderMap<const char *> kDefaultUniformNames = {
+    {gl::ShaderType::Vertex, sh::vk::kDefaultUniformsNameVS},
+    {gl::ShaderType::Geometry, sh::vk::kDefaultUniformsNameGS},
+    {gl::ShaderType::Fragment, sh::vk::kDefaultUniformsNameFS},
+    {gl::ShaderType::Compute, sh::vk::kDefaultUniformsNameCS},
+};
+
 struct GlslangProgramInterfaceInfo
 {
     // Uniforms set index:
     uint32_t uniformsAndXfbDescriptorSetIndex;
+    uint32_t currentUniformBindingIndex;
     // Textures set index:
     uint32_t textureDescriptorSetIndex;
+    uint32_t currentTextureBindingIndex;
     // Other shader resources set index:
     uint32_t shaderResourceDescriptorSetIndex;
+    uint32_t currentShaderResourceBindingIndex;
     // ANGLE driver uniforms set index:
     uint32_t driverUniformsDescriptorSetIndex;
 
-    // Binding index start for transform feedback buffers:
-    uint32_t xfbBindingIndexStart;
-
     uint32_t locationsUsedForXfbExtension;
 };
 
@@ -76,26 +83,32 @@ struct ShaderInterfaceVariableInfo
     uint32_t xfbStride = kInvalid;
 };
 
+// TODO: http://anglebug.com/4524: Need a different hash key than a string, since
+// that's slow to calculate.
 using ShaderInterfaceVariableInfoMap = std::unordered_map<std::string, ShaderInterfaceVariableInfo>;
 
 void GlslangInitialize();
 void GlslangRelease();
 
+bool GetImageNameWithoutIndices(std::string *name);
+
 // Get the mapped sampler name after the soure is transformed by GlslangGetShaderSource()
+std::string GetMappedSamplerNameOld(const std::string &originalName);
 std::string GlslangGetMappedSamplerName(const std::string &originalName);
+std::string GetXfbBufferName(const uint32_t bufferIndex);
 
 // Transform the source to include actual binding points for various shader resources (textures,
 // buffers, xfb, etc).  For some variables, these values are instead output to the variableInfoMap
 // to be set during a SPIR-V transformation.  This is a transitory step towards moving all variables
 // to this map, at which point GlslangGetShaderSpirvCode will also be called by this function.
-void GlslangGetShaderSource(const GlslangSourceOptions &options,
+void GlslangGetShaderSource(GlslangSourceOptions &options,
                             const gl::ProgramState &programState,
                             const gl::ProgramLinkedResources &resources,
                             GlslangProgramInterfaceInfo *programInterfaceInfo,
                             gl::ShaderMap<std::string> *shaderSourcesOut,
                             ShaderInterfaceVariableInfoMap *variableInfoMapOut);
 
-angle::Result GlslangGetShaderSpirvCode(GlslangErrorCallback callback,
+angle::Result GlslangGetShaderSpirvCode(const GlslangErrorCallback &callback,
                                         const gl::Caps &glCaps,
                                         const gl::ShaderMap<std::string> &shaderSources,
                                         const ShaderInterfaceVariableInfoMap &variableInfoMap,

src/libANGLE/renderer/metal/mtl_glslang_utils.mm

@@ -27,12 +27,14 @@ void ResetGlslangProgramInterfaceInfo(GlslangProgramInterfaceInfo *programInterf
     // We don't actually use descriptor set for now, the actual binding will be done inside
     // ProgramMtl using spirv-cross.
     programInterfaceInfo->uniformsAndXfbDescriptorSetIndex = kDefaultUniformsBindingIndex;
+    programInterfaceInfo->currentUniformBindingIndex       = 0;
     programInterfaceInfo->textureDescriptorSetIndex        = 0;
+    programInterfaceInfo->currentTextureBindingIndex       = 0;
     programInterfaceInfo->driverUniformsDescriptorSetIndex = kDriverUniformsBindingIndex;
     // NOTE(hqle): Unused for now, until we support ES 3.0
-    programInterfaceInfo->shaderResourceDescriptorSetIndex = -1;
-    programInterfaceInfo->xfbBindingIndexStart             = -1;
-    programInterfaceInfo->locationsUsedForXfbExtension     = 0;
+    programInterfaceInfo->shaderResourceDescriptorSetIndex  = -1;
+    programInterfaceInfo->currentShaderResourceBindingIndex = 0;
+    programInterfaceInfo->locationsUsedForXfbExtension      = 0;
 
     static_assert(kDefaultUniformsBindingIndex != 0, "kDefaultUniformsBindingIndex must not be 0");
     static_assert(kDriverUniformsBindingIndex != 0, "kDriverUniformsBindingIndex must not be 0");
@@ -50,11 +52,12 @@ void GlslangGetShaderSource(const gl::ProgramState &programState,
                             gl::ShaderMap<std::string> *shaderSourcesOut,
                             ShaderInterfaceVariableInfoMap *variableInfoMapOut)
 {
+    GlslangSourceOptions options = CreateSourceOptions();
     GlslangProgramInterfaceInfo programInterfaceInfo;
     ResetGlslangProgramInterfaceInfo(&programInterfaceInfo);
 
-    rx::GlslangGetShaderSource(CreateSourceOptions(), programState, resources,
-                               &programInterfaceInfo, shaderSourcesOut, variableInfoMapOut);
+    rx::GlslangGetShaderSource(options, programState, resources, &programInterfaceInfo,
+                               shaderSourcesOut, variableInfoMapOut);
 }
 
 angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context,

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -598,6 +598,7 @@ ContextVk::ContextVk(const gl::State &state, gl::ErrorSet *errorSet, RendererVk
       mVertexArray(nullptr),
       mDrawFramebuffer(nullptr),
       mProgram(nullptr),
+      mExecutable(nullptr),
       mLastIndexBufferOffset(0),
       mCurrentDrawElementsType(gl::DrawElementsType::InvalidEnum),
       mXfbBaseVertex(0),
@@ -2792,7 +2793,8 @@ angle::Result ContextVk::syncState(const gl::Context *context,
             case gl::State::DIRTY_BIT_DISPATCH_INDIRECT_BUFFER_BINDING:
                 break;
             case gl::State::DIRTY_BIT_PROGRAM_BINDING:
-                mProgram = vk::GetImpl(glState.getProgram());
+                mProgram    = vk::GetImpl(glState.getProgram());
+                mExecutable = &mProgram->getExecutable();
                 break;
             case gl::State::DIRTY_BIT_PROGRAM_EXECUTABLE:
             {

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -26,6 +26,7 @@ struct FeaturesVk;
 
 namespace rx
 {
+class ProgramExecutableVk;
 class RendererVk;
 class WindowSurfaceVk;
 
@@ -657,6 +658,11 @@ class ContextVk : public ContextImpl, public vk::Context
     size_t getVkIndexTypeSize(gl::DrawElementsType glIndexType) const;
     bool shouldConvertUint8VkIndexType(gl::DrawElementsType glIndexType) const;
 
+    const ProgramExecutableVk *getExecutable() const { return mExecutable; }
+    ProgramExecutableVk *getExecutable() { return mExecutable; }
+
+    ProgramVk *getShaderProgram(const gl::State &glState, gl::ShaderType shaderType) const;
+
   private:
     // Dirty bits.
     enum DirtyBitType : size_t
@@ -950,6 +956,7 @@ class ContextVk : public ContextImpl, public vk::Context
     VertexArrayVk *mVertexArray;
     FramebufferVk *mDrawFramebuffer;
     ProgramVk *mProgram;
+    ProgramExecutableVk *mExecutable;
 
     // Graph resource used to record dispatch commands and hold resource dependencies.
     vk::DispatchHelper mDispatcher;

src/libANGLE/renderer/vulkan/GlslangWrapperVk.cpp

@@ -21,7 +21,10 @@ angle::Result ErrorHandler(vk::Context *context, GlslangError)
     return angle::Result::Stop;
 }
 
-GlslangSourceOptions CreateSourceOptions(const angle::FeaturesVk &features)
+}  // namespace
+
+// static
+GlslangSourceOptions GlslangWrapperVk::CreateSourceOptions(const angle::FeaturesVk &features)
 {
     GlslangSourceOptions options;
 
@@ -33,7 +36,6 @@ GlslangSourceOptions CreateSourceOptions(const angle::FeaturesVk &features)
 
     return options;
 }
-}  // namespace
 
 // static
 void GlslangWrapperVk::ResetGlslangProgramInterfaceInfo(
@@ -41,12 +43,14 @@ void GlslangWrapperVk::ResetGlslangProgramInterfaceInfo(
 {
     glslangProgramInterfaceInfo->uniformsAndXfbDescriptorSetIndex =
         kUniformsAndXfbDescriptorSetIndex;
-    glslangProgramInterfaceInfo->textureDescriptorSetIndex = kTextureDescriptorSetIndex;
+    glslangProgramInterfaceInfo->currentUniformBindingIndex = 0;
+    glslangProgramInterfaceInfo->textureDescriptorSetIndex  = kTextureDescriptorSetIndex;
+    glslangProgramInterfaceInfo->currentTextureBindingIndex = 0;
     glslangProgramInterfaceInfo->shaderResourceDescriptorSetIndex =
         kShaderResourceDescriptorSetIndex;
+    glslangProgramInterfaceInfo->currentShaderResourceBindingIndex = 0;
     glslangProgramInterfaceInfo->driverUniformsDescriptorSetIndex =
         kDriverUniformsDescriptorSetIndex;
-    glslangProgramInterfaceInfo->xfbBindingIndexStart = kXfbBindingIndexStart;
 
     glslangProgramInterfaceInfo->locationsUsedForXfbExtension = 0;
 }
@@ -59,8 +63,9 @@ void GlslangWrapperVk::GetShaderSource(const angle::FeaturesVk &features,
                                        gl::ShaderMap<std::string> *shaderSourcesOut,
                                        ShaderInterfaceVariableInfoMap *variableInfoMapOut)
 {
-    GlslangGetShaderSource(CreateSourceOptions(features), programState, resources,
-                           programInterfaceInfo, shaderSourcesOut, variableInfoMapOut);
+    GlslangSourceOptions options = CreateSourceOptions(features);
+    GlslangGetShaderSource(options, programState, resources, programInterfaceInfo, shaderSourcesOut,
+                           variableInfoMapOut);
 }
 
 // static

src/libANGLE/renderer/vulkan/GlslangWrapperVk.h

@@ -25,6 +25,8 @@ namespace rx
 class GlslangWrapperVk
 {
   public:
+    static GlslangSourceOptions CreateSourceOptions(const angle::FeaturesVk &features);
+
     static void ResetGlslangProgramInterfaceInfo(
         GlslangProgramInterfaceInfo *glslangProgramInterfaceInfo);
 

src/libANGLE/renderer/vulkan/ProgramExecutableVk.h

@@ -44,9 +44,13 @@ class ProgramExecutableVk
 
     void reset(ContextVk *contextVk);
 
+    void save(gl::BinaryOutputStream *stream);
+    std::unique_ptr<rx::LinkEvent> load(gl::BinaryInputStream *stream);
+
     void clearVariableInfoMap();
     ShaderInterfaceVariableInfoMap &getShaderInterfaceVariableInfoMap() { return mVariableInfoMap; }
 
+    const vk::PipelineLayout &getPipelineLayout() const { return mPipelineLayout.get(); }
     angle::Result createPipelineLayout(const gl::Context *glContext,
                                        const gl::ProgramExecutable &glExecutable,
                                        const gl::ProgramState &programState);
@@ -68,19 +72,21 @@ class ProgramExecutableVk
     friend class ProgramVk;
     friend class ProgramPipelineVk;
 
-    void updateBindingOffsets(const gl::ProgramState &programState);
-    uint32_t getUniformBlockBindingsOffset() const { return 0; }
-    uint32_t getStorageBlockBindingsOffset() const { return mStorageBlockBindingsOffset; }
-    uint32_t getAtomicCounterBufferBindingsOffset() const
-    {
-        return mAtomicCounterBufferBindingsOffset;
-    }
-    uint32_t getImageBindingsOffset() const { return mImageBindingsOffset; }
-
     angle::Result allocateDescriptorSet(ContextVk *contextVk, uint32_t descriptorSetIndex);
     angle::Result allocateDescriptorSetAndGetInfo(ContextVk *contextVk,
                                                   uint32_t descriptorSetIndex,
                                                   bool *newPoolAllocatedOut);
+    void addInterfaceBlockDescriptorSetDesc(const std::vector<gl::InterfaceBlock> &blocks,
+                                            VkDescriptorType descType,
+                                            vk::DescriptorSetLayoutDesc *descOut);
+    void addAtomicCounterBufferDescriptorSetDesc(
+        const std::vector<gl::AtomicCounterBuffer> &atomicCounterBuffers,
+        vk::DescriptorSetLayoutDesc *descOut);
+    void addImageDescriptorSetDesc(const gl::ProgramState &programState,
+                                   vk::DescriptorSetLayoutDesc *descOut);
+    void addTextureDescriptorSetDesc(const gl::ProgramState &programState,
+                                     bool useOldRewriteStructSamplers,
+                                     vk::DescriptorSetLayoutDesc *descOut);
 
     void updateDefaultUniformsDescriptorSet(
         const gl::ProgramState &programState,
@@ -100,13 +106,6 @@ class ProgramExecutableVk
     angle::Result updateImagesDescriptorSet(const gl::ProgramState &programState,
                                             ContextVk *contextVk);
 
-    // In their descriptor set, uniform buffers are placed first, then storage buffers, then atomic
-    // counter buffers and then images.  These cached values contain the offsets where storage
-    // buffer, atomic counter buffer and image bindings start.
-    uint32_t mStorageBlockBindingsOffset;
-    uint32_t mAtomicCounterBufferBindingsOffset;
-    uint32_t mImageBindingsOffset;
-
     // This is a special "empty" placeholder buffer for when a shader has no uniforms or doesn't
     // use all slots in the atomic counter buffer array.
     //
@@ -118,6 +117,7 @@ class ProgramExecutableVk
     std::vector<VkDescriptorSet> mDescriptorSets;
     vk::DescriptorSetLayoutArray<VkDescriptorSet> mEmptyDescriptorSets;
     std::vector<vk::BufferHelper *> mDescriptorBuffersCache;
+    size_t mNumDefaultUniformDescriptors;
 
     std::unordered_map<vk::TextureDescriptorDesc, VkDescriptorSet> mTextureDescriptorsCache;
 
@@ -137,6 +137,8 @@ class ProgramExecutableVk
 
     gl::ShaderVector<uint32_t> mDynamicBufferOffsets;
 
+    // TODO: http://anglebug.com/4524: Need a different hash key than a string,
+    // since that's slow to calculate.
     ShaderInterfaceVariableInfoMap mVariableInfoMap;
 };
 

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -303,6 +303,7 @@ std::unique_ptr<rx::LinkEvent> ProgramVk::load(const gl::Context *context,
     reset(contextVk);
 
     mShaderInfo.load(stream);
+    mExecutable.load(stream);
 
     // Deserializes the uniformLayout data of mDefaultUniformBlocks
     for (gl::ShaderType shaderType : gl::AllShaderTypes())
@@ -337,6 +338,7 @@ std::unique_ptr<rx::LinkEvent> ProgramVk::load(const gl::Context *context,
 void ProgramVk::save(const gl::Context *context, gl::BinaryOutputStream *stream)
 {
     mShaderInfo.save(stream);
+    mExecutable.save(stream);
 
     // Serializes the uniformLayout data of mDefaultUniformBlocks
     for (gl::ShaderType shaderType : gl::AllShaderTypes())
@@ -378,6 +380,7 @@ std::unique_ptr<LinkEvent> ProgramVk::link(const gl::Context *context,
     linkResources(resources);
 
     reset(contextVk);
+    mExecutable.clearVariableInfoMap();
 
     // Gather variable info and transform sources.
     gl::ShaderMap<std::string> shaderSources;

src/libANGLE/renderer/vulkan/TransformFeedbackVk.cpp

@@ -11,6 +11,7 @@
 
 #include "libANGLE/Context.h"
 #include "libANGLE/Query.h"
+#include "libANGLE/renderer/glslang_wrapper_utils.h"
 #include "libANGLE/renderer/vulkan/BufferVk.h"
 #include "libANGLE/renderer/vulkan/ContextVk.h"
 #include "libANGLE/renderer/vulkan/FramebufferVk.h"
@@ -161,6 +162,7 @@ angle::Result TransformFeedbackVk::bindIndexedBuffer(
 
 void TransformFeedbackVk::updateDescriptorSetLayout(
     ContextVk *contextVk,
+    ShaderInterfaceVariableInfoMap &vsVariableInfoMap,
     size_t xfbBufferCount,
     vk::DescriptorSetLayoutDesc *descSetLayoutOut) const
 {
@@ -169,8 +171,11 @@ void TransformFeedbackVk::updateDescriptorSetLayout(
 
     for (uint32_t bufferIndex = 0; bufferIndex < xfbBufferCount; ++bufferIndex)
     {
-        descSetLayoutOut->update(kXfbBindingIndexStart + bufferIndex,
-                                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT);
+        const std::string bufferName            = GetXfbBufferName(bufferIndex);
+        const ShaderInterfaceVariableInfo &info = vsVariableInfoMap[bufferName];
+
+        descSetLayoutOut->update(info.binding, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1,
+                                 VK_SHADER_STAGE_VERTEX_BIT);
     }
 }
 
@@ -296,12 +301,17 @@ void TransformFeedbackVk::writeDescriptorSet(ContextVk *contextVk,
                                              VkDescriptorBufferInfo *pBufferInfo,
                                              VkDescriptorSet descSet) const
 {
-    VkDevice device = contextVk->getDevice();
+    VkDevice device                   = contextVk->getDevice();
+    ProgramExecutableVk *executableVk = contextVk->getExecutable();
+    ShaderInterfaceVariableInfoMap variableInfoMap =
+        executableVk->getShaderInterfaceVariableInfoMap();
+    const std::string bufferName      = GetXfbBufferName(0);
+    ShaderInterfaceVariableInfo &info = variableInfoMap[bufferName];
 
     VkWriteDescriptorSet writeDescriptorInfo = {};
     writeDescriptorInfo.sType                = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
     writeDescriptorInfo.dstSet               = descSet;
-    writeDescriptorInfo.dstBinding           = kXfbBindingIndexStart;
+    writeDescriptorInfo.dstBinding           = info.binding;
     writeDescriptorInfo.dstArrayElement      = 0;
     writeDescriptorInfo.descriptorCount      = static_cast<uint32_t>(xfbBufferCount);
     writeDescriptorInfo.descriptorType       = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;

src/libANGLE/renderer/vulkan/TransformFeedbackVk.h

@@ -11,6 +11,8 @@
 #define LIBANGLE_RENDERER_VULKAN_TRANSFORMFEEDBACKVK_H_
 
 #include "libANGLE/renderer/TransformFeedbackImpl.h"
+
+#include "libANGLE/renderer/glslang_wrapper_utils.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 
 namespace gl
@@ -54,6 +56,7 @@ class TransformFeedbackVk : public TransformFeedbackImpl
                                     const gl::OffsetBindingPointer<gl::Buffer> &binding) override;
 
     void updateDescriptorSetLayout(ContextVk *contextVk,
+                                   ShaderInterfaceVariableInfoMap &vsVariableInfoMap,
                                    size_t xfbBufferCount,
                                    vk::DescriptorSetLayoutDesc *descSetLayoutOut) const;
     void initDescriptorSet(ContextVk *contextVk,

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -977,8 +977,6 @@ constexpr uint32_t kReservedDriverUniformBindingCount = 1;
 // supported.
 constexpr uint32_t kReservedPerStageDefaultUniformBindingCount = 1;
 constexpr uint32_t kReservedDefaultUniformBindingCount         = 3;
-// Binding index start for transform feedback buffers:
-constexpr uint32_t kXfbBindingIndexStart = kReservedDefaultUniformBindingCount;
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_VULKAN_VK_CACHE_UTILS_H_

src/tests/gl_tests/TextureTest.cpp

@@ -3998,6 +3998,12 @@ TEST_P(TextureLimitsTest, MaxFragmentTextures)
 // Test rendering with maximum combined texture units.
 TEST_P(TextureLimitsTest, MaxCombinedTextures)
 {
+    // TODO(timvp): http://anglebug.com/3570
+    // Currently only fails on SwiftShader but we don't have an IsSwiftShader().
+    // max per-stage sampled image bindings count (32) exceeds device
+    // maxPerStageDescriptorSampledImages limit (16)
+    ANGLE_SKIP_TEST_IF(IsVulkan());
+
     GLint vertexTextures = mMaxVertexTextures;
 
     if (vertexTextures + mMaxFragmentTextures > mMaxCombinedTextures)