#include <VulkanBuffer.h>

Inheritance diagram for skgpu::graphite::VulkanBuffer:

Public Member Functions
void	freeGpuData () override

VkBuffer	vkBuffer () const

VkBufferUsageFlags	bufferUsageFlags () const

void	setBufferAccess (VulkanCommandBuffer *buffer, VkAccessFlags dstAccessMask, VkPipelineStageFlags dstStageMask) const

Public Member Functions inherited from skgpu::graphite::Buffer
size_t	size () const

void *	map ()

void	asyncMap (GpuFinishedProc=nullptr, GpuFinishedContext=nullptr)

void	unmap ()

bool	isMapped () const

virtual bool	isUnmappable () const

const char *	getResourceType () const override

Public Member Functions inherited from skgpu::graphite::Resource
	Resource (const Resource &)=delete

	Resource (Resource &&)=delete

Resource &	operator= (const Resource &)=delete

Resource &	operator= (Resource &&)=delete

void	ref () const

void	unref () const

void	refCommandBuffer () const

void	unrefCommandBuffer () const

Ownership	ownership () const

skgpu::Budgeted	budgeted () const

size_t	gpuMemorySize () const

UniqueID	uniqueID () const

std::string	getLabel () const

void	setLabel (std::string_view label)

bool	wasDestroyed () const

const GraphiteResourceKey &	key () const

void	setKey (const GraphiteResourceKey &key)

void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const

virtual void	prepareForReturnToCache (const std::function< void()> &takeRef)

Static Public Member Functions
static sk_sp< Buffer >	Make (const VulkanSharedContext *, size_t, BufferType, AccessPattern, std::string_view label)

Private Member Functions
void	onMap () override

void	onUnmap () override

Additional Inherited Members
Protected Member Functions inherited from skgpu::graphite::Buffer
	Buffer (const SharedContext *sharedContext, size_t size, std::string_view label, bool commandBufferRefsAsUsageRefs=false)

Protected Member Functions inherited from skgpu::graphite::Resource
	Resource (const SharedContext *, Ownership, skgpu::Budgeted, size_t gpuMemorySize, std::string_view label, bool commandBufferRefsAsUsageRefs=false)

virtual	~Resource ()

const SharedContext *	sharedContext () const

virtual void	invokeReleaseProc ()

virtual void	onDumpMemoryStatistics (SkTraceMemoryDump traceMemoryDump, const char dumpName) const

void	setDeleteASAP ()

Protected Attributes inherited from skgpu::graphite::Buffer
void *	fMapPtr = nullptr

Detailed Description

Definition at line 19 of file VulkanBuffer.h.

Member Function Documentation

◆ bufferUsageFlags()

VkBufferUsageFlags skgpu::graphite::VulkanBuffer::bufferUsageFlags ( ) const

inline

Definition at line 28 of file VulkanBuffer.h.

28{ return fBufferUsageFlags; }

◆ freeGpuData()

void skgpu::graphite::VulkanBuffer::freeGpuData ( )

overridevirtual

Implements skgpu::graphite::Resource.

Definition at line 166 of file VulkanBuffer.cpp.

                               {
    if (fMapPtr) {
        this->internalUnmap(0, this->size());
        fMapPtr = nullptr;
    }
 
    const VulkanSharedContext* sharedContext =
            static_cast<const VulkanSharedContext*>(this->sharedContext());
    SkASSERT(fBuffer);
    SkASSERT(fAlloc.fMemory && fAlloc.fBackendMemory);
    VULKAN_CALL(sharedContext->interface(),
                DestroyBuffer(sharedContext->device(), fBuffer, nullptr));
    fBuffer = VK_NULL_HANDLE;
 
    skgpu::VulkanMemory::FreeBufferMemory(sharedContext->memoryAllocator(), fAlloc);
    fAlloc.fMemory = VK_NULL_HANDLE;
    fAlloc.fBackendMemory = 0;
}

◆ Make()

sk_sp< Buffer > skgpu::graphite::VulkanBuffer::Make	(	const VulkanSharedContext *	sharedContext,
		size_t	size,
		BufferType	type,
		AccessPattern	accessPattern,
		std::string_view	label
	)

static

Definition at line 17 of file VulkanBuffer.cpp.

                                                       {
    if (size <= 0) {
        return nullptr;
    }
    VkBuffer buffer;
    skgpu::VulkanAlloc alloc;
 
    // The only time we don't require mappable buffers is when we're on a device where gpu only
    // memory has faster reads on the gpu than memory that is also mappable on the cpu. Protected
    // memory always uses mappable buffers.
    bool requiresMappable = sharedContext->isProtected() == Protected::kYes ||
                            accessPattern == AccessPattern::kHostVisible ||
                            !sharedContext->vulkanCaps().gpuOnlyBuffersMorePerformant();
 
    using BufferUsage = skgpu::VulkanMemoryAllocator::BufferUsage;
 
    // The default usage captures use cases besides transfer buffers. GPU-only buffers are preferred
    // unless mappability is required.
    BufferUsage allocUsage =
            requiresMappable ? BufferUsage::kCpuWritesGpuReads : BufferUsage::kGpuOnly;
 
    // Create the buffer object
    VkBufferCreateInfo bufInfo;
    memset(&bufInfo, 0, sizeof(VkBufferCreateInfo));
    bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    bufInfo.flags = 0;
    bufInfo.size = size;
 
    // To support SkMesh buffer updates we make Vertex and Index buffers capable of being transfer
    // dsts. To support rtAdjust uniform buffer updates, we make host-visible uniform buffers also
    // capable of being transfer dsts.
    switch (type) {
        case BufferType::kVertex:
            bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
            break;
        case BufferType::kIndex:
            bufInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
            break;
        case BufferType::kStorage:
            bufInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
            break;
        case BufferType::kIndirect:
            bufInfo.usage =
                    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
            break;
        case BufferType::kVertexStorage:
            bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
            break;
        case BufferType::kIndexStorage:
            bufInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
            break;
        case BufferType::kUniform:
            bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
            allocUsage = BufferUsage::kCpuWritesGpuReads;
            break;
        case BufferType::kXferCpuToGpu:
            bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
            allocUsage = BufferUsage::kTransfersFromCpuToGpu;
            break;
        case BufferType::kXferGpuToCpu:
            bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
            allocUsage = BufferUsage::kTransfersFromGpuToCpu;
            break;
    }
 
    // We may not always get a mappable buffer for non-dynamic access buffers. Thus we set the
    // transfer dst usage bit in case we need to do a copy to write data. It doesn't really hurt
    // to set this extra usage flag, but we could narrow the scope of buffers we set it on more than
    // just not dynamic.
    if (!requiresMappable || accessPattern == AccessPattern::kGpuOnly) {
        bufInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
    }
 
    bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    bufInfo.queueFamilyIndexCount = 0;
    bufInfo.pQueueFamilyIndices = nullptr;
 
    VkResult result;
    VULKAN_CALL_RESULT(sharedContext,
                       result,
                       CreateBuffer(sharedContext->device(),
                                    &bufInfo,
                                    nullptr, /*const VkAllocationCallbacks*/
                                    &buffer));
    if (result != VK_SUCCESS) {
        return nullptr;
    }
 
    auto allocator = sharedContext->memoryAllocator();
    bool shouldPersistentlyMapCpuToGpu =
        sharedContext->vulkanCaps().shouldPersistentlyMapCpuToGpuBuffers();
    //AllocBufferMemory
    auto checkResult = [](VkResult result) {
        return result == VK_SUCCESS;
    };
    if (!skgpu::VulkanMemory::AllocBufferMemory(allocator,
                                                buffer,
                                                allocUsage,
                                                shouldPersistentlyMapCpuToGpu,
                                                checkResult,
                                                &alloc)) {
        VULKAN_CALL(sharedContext->interface(), DestroyBuffer(sharedContext->device(),
                buffer,
                /*const VkAllocationCallbacks*=*/nullptr));
        return nullptr;
    }
 
    // Bind buffer
    VULKAN_CALL_RESULT(
            sharedContext,
            result,
            BindBufferMemory(sharedContext->device(), buffer, alloc.fMemory, alloc.fOffset));
    if (result != VK_SUCCESS) {
        skgpu::VulkanMemory::FreeBufferMemory(allocator, alloc);
        VULKAN_CALL(sharedContext->interface(), DestroyBuffer(sharedContext->device(),
                buffer,
                /*const VkAllocationCallbacks*=*/nullptr));
        return nullptr;
    }
 
    return sk_sp<Buffer>(new VulkanBuffer(sharedContext,
                                          size,
                                          type,
                                          accessPattern,
                                          std::move(buffer),
                                          alloc,
                                          bufInfo.usage,
                                          std::move(label)));
}

◆ onMap()

void skgpu::graphite::VulkanBuffer::onMap ( )

overrideprivatevirtual

Implements skgpu::graphite::Buffer.

Definition at line 249 of file VulkanBuffer.cpp.

                         {
    SkASSERT(fBuffer);
    SkASSERT(!this->isMapped());
 
    this->internalMap(0, fBufferUsedForCPURead ? this->size() : 0);
}

◆ onUnmap()

void skgpu::graphite::VulkanBuffer::onUnmap ( )

overrideprivatevirtual

Implements skgpu::graphite::Buffer.

Definition at line 256 of file VulkanBuffer.cpp.

                           {
    SkASSERT(fBuffer);
    SkASSERT(this->isMapped());
    this->internalUnmap(0, fBufferUsedForCPURead ? 0 : this->size());
}

◆ setBufferAccess()

void skgpu::graphite::VulkanBuffer::setBufferAccess	(	VulkanCommandBuffer *	buffer,
		VkAccessFlags	dstAccessMask,
		VkPipelineStageFlags	dstStageMask
	)		const

Definition at line 262 of file VulkanBuffer.cpp.

                                                                            {
    // TODO: fill out other cases where we need a barrier
    if (dstAccessMask == VK_ACCESS_HOST_READ_BIT      ||
        dstAccessMask == VK_ACCESS_TRANSFER_WRITE_BIT ||
        dstAccessMask == VK_ACCESS_UNIFORM_READ_BIT) {
        VkPipelineStageFlags srcStageMask =
            VulkanBuffer::AccessMaskToPipelineSrcStageFlags(fCurrentAccessMask);
 
        VkBufferMemoryBarrier bufferMemoryBarrier = {
                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,  // sType
                 nullptr,                                  // pNext
                 fCurrentAccessMask,                       // srcAccessMask
                 dstAccessMask,                            // dstAccessMask
                 VK_QUEUE_FAMILY_IGNORED,                  // srcQueueFamilyIndex
                 VK_QUEUE_FAMILY_IGNORED,                  // dstQueueFamilyIndex
                 fBuffer,                                  // buffer
                 0,                                        // offset
                 this->size(),                             // size
        };
        cmdBuffer->addBufferMemoryBarrier(srcStageMask, dstStageMask, &bufferMemoryBarrier);
    }
 
    fCurrentAccessMask = dstAccessMask;
}

◆ vkBuffer()

VkBuffer skgpu::graphite::VulkanBuffer::vkBuffer ( ) const

inline

Definition at line 27 of file VulkanBuffer.h.

27{ return fBuffer; }

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

third_party/skia/src/gpu/graphite/vk/VulkanBuffer.h
third_party/skia/src/gpu/graphite/vk/VulkanBuffer.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members