GrVkCommandPool Class Reference

#include <GrVkCommandPool.h>

Inheritance diagram for GrVkCommandPool:

Public Member Functions
VkCommandPool	vkCommandPool () const
void	reset (GrVkGpu *gpu)
GrVkPrimaryCommandBuffer *	getPrimaryCommandBuffer ()
std::unique_ptr< GrVkSecondaryCommandBuffer >	findOrCreateSecondaryCommandBuffer (GrVkGpu *gpu)
void	recycleSecondaryCommandBuffer (GrVkSecondaryCommandBuffer *buffer)
void	close ()
bool	isOpen () const
Public Member Functions inherited from GrVkManagedResource
	GrVkManagedResource (const GrVkGpu *gpu)
Public Member Functions inherited from GrManagedResource
	GrManagedResource ()
virtual	~GrManagedResource ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static GrVkCommandPool *	Create (GrVkGpu *gpu)

Private Member Functions
void	freeGPUData () const override

Additional Inherited Members
Protected Attributes inherited from GrVkManagedResource
const GrVkGpu *	fGpu

Detailed Description

Definition at line 21 of file GrVkCommandPool.h.

Member Function Documentation

close()

void GrVkCommandPool::close

(

)

Definition at line 75 of file GrVkCommandPool.cpp.

                            {
    fOpen = false;
}

Create()

GrVkCommandPool * GrVkCommandPool::Create ( GrVkGpu *  gpu )

static

Definition at line 15 of file GrVkCommandPool.cpp.

                                                     {
    VkCommandPoolCreateFlags cmdPoolCreateFlags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
    if (gpu->protectedContext()) {
        cmdPoolCreateFlags |= VK_COMMAND_POOL_CREATE_PROTECTED_BIT;
    }
 
    const VkCommandPoolCreateInfo cmdPoolInfo = {
        VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,  // sType
        nullptr,                                     // pNext
        cmdPoolCreateFlags,                          // CmdPoolCreateFlags
        gpu->queueIndex(),                           // queueFamilyIndex
    };
    VkResult result;
    VkCommandPool pool;
    GR_VK_CALL_RESULT(gpu, result, CreateCommandPool(gpu->device(), &cmdPoolInfo, nullptr, &pool));
    if (result != VK_SUCCESS) {
        return nullptr;
    }
 
    GrVkPrimaryCommandBuffer* primaryCmdBuffer = GrVkPrimaryCommandBuffer::Create(gpu, pool);
    if (!primaryCmdBuffer) {
        GR_VK_CALL(gpu->vkInterface(), DestroyCommandPool(gpu->device(), pool, nullptr));
        return nullptr;
    }
 
    return new GrVkCommandPool(gpu, pool, primaryCmdBuffer);
}

findOrCreateSecondaryCommandBuffer()

std::unique_ptr< GrVkSecondaryCommandBuffer > GrVkCommandPool::findOrCreateSecondaryCommandBuffer

(

GrVkGpu *

gpu

)

Definition at line 52 of file GrVkCommandPool.cpp.

                      {
    std::unique_ptr<GrVkSecondaryCommandBuffer> result;
    if (!fAvailableSecondaryBuffers.empty()) {
        result = std::move(fAvailableSecondaryBuffers.back());
        fAvailableSecondaryBuffers.pop_back();
    } else{
        result.reset(GrVkSecondaryCommandBuffer::Create(gpu, this));
    }
    return result;
}

freeGPUData()

void GrVkCommandPool::freeGPUData ( ) const

overrideprivatevirtual

Must be implemented by any subclasses. Deletes any GPU data associated with this resource

Implements GrManagedResource.

Definition at line 108 of file GrVkCommandPool.cpp.

                                        {
    // TODO: having freeGPUData virtual on GrManagedResource be const seems like a bad restriction since
    // we are changing the internal objects of these classes when it is called. We should go back a
    // revisit how much of a headache it would be to make this function non-const
    GrVkCommandPool* nonConstThis = const_cast<GrVkCommandPool*>(this);
    nonConstThis->close();
    nonConstThis->releaseResources();
    fPrimaryCommandBuffer->freeGPUData(fGpu, fCommandPool);
    for (const auto& buffer : fAvailableSecondaryBuffers) {
        buffer->freeGPUData(fGpu, fCommandPool);
    }
    if (fCommandPool != VK_NULL_HANDLE) {
        GR_VK_CALL(fGpu->vkInterface(),
                   DestroyCommandPool(fGpu->device(), fCommandPool, nullptr));
    }
}

getPrimaryCommandBuffer()

GrVkPrimaryCommandBuffer * GrVkCommandPool::getPrimaryCommandBuffer ( )

inline

Definition at line 32 of file GrVkCommandPool.h.

{ return fPrimaryCommandBuffer.get(); }

isOpen()

bool GrVkCommandPool::isOpen ( ) const

inline

Definition at line 43 of file GrVkCommandPool.h.

{ return fOpen; }

recycleSecondaryCommandBuffer()

void GrVkCommandPool::recycleSecondaryCommandBuffer

(

GrVkSecondaryCommandBuffer *

buffer

)

Definition at line 64 of file GrVkCommandPool.cpp.

                                                                                      {
    std::unique_ptr<GrVkSecondaryCommandBuffer> scb(buffer);
    if (fAvailableSecondaryBuffers.size() < fMaxCachedSecondaryCommandBuffers) {
        fAvailableSecondaryBuffers.push_back(std::move(scb));
    } else {
        VkCommandBuffer vkBuffer = buffer->vkCommandBuffer();
        GR_VK_CALL(fGpu->vkInterface(),
                   FreeCommandBuffers(fGpu->device(), fCommandPool, 1, &vkBuffer));
    }
}

reset()

void GrVkCommandPool::reset

(

GrVkGpu *

gpu

)

Definition at line 79 of file GrVkCommandPool.cpp.

                                        {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    SkASSERT(!fOpen);
    // We can't use the normal result macro calls here because we may call reset on a different
    // thread and we can't be modifying the lost state on the GrVkGpu. We just call
    // vkResetCommandPool and assume the "next" vulkan call will catch the lost device.
    SkDEBUGCODE(VkResult result = )GR_VK_CALL(gpu->vkInterface(),
                                              ResetCommandPool(gpu->device(), fCommandPool, 0));
    SkASSERT(result == VK_SUCCESS || result == VK_ERROR_DEVICE_LOST);
 
    // It should be safe to release the resources before actually resetting the VkCommandPool.
    // However, on qualcomm devices running R drivers there was a few months period where the driver
    // had a bug which it incorrectly was accessing objects on the command buffer while it was being
    // reset. If these objects were already destroyed (which is a valid thing to do) it would crash.
    // So to be safe we do the reset first since it doesn't really matter when single threaded. If
    // we ever add back in threaded resets we'll want to add checks to make sure everything happens
    // in the right order (and probably do single threaded resets on bad devices).
    this->releaseResources();
 
    fOpen = true;
}

vkCommandPool()

VkCommandPool GrVkCommandPool::vkCommandPool ( ) const

inline

Definition at line 25 of file GrVkCommandPool.h.

                                        {
        return fCommandPool;
    }

---

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

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