kc3-lang/angle/src/libANGLE/renderer/vulkan/ShareGroupVk.h

• Show log

  Commit

• Hash : 4b356c39
  Author :
  Date : 2023-08-17T10:49:19
  

  Vulkan: Drop support for VMA 2.0
  
    Since ANGLE and Chromium were last updated to use VMA 3.0, there have
  been no breaking issues so far.
    * ANGLE update: https://crrev.com/c/4777337
    * Chromium update: https://crrev.com/c/4911597
  
  Therefore, the support for the old VMA (2.3) can now be removed.
  
  * Removed ANGLE_VMA_VERSION from the build files, since they are
    no longer required.
    * Removed the VMA-related guards in the code as well.
  
  * Removed the flags and thresholds for the buddy algorithm, which were
    used in VMA 2.3.
    * Share group buffer pools is no longer a map.
  
  Bug: b/303290680
  Change-Id: Ic2b29e8f95ca5c941b297b20442c5bad4b8f52e3
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4791667
  Reviewed-by: Charlie Lao <cclao@google.com>
  Commit-Queue: Amirali Abdolrashidi <abdolrashidi@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/ShareGroupVk.h

• //
  // Copyright 2023 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.
  //
  // ShareGroupVk.h:
  //    Defines the class interface for ShareGroupVk, implementing ShareGroupImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_SHAREGROUPVK_H_
  #define LIBANGLE_RENDERER_VULKAN_SHAREGROUPVK_H_
  
  #include "libANGLE/renderer/ShareGroupImpl.h"
  #include "libANGLE/renderer/vulkan/ResourceVk.h"
  #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
  #include "libANGLE/renderer/vulkan/vk_helpers.h"
  #include "libANGLE/renderer/vulkan/vk_utils.h"
  
  namespace rx
  {
  constexpr VkDeviceSize kMaxTotalEmptyBufferBytes = 16 * 1024 * 1024;
  
  class RendererVk;
  
  class TextureUpload
  {
    public:
      TextureUpload() { mPrevUploadedMutableTexture = nullptr; }
      ~TextureUpload() { resetPrevTexture(); }
      angle::Result onMutableTextureUpload(ContextVk *contextVk, TextureVk *newTexture);
      void onTextureRelease(TextureVk *textureVk);
      void resetPrevTexture() { mPrevUploadedMutableTexture = nullptr; }
  
    private:
      // Keep track of the previously stored texture. Used to flush mutable textures.
      TextureVk *mPrevUploadedMutableTexture;
  };
  
  class UpdateDescriptorSetsBuilder final : angle::NonCopyable
  {
    public:
      UpdateDescriptorSetsBuilder();
      ~UpdateDescriptorSetsBuilder();
  
      VkDescriptorBufferInfo *allocDescriptorBufferInfos(size_t count);
      VkDescriptorImageInfo *allocDescriptorImageInfos(size_t count);
      VkWriteDescriptorSet *allocWriteDescriptorSets(size_t count);
      VkBufferView *allocBufferViews(size_t count);
  
      VkDescriptorBufferInfo &allocDescriptorBufferInfo() { return *allocDescriptorBufferInfos(1); }
      VkDescriptorImageInfo &allocDescriptorImageInfo() { return *allocDescriptorImageInfos(1); }
      VkWriteDescriptorSet &allocWriteDescriptorSet() { return *allocWriteDescriptorSets(1); }
      VkBufferView &allocBufferView() { return *allocBufferViews(1); }
  
      // Returns the number of written descriptor sets.
      uint32_t flushDescriptorSetUpdates(VkDevice device);
  
    private:
      template <typename T, const T *VkWriteDescriptorSet::*pInfo>
      T *allocDescriptorInfos(std::vector<T> *descriptorVector, size_t count);
      template <typename T, const T *VkWriteDescriptorSet::*pInfo>
      void growDescriptorCapacity(std::vector<T> *descriptorVector, size_t newSize);
  
      std::vector<VkDescriptorBufferInfo> mDescriptorBufferInfos;
      std::vector<VkDescriptorImageInfo> mDescriptorImageInfos;
      std::vector<VkWriteDescriptorSet> mWriteDescriptorSets;
      std::vector<VkBufferView> mBufferViews;
  };
  
  class ShareGroupVk : public ShareGroupImpl
  {
    public:
      ShareGroupVk(const egl::ShareGroupState &state);
      void onDestroy(const egl::Display *display) override;
  
      void onContextAdd() override;
  
      FramebufferCache &getFramebufferCache() { return mFramebufferCache; }
  
      bool hasAnyContextWithRobustness() const { return mState.hasAnyContextWithRobustness(); }
  
      // PipelineLayoutCache and DescriptorSetLayoutCache can be shared between multiple threads
      // accessing them via shared contexts. The ShareGroup locks around gl entrypoints ensuring
      // synchronous update to the caches.
      PipelineLayoutCache &getPipelineLayoutCache() { return mPipelineLayoutCache; }
      DescriptorSetLayoutCache &getDescriptorSetLayoutCache() { return mDescriptorSetLayoutCache; }
      const egl::ContextMap &getContexts() const { return mState.getContexts(); }
      vk::DescriptorSetArray<vk::MetaDescriptorPool> &getMetaDescriptorPools()
      {
          return mMetaDescriptorPools;
      }
  
      // Used to flush the mutable textures more often.
      angle::Result onMutableTextureUpload(ContextVk *contextVk, TextureVk *newTexture);
  
      vk::BufferPool *getDefaultBufferPool(RendererVk *renderer,
                                           VkDeviceSize size,
                                           uint32_t memoryTypeIndex,
                                           BufferUsageType usageType);
      void pruneDefaultBufferPools(RendererVk *renderer);
      bool isDueForBufferPoolPrune(RendererVk *renderer);
  
      void calculateTotalBufferCount(size_t *bufferCount, VkDeviceSize *totalSize) const;
      void logBufferPools() const;
  
      // Temporary workaround until VkSemaphore(s) will be used between different priorities.
      angle::Result unifyContextsPriority(ContextVk *newContextVk);
      // Temporary workaround until VkSemaphore(s) will be used between different priorities.
      angle::Result lockDefaultContextsPriority(ContextVk *contextVk);
  
      UpdateDescriptorSetsBuilder *getUpdateDescriptorSetsBuilder()
      {
          return &mUpdateDescriptorSetsBuilder;
      }
  
      void onTextureRelease(TextureVk *textureVk);
  
      angle::Result scheduleMonolithicPipelineCreationTask(
          ContextVk *contextVk,
          vk::WaitableMonolithicPipelineCreationTask *taskOut);
      void waitForCurrentMonolithicPipelineCreationTask();
  
    private:
      angle::Result updateContextsPriority(ContextVk *contextVk, egl::ContextPriority newPriority);
  
      // VkFramebuffer caches
      FramebufferCache mFramebufferCache;
  
      void resetPrevTexture() { mTextureUpload.resetPrevTexture(); }
  
      // ANGLE uses a PipelineLayout cache to store compatible pipeline layouts.
      PipelineLayoutCache mPipelineLayoutCache;
  
      // DescriptorSetLayouts are also managed in a cache.
      DescriptorSetLayoutCache mDescriptorSetLayoutCache;
  
      // Descriptor set caches
      vk::DescriptorSetArray<vk::MetaDescriptorPool> mMetaDescriptorPools;
  
      // Priority of all Contexts in the context set
      egl::ContextPriority mContextsPriority;
      bool mIsContextsPriorityLocked;
  
      // Storage for vkUpdateDescriptorSets
      UpdateDescriptorSetsBuilder mUpdateDescriptorSetsBuilder;
  
      // The per shared group buffer pools that all buffers should sub-allocate from.
      vk::BufferPoolPointerArray mDefaultBufferPools;
  
      // The system time when last pruneEmptyBuffer gets called.
      double mLastPruneTime;
  
      // The system time when the last monolithic pipeline creation job was launched.  This is
      // rate-limited to avoid hogging all cores and interfering with the application threads.  A
      // single pipeline creation job is currently supported.
      double mLastMonolithicPipelineJobTime;
      std::shared_ptr<angle::WaitableEvent> mMonolithicPipelineCreationEvent;
  
      // Texture update manager used to flush uploaded mutable textures.
      TextureUpload mTextureUpload;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_SHAREGROUPVK_H_
  

Download