Vulkan: Support VS, FS, and CS in the same PPO

This CL adds support for a Program Pipeline Object to have a VS, FS,
and CS attached to the same PPO and then using that PPO for both draw
and dispatch calls.

Bug: angleproject:3570
Test: KHR-GLES31.core.compute_shader.sso*
Change-Id: I262cdbdfd442f6db5ba2b45d1308003102b237cb
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2150078
Reviewed-by: Tim Van Patten <[email protected]>
Reviewed-by: Courtney Goeltzenleuchter <[email protected]>
Commit-Queue: Tim Van Patten <[email protected]>

Author: timvpGoogle

src/libANGLE/Context.cpp

@@ -3579,6 +3579,10 @@ ANGLE_INLINE angle::Result Context::prepareForCopyImage()
 
 ANGLE_INLINE angle::Result Context::prepareForDispatch()
 {
+    // We always assume PPOs are used for draws, until they aren't. If we are executing a dispatch
+    // with a PPO, we need to convert it from a "draw"-type to "dispatch"-type.
+    convertPpoToComputeOrDraw(true);
+
     ANGLE_TRY(syncDirtyObjects(mComputeDirtyObjects));
     return syncDirtyBits(mComputeDirtyBits);
 }
@@ -5516,11 +5520,35 @@ void Context::dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGr
     }
 
     ANGLE_CONTEXT_TRY(prepareForDispatch());
-    ANGLE_CONTEXT_TRY(mImplementation->dispatchCompute(this, numGroupsX, numGroupsY, numGroupsZ));
+
+    angle::Result result =
+        mImplementation->dispatchCompute(this, numGroupsX, numGroupsY, numGroupsZ);
+
+    // We always assume PPOs are used for draws, until they aren't. If we just executed a dispatch
+    // with a PPO, we need to convert it back to a "draw"-type.
+    convertPpoToComputeOrDraw(false);
+
+    if (ANGLE_UNLIKELY(IsError(result)))
+    {
+        return;
+    }
 
     MarkShaderStorageBufferUsage(this);
 }
 
+void Context::convertPpoToComputeOrDraw(bool isCompute)
+{
+    Program *program          = mState.getProgram();
+    ProgramPipeline *pipeline = mState.getProgramPipeline();
+    if (!program && pipeline)
+    {
+        pipeline->getExecutable().setIsCompute(isCompute);
+        pipeline->setDirtyBit(ProgramPipeline::DirtyBitType::DIRTY_BIT_DRAW_DISPATCH_CHANGE);
+        mState.mDirtyObjects.set(State::DIRTY_OBJECT_PROGRAM_PIPELINE);
+        mState.mDirtyBits.set(State::DirtyBitType::DIRTY_BIT_PROGRAM_EXECUTABLE);
+    }
+}
+
 void Context::dispatchComputeIndirect(GLintptr indirect)
 {
     ANGLE_CONTEXT_TRY(prepareForDispatch());

src/libANGLE/Context.h

@@ -651,6 +651,8 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl
                           GLsizei count,
                           const GLint *v);
 
+    void convertPpoToComputeOrDraw(bool isCompute);
+
     State mState;
     bool mShared;
     bool mSkipValidation;

src/libANGLE/Program.cpp

@@ -1211,20 +1211,12 @@ bool ProgramState::hasAttachedShader() const
 
 ShaderType ProgramState::getFirstAttachedShaderStageType() const
 {
-    for (const gl::ShaderType shaderType : gl::kAllGraphicsShaderTypes)
+    if (mExecutable.getLinkedShaderStages().none())
     {
-        if (mExecutable.hasLinkedShaderStage(shaderType))
-        {
-            return shaderType;
-        }
+        return ShaderType::InvalidEnum;
     }
 
-    if (mExecutable.hasLinkedShaderStage(ShaderType::Compute))
-    {
-        return ShaderType::Compute;
-    }
-
-    return ShaderType::InvalidEnum;
+    return *mExecutable.getLinkedShaderStages().begin();
 }
 
 ShaderType ProgramState::getLastAttachedShaderStageType() const
@@ -1665,13 +1657,13 @@ void Program::resolveLinkImpl(const Context *context)
 
 void Program::updateLinkedShaderStages()
 {
-    mState.mExecutable.getLinkedShaderStages().reset();
+    mState.mExecutable.resetLinkedShaderStages();
 
     for (const Shader *shader : mState.mAttachedShaders)
     {
         if (shader)
         {
-            mState.mExecutable.getLinkedShaderStages().set(shader->getType());
+            mState.mExecutable.setLinkedShaderStages(shader->getType());
         }
     }
 }
@@ -5064,13 +5056,6 @@ angle::Result Program::serialize(const Context *context, angle::MemoryBuffer *bi
     stream.writeInt(mState.mNumViews);
     stream.writeInt(mState.mEarlyFramentTestsOptimization);
 
-    static_assert(MAX_VERTEX_ATTRIBS * 2 <= sizeof(uint32_t) * 8,
-                  "All bits of mAttributesTypeMask types and mask fit into 32 bits each");
-    stream.writeInt(static_cast<int>(mState.mExecutable.mAttributesTypeMask.to_ulong()));
-    stream.writeInt(static_cast<int>(mState.mExecutable.mAttributesMask.to_ulong()));
-    stream.writeInt(mState.mExecutable.getActiveAttribLocationsMask().to_ulong());
-    stream.writeInt(mState.mExecutable.mMaxActiveAttribLocation);
-
     stream.writeInt(mState.getProgramInputs().size());
     for (const sh::ShaderVariable &attrib : mState.getProgramInputs())
     {
@@ -5216,7 +5201,7 @@ angle::Result Program::serialize(const Context *context, angle::MemoryBuffer *bi
     stream.writeInt(mState.getAtomicCounterUniformRange().low());
     stream.writeInt(mState.getAtomicCounterUniformRange().high());
 
-    stream.writeInt(mState.mExecutable.getLinkedShaderStages().to_ulong());
+    mState.mExecutable.save(&stream);
 
     mProgram->save(context, &stream);
 
@@ -5265,14 +5250,6 @@ angle::Result Program::deserialize(const Context *context,
     mState.mNumViews                      = stream.readInt<int>();
     mState.mEarlyFramentTestsOptimization = stream.readInt<bool>();
 
-    static_assert(MAX_VERTEX_ATTRIBS * 2 <= sizeof(uint32_t) * 8,
-                  "Too many vertex attribs for mask: All bits of mAttributesTypeMask types and "
-                  "mask fit into 32 bits each");
-    mState.mExecutable.mAttributesTypeMask = gl::ComponentTypeMask(stream.readInt<uint32_t>());
-    mState.mExecutable.mAttributesMask     = stream.readInt<gl::AttributesMask>();
-    mState.mExecutable.mActiveAttribLocationsMask = stream.readInt<gl::AttributesMask>();
-    mState.mExecutable.mMaxActiveAttribLocation   = stream.readInt<unsigned int>();
-
     unsigned int attribCount = stream.readInt<unsigned int>();
     ASSERT(mState.mProgramInputs.empty());
     for (unsigned int attribIndex = 0; attribIndex < attribCount; ++attribIndex)
@@ -5470,13 +5447,14 @@ angle::Result Program::deserialize(const Context *context,
 
     static_assert(static_cast<unsigned long>(ShaderType::EnumCount) <= sizeof(unsigned long) * 8,
                   "Too many shader types");
-    mState.mExecutable.getLinkedShaderStages() = ShaderBitSet(stream.readInt<uint8_t>());
 
     if (!mState.mAttachedShaders[ShaderType::Compute])
     {
         mState.updateTransformFeedbackStrides();
     }
 
+    mState.mExecutable.load(&stream);
+
     postResolveLink(context);
 
     return angle::Result::Continue;

src/libANGLE/Program.h

@@ -353,6 +353,10 @@ class ProgramState final : angle::NonCopyable
         return mAttachedShadersMarkedForDetach[shaderType];
     }
 
+    // A Program can only either be graphics or compute, but never both, so it
+    // can answer isCompute() based on which shaders it has.
+    bool isCompute() const { return mExecutable.hasLinkedShaderStage(ShaderType::Compute); }
+
   private:
     friend class MemoryProgramCache;
     friend class Program;

src/libANGLE/ProgramExecutable.cpp

@@ -48,6 +48,33 @@ void ProgramExecutable::reset()
     mActiveImagesMask.reset();
 }
 
+void ProgramExecutable::load(gl::BinaryInputStream *stream)
+{
+    static_assert(MAX_VERTEX_ATTRIBS * 2 <= sizeof(uint32_t) * 8,
+                  "Too many vertex attribs for mask: All bits of mAttributesTypeMask types and "
+                  "mask fit into 32 bits each");
+    mAttributesTypeMask        = gl::ComponentTypeMask(stream->readInt<uint32_t>());
+    mAttributesMask            = stream->readInt<gl::AttributesMask>();
+    mActiveAttribLocationsMask = stream->readInt<gl::AttributesMask>();
+    mMaxActiveAttribLocation   = stream->readInt<unsigned int>();
+
+    mLinkedGraphicsShaderStages = ShaderBitSet(stream->readInt<uint8_t>());
+    mLinkedComputeShaderStages  = ShaderBitSet(stream->readInt<uint8_t>());
+}
+
+void ProgramExecutable::save(gl::BinaryOutputStream *stream) const
+{
+    static_assert(MAX_VERTEX_ATTRIBS * 2 <= sizeof(uint32_t) * 8,
+                  "All bits of mAttributesTypeMask types and mask fit into 32 bits each");
+    stream->writeInt(static_cast<int>(mAttributesTypeMask.to_ulong()));
+    stream->writeInt(static_cast<int>(mAttributesMask.to_ulong()));
+    stream->writeInt(mActiveAttribLocationsMask.to_ulong());
+    stream->writeInt(mMaxActiveAttribLocation);
+
+    stream->writeInt(mLinkedGraphicsShaderStages.bits());
+    stream->writeInt(mLinkedComputeShaderStages.bits());
+}
+
 const ProgramState *ProgramExecutable::getProgramState(ShaderType shaderType) const
 {
     if (mProgramState &&
@@ -64,6 +91,30 @@ const ProgramState *ProgramExecutable::getProgramState(ShaderType shaderType) co
     return nullptr;
 }
 
+bool ProgramExecutable::isCompute() const
+{
+    ASSERT(mProgramState || mProgramPipelineState);
+
+    if (mProgramState)
+    {
+        return mProgramState->isCompute();
+    }
+
+    return mProgramPipelineState->isCompute();
+}
+
+void ProgramExecutable::setIsCompute(bool isComputeIn)
+{
+    // A Program can only either be graphics or compute, but never both, so it can answer
+    // isCompute() based on which shaders it has. However, a PPO can have both graphics and compute
+    // programs attached, so we don't know if the PPO is a 'graphics' or 'compute' PPO until the
+    // actual draw/dispatch call, which is why only PPOs need to record the type of call here.
+    if (mProgramPipelineState)
+    {
+        mProgramPipelineState->setIsCompute(isComputeIn);
+    }
+}
+
 int ProgramExecutable::getInfoLogLength() const
 {
     return static_cast<int>(mInfoLog.getLength());

src/libANGLE/ProgramExecutable.h

@@ -9,6 +9,7 @@
 #ifndef LIBANGLE_PROGRAMEXECUTABLE_H_
 #define LIBANGLE_PROGRAMEXECUTABLE_H_
 
+#include "BinaryStream.h"
 #include "libANGLE/Caps.h"
 #include "libANGLE/InfoLog.h"
 #include "libANGLE/VaryingPacking.h"
@@ -63,6 +64,9 @@ class ProgramExecutable
 
     void reset();
 
+    void save(gl::BinaryOutputStream *stream) const;
+    void load(gl::BinaryInputStream *stream);
+
     const ProgramState *getProgramState(ShaderType shaderType) const;
 
     int getInfoLogLength() const;
@@ -71,15 +75,38 @@ class ProgramExecutable
     std::string getInfoLogString() const;
     void resetInfoLog() { mInfoLog.reset(); }
 
-    const ShaderBitSet &getLinkedShaderStages() const { return mLinkedShaderStages; }
-    ShaderBitSet &getLinkedShaderStages() { return mLinkedShaderStages; }
+    void resetLinkedShaderStages()
+    {
+        mLinkedComputeShaderStages.reset();
+        mLinkedGraphicsShaderStages.reset();
+    }
+    const ShaderBitSet &getLinkedShaderStages() const
+    {
+        return isCompute() ? mLinkedComputeShaderStages : mLinkedGraphicsShaderStages;
+    }
+    void setLinkedShaderStages(ShaderType shaderType)
+    {
+        if (shaderType == ShaderType::Compute)
+        {
+            mLinkedComputeShaderStages.set(ShaderType::Compute);
+        }
+        else
+        {
+            mLinkedGraphicsShaderStages.set(shaderType);
+        }
+    }
     bool hasLinkedShaderStage(ShaderType shaderType) const
     {
         ASSERT(shaderType != ShaderType::InvalidEnum);
-        return mLinkedShaderStages[shaderType];
+        return (shaderType == ShaderType::Compute) ? mLinkedComputeShaderStages[shaderType]
+                                                   : mLinkedGraphicsShaderStages[shaderType];
     }
-    size_t getLinkedShaderStageCount() const { return mLinkedShaderStages.count(); }
-    bool isCompute() const { return hasLinkedShaderStage(ShaderType::Compute); }
+    size_t getLinkedShaderStageCount() const
+    {
+        return isCompute() ? mLinkedComputeShaderStages.count()
+                           : mLinkedGraphicsShaderStages.count();
+    }
+    bool isCompute() const;
 
     const AttributesMask &getActiveAttribLocationsMask() const
     {
@@ -136,6 +163,8 @@ class ProgramExecutable
         mProgramPipelineState = state;
     }
 
+    void setIsCompute(bool isComputeIn);
+
   private:
     // TODO(timvp): http://anglebug.com/3570: Investigate removing these friend
     // class declarations and accessing the necessary members with getters/setters.
@@ -156,7 +185,8 @@ class ProgramExecutable
 
     InfoLog mInfoLog;
 
-    ShaderBitSet mLinkedShaderStages;
+    ShaderBitSet mLinkedGraphicsShaderStages;
+    ShaderBitSet mLinkedComputeShaderStages;
 
     angle::BitSet<MAX_VERTEX_ATTRIBS> mActiveAttribLocationsMask;
     unsigned int mMaxActiveAttribLocation;