kc3-lang/angle/src/libANGLE/renderer/vulkan/ProgramVk.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/renderer/vulkan/ProgramVk.h

• //
  // Copyright 2016 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.
  //
  // ProgramVk.h:
  //    Defines the class interface for ProgramVk, implementing ProgramImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_PROGRAMVK_H_
  #define LIBANGLE_RENDERER_VULKAN_PROGRAMVK_H_
  
  #include <array>
  
  #include "common/utilities.h"
  #include "libANGLE/renderer/ProgramImpl.h"
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "libANGLE/renderer/vulkan/ProgramExecutableVk.h"
  #include "libANGLE/renderer/vulkan/RendererVk.h"
  #include "libANGLE/renderer/vulkan/TransformFeedbackVk.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  
  namespace rx
  {
  class ProgramVk : public ProgramImpl
  {
    public:
      ProgramVk(const gl::ProgramState &state);
      ~ProgramVk() override;
      void destroy(const gl::Context *context) override;
  
      std::unique_ptr<LinkEvent> load(const gl::Context *context,
                                      gl::BinaryInputStream *stream,
                                      gl::InfoLog &infoLog) override;
      void save(const gl::Context *context, gl::BinaryOutputStream *stream) override;
      void setBinaryRetrievableHint(bool retrievable) override;
      void setSeparable(bool separable) override;
  
      std::unique_ptr<LinkEvent> link(const gl::Context *context,
                                      const gl::ProgramLinkedResources &resources,
                                      gl::InfoLog &infoLog,
                                      const gl::ProgramMergedVaryings &mergedVaryings) override;
      GLboolean validate(const gl::Caps &caps, gl::InfoLog *infoLog) override;
  
      angle::Result syncState(const gl::Context *context,
                              const gl::Program::DirtyBits &dirtyBits) override;
  
      void setUniform1fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform2fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform3fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform4fv(GLint location, GLsizei count, const GLfloat *v) override;
      void setUniform1iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform2iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform3iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform4iv(GLint location, GLsizei count, const GLint *v) override;
      void setUniform1uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniform2uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniform3uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniform4uiv(GLint location, GLsizei count, const GLuint *v) override;
      void setUniformMatrix2fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
      void setUniformMatrix3fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
      void setUniformMatrix4fv(GLint location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value) override;
      void setUniformMatrix2x3fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix3x2fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix2x4fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix4x2fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix3x4fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
      void setUniformMatrix4x3fv(GLint location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value) override;
  
      void getUniformfv(const gl::Context *context, GLint location, GLfloat *params) const override;
      void getUniformiv(const gl::Context *context, GLint location, GLint *params) const override;
      void getUniformuiv(const gl::Context *context, GLint location, GLuint *params) const override;
  
      bool areShaderUniformsDirty(gl::ShaderType shaderType) const
      {
          return mExecutable.mDefaultUniformBlocksDirty[shaderType];
      }
      void setShaderUniformDirtyBit(gl::ShaderType shaderType)
      {
          if (!mExecutable.mDefaultUniformBlocks[shaderType]->uniformData.empty())
          {
              mExecutable.mDefaultUniformBlocksDirty.set(shaderType);
          }
      }
      void clearShaderUniformDirtyBit(gl::ShaderType shaderType)
      {
          mExecutable.mDefaultUniformBlocksDirty.reset(shaderType);
      }
  
      const ProgramExecutableVk &getExecutable() const { return mExecutable; }
      ProgramExecutableVk &getExecutable() { return mExecutable; }
  
      const SpvProgramInterfaceInfo &getSpvProgramInterfaceInfo() { return mSpvProgramInterfaceInfo; }
  
    private:
      template <int cols, int rows>
      void setUniformMatrixfv(GLint location,
                              GLsizei count,
                              GLboolean transpose,
                              const GLfloat *value);
  
      void reset(ContextVk *contextVk);
      angle::Result initDefaultUniformBlocks(const gl::Context *glContext);
      void generateUniformLayoutMapping(const gl::Context *context,
                                        gl::ShaderMap<sh::BlockLayoutMap> &layoutMap,
                                        gl::ShaderMap<size_t> &requiredBufferSize);
      void initDefaultUniformLayoutMapping(gl::ShaderMap<sh::BlockLayoutMap> &layoutMap);
  
      template <class T>
      void getUniformImpl(GLint location, T *v, GLenum entryPointType) const;
  
      template <typename T>
      void setUniformImpl(GLint location, GLsizei count, const T *v, GLenum entryPointType);
      void linkResources(const gl::Context *context, const gl::ProgramLinkedResources &resources);
  
      angle::Result createGraphicsPipelineWithDefaultState(const gl::Context *context,
                                                           vk::PipelineCacheAccess *pipelineCache);
  
      // We keep the SPIR-V code to use for draw call pipeline creation.
      SpvProgramInterfaceInfo mSpvProgramInterfaceInfo;
  
      ProgramExecutableVk mExecutable;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_PROGRAMVK_H_
  

Download