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

• Show log

  Commit

• Hash : e21ecd1b
  Author :
  Date : 2023-05-26T14:06:46
  

  Vulkan: Add dirty bit processing for uniform buffer change
  
  When app calls glBufferData for the uniform buffer, we may end up
  reallocate the storage. This will set DIRTY_BIT_UNIFORM_BUFFER_BINDINGS
  on the context, but the exact uniform block index gets lost along the
  way. This CL sets mDirtyBits on the program for the corresponding block
  index and then changed vulkan backend to utilize the program's
  mDirtyBits and only update the buffer if it is dirty, instead of always
  update all uniform buffers even if only one of the buffer is dirty. In
  order to make this work, this CL also adds the reverse tracking from
  buffer binding to uniform blocks. Previously we already have the
  tracking of which buffer binding index is used for which buffer block
  index. This CL adds mUniformBlockBindingMasks which is an array of
  BitSets. Each array element tracks all the uniform block index that is
  using this buffer binding index (you can have the same buffer bound to
  multiple uniform block index). Then when a buffer binding index is
  dirty, that BitSet gets added into program's uniform block dirty bits.
  
  This CL and previous CL improves GfxBench gl_driver2_off score 1.8%
  (from average 6797 to average 6919) on pixel 7 pro.
  
  Bug: b/282194402
  Change-Id: Ic5002643a5297907276fc9b20ca7d21af9bdc4fe
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4553136
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Roman Lavrov <romanl@google.com>
  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;
  
      ProgramExecutable &getExecutable() const
      {
          ASSERT(mExecutable);
          return *mExecutable;
      }
  
      void activeShaderProgram(Program *shaderProgram);
      void useProgramStages(const Context *context,
                            const gl::ShaderBitSet &shaderTypes,
                            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 angle::Subject
  {
    public:
      ProgramPipeline(rx::GLImplFactory *factory, ProgramPipelineID handle);
      ~ProgramPipeline() override;
  
      void onDestroy(const Context *context) override;
  
      angle::Result 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; }
  
      ProgramExecutable &getExecutable() const { return mState.getExecutable(); }
  
      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;
      }
  
      angle::Result useProgramStages(const Context *context,
                                     GLbitfield stages,
                                     Program *shaderProgram);
  
      Program *getShaderProgram(ShaderType shaderType) const { return mState.mPrograms[shaderType]; }
  
      void resetIsLinked() { mState.mIsLinked = false; }
      angle::Result link(const gl::Context *context);
  
      angle::Result syncState(const Context *context);
  
      // Ensure program pipeline is linked. Inlined to make sure its overhead is as low as possible.
      void resolveLink(const Context *context)
      {
          if (mState.mIsLinked)
          {
              // Already linked, nothing to do.
              return;
          }
  
          angle::Result linkResult = link(context);
          if (linkResult != angle::Result::Continue)
          {
              // If the link failed then log a warning, swallow the error and move on.
              WARN() << "ProgramPipeline link failed" << std::endl;
          }
          return;
      }
  
      void validate(const gl::Context *context);
      GLboolean isValid() const { return mState.isValid(); }
      bool isLinked() const { return mState.mIsLinked; }
  
      void onUniformBufferStateChange(size_t uniformBufferIndex);
      // ObserverInterface implementation.
      void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
  
    private:
      bool linkVaryings(InfoLog &infoLog) const;
      void updateLinkedShaderStages();
      void updateExecutableAttributes();
      void updateTransformFeedbackMembers();
      void updateShaderStorageBlocks();
      void updateImageBindings();
      void updateExecutableGeometryProperties();
      void updateExecutableTessellationProperties();
      void updateFragmentInoutRangeAndEnablesPerSampleShading();
      void updateLinkedVaryings();
      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