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

• Show log

  Commit

• Hash : be8739f2
  Author :
  Date : 2023-09-22T14:36:45
  

  Vulkan: Fix StatInfo in vk_mem_alloc_wrapper.h to match VMA
  
  Right now we are defining our own StatInfo structure in
  vk_mem_alloc_wrapper.h to avoid inclusion of VMA header directly in
  other ANGLE code. This caused this struct no longer matches VMA's
  structure since VMA 3.0 switch. For quick fix, this CL just update
  StatInfo to match VMA 3.0 define.
  
  Bug: b/301653706
  Change-Id: Ic510c362f30d9296a13964e6ba9c617e80e49ceb
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4888625
  Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

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

• //
  // Copyright 2020 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.
  //
  // vma_allocator_wrapper.h:
  //    Hides VMA functions so we can use separate warning sets.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_VK_MEM_ALLOC_WRAPPER_H_
  #define LIBANGLE_RENDERER_VULKAN_VK_MEM_ALLOC_WRAPPER_H_
  
  #include "common/vulkan/vk_headers.h"
  
  VK_DEFINE_HANDLE(VmaAllocator)
  VK_DEFINE_HANDLE(VmaAllocation)
  VK_DEFINE_HANDLE(VmaPool)
  VK_DEFINE_NON_DISPATCHABLE_HANDLE(VmaVirtualAllocation)
  VK_DEFINE_HANDLE(VmaVirtualBlock)
  
  namespace vma
  {
  typedef VkFlags VirtualBlockCreateFlags;
  #if ANGLE_VMA_VERSION < 3000000
  typedef enum VirtualBlockCreateFlagBits
  {
      GENERAL = 0x00000000,
      LINEAR  = 0x00000001,
      BUDDY   = 0x00000002
  } VirtualBlockCreateFlagBits;
  #else
  typedef enum VirtualBlockCreateFlagBits
  {
      GENERAL = 0x00000000,
      LINEAR  = 0x00000001,
  } VirtualBlockCreateFlagBits;
  #endif
  
  typedef struct StatInfo
  {
  #if ANGLE_VMA_VERSION < 3000000
      // Number of VkDeviceMemory Vulkan memory blocks allocated.
      uint32_t blockCount;
      // Number of VmaAllocation allocation objects allocated.
      uint32_t allocationCount;
      // Number of free ranges of memory between allocations.
      uint32_t unusedRangeCount;
      // Total number of bytes occupied by all allocations.
      VkDeviceSize usedBytes;
      // Total number of bytes occupied by unused ranges.
      VkDeviceSize unusedBytes;
      VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
      VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
  #else
      struct BasicInfo
      {
          // Number of VkDeviceMemory Vulkan memory blocks allocated.
          uint32_t blockCount;
          // Number of VmaAllocation allocation objects allocated.
          uint32_t allocationCount;
          VkDeviceSize blockBytes;
          VkDeviceSize allocationBytes;
      } basicInfo;
      /// Number of free ranges of memory between allocations.
      uint32_t unusedRangeCount;
      /// Smallest allocation size. `VK_WHOLE_SIZE` if there are 0 allocations.
      VkDeviceSize allocationSizeMin;
      /// Largest allocation size. 0 if there are 0 allocations.
      VkDeviceSize allocationSizeMax;
      /// Smallest empty range size. `VK_WHOLE_SIZE` if there are 0 empty ranges.
      VkDeviceSize unusedRangeSizeMin;
      /// Largest empty range size. 0 if there are 0 empty ranges.
      VkDeviceSize unusedRangeSizeMax;
  #endif
  } StatInfo;
  
  VkResult InitAllocator(VkPhysicalDevice physicalDevice,
                         VkDevice device,
                         VkInstance instance,
                         uint32_t apiVersion,
                         VkDeviceSize preferredLargeHeapBlockSize,
                         VmaAllocator *pAllocator);
  
  void DestroyAllocator(VmaAllocator allocator);
  
  VkResult CreatePool(VmaAllocator allocator,
                      uint32_t memoryTypeIndex,
  #if ANGLE_VMA_VERSION < 3000000
                      bool buddyAlgorithm,
  #endif  // ANGLE_VMA_VERSION < 3000000
                      VkDeviceSize blockSize,
                      VmaPool *pPool);
  void DestroyPool(VmaAllocator allocator, VmaPool pool);
  
  void FreeMemory(VmaAllocator allocator, VmaAllocation allocation);
  
  VkResult CreateBuffer(VmaAllocator allocator,
                        const VkBufferCreateInfo *pBufferCreateInfo,
                        VkMemoryPropertyFlags requiredFlags,
                        VkMemoryPropertyFlags preferredFlags,
                        bool persistentlyMapped,
                        uint32_t *pMemoryTypeIndexOut,
                        VkBuffer *pBuffer,
                        VmaAllocation *pAllocation);
  
  VkResult AllocateAndBindMemoryForImage(VmaAllocator allocator,
                                         VkImage *pImage,
                                         VkMemoryPropertyFlags requiredFlags,
                                         VkMemoryPropertyFlags preferredFlags,
                                         uint32_t memoryTypeBits,
                                         bool allocateDedicatedMemory,
                                         VmaAllocation *pAllocationOut,
                                         uint32_t *pMemoryTypeIndexOut,
                                         VkDeviceSize *sizeOut);
  
  VkResult FindMemoryTypeIndexForBufferInfo(VmaAllocator allocator,
                                            const VkBufferCreateInfo *pBufferCreateInfo,
                                            VkMemoryPropertyFlags requiredFlags,
                                            VkMemoryPropertyFlags preferredFlags,
                                            bool persistentlyMappedBuffers,
                                            uint32_t *pMemoryTypeIndexOut);
  
  VkResult FindMemoryTypeIndexForImageInfo(VmaAllocator allocator,
                                           const VkImageCreateInfo *pImageCreateInfo,
                                           VkMemoryPropertyFlags requiredFlags,
                                           VkMemoryPropertyFlags preferredFlags,
                                           bool allocateDedicatedMemory,
                                           uint32_t *pMemoryTypeIndexOut);
  
  void GetMemoryTypeProperties(VmaAllocator allocator,
                               uint32_t memoryTypeIndex,
                               VkMemoryPropertyFlags *pFlags);
  
  VkResult MapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData);
  
  void UnmapMemory(VmaAllocator allocator, VmaAllocation allocation);
  
  void FlushAllocation(VmaAllocator allocator,
                       VmaAllocation allocation,
                       VkDeviceSize offset,
                       VkDeviceSize size);
  
  void InvalidateAllocation(VmaAllocator allocator,
                            VmaAllocation allocation,
                            VkDeviceSize offset,
                            VkDeviceSize size);
  
  void BuildStatsString(VmaAllocator allocator, char **statsString, VkBool32 detailedMap);
  void FreeStatsString(VmaAllocator allocator, char *statsString);
  
  // VMA virtual block
  VkResult CreateVirtualBlock(VkDeviceSize size,
                              VirtualBlockCreateFlags flags,
                              VmaVirtualBlock *pVirtualBlock);
  void DestroyVirtualBlock(VmaVirtualBlock virtualBlock);
  VkResult VirtualAllocate(VmaVirtualBlock virtualBlock,
                           VkDeviceSize size,
                           VkDeviceSize alignment,
                           VmaVirtualAllocation *pAllocation,
                           VkDeviceSize *pOffset);
  void VirtualFree(VmaVirtualBlock virtualBlock,
                   VmaVirtualAllocation allocation,
                   VkDeviceSize offset);
  VkBool32 IsVirtualBlockEmpty(VmaVirtualBlock virtualBlock);
  void GetVirtualAllocationInfo(VmaVirtualBlock virtualBlock,
                                VmaVirtualAllocation allocation,
                                VkDeviceSize offset,
                                VkDeviceSize *sizeOut,
                                void **pUserDataOut);
  void ClearVirtualBlock(VmaVirtualBlock virtualBlock);
  void SetVirtualAllocationUserData(VmaVirtualBlock virtualBlock,
                                    VkDeviceSize offset,
                                    void *pUserData);
  void CalculateVirtualBlockStats(VmaVirtualBlock virtualBlock, StatInfo *pStatInfo);
  void BuildVirtualBlockStatsString(VmaVirtualBlock virtualBlock,
                                    char **ppStatsString,
                                    VkBool32 detailedMap);
  void FreeVirtualBlockStatsString(VmaVirtualBlock virtualBlock, char *pStatsString);
  }  // namespace vma
  
  #endif  // LIBANGLE_RENDERER_VULKAN_VK_MEM_ALLOC_WRAPPER_H_
  

Download