kc3-lang/angle/src/libANGLE/ProgramPipeline.h

• Show log

  Commit

• Hash : 24f64249
  Author :
  Date : 2020-11-16T17:55:02
  

  Vulkan: Track specialization constant usage bit and feedback to ctx
  
  Right now context does not know which specialization constant is used by
  the shader. Whenever a specialization constant changes, we assume shader
  program is using it, we always reach into vulkan driver to ask for a new
  program. Instead we can track shader's usage of specialization constant
  so that context can utilize this information to avoid recompile pipeline
  program if an unused specialization constant has changed.
  
  This CL implements the plumbing the usage bits form compiler to program
  object, it does not actually utilize the usage bits to avoid unnecessary
  compilation yet.
  
  Bug: b/173461931
  Change-Id: Iebc9d0638c17b1a282c8b6093ce6bae154246e57
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2542866
  Reviewed-by: Ian Elliott <ianelliott@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

• src/libANGLE/ProgramPipeline.h

• //
  // Copyright 2017 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // ProgramPipeline.h: Defines the gl::ProgramPipeline class.
  // Implements GL program pipeline objects and related functionality.
  // [OpenGL ES 3.1] section 7.4 page 105.
  
  #ifndef LIBANGLE_PROGRAMPIPELINE_H_
  #define LIBANGLE_PROGRAMPIPELINE_H_
  
  #include <memory>
  
  #include "common/angleutils.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Program.h"
  #include "libANGLE/ProgramExecutable.h"
  #include "libANGLE/RefCountObject.h"
  
  namespace rx
  {
  class GLImplFactory;
  class ProgramPipelineImpl;
  }  // namespace rx
  
  namespace gl
  {
  class Context;
  class ProgramPipeline;
  
  class ProgramPipelineState final : angle::NonCopyable
  {
    public:
      ProgramPipelineState();
      ~ProgramPipelineState();
  
      const std::string &getLabel() const;
  
      const ProgramExecutable &getProgramExecutable() const
      {
          ASSERT(mExecutable);
          return *mExecutable;
      }
      ProgramExecutable &getProgramExecutable()
      {
          ASSERT(mExecutable);
          return *mExecutable;
      }
  
      void activeShaderProgram(Program *shaderProgram);
      void useProgramStages(const Context *context,
                            GLbitfield stages,
                            Program *shaderProgram,
                            std::vector<angle::ObserverBinding> *programObserverBindings);
  
      Program *getActiveShaderProgram() { return mActiveShaderProgram; }
  
      GLboolean isValid() const { return mValid; }
  
      const Program *getShaderProgram(ShaderType shaderType) const { return mPrograms[shaderType]; }
  
      bool usesShaderProgram(ShaderProgramID program) const;
  
      void updateExecutableTextures();
  
      rx::SpecConstUsageBits getSpecConstUsageBits() const;
  
    private:
      void useProgramStage(const Context *context,
                           ShaderType shaderType,
                           Program *shaderProgram,
                           angle::ObserverBinding *programObserverBindings);
  
      friend class ProgramPipeline;
  
      std::string mLabel;
  
      // The active shader program
      Program *mActiveShaderProgram;
      // The shader programs for each stage.
      ShaderMap<Program *> mPrograms;
  
      GLboolean mValid;
  
      ProgramExecutable *mExecutable;
  
      bool mIsLinked;
  };
  
  class ProgramPipeline final : public RefCountObject<ProgramPipelineID>,
                                public LabeledObject,
                                public angle::ObserverInterface
  {
    public:
      ProgramPipeline(rx::GLImplFactory *factory, ProgramPipelineID handle);
      ~ProgramPipeline() override;
  
      void onDestroy(const Context *context) override;
  
      void setLabel(const Context *context, const std::string &label) override;
      const std::string &getLabel() const override;
  
      const ProgramPipelineState &getState() const { return mState; }
      ProgramPipelineState &getState() { return mState; }
  
      const ProgramExecutable &getExecutable() const { return mState.getProgramExecutable(); }
      ProgramExecutable &getExecutable() { return mState.getProgramExecutable(); }
  
      rx::ProgramPipelineImpl *getImplementation() const;
  
      Program *getActiveShaderProgram() { return mState.getActiveShaderProgram(); }
      void activeShaderProgram(Program *shaderProgram);
      Program *getLinkedActiveShaderProgram(const Context *context)
      {
          Program *program = mState.getActiveShaderProgram();
          if (program)
          {
              program->resolveLink(context);
          }
          return program;
      }
  
      void useProgramStages(const Context *context, GLbitfield stages, Program *shaderProgram);
  
      Program *getShaderProgram(ShaderType shaderType) const { return mState.mPrograms[shaderType]; }
  
      void resetIsLinked() { mState.mIsLinked = false; }
      ProgramMergedVaryings getMergedVaryings() const;
      angle::Result link(const gl::Context *context);
      bool linkVaryings(InfoLog &infoLog) const;
      void validate(const gl::Context *context);
      bool validateSamplers(InfoLog *infoLog, const Caps &caps);
  
      bool usesShaderProgram(ShaderProgramID program) const
      {
          return mState.usesShaderProgram(program);
      }
  
      GLboolean isValid() const { return mState.isValid(); }
  
      // ObserverInterface implementation.
      void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
  
      void fillProgramStateMap(gl::ShaderMap<const gl::ProgramState *> *programStatesOut);
  
    private:
      void updateLinkedShaderStages();
      void updateExecutableAttributes();
      void updateTransformFeedbackMembers();
      void updateShaderStorageBlocks();
      void updateImageBindings();
      void updateHasBooleans();
      void updateExecutable();
  
      std::unique_ptr<rx::ProgramPipelineImpl> mProgramPipelineImpl;
  
      ProgramPipelineState mState;
  
      std::vector<angle::ObserverBinding> mProgramObserverBindings;
      angle::ObserverBinding mExecutableObserverBinding;
  };
  }  // namespace gl
  
  #endif  // LIBANGLE_PROGRAMPIPELINE_H_
  

Download