skgpu::graphite::VulkanCommandBuffer Class Reference

#include <VulkanCommandBuffer.h>

Inheritance diagram for skgpu::graphite::VulkanCommandBuffer:

Public Member Functions
	~VulkanCommandBuffer () override
bool	setNewCommandBufferResources () override
bool	submit (VkQueue)
bool	isFinished ()
void	waitUntilFinished ()
void	addBufferMemoryBarrier (const Resource *resource, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkBufferMemoryBarrier *barrier)
void	addBufferMemoryBarrier (VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkBufferMemoryBarrier *barrier)
void	addImageMemoryBarrier (const Resource *, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, bool byRegion, VkImageMemoryBarrier *barrier)
Public Member Functions inherited from skgpu::graphite::CommandBuffer
virtual	~CommandBuffer ()
void	trackResource (sk_sp< Resource > resource)
void	trackCommandBufferResource (sk_sp< Resource > resource)
void	resetCommandBuffer ()
virtual bool	setNewCommandBufferResources ()=0
void	addFinishedProc (sk_sp< RefCntedCallback > finishedProc)
void	callFinishedProcs (bool success)
virtual void	addWaitSemaphores (size_t numWaitSemaphores, const BackendSemaphore *waitSemaphores)
virtual void	addSignalSemaphores (size_t numWaitSemaphores, const BackendSemaphore *signalSemaphores)
virtual void	prepareSurfaceForStateUpdate (SkSurface *targetSurface, const MutableTextureState *newState)
void	addBuffersToAsyncMapOnSubmit (SkSpan< const sk_sp< Buffer > >)
SkSpan< const sk_sp< Buffer > >	buffersToAsyncMapOnSubmit () const
bool	addRenderPass (const RenderPassDesc &, sk_sp< Texture > colorTexture, sk_sp< Texture > resolveTexture, sk_sp< Texture > depthStencilTexture, SkRect viewport, const DrawPassList &drawPasses)
bool	addComputePass (DispatchGroupSpan dispatchGroups)
bool	copyBufferToBuffer (const Buffer *srcBuffer, size_t srcOffset, sk_sp< Buffer > dstBuffer, size_t dstOffset, size_t size)
bool	copyTextureToBuffer (sk_sp< Texture >, SkIRect srcRect, sk_sp< Buffer >, size_t bufferOffset, size_t bufferRowBytes)
bool	copyBufferToTexture (const Buffer *, sk_sp< Texture >, const BufferTextureCopyData *, int count)
bool	copyTextureToTexture (sk_sp< Texture > src, SkIRect srcRect, sk_sp< Texture > dst, SkIPoint dstPoint, int mipLevel)
bool	synchronizeBufferToCpu (sk_sp< Buffer >)
bool	clearBuffer (const Buffer *buffer, size_t offset, size_t size)
void	setReplayTranslation (SkIVector translation)
void	clearReplayTranslation ()

Static Public Member Functions
static std::unique_ptr< VulkanCommandBuffer >	Make (const VulkanSharedContext *, VulkanResourceProvider *)

Additional Inherited Members
Public Types inherited from skgpu::graphite::CommandBuffer
using	DrawPassList = skia_private::TArray< std::unique_ptr< DrawPass > >
using	DispatchGroupSpan = SkSpan< const std::unique_ptr< DispatchGroup > >
Protected Member Functions inherited from skgpu::graphite::CommandBuffer
	CommandBuffer ()
Protected Attributes inherited from skgpu::graphite::CommandBuffer
SkISize	fRenderPassSize
SkIVector	fReplayTranslation

Detailed Description

Definition at line 26 of file VulkanCommandBuffer.h.

Constructor & Destructor Documentation

~VulkanCommandBuffer()

skgpu::graphite::VulkanCommandBuffer::~VulkanCommandBuffer ( )

override

Definition at line 98 of file VulkanCommandBuffer.cpp.

                                          {
    if (fActive) {
        // Need to end command buffer before deleting it
        VULKAN_CALL(fSharedContext->interface(), EndCommandBuffer(fPrimaryCommandBuffer));
        fActive = false;
    }
 
    if (VK_NULL_HANDLE != fSubmitFence) {
        VULKAN_CALL(fSharedContext->interface(),
                    DestroyFence(fSharedContext->device(), fSubmitFence, nullptr));
    }
    // This should delete any command buffers as well.
    VULKAN_CALL(fSharedContext->interface(),
                DestroyCommandPool(fSharedContext->device(), fPool, nullptr));
}

Member Function Documentation

addBufferMemoryBarrier() [1/2]

void skgpu::graphite::VulkanCommandBuffer::addBufferMemoryBarrier	(	const Resource *	resource,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		VkBufferMemoryBarrier *	barrier
	)

Definition at line 1438 of file VulkanCommandBuffer.cpp.

                                                                                 {
    SkASSERT(resource);
    this->pipelineBarrier(resource,
                          srcStageMask,
                          dstStageMask,
                          /*byRegion=*/false,
                          kBufferMemory_BarrierType,
                          barrier);
}

addBufferMemoryBarrier() [2/2]

void skgpu::graphite::VulkanCommandBuffer::addBufferMemoryBarrier	(	VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		VkBufferMemoryBarrier *	barrier
	)

Definition at line 1451 of file VulkanCommandBuffer.cpp.

                                                                                 {
    // We don't pass in a resource here to the command buffer. The command buffer only is using it
    // to hold a ref, but every place where we add a buffer memory barrier we are doing some other
    // command with the buffer on the command buffer. Thus those other commands will already cause
    // the command buffer to be holding a ref to the buffer.
    this->pipelineBarrier(/*resource=*/nullptr,
                          srcStageMask,
                          dstStageMask,
                          /*byRegion=*/false,
                          kBufferMemory_BarrierType,
                          barrier);
}

addImageMemoryBarrier()

void skgpu::graphite::VulkanCommandBuffer::addImageMemoryBarrier	(	const Resource *	resource,
		VkPipelineStageFlags	srcStageMask,
		VkPipelineStageFlags	dstStageMask,
		bool	byRegion,
		VkImageMemoryBarrier *	barrier
	)

Definition at line 1466 of file VulkanCommandBuffer.cpp.

                                                                               {
    SkASSERT(resource);
    this->pipelineBarrier(resource,
                          srcStageMask,
                          dstStageMask,
                          byRegion,
                          kImageMemory_BarrierType,
                          barrier);
}

isFinished()

bool skgpu::graphite::VulkanCommandBuffer::isFinished

(

)

Definition at line 319 of file VulkanCommandBuffer.cpp.

                                     {
    SkASSERT(!fActive);
    if (VK_NULL_HANDLE == fSubmitFence) {
        return true;
    }
 
    VkResult err;
    VULKAN_CALL_RESULT_NOCHECK(fSharedContext->interface(), err,
                               GetFenceStatus(fSharedContext->device(), fSubmitFence));
    switch (err) {
        case VK_SUCCESS:
        case VK_ERROR_DEVICE_LOST:
            return true;
 
        case VK_NOT_READY:
            return false;
 
        default:
            SKGPU_LOG_F("Error calling vkGetFenceStatus. Error: %d", err);
            SK_ABORT("Got an invalid fence status");
            return false;
    }
}

Make()

std::unique_ptr< VulkanCommandBuffer > skgpu::graphite::VulkanCommandBuffer::Make ( const VulkanSharedContext *  sharedContext, VulkanResourceProvider *  resourceProvider  )

static

Definition at line 37 of file VulkanCommandBuffer.cpp.

                                                  {
    // Create VkCommandPool
    VkCommandPoolCreateFlags cmdPoolCreateFlags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
    if (sharedContext->isProtected() == Protected::kYes) {
        cmdPoolCreateFlags |= VK_COMMAND_POOL_CREATE_PROTECTED_BIT;
    }
 
    const VkCommandPoolCreateInfo cmdPoolInfo = {
            VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,  // sType
            nullptr,                                     // pNext
            cmdPoolCreateFlags,                          // CmdPoolCreateFlags
            sharedContext->queueIndex(),                 // queueFamilyIndex
    };
    VkResult result;
    VkCommandPool pool;
    VULKAN_CALL_RESULT(sharedContext,
                       result,
                       CreateCommandPool(sharedContext->device(), &cmdPoolInfo, nullptr, &pool));
    if (result != VK_SUCCESS) {
        return nullptr;
    }
 
    const VkCommandBufferAllocateInfo cmdInfo = {
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
        nullptr,                                          // pNext
        pool,                                             // commandPool
        VK_COMMAND_BUFFER_LEVEL_PRIMARY,                  // level
        1                                                 // bufferCount
    };
 
    VkCommandBuffer primaryCmdBuffer;
    VULKAN_CALL_RESULT(
            sharedContext,
            result,
            AllocateCommandBuffers(sharedContext->device(), &cmdInfo, &primaryCmdBuffer));
    if (result != VK_SUCCESS) {
        VULKAN_CALL(sharedContext->interface(),
                    DestroyCommandPool(sharedContext->device(), pool, nullptr));
        return nullptr;
    }
 
    return std::unique_ptr<VulkanCommandBuffer>(new VulkanCommandBuffer(pool,
                                                                        primaryCmdBuffer,
                                                                        sharedContext,
                                                                        resourceProvider));
}

setNewCommandBufferResources()

bool skgpu::graphite::VulkanCommandBuffer::setNewCommandBufferResources ( )

overridevirtual

Implements skgpu::graphite::CommandBuffer.

Definition at line 137 of file VulkanCommandBuffer.cpp.

                                                       {
    this->begin();
    return true;
}

submit()

bool skgpu::graphite::VulkanCommandBuffer::submit

(

VkQueue

queue

)

Definition at line 267 of file VulkanCommandBuffer.cpp.

                                              {
    this->end();
 
    auto device = fSharedContext->device();
    VkResult err;
 
    if (fSubmitFence == VK_NULL_HANDLE) {
        VkFenceCreateInfo fenceInfo;
        memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
        fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
        VULKAN_CALL_RESULT(
                fSharedContext, err, CreateFence(device, &fenceInfo, nullptr, &fSubmitFence));
        if (err) {
            fSubmitFence = VK_NULL_HANDLE;
            return false;
        }
    } else {
        // This cannot return DEVICE_LOST so we assert we succeeded.
        VULKAN_CALL_RESULT(fSharedContext, err, ResetFences(device, 1, &fSubmitFence));
        SkASSERT(err == VK_SUCCESS);
    }
 
    SkASSERT(fSubmitFence != VK_NULL_HANDLE);
    int waitCount = fWaitSemaphores.size();
    TArray<VkPipelineStageFlags> vkWaitStages(waitCount);
    for (int i = 0; i < waitCount; ++i) {
        vkWaitStages.push_back(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
                               VK_PIPELINE_STAGE_TRANSFER_BIT);
    }
 
    bool submitted = submit_to_queue(fSharedContext,
                                     queue,
                                     fSubmitFence,
                                     waitCount,
                                     fWaitSemaphores.data(),
                                     vkWaitStages.data(),
                                     /*commandBufferCount*/ 1,
                                     &fPrimaryCommandBuffer,
                                     fSignalSemaphores.size(),
                                     fSignalSemaphores.data(),
                                     fSharedContext->isProtected());
    fWaitSemaphores.clear();
    fSignalSemaphores.clear();
    if (!submitted) {
        // Destroy the fence or else we will try to wait forever for it to finish.
        VULKAN_CALL(fSharedContext->interface(), DestroyFence(device, fSubmitFence, nullptr));
        fSubmitFence = VK_NULL_HANDLE;
        return false;
    }
    return true;
}

waitUntilFinished()

void skgpu::graphite::VulkanCommandBuffer::waitUntilFinished

(

)

Definition at line 343 of file VulkanCommandBuffer.cpp.

                                            {
    if (fSubmitFence == VK_NULL_HANDLE) {
        return;
    }
    VULKAN_CALL_ERRCHECK(fSharedContext,
                         WaitForFences(fSharedContext->device(),
                                       1,
                                       &fSubmitFence,
                                       /*waitAll=*/true,
                                       /*timeout=*/UINT64_MAX));
}

---

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

• third_party/skia/src/gpu/graphite/vk/VulkanCommandBuffer.h
• third_party/skia/src/gpu/graphite/vk/VulkanCommandBuffer.cpp