skgpu::VulkanMemory Namespace Reference

Typedefs
using	CheckResult = bool(VkResult)

Functions
bool	AllocBufferMemory (VulkanMemoryAllocator *, VkBuffer buffer, skgpu::VulkanMemoryAllocator::BufferUsage, bool shouldPersistentlyMapCpuToGpu, const std::function< CheckResult > &, VulkanAlloc *alloc)
void	FreeBufferMemory (VulkanMemoryAllocator *, const VulkanAlloc &alloc)
bool	AllocImageMemory (VulkanMemoryAllocator *, VkImage image, skgpu::Protected isProtected, bool forceDedicatedMemory, bool useLazyAllocation, const std::function< CheckResult > &, VulkanAlloc *alloc)
void	FreeImageMemory (VulkanMemoryAllocator *, const VulkanAlloc &alloc)
void *	MapAlloc (VulkanMemoryAllocator *, const VulkanAlloc &, const std::function< CheckResult > &)
void	UnmapAlloc (VulkanMemoryAllocator *, const VulkanAlloc &alloc)
void	FlushMappedAlloc (VulkanMemoryAllocator *, const skgpu::VulkanAlloc &, VkDeviceSize offset, VkDeviceSize size, const std::function< CheckResult > &)
void	InvalidateMappedAlloc (VulkanMemoryAllocator *, const VulkanAlloc &alloc, VkDeviceSize offset, VkDeviceSize size, const std::function< CheckResult > &)
void	GetNonCoherentMappedMemoryRange (const VulkanAlloc &, VkDeviceSize offset, VkDeviceSize size, VkDeviceSize alignment, VkMappedMemoryRange *)

Typedef Documentation

CheckResult

using skgpu::VulkanMemory::CheckResult = typedef bool(VkResult)

Definition at line 21 of file VulkanMemory.h.

Function Documentation

AllocBufferMemory()

bool skgpu::VulkanMemory::AllocBufferMemory	(	VulkanMemoryAllocator *	allocator,
		VkBuffer	buffer,
		skgpu::VulkanMemoryAllocator::BufferUsage	usage,
		bool	shouldPersistentlyMapCpuToGpu,
		const std::function< CheckResult > &	checkResult,
		VulkanAlloc *	alloc
	)

Definition at line 16 of file VulkanMemory.cpp.

                                                         {
    VulkanBackendMemory memory = 0;
    uint32_t propFlags;
    if (usage == BufferUsage::kTransfersFromCpuToGpu ||
        (usage == BufferUsage::kCpuWritesGpuReads && shouldPersistentlyMapCpuToGpu)) {
        // In general it is always fine (and often better) to keep buffers always mapped that we are
        // writing to on the cpu.
        propFlags = VulkanMemoryAllocator::kPersistentlyMapped_AllocationPropertyFlag;
    } else {
        propFlags = VulkanMemoryAllocator::kNone_AllocationPropertyFlag;
    }
 
    VkResult result = allocator->allocateBufferMemory(buffer, usage, propFlags, &memory);
    if (!checkResult(result)) {
        return false;
    }
    allocator->getAllocInfo(memory, alloc);
    return true;
}

AllocImageMemory()

bool skgpu::VulkanMemory::AllocImageMemory	(	VulkanMemoryAllocator *	allocator,
		VkImage	image,
		skgpu::Protected	isProtected,
		bool	forceDedicatedMemory,
		bool	useLazyAllocation,
		const std::function< CheckResult > &	checkResult,
		VulkanAlloc *	alloc
	)

Definition at line 46 of file VulkanMemory.cpp.

                                                        {
    VulkanBackendMemory memory = 0;
 
    uint32_t propFlags;
    // If we ever find that our allocator is not aggressive enough in using dedicated image
    // memory we can add a size check here to force the use of dedicate memory. However for now,
    // we let the allocators decide. The allocator can query the GPU for each image to see if the
    // GPU recommends or requires the use of dedicated memory.
    if (forceDedicatedMemory) {
        propFlags = VulkanMemoryAllocator::kDedicatedAllocation_AllocationPropertyFlag;
    } else {
        propFlags = VulkanMemoryAllocator::kNone_AllocationPropertyFlag;
    }
 
    if (isProtected == Protected::kYes) {
        propFlags = propFlags | VulkanMemoryAllocator::kProtected_AllocationPropertyFlag;
    }
 
    if (useLazyAllocation) {
        propFlags = propFlags | VulkanMemoryAllocator::kLazyAllocation_AllocationPropertyFlag;
    }
 
    VkResult result = allocator->allocateImageMemory(image, propFlags, &memory);
    if (!checkResult(result)) {
        return false;
    }
 
    allocator->getAllocInfo(memory, alloc);
    return true;
}

FlushMappedAlloc()

void skgpu::VulkanMemory::FlushMappedAlloc	(	VulkanMemoryAllocator *	allocator,
		const skgpu::VulkanAlloc &	alloc,
		VkDeviceSize	offset,
		VkDeviceSize	size,
		const std::function< CheckResult > &	checkResult
	)

Definition at line 133 of file VulkanMemory.cpp.

                                                                                 {
    if (alloc.fFlags & VulkanAlloc::kNoncoherent_Flag) {
        SkASSERT(offset == 0);
        SkASSERT(size <= alloc.fSize);
        SkASSERT(alloc.fBackendMemory);
        VkResult result = allocator->flushMemory(alloc.fBackendMemory, offset, size);
        checkResult(result);
    }
}

FreeBufferMemory()

void skgpu::VulkanMemory::FreeBufferMemory	(	VulkanMemoryAllocator *	allocator,
		const VulkanAlloc &	alloc
	)

Definition at line 41 of file VulkanMemory.cpp.

                                                                                              {
    SkASSERT(alloc.fBackendMemory);
    allocator->freeMemory(alloc.fBackendMemory);
}

FreeImageMemory()

void skgpu::VulkanMemory::FreeImageMemory	(	VulkanMemoryAllocator *	allocator,
		const VulkanAlloc &	alloc
	)

Definition at line 83 of file VulkanMemory.cpp.

                                                             {
    SkASSERT(alloc.fBackendMemory);
    allocator->freeMemory(alloc.fBackendMemory);
}

GetNonCoherentMappedMemoryRange()

void skgpu::VulkanMemory::GetNonCoherentMappedMemoryRange	(	const VulkanAlloc &	alloc,
		VkDeviceSize	offset,
		VkDeviceSize	size,
		VkDeviceSize	alignment,
		VkMappedMemoryRange *	range
	)

Definition at line 108 of file VulkanMemory.cpp.

                                                                               {
    SkASSERT(alloc.fFlags & VulkanAlloc::kNoncoherent_Flag);
    offset = offset + alloc.fOffset;
    VkDeviceSize offsetDiff = offset & (alignment -1);
    offset = offset - offsetDiff;
    size = (size + alignment - 1) & ~(alignment - 1);
#ifdef SK_DEBUG
    SkASSERT(offset >= alloc.fOffset);
    SkASSERT(offset + size <= alloc.fOffset + alloc.fSize);
    SkASSERT(0 == (offset & (alignment-1)));
    SkASSERT(size > 0);
    SkASSERT(0 == (size & (alignment-1)));
#endif
 
    memset(range, 0, sizeof(VkMappedMemoryRange));
    range->sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
    range->memory = alloc.fMemory;
    range->offset = offset;
    range->size = size;
}

InvalidateMappedAlloc()

void skgpu::VulkanMemory::InvalidateMappedAlloc	(	VulkanMemoryAllocator *	allocator,
		const VulkanAlloc &	alloc,
		VkDeviceSize	offset,
		VkDeviceSize	size,
		const std::function< CheckResult > &	checkResult
	)

Definition at line 147 of file VulkanMemory.cpp.

                                                                                      {
    if (alloc.fFlags & VulkanAlloc::kNoncoherent_Flag) {
        SkASSERT(offset == 0);
        SkASSERT(size <= alloc.fSize);
        SkASSERT(alloc.fBackendMemory);
        VkResult result = allocator->invalidateMemory(alloc.fBackendMemory, offset, size);
        checkResult(result);
    }
}

MapAlloc()

void * skgpu::VulkanMemory::MapAlloc	(	VulkanMemoryAllocator *	allocator,
		const VulkanAlloc &	alloc,
		const std::function< CheckResult > &	checkResult
	)

Definition at line 89 of file VulkanMemory.cpp.

                                                                          {
    SkASSERT(VulkanAlloc::kMappable_Flag & alloc.fFlags);
    SkASSERT(alloc.fBackendMemory);
    void* mapPtr;
    VkResult result = allocator->mapMemory(alloc.fBackendMemory, &mapPtr);
    if (!checkResult(result)) {
        return nullptr;
    }
    return mapPtr;
}

UnmapAlloc()

void skgpu::VulkanMemory::UnmapAlloc	(	VulkanMemoryAllocator *	allocator,
		const VulkanAlloc &	alloc
	)

Definition at line 102 of file VulkanMemory.cpp.

                                                        {
    SkASSERT(alloc.fBackendMemory);
    allocator->unmapMemory(alloc.fBackendMemory);
}