#include <GrVkBuffer.h>

Inheritance diagram for GrVkBuffer:

Public Member Functions
VkBuffer	vkBuffer () const

void	addMemoryBarrier (VkAccessFlags srcAccessMask, VkAccessFlags dstAccesMask, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, bool byRegion) const

const VkDescriptorSet *	uniformDescriptorSet () const

Public Member Functions inherited from GrGpuBuffer
GrAccessPattern	accessPattern () const

size_t	size () const final

void	ref () const final

void	unref () const final

void *	map ()

void	unmap ()

bool	isMapped () const

bool	isCpuBuffer () const final

bool	clearToZero ()

bool	updateData (const void *src, size_t offset, size_t size, bool preserve)

GrGpuBufferType	intendedType () const

Public Member Functions inherited from GrGpuResource
bool	wasDestroyed () const

const GrDirectContext *	getContext () const

GrDirectContext *	getContext ()

size_t	gpuMemorySize () const

UniqueID	uniqueID () const

const skgpu::UniqueKey &	getUniqueKey () const

std::string	getLabel () const

void	setLabel (std::string_view label)

CacheAccess	cacheAccess ()

const CacheAccess	cacheAccess () const

ProxyAccess	proxyAccess ()

ResourcePriv	resourcePriv ()

const ResourcePriv	resourcePriv () const

virtual void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const

Public Member Functions inherited from GrIORef< GrGpuResource >
bool	unique () const

void	ref () const

void	unref () const

void	refCommandBuffer () const

void	unrefCommandBuffer () const

Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default

	SkNoncopyable (SkNoncopyable &&)=default

SkNoncopyable &	operator= (SkNoncopyable &&)=default

Public Member Functions inherited from GrBuffer
	GrBuffer (const GrBuffer &)=delete

GrBuffer &	operator= (const GrBuffer &)=delete

virtual	~GrBuffer ()=default

Static Public Member Functions
static sk_sp< GrVkBuffer >	Make (GrVkGpu *gpu, size_t size, GrGpuBufferType bufferType, GrAccessPattern accessPattern)

Static Public Member Functions inherited from GrGpuBuffer
static void	ComputeScratchKeyForDynamicBuffer (size_t size, GrGpuBufferType, skgpu::ScratchKey *)

Static Public Member Functions inherited from GrGpuResource
static uint32_t	CreateUniqueID ()

Private Member Functions
void	onMap (MapType) override

void	onUnmap (MapType) override

bool	onClearToZero () override

bool	onUpdateData (const void *src, size_t offset, size_t size, bool preserve) override

void	onAbandon () override

void	onRelease () override

Additional Inherited Members
Public Types inherited from GrIORef< GrGpuResource >
enum	LastRemovedRef

Protected Types inherited from GrGpuBuffer
enum class	MapType { kRead , kWriteDiscard }

Protected Member Functions inherited from GrGpuBuffer
	GrGpuBuffer (GrGpu *, size_t sizeInBytes, GrGpuBufferType, GrAccessPattern, std::string_view label)

Protected Member Functions inherited from GrGpuResource
void	registerWithCache (skgpu::Budgeted)

void	registerWithCacheWrapped (GrWrapCacheable)

	GrGpuResource (GrGpu *, std::string_view label)

virtual	~GrGpuResource ()

GrGpu *	getGpu () const

virtual void	setMemoryBacking (SkTraceMemoryDump *, const SkString &) const

SkString	getResourceName () const

void	dumpMemoryStatisticsPriv (SkTraceMemoryDump traceMemoryDump, const SkString &resourceName, const char type, size_t size) const

Protected Member Functions inherited from GrIORef< GrGpuResource >
	GrIORef ()

bool	internalHasRef () const

bool	internalHasNoCommandBufferUsages () const

void	addInitialRef () const

Protected Member Functions inherited from GrBuffer
	GrBuffer ()=default

Protected Attributes inherited from GrGpuBuffer
void *	fMapPtr

Detailed Description

Definition at line 17 of file GrVkBuffer.h.

Member Function Documentation

◆ addMemoryBarrier()

void GrVkBuffer::addMemoryBarrier	(	VkAccessFlags	srcAccessMask,
		VkAccessFlags	dstAccesMask,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion
	)		const

Definition at line 270 of file GrVkBuffer.cpp.

                                                       {
    VkBufferMemoryBarrier bufferMemoryBarrier = {
            VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,  // sType
            nullptr,                                  // pNext
            srcAccessMask,                            // srcAccessMask
            dstAccesMask,                             // dstAccessMask
            VK_QUEUE_FAMILY_IGNORED,                  // srcQueueFamilyIndex
            VK_QUEUE_FAMILY_IGNORED,                  // dstQueueFamilyIndex
            fBuffer,                                  // buffer
            0,                                        // offset
            this->size(),                             // size
    };
 
    // TODO: restrict to area of buffer we're interested in
    this->getVkGpu()->addBufferMemoryBarrier(srcStageMask, dstStageMask, byRegion,
                                             &bufferMemoryBarrier);
}

◆ Make()

sk_sp< GrVkBuffer > GrVkBuffer::Make	(	GrVkGpu *	gpu,
		size_t	size,
		GrGpuBufferType	bufferType,
		GrAccessPattern	accessPattern
	)

static

Definition at line 69 of file GrVkBuffer.cpp.

                                                                  {
    VkBuffer buffer;
    skgpu::VulkanAlloc alloc;
 
    // The only time we don't require mappable buffers is when we have a static access pattern and
    // 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 = gpu->protectedContext() ||
                            accessPattern == kDynamic_GrAccessPattern ||
                            accessPattern == kStream_GrAccessPattern ||
                            !gpu->vkCaps().gpuOnlyBuffersMorePerformant();
 
    using BufferUsage = skgpu::VulkanMemoryAllocator::BufferUsage;
    BufferUsage allocUsage;
 
    // 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.
    switch (bufferType) {
        case GrGpuBufferType::kVertex:
            bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
            allocUsage = requiresMappable ? BufferUsage::kCpuWritesGpuReads : BufferUsage::kGpuOnly;
            break;
        case GrGpuBufferType::kIndex:
            bufInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
            allocUsage = requiresMappable ? BufferUsage::kCpuWritesGpuReads : BufferUsage::kGpuOnly;
            break;
        case GrGpuBufferType::kDrawIndirect:
            bufInfo.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
            allocUsage = requiresMappable ? BufferUsage::kCpuWritesGpuReads : BufferUsage::kGpuOnly;
            break;
        case GrGpuBufferType::kUniform:
            bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
            allocUsage = BufferUsage::kCpuWritesGpuReads;
            break;
        case GrGpuBufferType::kXferCpuToGpu:
            bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
            allocUsage = BufferUsage::kTransfersFromCpuToGpu;
            break;
        case GrGpuBufferType::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.
    // TODO: It doesn't really hurt setting this extra usage flag, but maybe we can narrow the scope
    // of buffers we set it on more than just not dynamic.
    if (!requiresMappable) {
        bufInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
    }
 
    bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    bufInfo.queueFamilyIndexCount = 0;
    bufInfo.pQueueFamilyIndices = nullptr;
 
    VkResult err;
    err = VK_CALL(gpu, CreateBuffer(gpu->device(), &bufInfo, nullptr, &buffer));
    if (err) {
        return nullptr;
    }
 
    bool shouldPersistentlyMapCpuToGpu = gpu->vkCaps().shouldPersistentlyMapCpuToGpuBuffers();
    auto checkResult = [gpu, allocUsage, shouldPersistentlyMapCpuToGpu](VkResult result) {
        GR_VK_LOG_IF_NOT_SUCCESS(gpu, result, "skgpu::VulkanMemory::AllocBufferMemory "
                                 "(allocUsage:%d, shouldPersistentlyMapCpuToGpu:%d)",
                                 (int)allocUsage, (int)shouldPersistentlyMapCpuToGpu);
        return gpu->checkVkResult(result);
    };
    auto allocator = gpu->memoryAllocator();
    if (!skgpu::VulkanMemory::AllocBufferMemory(allocator,
                                                buffer,
                                                allocUsage,
                                                shouldPersistentlyMapCpuToGpu,
                                                checkResult,
                                                &alloc)) {
        VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
        return nullptr;
    }
 
    // Bind buffer
    GR_VK_CALL_RESULT(gpu, err, BindBufferMemory(gpu->device(),
                                                 buffer,
                                                 alloc.fMemory,
                                                 alloc.fOffset));
    if (err) {
        skgpu::VulkanMemory::FreeBufferMemory(allocator, alloc);
        VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
        return nullptr;
    }
 
    // If this is a uniform buffer we must setup a descriptor set
    const GrVkDescriptorSet* uniformDescSet = nullptr;
    if (bufferType == GrGpuBufferType::kUniform) {
        uniformDescSet = make_uniform_desc_set(gpu, buffer, size);
        if (!uniformDescSet) {
            VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
            skgpu::VulkanMemory::FreeBufferMemory(allocator, alloc);
            return nullptr;
        }
    }
 
    return sk_sp<GrVkBuffer>(new GrVkBuffer(
            gpu, size, bufferType, accessPattern, buffer, alloc, uniformDescSet,
            /*label=*/"MakeVkBuffer"));
}

◆ onAbandon()

void GrVkBuffer::onAbandon ( )

overrideprivatevirtual

Overridden to abandon any internal handles, ptrs, etc to backend API resources. This may be called when the underlying 3D context is no longer valid and so no backend API calls should be made.

Reimplemented from GrGpuResource.

Definition at line 322 of file GrVkBuffer.cpp.

                           {
    this->vkRelease();
    this->GrGpuBuffer::onAbandon();
}

◆ onClearToZero()

bool GrVkBuffer::onClearToZero ( )

overrideprivatevirtual

Implements GrGpuBuffer.

Definition at line 335 of file GrVkBuffer.cpp.

335{ return this->getVkGpu()->zeroBuffer(sk_ref_sp(this)); }

sk_ref_sp

sk_sp< T > sk_ref_sp(T *obj)

Definition SkRefCnt.h:381

GrVkGpu::zeroBuffer

bool zeroBuffer(sk_sp< GrGpuBuffer >)

Definition GrVkGpu.cpp:1265

◆ onMap()

void GrVkBuffer::onMap ( MapType type )

overrideprivatevirtual

Implements GrGpuBuffer.

Definition at line 327 of file GrVkBuffer.cpp.

                                   {
    this->vkMap(0, type == MapType::kRead ? this->size() : 0);
}

◆ onRelease()

void GrVkBuffer::onRelease ( )

overrideprivatevirtual

Overridden to free GPU resources in the backend API.

Reimplemented from GrGpuResource.

Definition at line 317 of file GrVkBuffer.cpp.

                           {
    this->vkRelease();
    this->GrGpuBuffer::onRelease();
}

◆ onUnmap()

void GrVkBuffer::onUnmap ( MapType type )

overrideprivatevirtual

Implements GrGpuBuffer.

Definition at line 331 of file GrVkBuffer.cpp.

                                     {
    this->vkUnmap(0, type == MapType::kWriteDiscard ? this->size() : 0);
}

◆ onUpdateData()

bool GrVkBuffer::onUpdateData	(	const void *	src,
		size_t	offset,
		size_t	size,
		bool	preserve
	)

overrideprivatevirtual

Implements GrGpuBuffer.

Definition at line 337 of file GrVkBuffer.cpp.

                                                                                 {
    if (this->isVkMappable()) {
        // We won't be reading the mapped memory so pass an empty range.
        this->vkMap(0, 0);
        if (!fMapPtr) {
            return false;
        }
        memcpy(SkTAddOffset<void>(fMapPtr, offset), src, size);
        // We only need to flush the updated portion so pass the true range here.
        this->vkUnmap(offset, size);
        fMapPtr = nullptr;
    } else {
        this->copyCpuDataToGpuBuffer(src, offset, size);
    }
    return true;
}

◆ uniformDescriptorSet()

const VkDescriptorSet * GrVkBuffer::uniformDescriptorSet ( ) const

Definition at line 359 of file GrVkBuffer.cpp.

                                                              {
    SkASSERT(fUniformDescriptorSet);
    return fUniformDescriptorSet->descriptorSet();
}

◆ vkBuffer()

VkBuffer GrVkBuffer::vkBuffer ( ) const

inline

Definition at line 24 of file GrVkBuffer.h.

24{ return fBuffer; }

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

third_party/skia/src/gpu/ganesh/vk/GrVkBuffer.h
third_party/skia/src/gpu/ganesh/vk/GrVkBuffer.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ addMemoryBarrier()

◆ Make()

◆ onAbandon()

◆ onClearToZero()

◆ onMap()

◆ onRelease()

◆ onUnmap()

◆ onUpdateData()

◆ uniformDescriptorSet()

◆ vkBuffer()