flutter::FlutterSkiaVulkanMemoryAllocator Class Reference

#include <flutter_skia_vma.h>

Inheritance diagram for flutter::FlutterSkiaVulkanMemoryAllocator:

Public Member Functions
	~FlutterSkiaVulkanMemoryAllocator () override
VkResult	allocateImageMemory (VkImage image, uint32_t allocationPropertyFlags, skgpu::VulkanBackendMemory *) override
VkResult	allocateBufferMemory (VkBuffer buffer, BufferUsage usage, uint32_t allocationPropertyFlags, skgpu::VulkanBackendMemory *) override
void	freeMemory (const skgpu::VulkanBackendMemory &) override
void	getAllocInfo (const skgpu::VulkanBackendMemory &, skgpu::VulkanAlloc *) const override
VkResult	mapMemory (const skgpu::VulkanBackendMemory &, void **data) override
void	unmapMemory (const skgpu::VulkanBackendMemory &) override
VkResult	flushMemory (const skgpu::VulkanBackendMemory &, VkDeviceSize offset, VkDeviceSize size) override
VkResult	invalidateMemory (const skgpu::VulkanBackendMemory &, VkDeviceSize offset, VkDeviceSize size) override
std::pair< uint64_t, uint64_t >	totalAllocatedAndUsedMemory () const override
Public Member Functions inherited from skgpu::VulkanMemoryAllocator
virtual void *	mapMemory (const skgpu::VulkanBackendMemory &)
virtual void	flushMappedMemory (const skgpu::VulkanBackendMemory &, VkDeviceSize, VkDeviceSize)
virtual void	invalidateMappedMemory (const skgpu::VulkanBackendMemory &, VkDeviceSize, VkDeviceSize)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< VulkanMemoryAllocator >	Make (uint32_t vulkan_api_version, VkInstance instance, VkPhysicalDevice physicalDevice, VkDevice device, const fml::RefPtr< vulkan::VulkanProcTable > &vk, bool mustUseCoherentHostVisibleMemory)

Additional Inherited Members
Public Types inherited from skgpu::VulkanMemoryAllocator
enum	AllocationPropertyFlags {   kNone_AllocationPropertyFlag = 0b0000 , kDedicatedAllocation_AllocationPropertyFlag = 0b0001 , kLazyAllocation_AllocationPropertyFlag = 0b0010 , kPersistentlyMapped_AllocationPropertyFlag = 0b0100 ,   kProtected_AllocationPropertyFlag = 0b1000 }
enum class	BufferUsage { kGpuOnly , kCpuWritesGpuReads , kTransfersFromCpuToGpu , kTransfersFromGpuToCpu }

Detailed Description

Definition at line 16 of file flutter_skia_vma.h.

Constructor & Destructor Documentation

~FlutterSkiaVulkanMemoryAllocator()

flutter::FlutterSkiaVulkanMemoryAllocator::~FlutterSkiaVulkanMemoryAllocator ( )

override

Definition at line 81 of file flutter_skia_vma.cc.

                                                                    {
  vmaDestroyAllocator(allocator_);
  allocator_ = VK_NULL_HANDLE;
}

Member Function Documentation

allocateBufferMemory()

VkResult flutter::FlutterSkiaVulkanMemoryAllocator::allocateBufferMemory ( VkBuffer  buffer, BufferUsage  usage, uint32_t  allocationPropertyFlags, skgpu::VulkanBackendMemory *  backendMemory  )

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 118 of file flutter_skia_vma.cc.

                                             {
  VmaAllocationCreateInfo info;
  info.flags = 0;
  info.usage = VMA_MEMORY_USAGE_UNKNOWN;
  info.memoryTypeBits = 0;
  info.pool = VK_NULL_HANDLE;
  info.pUserData = nullptr;
 
  switch (usage) {
    case BufferUsage::kGpuOnly:
      info.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      info.preferredFlags = 0;
      break;
    case BufferUsage::kCpuWritesGpuReads:
      // When doing cpu writes and gpu reads the general rule of thumb is to use
      // coherent memory. Though this depends on the fact that we are not doing
      // any cpu reads and the cpu writes are sequential. For sparse writes we'd
      // want cpu cached memory, however we don't do these types of writes in
      // Skia.
      //
      // TODO (kaushikiska): In the future there may be times where specific
      // types of memory could benefit from a coherent and cached memory.
      // Typically these allow for the gpu to read cpu writes from the cache
      // without needing to flush the writes throughout the cache. The reverse
      // is not true and GPU writes tend to invalidate the cache regardless.
      // Also these gpu cache read access are typically lower bandwidth than
      // non-cached memory. For now Skia doesn't really have a need or want of
      // this type of memory. But if we ever do we could pass in an
      // AllocationPropertyFlag that requests the cached property.
      info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      info.preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      break;
    case BufferUsage::kTransfersFromCpuToGpu:
      info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      info.preferredFlags = 0;
      break;
    case BufferUsage::kTransfersFromGpuToCpu:
      info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      info.preferredFlags = VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
      break;
  }
 
  if (must_use_coherent_host_visible_memory_ &&
      (info.requiredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) {
    info.requiredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
  }
  if (kDedicatedAllocation_AllocationPropertyFlag & allocationPropertyFlags) {
    info.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
  }
  if ((kLazyAllocation_AllocationPropertyFlag & allocationPropertyFlags) &&
      BufferUsage::kGpuOnly == usage) {
    info.preferredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
  }
 
  if (kPersistentlyMapped_AllocationPropertyFlag & allocationPropertyFlags) {
    SkASSERT(BufferUsage::kGpuOnly != usage);
    info.flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
  }
 
  VmaAllocation allocation;
  VkResult result = vmaAllocateMemoryForBuffer(allocator_, buffer, &info,
                                               &allocation, nullptr);
  if (VK_SUCCESS == result) {
    *backendMemory = reinterpret_cast<skgpu::VulkanBackendMemory>(allocation);
  }
 
  return result;
}

allocateImageMemory()

VkResult flutter::FlutterSkiaVulkanMemoryAllocator::allocateImageMemory ( VkImage  image, uint32_t  allocationPropertyFlags, skgpu::VulkanBackendMemory *  backendMemory  )

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 86 of file flutter_skia_vma.cc.

                                             {
  VmaAllocationCreateInfo info;
  info.flags = 0;
  info.usage = VMA_MEMORY_USAGE_UNKNOWN;
  info.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
  info.preferredFlags = 0;
  info.memoryTypeBits = 0;
  info.pool = VK_NULL_HANDLE;
  info.pUserData = nullptr;
 
  if (kDedicatedAllocation_AllocationPropertyFlag & allocationPropertyFlags) {
    info.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
  }
  if (kLazyAllocation_AllocationPropertyFlag & allocationPropertyFlags) {
    info.requiredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
  }
  if (kProtected_AllocationPropertyFlag & allocationPropertyFlags) {
    info.requiredFlags |= VK_MEMORY_PROPERTY_PROTECTED_BIT;
  }
 
  VmaAllocation allocation;
  VkResult result =
      vmaAllocateMemoryForImage(allocator_, image, &info, &allocation, nullptr);
  if (VK_SUCCESS == result) {
    *backendMemory = reinterpret_cast<skgpu::VulkanBackendMemory>(allocation);
  }
  return result;
}

flushMemory()

VkResult flutter::FlutterSkiaVulkanMemoryAllocator::flushMemory ( const skgpu::VulkanBackendMemory &  memoryHandle, VkDeviceSize  offset, VkDeviceSize  size  )

overridevirtual

Reimplemented from skgpu::VulkanMemoryAllocator.

Definition at line 244 of file flutter_skia_vma.cc.

                       {
  const VmaAllocation allocation =
      reinterpret_cast<const VmaAllocation>(memoryHandle);
  return vmaFlushAllocation(allocator_, allocation, offset, size);
}

freeMemory()

void flutter::FlutterSkiaVulkanMemoryAllocator::freeMemory ( const skgpu::VulkanBackendMemory &  memoryHandle )

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 193 of file flutter_skia_vma.cc.

                                                  {
  const VmaAllocation allocation =
      reinterpret_cast<const VmaAllocation>(memoryHandle);
  vmaFreeMemory(allocator_, allocation);
}

getAllocInfo()

void flutter::FlutterSkiaVulkanMemoryAllocator::getAllocInfo ( const skgpu::VulkanBackendMemory &  memoryHandle, skgpu::VulkanAlloc *  alloc  ) const

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 200 of file flutter_skia_vma.cc.

                                   {
  const VmaAllocation allocation =
      reinterpret_cast<const VmaAllocation>(memoryHandle);
  VmaAllocationInfo vmaInfo;
  vmaGetAllocationInfo(allocator_, allocation, &vmaInfo);
 
  VkMemoryPropertyFlags memFlags;
  vmaGetMemoryTypeProperties(allocator_, vmaInfo.memoryType, &memFlags);
 
  uint32_t flags = 0;
  if (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT & memFlags) {
    flags |= skgpu::VulkanAlloc::kMappable_Flag;
  }
  if (!(VK_MEMORY_PROPERTY_HOST_COHERENT_BIT & memFlags)) {
    flags |= skgpu::VulkanAlloc::kNoncoherent_Flag;
  }
  if (VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT & memFlags) {
    flags |= skgpu::VulkanAlloc::kLazilyAllocated_Flag;
  }
 
  alloc->fMemory = vmaInfo.deviceMemory;
  alloc->fOffset = vmaInfo.offset;
  alloc->fSize = vmaInfo.size;
  alloc->fFlags = flags;
  alloc->fBackendMemory = memoryHandle;
}

invalidateMemory()

VkResult flutter::FlutterSkiaVulkanMemoryAllocator::invalidateMemory ( const skgpu::VulkanBackendMemory &  memoryHandle, VkDeviceSize  offset, VkDeviceSize  size  )

overridevirtual

Reimplemented from skgpu::VulkanMemoryAllocator.

Definition at line 253 of file flutter_skia_vma.cc.

                       {
  const VmaAllocation allocation =
      reinterpret_cast<const VmaAllocation>(memoryHandle);
  return vmaInvalidateAllocation(allocator_, allocation, offset, size);
}

Make()

sk_sp< skgpu::VulkanMemoryAllocator > flutter::FlutterSkiaVulkanMemoryAllocator::Make ( uint32_t  vulkan_api_version, VkInstance  instance, VkPhysicalDevice  physicalDevice, VkDevice  device, const fml::RefPtr< vulkan::VulkanProcTable > &  vk, bool  mustUseCoherentHostVisibleMemory  )

static

Definition at line 13 of file flutter_skia_vma.cc.

                                           {
#define PROVIDE_PROC(tbl, proc, provider) tbl.vk##proc = provider->proc;
 
  VmaVulkanFunctions proc_table = {};
  proc_table.vkGetInstanceProcAddr = vk->NativeGetInstanceProcAddr();
  PROVIDE_PROC(proc_table, GetDeviceProcAddr, vk);
  PROVIDE_PROC(proc_table, GetPhysicalDeviceProperties, vk);
  PROVIDE_PROC(proc_table, GetPhysicalDeviceMemoryProperties, vk);
  PROVIDE_PROC(proc_table, AllocateMemory, vk);
  PROVIDE_PROC(proc_table, FreeMemory, vk);
  PROVIDE_PROC(proc_table, MapMemory, vk);
  PROVIDE_PROC(proc_table, UnmapMemory, vk);
  PROVIDE_PROC(proc_table, FlushMappedMemoryRanges, vk);
  PROVIDE_PROC(proc_table, InvalidateMappedMemoryRanges, vk);
  PROVIDE_PROC(proc_table, BindBufferMemory, vk);
  PROVIDE_PROC(proc_table, BindImageMemory, vk);
  PROVIDE_PROC(proc_table, GetBufferMemoryRequirements, vk);
  PROVIDE_PROC(proc_table, GetImageMemoryRequirements, vk);
  PROVIDE_PROC(proc_table, CreateBuffer, vk);
  PROVIDE_PROC(proc_table, DestroyBuffer, vk);
  PROVIDE_PROC(proc_table, CreateImage, vk);
  PROVIDE_PROC(proc_table, DestroyImage, vk);
  PROVIDE_PROC(proc_table, CmdCopyBuffer, vk);
 
#define PROVIDE_PROC_COALESCE(tbl, proc, provider) \
  tbl.vk##proc##KHR = provider->proc ? provider->proc : provider->proc##KHR;
  // See the following link for why we have to pick either KHR version or
  // promoted non-KHR version:
  // https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/issues/203
  PROVIDE_PROC_COALESCE(proc_table, GetBufferMemoryRequirements2, vk);
  PROVIDE_PROC_COALESCE(proc_table, GetImageMemoryRequirements2, vk);
  PROVIDE_PROC_COALESCE(proc_table, BindBufferMemory2, vk);
  PROVIDE_PROC_COALESCE(proc_table, BindImageMemory2, vk);
  PROVIDE_PROC_COALESCE(proc_table, GetPhysicalDeviceMemoryProperties2, vk);
#undef PROVIDE_PROC_COALESCE
 
#undef PROVIDE_PROC
 
  VmaAllocatorCreateInfo allocator_info = {};
  allocator_info.vulkanApiVersion = vulkan_api_version;
  allocator_info.physicalDevice = physicalDevice;
  allocator_info.device = device;
  allocator_info.instance = instance;
  allocator_info.pVulkanFunctions = &proc_table;
 
  VmaAllocator allocator;
  vmaCreateAllocator(&allocator_info, &allocator);
 
  return sk_sp<FlutterSkiaVulkanMemoryAllocator>(
      new FlutterSkiaVulkanMemoryAllocator(vk, allocator,
                                           mustUseCoherentHostVisibleMemory));
}

mapMemory()

VkResult flutter::FlutterSkiaVulkanMemoryAllocator::mapMemory ( const skgpu::VulkanBackendMemory &  memoryHandle, void **  data  )

overridevirtual

Reimplemented from skgpu::VulkanMemoryAllocator.

Definition at line 229 of file flutter_skia_vma.cc.

                 {
  const VmaAllocation allocation =
      reinterpret_cast<const VmaAllocation>(memoryHandle);
  return vmaMapMemory(allocator_, allocation, data);
}

totalAllocatedAndUsedMemory()

std::pair< uint64_t, uint64_t > flutter::FlutterSkiaVulkanMemoryAllocator::totalAllocatedAndUsedMemory ( ) const

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 263 of file flutter_skia_vma.cc.

                                                                    {
  VmaTotalStatistics stats;
  vmaCalculateStatistics(allocator_, &stats);
  return {stats.total.statistics.blockBytes,
          stats.total.statistics.allocationBytes};
}

unmapMemory()

void flutter::FlutterSkiaVulkanMemoryAllocator::unmapMemory ( const skgpu::VulkanBackendMemory &  memoryHandle )

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 237 of file flutter_skia_vma.cc.

                                                  {
  const VmaAllocation allocation =
      reinterpret_cast<const VmaAllocation>(memoryHandle);
  vmaUnmapMemory(allocator_, allocation);
}

---

The documentation for this class was generated from the following files:

• flutter_vma/flutter_skia_vma.h
• flutter_vma/flutter_skia_vma.cc