Reduce dependency on ProgramExecutable::mProgram[Pipeline]State

src/libANGLE/Program.cpp

@@ -1118,11 +1118,6 @@ Shader *ProgramState::getAttachedShader(ShaderType shaderType) const
     return mAttachedShaders[shaderType];
 }
 
-size_t ProgramState::getTransformFeedbackBufferCount() const
-{
-    return mExecutable->mTransformFeedbackStrides.size();
-}
-
 GLuint ProgramState::getUniformIndexFromName(const std::string &name) const
 {
     return GetResourceIndexFromName(mExecutable->mUniforms, name);

src/libANGLE/Program.h

@@ -279,9 +279,6 @@ class ProgramState final : angle::NonCopyable
         return mExecutable->getAtomicCounterBuffers();
     }
 
-    // Count the number of uniform and storage buffer declarations, counting arrays as one.
-    size_t getTransformFeedbackBufferCount() const;
-
     GLuint getUniformIndexFromName(const std::string &name) const;
     GLuint getUniformIndexFromLocation(UniformLocation location) const;
     Optional<GLuint> getSamplerIndex(UniformLocation location) const;
@@ -321,14 +318,7 @@ class ProgramState final : angle::NonCopyable
 
     bool hasDefaultUniforms() const { return !getDefaultUniformRange().empty(); }
     bool hasTextures() const { return !getSamplerBindings().empty(); }
-    bool hasUniformBuffers() const { return !getUniformBlocks().empty(); }
-    bool hasStorageBuffers() const { return !getShaderStorageBlocks().empty(); }
-    bool hasAtomicCounterBuffers() const { return !getAtomicCounterBuffers().empty(); }
     bool hasImages() const { return !getImageBindings().empty(); }
-    bool hasTransformFeedbackOutput() const
-    {
-        return !getLinkedTransformFeedbackVaryings().empty();
-    }
     bool hasEarlyFragmentTestsOptimization() const { return mEarlyFramentTestsOptimization; }
 
     bool isShaderMarkedForDetach(gl::ShaderType shaderType) const

src/libANGLE/ProgramExecutable.cpp

@@ -28,7 +28,13 @@ ProgramExecutable::ProgramExecutable()
       mCanDrawWith(false),
       mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS),
       mSamplerUniformRange(0, 0),
-      mImageUniformRange(0, 0)
+      mImageUniformRange(0, 0),
+      mPipelineHasGraphicsUniformBuffers(false),
+      mPipelineHasComputeUniformBuffers(false),
+      mPipelineHasGraphicsStorageBuffers(false),
+      mPipelineHasComputeStorageBuffers(false),
+      mPipelineHasGraphicsAtomicCounterBuffers(false),
+      mPipelineHasComputeAtomicCounterBuffers(false)
 {
     reset();
 }
@@ -61,7 +67,13 @@ ProgramExecutable::ProgramExecutable(const ProgramExecutable &other)
       mUniformBlocks(other.mUniformBlocks),
       mAtomicCounterBuffers(other.mAtomicCounterBuffers),
       mImageUniformRange(other.mImageUniformRange),
-      mShaderStorageBlocks(other.mShaderStorageBlocks)
+      mShaderStorageBlocks(other.mShaderStorageBlocks),
+      mPipelineHasGraphicsUniformBuffers(other.mPipelineHasGraphicsUniformBuffers),
+      mPipelineHasComputeUniformBuffers(other.mPipelineHasComputeUniformBuffers),
+      mPipelineHasGraphicsStorageBuffers(other.mPipelineHasGraphicsStorageBuffers),
+      mPipelineHasComputeStorageBuffers(other.mPipelineHasComputeStorageBuffers),
+      mPipelineHasGraphicsAtomicCounterBuffers(other.mPipelineHasGraphicsAtomicCounterBuffers),
+      mPipelineHasComputeAtomicCounterBuffers(other.mPipelineHasComputeAtomicCounterBuffers)
 {
     reset();
 }
@@ -91,6 +103,13 @@ void ProgramExecutable::reset()
     mAtomicCounterBuffers.clear();
     mOutputVariables.clear();
     mOutputLocations.clear();
+
+    mPipelineHasGraphicsUniformBuffers       = false;
+    mPipelineHasComputeUniformBuffers        = false;
+    mPipelineHasGraphicsStorageBuffers       = false;
+    mPipelineHasComputeStorageBuffers        = false;
+    mPipelineHasGraphicsAtomicCounterBuffers = false;
+    mPipelineHasComputeAtomicCounterBuffers  = false;
 }
 
 void ProgramExecutable::load(gl::BinaryInputStream *stream)
@@ -105,6 +124,13 @@ void ProgramExecutable::load(gl::BinaryInputStream *stream)
 
     mLinkedGraphicsShaderStages = ShaderBitSet(stream->readInt<uint8_t>());
     mLinkedComputeShaderStages  = ShaderBitSet(stream->readInt<uint8_t>());
+
+    mPipelineHasGraphicsUniformBuffers       = stream->readBool();
+    mPipelineHasComputeUniformBuffers        = stream->readBool();
+    mPipelineHasGraphicsStorageBuffers       = stream->readBool();
+    mPipelineHasComputeStorageBuffers        = stream->readBool();
+    mPipelineHasGraphicsAtomicCounterBuffers = stream->readBool();
+    mPipelineHasComputeAtomicCounterBuffers  = stream->readBool();
 }
 
 void ProgramExecutable::save(gl::BinaryOutputStream *stream) const
@@ -118,6 +144,13 @@ void ProgramExecutable::save(gl::BinaryOutputStream *stream) const
 
     stream->writeInt(mLinkedGraphicsShaderStages.bits());
     stream->writeInt(mLinkedComputeShaderStages.bits());
+
+    stream->writeInt(static_cast<bool>(mPipelineHasGraphicsUniformBuffers));
+    stream->writeInt(static_cast<bool>(mPipelineHasComputeUniformBuffers));
+    stream->writeInt(static_cast<bool>(mPipelineHasGraphicsStorageBuffers));
+    stream->writeInt(static_cast<bool>(mPipelineHasComputeStorageBuffers));
+    stream->writeInt(static_cast<bool>(mPipelineHasGraphicsAtomicCounterBuffers));
+    stream->writeInt(static_cast<bool>(mPipelineHasComputeAtomicCounterBuffers));
 }
 
 const ProgramState *ProgramExecutable::getProgramState(ShaderType shaderType) const
@@ -190,6 +223,7 @@ AttributesMask ProgramExecutable::getAttributesMask() const
     return mAttributesMask;
 }
 
+// TODO: http://anglebug.com/4520: Needs  mDefaultUniformRange moved to ProgramExecutable
 bool ProgramExecutable::hasDefaultUniforms() const
 {
     ASSERT(mProgramState || mProgramPipelineState);
@@ -201,6 +235,7 @@ bool ProgramExecutable::hasDefaultUniforms() const
     return mProgramPipelineState->hasDefaultUniforms();
 }
 
+// TODO: http://anglebug.com/4520: Needs  mSamplerBindings moved to ProgramExecutable
 bool ProgramExecutable::hasTextures() const
 {
     ASSERT(mProgramState || mProgramPipelineState);
@@ -212,39 +247,28 @@ bool ProgramExecutable::hasTextures() const
     return mProgramPipelineState->hasTextures();
 }
 
+// TODO: http://anglebug.com/3570: Remove mHas*UniformBuffers once PPO's have valid data in
+// mUniformBlocks
 bool ProgramExecutable::hasUniformBuffers() const
 {
-    ASSERT(mProgramState || mProgramPipelineState);
-    if (mProgramState)
-    {
-        return mProgramState->hasUniformBuffers();
-    }
-
-    return mProgramPipelineState->hasUniformBuffers();
+    return !getUniformBlocks().empty() ||
+           (isCompute() ? mPipelineHasComputeUniformBuffers : mPipelineHasGraphicsUniformBuffers);
 }
 
 bool ProgramExecutable::hasStorageBuffers() const
 {
-    ASSERT(mProgramState || mProgramPipelineState);
-    if (mProgramState)
-    {
-        return mProgramState->hasStorageBuffers();
-    }
-
-    return mProgramPipelineState->hasStorageBuffers();
+    return !getShaderStorageBlocks().empty() ||
+           (isCompute() ? mPipelineHasComputeStorageBuffers : mPipelineHasGraphicsStorageBuffers);
 }
 
 bool ProgramExecutable::hasAtomicCounterBuffers() const
 {
-    ASSERT(mProgramState || mProgramPipelineState);
-    if (mProgramState)
-    {
-        return mProgramState->hasAtomicCounterBuffers();
-    }
-
-    return mProgramPipelineState->hasAtomicCounterBuffers();
+    return !getAtomicCounterBuffers().empty() ||
+           (isCompute() ? mPipelineHasComputeAtomicCounterBuffers
+                        : mPipelineHasGraphicsAtomicCounterBuffers);
 }
 
+// TODO: http://anglebug.com/4520: Needs  mImageBindings moved to ProgramExecutable
 bool ProgramExecutable::hasImages() const
 {
     ASSERT(mProgramState || mProgramPipelineState);
@@ -256,30 +280,6 @@ bool ProgramExecutable::hasImages() const
     return mProgramPipelineState->hasImages();
 }
 
-bool ProgramExecutable::hasTransformFeedbackOutput() const
-{
-    ASSERT(mProgramState || mProgramPipelineState);
-    if (mProgramState)
-    {
-        return mProgramState->hasTransformFeedbackOutput();
-    }
-
-    return mProgramPipelineState->hasTransformFeedbackOutput();
-}
-
-size_t ProgramExecutable::getTransformFeedbackBufferCount(const gl::State &glState) const
-{
-    ASSERT(mProgramState || mProgramPipelineState);
-    if (mProgramState)
-    {
-        return mProgramState->getTransformFeedbackBufferCount();
-    }
-
-    // TODO(timvp): http://anglebug.com/3570: Support program pipelines
-
-    return 0;
-}
-
 void ProgramExecutable::updateActiveSamplers(const ProgramState &programState)
 {
     const std::vector<SamplerBinding> &samplerBindings = programState.getSamplerBindings();

src/libANGLE/ProgramExecutable.h

@@ -189,10 +189,13 @@ class ProgramExecutable
     bool hasStorageBuffers() const;
     bool hasAtomicCounterBuffers() const;
     bool hasImages() const;
-    bool hasTransformFeedbackOutput() const;
+    bool hasTransformFeedbackOutput() const
+    {
+        return !getLinkedTransformFeedbackVaryings().empty();
+    }
 
     // Count the number of uniform and storage buffer declarations, counting arrays as one.
-    size_t getTransformFeedbackBufferCount(const gl::State &glState) const;
+    size_t getTransformFeedbackBufferCount() const { return mTransformFeedbackStrides.size(); }
 
     bool linkValidateGlobalNames(InfoLog &infoLog) const;
 
@@ -355,6 +358,15 @@ class ProgramExecutable
     RangeUI mImageUniformRange;
     std::vector<InterfaceBlock> mShaderStorageBlocks;
 
+    // TODO: http://anglebug.com/3570: Remove mPipelineHas*UniformBuffers once PPO's have valid data
+    // in mUniformBlocks
+    bool mPipelineHasGraphicsUniformBuffers;
+    bool mPipelineHasComputeUniformBuffers;
+    bool mPipelineHasGraphicsStorageBuffers;
+    bool mPipelineHasComputeStorageBuffers;
+    bool mPipelineHasGraphicsAtomicCounterBuffers;
+    bool mPipelineHasComputeAtomicCounterBuffers;
+
     ShaderMap<std::vector<sh::ShaderVariable>> mLinkedOutputVaryings;
     ShaderMap<std::vector<sh::ShaderVariable>> mLinkedInputVaryings;
     ShaderMap<int> mLinkedShaderVersions;

src/libANGLE/ProgramPipeline.cpp

@@ -152,48 +152,6 @@ bool ProgramPipelineState::hasTextures() const
     return false;
 }
 
-bool ProgramPipelineState::hasUniformBuffers() const
-{
-    for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
-    {
-        const Program *shaderProgram = getShaderProgram(shaderType);
-        if (shaderProgram && shaderProgram->getState().hasUniformBuffers())
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool ProgramPipelineState::hasStorageBuffers() const
-{
-    for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
-    {
-        const Program *shaderProgram = getShaderProgram(shaderType);
-        if (shaderProgram && shaderProgram->getState().hasStorageBuffers())
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool ProgramPipelineState::hasAtomicCounterBuffers() const
-{
-    for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
-    {
-        const Program *shaderProgram = getShaderProgram(shaderType);
-        if (shaderProgram && shaderProgram->getState().hasAtomicCounterBuffers())
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 bool ProgramPipelineState::hasImages() const
 {
     for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
@@ -208,20 +166,6 @@ bool ProgramPipelineState::hasImages() const
     return false;
 }
 
-bool ProgramPipelineState::hasTransformFeedbackOutput() const
-{
-    for (const gl::ShaderType shaderType : mExecutable->getLinkedShaderStages())
-    {
-        const Program *shaderProgram = getShaderProgram(shaderType);
-        if (shaderProgram && shaderProgram->getState().hasTransformFeedbackOutput())
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 ProgramPipeline::ProgramPipeline(rx::GLImplFactory *factory, ProgramPipelineID handle)
     : RefCountObject(factory->generateSerial(), handle),
       mProgramPipelineImpl(factory->createProgramPipeline(mState))
@@ -311,6 +255,21 @@ void ProgramPipeline::updateExecutableAttributes()
     mState.mExecutable->mAttributesMask            = vertexExecutable.mAttributesMask;
 }
 
+void ProgramPipeline::updateTransformFeedbackMembers()
+{
+    Program *vertexProgram = getShaderProgram(gl::ShaderType::Vertex);
+
+    if (!vertexProgram)
+    {
+        return;
+    }
+
+    const ProgramExecutable &vertexExecutable     = vertexProgram->getExecutable();
+    mState.mExecutable->mTransformFeedbackStrides = vertexExecutable.mTransformFeedbackStrides;
+    mState.mExecutable->mLinkedTransformFeedbackVaryings =
+        vertexExecutable.mLinkedTransformFeedbackVaryings;
+}
+
 void ProgramPipeline::updateExecutableTextures()
 {
     for (const ShaderType shaderType : mState.mExecutable->getLinkedShaderStages())
@@ -327,15 +286,62 @@ void ProgramPipeline::updateExecutableTextures()
     }
 }
 
+void ProgramPipeline::updateHasBuffers()
+{
+    // Need to check all of the shader stages, not just linked, so we handle Compute correctly.
+    for (const gl::ShaderType shaderType : kAllGraphicsShaderTypes)
+    {
+        const Program *shaderProgram = getShaderProgram(shaderType);
+        if (shaderProgram)
+        {
+            const ProgramExecutable &executable = shaderProgram->getExecutable();
+
+            if (executable.hasUniformBuffers())
+            {
+                mState.mExecutable->mPipelineHasGraphicsUniformBuffers = true;
+            }
+            if (executable.hasStorageBuffers())
+            {
+                mState.mExecutable->mPipelineHasGraphicsStorageBuffers = true;
+            }
+            if (executable.hasAtomicCounterBuffers())
+            {
+                mState.mExecutable->mPipelineHasGraphicsAtomicCounterBuffers = true;
+            }
+        }
+    }
+
+    const Program *computeProgram = getShaderProgram(ShaderType::Compute);
+    if (computeProgram)
+    {
+        const ProgramExecutable &executable = computeProgram->getExecutable();
+
+        if (executable.hasUniformBuffers())
+        {
+            mState.mExecutable->mPipelineHasComputeUniformBuffers = true;
+        }
+        if (executable.hasStorageBuffers())
+        {
+            mState.mExecutable->mPipelineHasComputeStorageBuffers = true;
+        }
+        if (executable.hasAtomicCounterBuffers())
+        {
+            mState.mExecutable->mPipelineHasComputeAtomicCounterBuffers = true;
+        }
+    }
+}
+
 void ProgramPipeline::updateExecutable()
 {
     mState.mExecutable->reset();
 
     // Vertex Shader ProgramExecutable properties
     updateExecutableAttributes();
+    updateTransformFeedbackMembers();
 
     // All Shader ProgramExecutable properties
     updateExecutableTextures();
+    updateHasBuffers();
 }
 
 ProgramMergedVaryings ProgramPipeline::getMergedVaryings() const

src/libANGLE/ProgramPipeline.h

@@ -68,11 +68,7 @@ class ProgramPipelineState final : angle::NonCopyable
 
     bool hasDefaultUniforms() const;
     bool hasTextures() const;
-    bool hasUniformBuffers() const;
-    bool hasStorageBuffers() const;
-    bool hasAtomicCounterBuffers() const;
     bool hasImages() const;
-    bool hasTransformFeedbackOutput() const;
 
   private:
     void useProgramStage(const Context *context, ShaderType shaderType, Program *shaderProgram);
@@ -127,10 +123,6 @@ class ProgramPipeline final : public RefCountObject<ProgramPipelineID>, public L
 
     void useProgramStages(const Context *context, GLbitfield stages, Program *shaderProgram);
 
-    void updateExecutableAttributes();
-    void updateExecutableTextures();
-    void updateExecutable();
-
     Program *getShaderProgram(ShaderType shaderType) const { return mState.mPrograms[shaderType]; }
 
     ProgramMergedVaryings getMergedVaryings() const;
@@ -168,6 +160,11 @@ class ProgramPipeline final : public RefCountObject<ProgramPipelineID>, public L
 
   private:
     void updateLinkedShaderStages();
+    void updateExecutableAttributes();
+    void updateTransformFeedbackMembers();
+    void updateExecutableTextures();
+    void updateHasBuffers();
+    void updateExecutable();
 
     std::unique_ptr<rx::ProgramPipelineImpl> mProgramPipelineImpl;
 

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -1463,7 +1463,7 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackBuffersEmulation(
     }
 
     TransformFeedbackVk *transformFeedbackVk = vk::GetImpl(mState.getCurrentTransformFeedback());
-    size_t bufferCount                       = executable->getTransformFeedbackBufferCount(mState);
+    size_t bufferCount                       = executable->getTransformFeedbackBufferCount();
     const gl::TransformFeedbackBuffersArray<vk::BufferHelper *> &bufferHelpers =
         transformFeedbackVk->getBufferHelpers();
 
@@ -1491,7 +1491,7 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackBuffersExtension(
         return angle::Result::Continue;
 
     TransformFeedbackVk *transformFeedbackVk = vk::GetImpl(mState.getCurrentTransformFeedback());
-    size_t bufferCount                       = executable->getTransformFeedbackBufferCount(mState);
+    size_t bufferCount                       = executable->getTransformFeedbackBufferCount();
 
     const gl::TransformFeedbackBuffersArray<vk::BufferHelper *> &bufferHelpers =
         transformFeedbackVk->getBufferHelpers();
@@ -1533,7 +1533,7 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackState(const gl::Con
     TransformFeedbackVk *transformFeedbackVk = vk::GetImpl(mState.getCurrentTransformFeedback());
 
     // We should have same number of counter buffers as xfb buffers have
-    size_t bufferCount = executable->getTransformFeedbackBufferCount(mState);
+    size_t bufferCount = executable->getTransformFeedbackBufferCount();
     const gl::TransformFeedbackBuffersArray<VkBuffer> &counterBufferHandles =
         transformFeedbackVk->getCounterBufferHandles();
 

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -655,8 +655,9 @@ angle::Result ProgramExecutableVk::createPipelineLayout(const gl::Context *glCon
          !programStates[gl::ShaderType::Vertex]->getLinkedTransformFeedbackVaryings().empty());
     if (hasVertexShader && transformFeedback && hasXfbVaryings)
     {
-        size_t xfbBufferCount =
-            programStates[gl::ShaderType::Vertex]->getTransformFeedbackBufferCount();
+        const gl::ProgramExecutable &executable =
+            programStates[gl::ShaderType::Vertex]->getExecutable();
+        size_t xfbBufferCount                    = executable.getTransformFeedbackBufferCount();
         TransformFeedbackVk *transformFeedbackVk = vk::GetImpl(transformFeedback);
         transformFeedbackVk->updateDescriptorSetLayout(contextVk,
                                                        mVariableInfoMap[gl::ShaderType::Vertex],
@@ -1223,7 +1224,7 @@ void ProgramExecutableVk::updateTransformFeedbackDescriptorSetImpl(
         {
             TransformFeedbackVk *transformFeedbackVk = vk::GetImpl(transformFeedback);
             transformFeedbackVk->initDescriptorSet(
-                contextVk, programState.getTransformFeedbackBufferCount(), &mEmptyBuffer,
+                contextVk, executable.getTransformFeedbackBufferCount(), &mEmptyBuffer,
                 mDescriptorSets[kUniformsAndXfbDescriptorSetIndex]);
         }
         return;

src/libANGLE/renderer/vulkan/TransformFeedbackVk.cpp

@@ -55,7 +55,7 @@ angle::Result TransformFeedbackVk::begin(const gl::Context *context,
 
     const gl::ProgramExecutable *executable = contextVk->getState().getProgramExecutable();
     ASSERT(executable);
-    size_t xfbBufferCount = executable->getTransformFeedbackBufferCount(contextVk->getState());
+    size_t xfbBufferCount = executable->getTransformFeedbackBufferCount();
 
     for (size_t bufferIndex = 0; bufferIndex < xfbBufferCount; ++bufferIndex)
     {
@@ -235,7 +235,7 @@ void TransformFeedbackVk::updateDescriptorSet(ContextVk *contextVk,
 
     const gl::ProgramExecutable *executable = contextVk->getState().getProgramExecutable();
     ASSERT(executable);
-    size_t xfbBufferCount = executable->getTransformFeedbackBufferCount(contextVk->getState());
+    size_t xfbBufferCount = executable->getTransformFeedbackBufferCount();
 
     ASSERT(xfbBufferCount > 0);
     ASSERT(programState.getTransformFeedbackBufferMode() != GL_INTERLEAVED_ATTRIBS ||
@@ -271,7 +271,7 @@ void TransformFeedbackVk::getBufferOffsets(ContextVk *contextVk,
         mState.getBoundProgram()->getTransformFeedbackStrides();
     const gl::ProgramExecutable *executable = contextVk->getState().getProgramExecutable();
     ASSERT(executable);
-    size_t xfbBufferCount = executable->getTransformFeedbackBufferCount(contextVk->getState());
+    size_t xfbBufferCount = executable->getTransformFeedbackBufferCount();
 
     ASSERT(xfbBufferCount > 0);