GrVkPrimaryCommandBuffer Class Reference

#include <GrVkCommandBuffer.h>

Inheritance diagram for GrVkPrimaryCommandBuffer:

Public Member Functions
	~GrVkPrimaryCommandBuffer () override
void	begin (GrVkGpu *gpu)
void	end (GrVkGpu *gpu, bool abandoningBuffer=false)
bool	beginRenderPass (GrVkGpu *gpu, const GrVkRenderPass *, sk_sp< const GrVkFramebuffer >, const VkClearValue clearValues[], const GrSurface *target, const SkIRect &bounds, bool forSecondaryCB)
void	endRenderPass (const GrVkGpu *gpu)
void	nexSubpass (GrVkGpu *gpu, bool forSecondaryCB)
void	executeCommands (const GrVkGpu *gpu, std::unique_ptr< GrVkSecondaryCommandBuffer > secondaryBuffer)
void	clearColorImage (const GrVkGpu *gpu, GrVkImage *image, const VkClearColorValue *color, uint32_t subRangeCount, const VkImageSubresourceRange *subRanges)
void	clearDepthStencilImage (const GrVkGpu *gpu, GrVkImage *image, const VkClearDepthStencilValue *color, uint32_t subRangeCount, const VkImageSubresourceRange *subRanges)
void	copyImage (const GrVkGpu *gpu, GrVkImage *srcImage, VkImageLayout srcLayout, GrVkImage *dstImage, VkImageLayout dstLayout, uint32_t copyRegionCount, const VkImageCopy *copyRegions)
void	blitImage (const GrVkGpu *gpu, const GrManagedResource *srcResource, VkImage srcImage, VkImageLayout srcLayout, const GrManagedResource *dstResource, VkImage dstImage, VkImageLayout dstLayout, uint32_t blitRegionCount, const VkImageBlit *blitRegions, VkFilter filter)
void	blitImage (const GrVkGpu *gpu, const GrVkImage &srcImage, const GrVkImage &dstImage, uint32_t blitRegionCount, const VkImageBlit *blitRegions, VkFilter filter)
void	copyImageToBuffer (const GrVkGpu *gpu, GrVkImage *srcImage, VkImageLayout srcLayout, sk_sp< GrGpuBuffer > dstBuffer, uint32_t copyRegionCount, const VkBufferImageCopy *copyRegions)
void	copyBufferToImage (const GrVkGpu *gpu, VkBuffer srcBuffer, GrVkImage *dstImage, VkImageLayout dstLayout, uint32_t copyRegionCount, const VkBufferImageCopy *copyRegions)
void	fillBuffer (GrVkGpu *gpu, sk_sp< GrGpuBuffer >, VkDeviceSize offset, VkDeviceSize size, uint32_t data)
void	copyBuffer (GrVkGpu *gpu, sk_sp< GrGpuBuffer > srcBuffer, sk_sp< GrGpuBuffer > dstBuffer, uint32_t regionCount, const VkBufferCopy *regions)
void	updateBuffer (GrVkGpu *gpu, sk_sp< GrVkBuffer > dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *data)
void	resolveImage (GrVkGpu *gpu, const GrVkImage &srcImage, const GrVkImage &dstImage, uint32_t regionCount, const VkImageResolve *regions)
bool	submitToQueue (GrVkGpu *gpu, VkQueue queue, skia_private::TArray< GrVkSemaphore::Resource * > &signalSemaphores, skia_private::TArray< GrVkSemaphore::Resource * > &waitSemaphores)
void	forceSync (GrVkGpu *gpu)
bool	finished (GrVkGpu *gpu)
void	addFinishedProc (sk_sp< skgpu::RefCntedCallback > finishedProc)
void	callFinishedProcs ()
void	recycleSecondaryCommandBuffers (GrVkCommandPool *cmdPool)
Public Member Functions inherited from GrVkCommandBuffer
virtual	~GrVkCommandBuffer ()
void	invalidateState ()
void	pipelineBarrier (const GrVkGpu *gpu, const GrManagedResource *resource, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, bool byRegion, BarrierType barrierType, void *barrier)
void	bindInputBuffer (GrVkGpu *gpu, uint32_t binding, sk_sp< const GrBuffer > buffer)
void	bindIndexBuffer (GrVkGpu *gpu, sk_sp< const GrBuffer > buffer)
void	bindPipeline (const GrVkGpu *gpu, sk_sp< const GrVkPipeline > pipeline)
void	bindDescriptorSets (const GrVkGpu *gpu, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet *descriptorSets, uint32_t dynamicOffsetCount, const uint32_t *dynamicOffsets)
void	pushConstants (const GrVkGpu *gpu, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *values)
void	setViewport (const GrVkGpu *gpu, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *viewports)
void	setScissor (const GrVkGpu *gpu, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *scissors)
void	setBlendConstants (const GrVkGpu *gpu, const float blendConstants[4])
void	clearAttachments (const GrVkGpu *gpu, int numAttachments, const VkClearAttachment *attachments, int numRects, const VkClearRect *clearRects)
void	drawIndexed (const GrVkGpu *gpu, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
void	draw (const GrVkGpu *gpu, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
void	drawIndirect (const GrVkGpu *gpu, sk_sp< const GrBuffer > indirectBuffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void	drawIndexedIndirect (const GrVkGpu *gpu, sk_sp< const GrBuffer > indirectBuffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void	addResource (sk_sp< const GrManagedResource > resource)
void	addResource (const GrManagedResource *resource)
void	addRecycledResource (gr_rp< const GrRecycledResource > resource)
void	addRecycledResource (const GrRecycledResource *resource)
void	addGrBuffer (sk_sp< const GrBuffer > buffer)
void	addGrSurface (sk_sp< const GrSurface > surface)
void	releaseResources ()
void	freeGPUData (const GrGpu *gpu, VkCommandPool pool) const
bool	hasWork () const

Static Public Member Functions
static GrVkPrimaryCommandBuffer *	Create (GrVkGpu *gpu, VkCommandPool cmdPool)

Additional Inherited Members
Public Types inherited from GrVkCommandBuffer
enum	BarrierType { kBufferMemory_BarrierType , kImageMemory_BarrierType }
Protected Types inherited from GrVkCommandBuffer
template<typename T >
using	TrackedResourceArray = skia_private::STArray< kInitialTrackedResourcesCount, T >
Protected Member Functions inherited from GrVkCommandBuffer
	GrVkCommandBuffer (VkCommandBuffer cmdBuffer, bool isWrapped=false)
bool	isWrapped () const
void	addingWork (const GrVkGpu *gpu)
void	submitPipelineBarriers (const GrVkGpu *gpu, bool forSelfDependency=false)
virtual void	onReleaseResources ()
virtual void	onFreeGPUData (const GrVkGpu *gpu) const =0
Protected Attributes inherited from GrVkCommandBuffer
TrackedResourceArray< sk_sp< const GrManagedResource > >	fTrackedResources
TrackedResourceArray< gr_rp< const GrRecycledResource > >	fTrackedRecycledResources
skia_private::STArray< 16, sk_sp< const GrBuffer > >	fTrackedGpuBuffers
skia_private::STArray< 16, gr_cb< const GrSurface > >	fTrackedGpuSurfaces
bool	fIsActive
bool	fHasWork = false
const GrVkRenderPass *	fActiveRenderPass = nullptr
VkCommandBuffer	fCmdBuffer
VkBuffer	fBoundInputBuffers [kMaxInputBuffers]
VkBuffer	fBoundIndexBuffer
VkViewport	fCachedViewport
VkRect2D	fCachedScissor
float	fCachedBlendConstant [4]
skia_private::STArray< 1, VkBufferMemoryBarrier >	fBufferBarriers
skia_private::STArray< 2, VkImageMemoryBarrier >	fImageBarriers
bool	fBarriersByRegion = false
VkPipelineStageFlags	fSrcStageMask = 0
VkPipelineStageFlags	fDstStageMask = 0
bool	fIsWrapped
Static Protected Attributes inherited from GrVkCommandBuffer
static constexpr uint32_t	kMaxInputBuffers = 2

Detailed Description

Definition at line 206 of file GrVkCommandBuffer.h.

Constructor & Destructor Documentation

~GrVkPrimaryCommandBuffer()

GrVkPrimaryCommandBuffer::~GrVkPrimaryCommandBuffer ( )

override

Definition at line 410 of file GrVkCommandBuffer.cpp.

                                                    {
    // Should have ended any render pass we're in the middle of
    SkASSERT(!fActiveRenderPass);
}

Member Function Documentation

addFinishedProc()

void GrVkPrimaryCommandBuffer::addFinishedProc

(

sk_sp< skgpu::RefCntedCallback >

finishedProc

)

Definition at line 688 of file GrVkCommandBuffer.cpp.

                                                                                        {
    fFinishedProcs.push_back(std::move(finishedProc));
}

begin()

void GrVkPrimaryCommandBuffer::begin

(

GrVkGpu *

gpu

)

Definition at line 434 of file GrVkCommandBuffer.cpp.

                                                 {
    SkASSERT(!fIsActive);
    VkCommandBufferBeginInfo cmdBufferBeginInfo;
    memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
    cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    cmdBufferBeginInfo.pNext = nullptr;
    cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
    cmdBufferBeginInfo.pInheritanceInfo = nullptr;
 
    GR_VK_CALL_ERRCHECK(gpu, BeginCommandBuffer(fCmdBuffer, &cmdBufferBeginInfo));
    fIsActive = true;
}

beginRenderPass()

bool GrVkPrimaryCommandBuffer::beginRenderPass	(	GrVkGpu *	gpu,
		const GrVkRenderPass *	renderPass,
		sk_sp< const GrVkFramebuffer >	framebuffer,
		const VkClearValue	clearValues[],
		const GrSurface *	target,
		const SkIRect &	bounds,
		bool	forSecondaryCB
	)

Definition at line 467 of file GrVkCommandBuffer.cpp.

                                                                    {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
 
    SkASSERT(framebuffer);
 
    this->addingWork(gpu);
 
    VkRenderPassBeginInfo beginInfo;
    VkRect2D renderArea;
    renderArea.offset = { bounds.fLeft , bounds.fTop };
    renderArea.extent = { (uint32_t)bounds.width(), (uint32_t)bounds.height() };
 
    memset(&beginInfo, 0, sizeof(VkRenderPassBeginInfo));
    beginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
    beginInfo.pNext = nullptr;
    beginInfo.renderPass = renderPass->vkRenderPass();
    beginInfo.framebuffer = framebuffer->framebuffer();
    beginInfo.renderArea = renderArea;
    beginInfo.clearValueCount = renderPass->clearValueCount();
    beginInfo.pClearValues = clearValues;
 
    VkSubpassContents contents = forSecondaryCB ? VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
                                                : VK_SUBPASS_CONTENTS_INLINE;
 
    GR_VK_CALL(gpu->vkInterface(), CmdBeginRenderPass(fCmdBuffer, &beginInfo, contents));
    fActiveRenderPass = renderPass;
    this->addResource(renderPass);
    this->addResource(std::move(framebuffer));
    this->addGrSurface(sk_ref_sp(target));
    return true;
}

blitImage() [1/2]

void GrVkPrimaryCommandBuffer::blitImage	(	const GrVkGpu *	gpu,
		const GrManagedResource *	srcResource,
		VkImage	srcImage,
		VkImageLayout	srcLayout,
		const GrManagedResource *	dstResource,
		VkImage	dstImage,
		VkImageLayout	dstLayout,
		uint32_t	blitRegionCount,
		const VkImageBlit *	blitRegions,
		VkFilter	filter
	)

Definition at line 727 of file GrVkCommandBuffer.cpp.

                                                          {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
    this->addResource(srcResource);
    this->addResource(dstResource);
    GR_VK_CALL(gpu->vkInterface(), CmdBlitImage(fCmdBuffer,
                                                srcImage,
                                                srcLayout,
                                                dstImage,
                                                dstLayout,
                                                blitRegionCount,
                                                blitRegions,
                                                filter));
}

blitImage() [2/2]

void GrVkPrimaryCommandBuffer::blitImage	(	const GrVkGpu *	gpu,
		const GrVkImage &	srcImage,
		const GrVkImage &	dstImage,
		uint32_t	blitRegionCount,
		const VkImageBlit *	blitRegions,
		VkFilter	filter
	)

Definition at line 752 of file GrVkCommandBuffer.cpp.

                                                          {
    this->blitImage(gpu,
                    srcImage.resource(),
                    srcImage.image(),
                    srcImage.currentLayout(),
                    dstImage.resource(),
                    dstImage.image(),
                    dstImage.currentLayout(),
                    blitRegionCount,
                    blitRegions,
                    filter);
}

callFinishedProcs()

void GrVkPrimaryCommandBuffer::callFinishedProcs ( )

inline

Definition at line 324 of file GrVkCommandBuffer.h.

                             {
        fFinishedProcs.clear();
    }

clearColorImage()

void GrVkPrimaryCommandBuffer::clearColorImage	(	const GrVkGpu *	gpu,
		GrVkImage *	image,
		const VkClearColorValue *	color,
		uint32_t	subRangeCount,
		const VkImageSubresourceRange *	subRanges
	)

Definition at line 879 of file GrVkCommandBuffer.cpp.

                                                                                         {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
    this->addResource(image->resource());
    GR_VK_CALL(gpu->vkInterface(), CmdClearColorImage(fCmdBuffer,
                                                      image->image(),
                                                      image->currentLayout(),
                                                      color,
                                                      subRangeCount,
                                                      subRanges));
}

clearDepthStencilImage()

void GrVkPrimaryCommandBuffer::clearDepthStencilImage	(	const GrVkGpu *	gpu,
		GrVkImage *	image,
		const VkClearDepthStencilValue *	color,
		uint32_t	subRangeCount,
		const VkImageSubresourceRange *	subRanges
	)

Definition at line 896 of file GrVkCommandBuffer.cpp.

                                                                                                {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
    this->addResource(image->resource());
    GR_VK_CALL(gpu->vkInterface(), CmdClearDepthStencilImage(fCmdBuffer,
                                                             image->image(),
                                                             image->currentLayout(),
                                                             color,
                                                             subRangeCount,
                                                             subRanges));
}

copyBuffer()

void GrVkPrimaryCommandBuffer::copyBuffer	(	GrVkGpu *	gpu,
		sk_sp< GrGpuBuffer >	srcBuffer,
		sk_sp< GrGpuBuffer >	dstBuffer,
		uint32_t	regionCount,
		const VkBufferCopy *	regions
	)

Definition at line 829 of file GrVkCommandBuffer.cpp.

                                                                       {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
#ifdef SK_DEBUG
    for (uint32_t i = 0; i < regionCount; ++i) {
        const VkBufferCopy& region = regions[i];
        SkASSERT(region.size > 0);
        SkASSERT(region.srcOffset < srcBuffer->size());
        SkASSERT(region.dstOffset < dstBuffer->size());
        SkASSERT(region.srcOffset + region.size <= srcBuffer->size());
        SkASSERT(region.dstOffset + region.size <= dstBuffer->size());
    }
#endif
 
    const GrVkBuffer* srcVk = static_cast<GrVkBuffer*>(srcBuffer.get());
    const GrVkBuffer* dstVk = static_cast<GrVkBuffer*>(dstBuffer.get());
 
    GR_VK_CALL(gpu->vkInterface(), CmdCopyBuffer(fCmdBuffer,
                                                 srcVk->vkBuffer(),
                                                 dstVk->vkBuffer(),
                                                 regionCount,
                                                 regions));
    this->addGrBuffer(std::move(srcBuffer));
    this->addGrBuffer(std::move(dstBuffer));
}

copyBufferToImage()

void GrVkPrimaryCommandBuffer::copyBufferToImage	(	const GrVkGpu *	gpu,
		VkBuffer	srcBuffer,
		GrVkImage *	dstImage,
		VkImageLayout	dstLayout,
		uint32_t	copyRegionCount,
		const VkBufferImageCopy *	copyRegions
	)

Definition at line 791 of file GrVkCommandBuffer.cpp.

                                                                                       {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
 
    GR_VK_CALL(gpu->vkInterface(), CmdCopyBufferToImage(fCmdBuffer,
                                                        srcBuffer,
                                                        dstImage->image(),
                                                        dstLayout,
                                                        copyRegionCount,
                                                        copyRegions));
    this->addResource(dstImage->resource());
}

copyImage()

void GrVkPrimaryCommandBuffer::copyImage	(	const GrVkGpu *	gpu,
		GrVkImage *	srcImage,
		VkImageLayout	srcLayout,
		GrVkImage *	dstImage,
		VkImageLayout	dstLayout,
		uint32_t	copyRegionCount,
		const VkImageCopy *	copyRegions
	)

Definition at line 706 of file GrVkCommandBuffer.cpp.

                                                                         {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
    this->addResource(srcImage->resource());
    this->addResource(dstImage->resource());
    GR_VK_CALL(gpu->vkInterface(), CmdCopyImage(fCmdBuffer,
                                                srcImage->image(),
                                                srcLayout,
                                                dstImage->image(),
                                                dstLayout,
                                                copyRegionCount,
                                                copyRegions));
}

copyImageToBuffer()

void GrVkPrimaryCommandBuffer::copyImageToBuffer	(	const GrVkGpu *	gpu,
		GrVkImage *	srcImage,
		VkImageLayout	srcLayout,
		sk_sp< GrGpuBuffer >	dstBuffer,
		uint32_t	copyRegionCount,
		const VkBufferImageCopy *	copyRegions
	)

Definition at line 771 of file GrVkCommandBuffer.cpp.

                                                                                       {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
    GrVkBuffer* vkBuffer = static_cast<GrVkBuffer*>(dstBuffer.get());
    GR_VK_CALL(gpu->vkInterface(), CmdCopyImageToBuffer(fCmdBuffer,
                                                        srcImage->image(),
                                                        srcLayout,
                                                        vkBuffer->vkBuffer(),
                                                        copyRegionCount,
                                                        copyRegions));
    this->addResource(srcImage->resource());
    this->addGrBuffer(std::move(dstBuffer));
}

Create()

GrVkPrimaryCommandBuffer * GrVkPrimaryCommandBuffer::Create ( GrVkGpu *  gpu, VkCommandPool  cmdPool  )

static

Definition at line 415 of file GrVkCommandBuffer.cpp.

                                                                                  {
    const VkCommandBufferAllocateInfo cmdInfo = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
        nullptr,                                          // pNext
        cmdPool,                                          // commandPool
        VK_COMMAND_BUFFER_LEVEL_PRIMARY,                  // level
        1                                                 // bufferCount
    };
 
    VkCommandBuffer cmdBuffer;
    VkResult err;
    GR_VK_CALL_RESULT(gpu, err, AllocateCommandBuffers(gpu->device(), &cmdInfo, &cmdBuffer));
    if (err) {
        return nullptr;
    }
    return new GrVkPrimaryCommandBuffer(cmdBuffer);
}

end()

void GrVkPrimaryCommandBuffer::end	(	GrVkGpu *	gpu,
		bool	abandoningBuffer = false
	)

Definition at line 447 of file GrVkCommandBuffer.cpp.

                                                                      {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
 
    // If we are in the process of abandoning the context then the GrResourceCache will have freed
    // all resources before destroying the GrVkGpu. When we destroy the GrVkGpu we call end on the
    // command buffer to keep all our state tracking consistent. However, the vulkan validation
    // layers complain about calling end on a command buffer that contains resources that have
    // already been deleted. From the vulkan API it isn't required to end the command buffer to
    // delete it, so we just skip the vulkan API calls and update our own state tracking.
    if (!abandoningBuffer) {
        this->submitPipelineBarriers(gpu);
 
        GR_VK_CALL_ERRCHECK(gpu, EndCommandBuffer(fCmdBuffer));
    }
    this->invalidateState();
    fIsActive = false;
    fHasWork = false;
}

endRenderPass()

void GrVkPrimaryCommandBuffer::endRenderPass

(

const GrVkGpu *

gpu

)

Definition at line 506 of file GrVkCommandBuffer.cpp.

                                                               {
    SkASSERT(fIsActive);
    SkASSERT(fActiveRenderPass);
    this->addingWork(gpu);
    GR_VK_CALL(gpu->vkInterface(), CmdEndRenderPass(fCmdBuffer));
    fActiveRenderPass = nullptr;
}

executeCommands()

void GrVkPrimaryCommandBuffer::executeCommands	(	const GrVkGpu *	gpu,
		std::unique_ptr< GrVkSecondaryCommandBuffer >	secondaryBuffer
	)

Definition at line 523 of file GrVkCommandBuffer.cpp.

                                                                                                 {
    // The Vulkan spec allows secondary command buffers to be executed on a primary command buffer
    // if the command pools both were created from were created with the same queue family. However,
    // we currently always create them from the same pool.
    SkASSERT(fIsActive);
    SkASSERT(!buffer->fIsActive);
    SkASSERT(fActiveRenderPass);
    SkASSERT(fActiveRenderPass->isCompatible(*buffer->fActiveRenderPass));
 
    this->addingWork(gpu);
 
    GR_VK_CALL(gpu->vkInterface(), CmdExecuteCommands(fCmdBuffer, 1, &buffer->fCmdBuffer));
    fSecondaryCommandBuffers.push_back(std::move(buffer));
    // When executing a secondary command buffer all state (besides render pass state) becomes
    // invalidated and must be reset. This includes bound buffers, pipelines, dynamic state, etc.
    this->invalidateState();
}

fillBuffer()

void GrVkPrimaryCommandBuffer::fillBuffer	(	GrVkGpu *	gpu,
		sk_sp< GrGpuBuffer >	buffer,
		VkDeviceSize	offset,
		VkDeviceSize	size,
		uint32_t	data
	)

Definition at line 810 of file GrVkCommandBuffer.cpp.

                                                         {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    this->addingWork(gpu);
 
    const GrVkBuffer* bufferVk = static_cast<GrVkBuffer*>(buffer.get());
 
    GR_VK_CALL(gpu->vkInterface(), CmdFillBuffer(fCmdBuffer,
                                                 bufferVk->vkBuffer(),
                                                 offset,
                                                 size,
                                                 data));
    this->addGrBuffer(std::move(buffer));
}

finished()

bool GrVkPrimaryCommandBuffer::finished

(

GrVkGpu *

gpu

)

Definition at line 665 of file GrVkCommandBuffer.cpp.

                                                    {
    SkASSERT(!fIsActive);
    if (VK_NULL_HANDLE == fSubmitFence) {
        return true;
    }
 
    VkResult err;
    GR_VK_CALL_RESULT_NOCHECK(gpu, err, GetFenceStatus(gpu->device(), fSubmitFence));
    switch (err) {
        case VK_SUCCESS:
        case VK_ERROR_DEVICE_LOST:
            return true;
 
        case VK_NOT_READY:
            return false;
 
        default:
            SkDebugf("Error getting fence status: %d\n", err);
            SK_ABORT("Got an invalid fence status");
            return false;
    }
}

forceSync()

void GrVkPrimaryCommandBuffer::forceSync

(

GrVkGpu *

gpu

)

Definition at line 658 of file GrVkCommandBuffer.cpp.

                                                     {
    if (fSubmitFence == VK_NULL_HANDLE) {
        return;
    }
    GR_VK_CALL_ERRCHECK(gpu, WaitForFences(gpu->device(), 1, &fSubmitFence, true, UINT64_MAX));
}

nexSubpass()

void GrVkPrimaryCommandBuffer::nexSubpass	(	GrVkGpu *	gpu,
		bool	forSecondaryCB
	)

Definition at line 515 of file GrVkCommandBuffer.cpp.

                                                                           {
    SkASSERT(fIsActive);
    SkASSERT(fActiveRenderPass);
    VkSubpassContents contents = forSecondaryCB ? VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
                                                : VK_SUBPASS_CONTENTS_INLINE;
    GR_VK_CALL(gpu->vkInterface(), CmdNextSubpass(fCmdBuffer, contents));
}

recycleSecondaryCommandBuffers()

void GrVkPrimaryCommandBuffer::recycleSecondaryCommandBuffers

(

GrVkCommandPool *

cmdPool

)

Definition at line 699 of file GrVkCommandBuffer.cpp.

                                                                                      {
    for (int i = 0; i < fSecondaryCommandBuffers.size(); ++i) {
        fSecondaryCommandBuffers[i].release()->recycle(cmdPool);
    }
    fSecondaryCommandBuffers.clear();
}

resolveImage()

void GrVkPrimaryCommandBuffer::resolveImage	(	GrVkGpu *	gpu,
		const GrVkImage &	srcImage,
		const GrVkImage &	dstImage,
		uint32_t	regionCount,
		const VkImageResolve *	regions
	)

Definition at line 913 of file GrVkCommandBuffer.cpp.

                                                                           {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
 
    this->addingWork(gpu);
    this->addResource(srcImage.resource());
    this->addResource(dstImage.resource());
 
    GR_VK_CALL(gpu->vkInterface(), CmdResolveImage(fCmdBuffer,
                                                   srcImage.image(),
                                                   srcImage.currentLayout(),
                                                   dstImage.image(),
                                                   dstImage.currentLayout(),
                                                   regionCount,
                                                   regions));
}

submitToQueue()

bool GrVkPrimaryCommandBuffer::submitToQueue	(	GrVkGpu *	gpu,
		VkQueue	queue,
		skia_private::TArray< GrVkSemaphore::Resource * > &	signalSemaphores,
		skia_private::TArray< GrVkSemaphore::Resource * > &	waitSemaphores
	)

Definition at line 577 of file GrVkCommandBuffer.cpp.

                                                        {
    SkASSERT(!fIsActive);
 
    VkResult err;
    if (VK_NULL_HANDLE == fSubmitFence) {
        VkFenceCreateInfo fenceInfo;
        memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
        fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
        GR_VK_CALL_RESULT(gpu, err, CreateFence(gpu->device(), &fenceInfo, nullptr,
                                                &fSubmitFence));
        if (err) {
            fSubmitFence = VK_NULL_HANDLE;
            return false;
        }
    } else {
        // This cannot return DEVICE_LOST so we assert we succeeded.
        GR_VK_CALL_RESULT(gpu, err, ResetFences(gpu->device(), 1, &fSubmitFence));
        SkASSERT(err == VK_SUCCESS);
    }
 
    int signalCount = signalSemaphores.size();
    int waitCount = waitSemaphores.size();
 
    bool submitted = false;
 
    if (0 == signalCount && 0 == waitCount) {
        // This command buffer has no dependent semaphores so we can simply just submit it to the
        // queue with no worries.
        submitted = submit_to_queue(
                gpu, queue, fSubmitFence, 0, nullptr, nullptr, 1, &fCmdBuffer, 0, nullptr,
                GrProtected(gpu->protectedContext()));
    } else {
        TArray<VkSemaphore> vkSignalSems(signalCount);
        for (int i = 0; i < signalCount; ++i) {
            if (signalSemaphores[i]->shouldSignal()) {
                this->addResource(signalSemaphores[i]);
                vkSignalSems.push_back(signalSemaphores[i]->semaphore());
            }
        }
 
        TArray<VkSemaphore> vkWaitSems(waitCount);
        TArray<VkPipelineStageFlags> vkWaitStages(waitCount);
        for (int i = 0; i < waitCount; ++i) {
            if (waitSemaphores[i]->shouldWait()) {
                this->addResource(waitSemaphores[i]);
                vkWaitSems.push_back(waitSemaphores[i]->semaphore());
                // We only block the fragment stage since client provided resources are not used
                // before the fragment stage. This allows the driver to begin vertex work while
                // waiting on the semaphore. We also add in the transfer stage for uses of clients
                // calling read or write pixels.
                vkWaitStages.push_back(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
                                       VK_PIPELINE_STAGE_TRANSFER_BIT);
            }
        }
        submitted = submit_to_queue(gpu, queue, fSubmitFence, vkWaitSems.size(),
                                    vkWaitSems.begin(), vkWaitStages.begin(), 1, &fCmdBuffer,
                                    vkSignalSems.size(), vkSignalSems.begin(),
                                    GrProtected(gpu->protectedContext()));
        if (submitted) {
            for (int i = 0; i < signalCount; ++i) {
                signalSemaphores[i]->markAsSignaled();
            }
            for (int i = 0; i < waitCount; ++i) {
                waitSemaphores[i]->markAsWaited();
            }
        }
    }
 
    if (!submitted) {
        // Destroy the fence or else we will try to wait forever for it to finish.
        GR_VK_CALL(gpu->vkInterface(), DestroyFence(gpu->device(), fSubmitFence, nullptr));
        fSubmitFence = VK_NULL_HANDLE;
        return false;
    }
    return true;
}

updateBuffer()

void GrVkPrimaryCommandBuffer::updateBuffer	(	GrVkGpu *	gpu,
		sk_sp< GrVkBuffer >	dstBuffer,
		VkDeviceSize	dstOffset,
		VkDeviceSize	dataSize,
		const void *	data
	)

Definition at line 860 of file GrVkCommandBuffer.cpp.

                                                              {
    SkASSERT(fIsActive);
    SkASSERT(!fActiveRenderPass);
    SkASSERT(0 == (dstOffset & 0x03));  // four byte aligned
    // TODO: handle larger transfer sizes
    SkASSERT(dataSize <= 65536);
    SkASSERT(0 == (dataSize & 0x03));  // four byte aligned
    this->addingWork(gpu);
    GR_VK_CALL(
            gpu->vkInterface(),
            CmdUpdateBuffer(
                    fCmdBuffer, dstBuffer->vkBuffer(), dstOffset, dataSize, (const uint32_t*)data));
    this->addGrBuffer(std::move(dstBuffer));
}

---

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

• third_party/skia/src/gpu/ganesh/vk/GrVkCommandBuffer.h
• third_party/skia/src/gpu/ganesh/vk/GrVkCommandBuffer.cpp