skgpu::VulkanAMDMemoryAllocator Class Reference

#include <VulkanAMDMemoryAllocator.h>

Inheritance diagram for skgpu::VulkanAMDMemoryAllocator:

Public Member Functions
	~VulkanAMDMemoryAllocator () 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 VulkanBackendMemory &) override
void	getAllocInfo (const VulkanBackendMemory &, VulkanAlloc *) const override
VkResult	mapMemory (const VulkanBackendMemory &, void **data) override
void	unmapMemory (const VulkanBackendMemory &) override
VkResult	flushMemory (const VulkanBackendMemory &, VkDeviceSize offset, VkDeviceSize size) override
VkResult	invalidateMemory (const VulkanBackendMemory &, VkDeviceSize offset, VkDeviceSize size) override
std::pair< uint64_t, uint64_t >	totalAllocatedAndUsedMemory () const override
Public Member Functions inherited from skgpu::VulkanMemoryAllocator
virtual VkResult	allocateImageMemory (VkImage image, uint32_t allocationPropertyFlags, skgpu::VulkanBackendMemory *memory)=0
virtual VkResult	allocateBufferMemory (VkBuffer buffer, BufferUsage usage, uint32_t allocationPropertyFlags, skgpu::VulkanBackendMemory *memory)=0
virtual void	getAllocInfo (const skgpu::VulkanBackendMemory &, skgpu::VulkanAlloc *) const =0
virtual void *	mapMemory (const skgpu::VulkanBackendMemory &)
virtual VkResult	mapMemory (const skgpu::VulkanBackendMemory &memory, void **data)
virtual void	unmapMemory (const skgpu::VulkanBackendMemory &)=0
virtual void	flushMappedMemory (const skgpu::VulkanBackendMemory &, VkDeviceSize, VkDeviceSize)
virtual VkResult	flushMemory (const skgpu::VulkanBackendMemory &memory, VkDeviceSize offset, VkDeviceSize size)
virtual void	invalidateMappedMemory (const skgpu::VulkanBackendMemory &, VkDeviceSize, VkDeviceSize)
virtual VkResult	invalidateMemory (const skgpu::VulkanBackendMemory &memory, VkDeviceSize offset, VkDeviceSize size)
virtual void	freeMemory (const skgpu::VulkanBackendMemory &)=0
virtual std::pair< uint64_t, uint64_t >	totalAllocatedAndUsedMemory () const =0
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 (VkInstance instance, VkPhysicalDevice physicalDevice, VkDevice device, uint32_t physicalDeviceVersion, const VulkanExtensions *extensions, const VulkanInterface *interface, ThreadSafe)

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 30 of file VulkanAMDMemoryAllocator.h.

Constructor & Destructor Documentation

~VulkanAMDMemoryAllocator()

skgpu::VulkanAMDMemoryAllocator::~VulkanAMDMemoryAllocator ( )

override

Definition at line 100 of file VulkanAMDMemoryAllocator.cpp.

                                                    {
    vmaDestroyAllocator(fAllocator);
    fAllocator = VK_NULL_HANDLE;
}

Member Function Documentation

allocateBufferMemory()

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

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 136 of file VulkanAMDMemoryAllocator.cpp.

                                                                                                 {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    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: 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 (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(fAllocator, buffer, &info, &allocation, nullptr);
    if (VK_SUCCESS == result) {
        *backendMemory = (VulkanBackendMemory)allocation;
    }
 
    return result;
}

allocateImageMemory()

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

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 105 of file VulkanAMDMemoryAllocator.cpp.

                                                                                                {
    TRACE_EVENT0_ALWAYS("skia.gpu", TRACE_FUNC);
    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(fAllocator, image, &info, &allocation, nullptr);
    if (VK_SUCCESS == result) {
        *backendMemory = (VulkanBackendMemory)allocation;
    }
    return result;
}

flushMemory()

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

overridevirtual

Reimplemented from skgpu::VulkanMemoryAllocator.

Definition at line 249 of file VulkanAMDMemoryAllocator.cpp.

                                                                                       {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    const VmaAllocation allocation = (VmaAllocation)memoryHandle;
    return vmaFlushAllocation(fAllocator, allocation, offset, size);
}

freeMemory()

void skgpu::VulkanAMDMemoryAllocator::freeMemory ( const VulkanBackendMemory &  memoryHandle )

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 203 of file VulkanAMDMemoryAllocator.cpp.

                                                                                 {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    const VmaAllocation allocation = (VmaAllocation)memoryHandle;
    vmaFreeMemory(fAllocator, allocation);
}

getAllocInfo()

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

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 209 of file VulkanAMDMemoryAllocator.cpp.

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

invalidateMemory()

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

overridevirtual

Reimplemented from skgpu::VulkanMemoryAllocator.

Definition at line 256 of file VulkanAMDMemoryAllocator.cpp.

                                                                                            {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    const VmaAllocation allocation = (VmaAllocation)memoryHandle;
    return vmaInvalidateAllocation(fAllocator, allocation, offset, size);
}

Make()

sk_sp< VulkanMemoryAllocator > skgpu::VulkanAMDMemoryAllocator::Make ( VkInstance  instance, VkPhysicalDevice  physicalDevice, VkDevice  device, uint32_t  physicalDeviceVersion, const VulkanExtensions *  extensions, const VulkanInterface *  interface, ThreadSafe  threadSafe  )

static

Definition at line 21 of file VulkanAMDMemoryAllocator.cpp.

                                                                                   {
#define SKGPU_COPY_FUNCTION(NAME) functions.vk##NAME = interface->fFunctions.f##NAME
#define SKGPU_COPY_FUNCTION_KHR(NAME) functions.vk##NAME##KHR = interface->fFunctions.f##NAME
 
    VmaVulkanFunctions functions;
    // We should be setting all the required functions (at least through vulkan 1.1), but this is
    // just extra belt and suspenders to make sure there isn't unitialized values here.
    std::memset(&functions, 0, sizeof(VmaVulkanFunctions));
 
    // We don't use dynamic function getting in the allocator so we set the getProc functions to
    // null.
    functions.vkGetInstanceProcAddr = nullptr;
    functions.vkGetDeviceProcAddr = nullptr;
    SKGPU_COPY_FUNCTION(GetPhysicalDeviceProperties);
    SKGPU_COPY_FUNCTION(GetPhysicalDeviceMemoryProperties);
    SKGPU_COPY_FUNCTION(AllocateMemory);
    SKGPU_COPY_FUNCTION(FreeMemory);
    SKGPU_COPY_FUNCTION(MapMemory);
    SKGPU_COPY_FUNCTION(UnmapMemory);
    SKGPU_COPY_FUNCTION(FlushMappedMemoryRanges);
    SKGPU_COPY_FUNCTION(InvalidateMappedMemoryRanges);
    SKGPU_COPY_FUNCTION(BindBufferMemory);
    SKGPU_COPY_FUNCTION(BindImageMemory);
    SKGPU_COPY_FUNCTION(GetBufferMemoryRequirements);
    SKGPU_COPY_FUNCTION(GetImageMemoryRequirements);
    SKGPU_COPY_FUNCTION(CreateBuffer);
    SKGPU_COPY_FUNCTION(DestroyBuffer);
    SKGPU_COPY_FUNCTION(CreateImage);
    SKGPU_COPY_FUNCTION(DestroyImage);
    SKGPU_COPY_FUNCTION(CmdCopyBuffer);
    SKGPU_COPY_FUNCTION_KHR(GetBufferMemoryRequirements2);
    SKGPU_COPY_FUNCTION_KHR(GetImageMemoryRequirements2);
    SKGPU_COPY_FUNCTION_KHR(BindBufferMemory2);
    SKGPU_COPY_FUNCTION_KHR(BindImageMemory2);
    SKGPU_COPY_FUNCTION_KHR(GetPhysicalDeviceMemoryProperties2);
 
    VmaAllocatorCreateInfo info;
    info.flags = 0;
    if (threadSafe == ThreadSafe::kNo) {
        info.flags |= VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT;
    }
    if (physicalDeviceVersion >= VK_MAKE_VERSION(1, 1, 0) ||
        (extensions->hasExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, 1) &&
         extensions->hasExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, 1))) {
        info.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT;
    }
 
    info.physicalDevice = physicalDevice;
    info.device = device;
    // 4MB was picked for the size here by looking at memory usage of Android apps and runs of DM.
    // It seems to be a good compromise of not wasting unused allocated space and not making too
    // many small allocations. The AMD allocator will start making blocks at 1/8 the max size and
    // builds up block size as needed before capping at the max set here.
    info.preferredLargeHeapBlockSize = 4*1024*1024;
    info.pAllocationCallbacks = nullptr;
    info.pDeviceMemoryCallbacks = nullptr;
    info.pHeapSizeLimit = nullptr;
    info.pVulkanFunctions = &functions;
    info.instance = instance;
    // TODO: Update our interface and headers to support vulkan 1.3 and add in the new required
    // functions for 1.3 that the allocator needs. Until then we just clamp the version to 1.1.
    info.vulkanApiVersion = std::min(physicalDeviceVersion, VK_MAKE_VERSION(1, 1, 0));
    info.pTypeExternalMemoryHandleTypes = nullptr;
 
    VmaAllocator allocator;
    vmaCreateAllocator(&info, &allocator);
 
    return sk_sp<VulkanAMDMemoryAllocator>(new VulkanAMDMemoryAllocator(allocator));
}

mapMemory()

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

overridevirtual

Reimplemented from skgpu::VulkanMemoryAllocator.

Definition at line 236 of file VulkanAMDMemoryAllocator.cpp.

                                                          {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    const VmaAllocation allocation = (VmaAllocation)memoryHandle;
    return vmaMapMemory(fAllocator, allocation, data);
}

totalAllocatedAndUsedMemory()

std::pair< uint64_t, uint64_t > skgpu::VulkanAMDMemoryAllocator::totalAllocatedAndUsedMemory ( ) const

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 263 of file VulkanAMDMemoryAllocator.cpp.

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

unmapMemory()

void skgpu::VulkanAMDMemoryAllocator::unmapMemory ( const VulkanBackendMemory &  memoryHandle )

overridevirtual

Implements skgpu::VulkanMemoryAllocator.

Definition at line 243 of file VulkanAMDMemoryAllocator.cpp.

                                                                                  {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    const VmaAllocation allocation = (VmaAllocation)memoryHandle;
    vmaUnmapMemory(fAllocator, allocation);
}

---

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

• third_party/skia/src/gpu/vk/VulkanAMDMemoryAllocator.h
• third_party/skia/src/gpu/vk/VulkanAMDMemoryAllocator.cpp