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

• Show log

  Commit

• Hash : 1e435d07
  Author :
  Date : 2020-10-14T13:33:10
  

  Vulkan: Support dumping VMA stats string
  
  This CL adds support for dumping the VMA stats string, which can be
  given to VmaDumpVis.py to visualize the allocations that the VMA has
  performed.
  
  To enable dumping the string, set:
  RendererVk.cpp
    rx::kOutputVmaStatsString = true
  
  Copy the desired JSON output into a text file, and pass that to
  VmaDumpVis.py:
  python3 \
    third_party/vulkan_memory_allocator/tools/VmaDumpVis/VmaDumpVis.py \
    -o stats.png stats.txt
  
  The legend for the visualization is available at:
  https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/tree/master/tools/VmaDumpVis
  
  Bug: angleproject:2162
  Test: Manual verification
  Change-Id: Ic8c1002805dd57e594df724bcf1cdbc1d1599a3e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2472525
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Charlie Lao <cclao@google.com>
  Commit-Queue: Tim Van Patten <timvp@google.com>
  

Download

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

• //
  // 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.cpp:
  //    Hides VMA functions so we can use separate warning sets.
  //
  
  #include "vk_mem_alloc_wrapper.h"
  
  #include <vk_mem_alloc.h>
  
  namespace vma
  {
  VkResult InitAllocator(VkPhysicalDevice physicalDevice,
                         VkDevice device,
                         VkInstance instance,
                         uint32_t apiVersion,
                         VkDeviceSize preferredLargeHeapBlockSize,
                         VmaAllocator *pAllocator)
  {
      VmaVulkanFunctions funcs                  = {};
      funcs.vkGetPhysicalDeviceProperties       = vkGetPhysicalDeviceProperties;
      funcs.vkGetPhysicalDeviceMemoryProperties = vkGetPhysicalDeviceMemoryProperties;
      funcs.vkAllocateMemory                    = vkAllocateMemory;
      funcs.vkFreeMemory                        = vkFreeMemory;
      funcs.vkMapMemory                         = vkMapMemory;
      funcs.vkUnmapMemory                       = vkUnmapMemory;
      funcs.vkFlushMappedMemoryRanges           = vkFlushMappedMemoryRanges;
      funcs.vkInvalidateMappedMemoryRanges      = vkInvalidateMappedMemoryRanges;
      funcs.vkBindBufferMemory                  = vkBindBufferMemory;
      funcs.vkBindImageMemory                   = vkBindImageMemory;
      funcs.vkGetBufferMemoryRequirements       = vkGetBufferMemoryRequirements;
      funcs.vkGetImageMemoryRequirements        = vkGetImageMemoryRequirements;
      funcs.vkCreateBuffer                      = vkCreateBuffer;
      funcs.vkDestroyBuffer                     = vkDestroyBuffer;
      funcs.vkCreateImage                       = vkCreateImage;
      funcs.vkDestroyImage                      = vkDestroyImage;
      funcs.vkCmdCopyBuffer                     = vkCmdCopyBuffer;
      {
  #if !defined(ANGLE_SHARED_LIBVULKAN)
          // When the vulkan-loader is statically linked, we need to use the extension
          // functions defined in ANGLE's rx namespace. When it's dynamically linked
          // with volk, this will default to the function definitions with no namespace
          using rx::vkBindBufferMemory2KHR;
          using rx::vkBindImageMemory2KHR;
          using rx::vkGetBufferMemoryRequirements2KHR;
          using rx::vkGetImageMemoryRequirements2KHR;
          using rx::vkGetPhysicalDeviceMemoryProperties2KHR;
  #endif  // !defined(ANGLE_SHARED_LIBVULKAN)
          funcs.vkGetBufferMemoryRequirements2KHR       = vkGetBufferMemoryRequirements2KHR;
          funcs.vkGetImageMemoryRequirements2KHR        = vkGetImageMemoryRequirements2KHR;
          funcs.vkBindBufferMemory2KHR                  = vkBindBufferMemory2KHR;
          funcs.vkBindImageMemory2KHR                   = vkBindImageMemory2KHR;
          funcs.vkGetPhysicalDeviceMemoryProperties2KHR = vkGetPhysicalDeviceMemoryProperties2KHR;
      }
  
      VmaAllocatorCreateInfo allocatorInfo      = {};
      allocatorInfo.physicalDevice              = physicalDevice;
      allocatorInfo.device                      = device;
      allocatorInfo.instance                    = instance;
      allocatorInfo.pVulkanFunctions            = &funcs;
      allocatorInfo.vulkanApiVersion            = apiVersion;
      allocatorInfo.preferredLargeHeapBlockSize = preferredLargeHeapBlockSize;
  
      return vmaCreateAllocator(&allocatorInfo, pAllocator);
  }
  
  void DestroyAllocator(VmaAllocator allocator)
  {
      vmaDestroyAllocator(allocator);
  }
  
  void FreeMemory(VmaAllocator allocator, VmaAllocation allocation)
  {
      vmaFreeMemory(allocator, allocation);
  }
  
  VkResult CreateBuffer(VmaAllocator allocator,
                        const VkBufferCreateInfo *pBufferCreateInfo,
                        VkMemoryPropertyFlags requiredFlags,
                        VkMemoryPropertyFlags preferredFlags,
                        bool persistentlyMappedBuffers,
                        uint32_t *pMemoryTypeIndexOut,
                        VkBuffer *pBuffer,
                        VmaAllocation *pAllocation)
  {
      VkResult result;
      VmaAllocationCreateInfo allocationCreateInfo = {};
      allocationCreateInfo.requiredFlags           = requiredFlags;
      allocationCreateInfo.preferredFlags          = preferredFlags;
      allocationCreateInfo.flags = (persistentlyMappedBuffers) ? VMA_ALLOCATION_CREATE_MAPPED_BIT : 0;
      VmaAllocationInfo allocationInfo = {};
  
      result = vmaCreateBuffer(allocator, pBufferCreateInfo, &allocationCreateInfo, pBuffer,
                               pAllocation, &allocationInfo);
      *pMemoryTypeIndexOut = allocationInfo.memoryType;
  
      return result;
  }
  
  VkResult FindMemoryTypeIndexForBufferInfo(VmaAllocator allocator,
                                            const VkBufferCreateInfo *pBufferCreateInfo,
                                            VkMemoryPropertyFlags requiredFlags,
                                            VkMemoryPropertyFlags preferredFlags,
                                            bool persistentlyMappedBuffers,
                                            uint32_t *pMemoryTypeIndexOut)
  {
      VmaAllocationCreateInfo allocationCreateInfo = {};
      allocationCreateInfo.requiredFlags           = requiredFlags;
      allocationCreateInfo.preferredFlags          = preferredFlags;
      allocationCreateInfo.flags = (persistentlyMappedBuffers) ? VMA_ALLOCATION_CREATE_MAPPED_BIT : 0;
  
      return vmaFindMemoryTypeIndexForBufferInfo(allocator, pBufferCreateInfo, &allocationCreateInfo,
                                                 pMemoryTypeIndexOut);
  }
  
  void GetMemoryTypeProperties(VmaAllocator allocator,
                               uint32_t memoryTypeIndex,
                               VkMemoryPropertyFlags *pFlags)
  {
      vmaGetMemoryTypeProperties(allocator, memoryTypeIndex, pFlags);
  }
  
  VkResult MapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
  {
      return vmaMapMemory(allocator, allocation, ppData);
  }
  
  void UnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
  {
      return vmaUnmapMemory(allocator, allocation);
  }
  
  void FlushAllocation(VmaAllocator allocator,
                       VmaAllocation allocation,
                       VkDeviceSize offset,
                       VkDeviceSize size)
  {
      vmaFlushAllocation(allocator, allocation, offset, size);
  }
  
  void InvalidateAllocation(VmaAllocator allocator,
                            VmaAllocation allocation,
                            VkDeviceSize offset,
                            VkDeviceSize size)
  {
      vmaInvalidateAllocation(allocator, allocation, offset, size);
  }
  
  void BuildStatsString(VmaAllocator allocator, char **statsString, VkBool32 detailedMap)
  {
      vmaBuildStatsString(allocator, statsString, detailedMap);
  }
  
  void FreeStatsString(VmaAllocator allocator, char *statsString)
  {
      vmaFreeStatsString(allocator, statsString);
  }
  }  // namespace vma
  

Download