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

• Show log

  Commit

• Hash : d375547c
  Author :
  Date : 2022-08-12T15:54:39
  

  Do not link program pipeline in glUseProgramStages
  
  1. The commit 3a9f18f135fe82 caused a link to occur everytime
     glUseProgramStages is called. This is redundant since the program
     pipeline can be linked just before usage, thus allowing for multiple
     stages to be bound before linking the executable.
  
  2. Mark PPO as a dirty object and link the PPO in dirty object handler
  
  3. Early return if the same program is being bound to the same stage
     of the pipeline.
  
  4. Added ProgramPipelineObjectBenchmark perf test that switches programs
     before a draw and observed following data -
     1. vulkan profile -
         1. wall_time before patch - 102000 ns
         2. wall_time after patch  -  38000 ns
     2. vulkan_null profile -
         1. wall_time before patch - 125000 ns
         2. wall_time after patch  -  52000 ns
  
  Bug: angleproject:5102
  Bug: angleproject:6566
  Test: ContextNoErrorPPOTest31.*Vulkan
  Test: ProgramPipelineTest31.*Vulkan
  Test: ProgramPipelineObjectBenchmark*
  Change-Id: Idbc2fcb4875bbd040e9ec847eb2a8f96f287173c
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3830170
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: mohan maiya <m.maiya@samsung.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);
  
      // 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; }
  
      // 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