GrVkResourceProvider Class Reference

#include <GrVkResourceProvider.h>

Public Types
using	SelfDependencyFlags = GrVkRenderPass::SelfDependencyFlags
using	LoadFromResolve = GrVkRenderPass::LoadFromResolve

Public Member Functions
	GrVkResourceProvider (GrVkGpu *gpu)
	~GrVkResourceProvider ()
GrThreadSafePipelineBuilder *	pipelineStateCache ()
sk_sp< GrThreadSafePipelineBuilder >	refPipelineStateCache ()
void	init ()
sk_sp< const GrVkPipeline >	makePipeline (const GrProgramInfo &, VkPipelineShaderStageCreateInfo *shaderStageInfo, int shaderStageCount, VkRenderPass compatibleRenderPass, VkPipelineLayout layout, uint32_t subpass)
const GrVkRenderPass *	findCompatibleRenderPass (GrVkRenderTarget *target, CompatibleRPHandle *compatibleHandle, bool withResolve, bool withStencil, SelfDependencyFlags selfDepFlags, LoadFromResolve)
const GrVkRenderPass *	findCompatibleRenderPass (GrVkRenderPass::AttachmentsDescriptor *, GrVkRenderPass::AttachmentFlags, SelfDependencyFlags selfDepFlags, LoadFromResolve, CompatibleRPHandle *compatibleHandle=nullptr)
const GrVkRenderPass *	findCompatibleExternalRenderPass (VkRenderPass, uint32_t colorAttachmentIndex)
const GrVkRenderPass *	findRenderPass (GrVkRenderTarget *target, const GrVkRenderPass::LoadStoreOps &colorOps, const GrVkRenderPass::LoadStoreOps &resolveOps, const GrVkRenderPass::LoadStoreOps &stencilOps, CompatibleRPHandle *compatibleHandle, bool withResolve, bool withStencil, SelfDependencyFlags selfDepFlags, LoadFromResolve)
const GrVkRenderPass *	findRenderPass (const CompatibleRPHandle &compatibleHandle, const GrVkRenderPass::LoadStoreOps &colorOps, const GrVkRenderPass::LoadStoreOps &resolveOps, const GrVkRenderPass::LoadStoreOps &stencilOps)
GrVkCommandPool *	findOrCreateCommandPool ()
void	checkCommandBuffers ()
void	forceSyncAllCommandBuffers ()
void	addFinishedProcToActiveCommandBuffers (sk_sp< skgpu::RefCntedCallback > finishedCallback)
GrVkDescriptorPool *	findOrCreateCompatibleDescriptorPool (VkDescriptorType type, uint32_t count)
GrVkSampler *	findOrCreateCompatibleSampler (GrSamplerState, const skgpu::VulkanYcbcrConversionInfo &ycbcrInfo)
GrVkSamplerYcbcrConversion *	findOrCreateCompatibleSamplerYcbcrConversion (const skgpu::VulkanYcbcrConversionInfo &ycbcrInfo)
GrVkPipelineState *	findOrCreateCompatiblePipelineState (GrRenderTarget *, const GrProgramInfo &, VkRenderPass compatibleRenderPass, bool overrideSubpassForResolveLoad)
GrVkPipelineState *	findOrCreateCompatiblePipelineState (const GrProgramDesc &, const GrProgramInfo &, VkRenderPass compatibleRenderPass, GrThreadSafePipelineBuilder::Stats::ProgramCacheResult *stat)
sk_sp< const GrVkPipeline >	findOrCreateMSAALoadPipeline (const GrVkRenderPass &renderPass, int numSamples, VkPipelineShaderStageCreateInfo *, VkPipelineLayout)
void	getSamplerDescriptorSetHandle (VkDescriptorType type, const GrVkUniformHandler &, GrVkDescriptorSetManager::Handle *handle)
void	getZeroSamplerDescriptorSetHandle (GrVkDescriptorSetManager::Handle *handle)
VkDescriptorSetLayout	getUniformDSLayout () const
VkDescriptorSetLayout	getInputDSLayout () const
VkDescriptorSetLayout	getSamplerDSLayout (const GrVkDescriptorSetManager::Handle &) const
const GrVkDescriptorSet *	getUniformDescriptorSet ()
const GrVkDescriptorSet *	getSamplerDescriptorSet (const GrVkDescriptorSetManager::Handle &)
const GrVkDescriptorSet *	getInputDescriptorSet ()
void	recycleDescriptorSet (const GrVkDescriptorSet *descSet, const GrVkDescriptorSetManager::Handle &)
void	storePipelineCacheData ()
void	destroyResources ()
void	releaseUnlockedBackendObjects ()

Detailed Description

Definition at line 40 of file GrVkResourceProvider.h.

Member Typedef Documentation

LoadFromResolve

using GrVkResourceProvider::LoadFromResolve = GrVkRenderPass::LoadFromResolve

Definition at line 66 of file GrVkResourceProvider.h.

SelfDependencyFlags

using GrVkResourceProvider::SelfDependencyFlags = GrVkRenderPass::SelfDependencyFlags

Definition at line 65 of file GrVkResourceProvider.h.

Constructor & Destructor Documentation

GrVkResourceProvider()

GrVkResourceProvider::GrVkResourceProvider

(

GrVkGpu *

gpu

)

Definition at line 23 of file GrVkResourceProvider.cpp.

    : fGpu(gpu)
    , fPipelineCache(VK_NULL_HANDLE) {
    fPipelineStateCache = sk_make_sp<PipelineStateCache>(gpu);
}

~GrVkResourceProvider()

GrVkResourceProvider::~GrVkResourceProvider

(

)

Definition at line 29 of file GrVkResourceProvider.cpp.

                                            {
    SkASSERT(fRenderPassArray.empty());
    SkASSERT(fExternalRenderPasses.empty());
    SkASSERT(fMSAALoadPipelines.empty());
    SkASSERT(VK_NULL_HANDLE == fPipelineCache);
}

Member Function Documentation

addFinishedProcToActiveCommandBuffers()

void GrVkResourceProvider::addFinishedProcToActiveCommandBuffers

(

sk_sp< skgpu::RefCntedCallback >

finishedCallback

)

Definition at line 471 of file GrVkResourceProvider.cpp.

                                                       {
    for (int i = 0; i < fActiveCommandPools.size(); ++i) {
        GrVkCommandPool* pool = fActiveCommandPools[i];
        GrVkPrimaryCommandBuffer* buffer = pool->getPrimaryCommandBuffer();
        buffer->addFinishedProc(finishedCallback);
    }
}

checkCommandBuffers()

void GrVkResourceProvider::checkCommandBuffers

(

)

Definition at line 428 of file GrVkResourceProvider.cpp.

                                               {
    // When resetting a command buffer it can trigger client provided procs (e.g. release or
    // finished) to be called. During these calls the client could trigger us to abandon the vk
    // context, e.g. if we are in a DEVICE_LOST state. When we abandon the vk context we will
    // unref all the fActiveCommandPools and reset the array. Since this can happen in the middle
    // of the loop here, we need to additionally check that fActiveCommandPools still has pools on
    // each iteration.
    //
    // TODO: We really need to have a more robust way to protect us from client proc calls that
    // happen in the middle of us doing work. This may be just one of many potential pitfalls that
    // could happen from the client triggering GrDirectContext changes during a proc call.
    for (int i = fActiveCommandPools.size() - 1; !fActiveCommandPools.empty() && i >= 0; --i) {
        GrVkCommandPool* pool = fActiveCommandPools[i];
        if (!pool->isOpen()) {
            GrVkPrimaryCommandBuffer* buffer = pool->getPrimaryCommandBuffer();
            if (buffer->finished(fGpu)) {
                fActiveCommandPools.removeShuffle(i);
                SkASSERT(pool->unique());
                pool->reset(fGpu);
                // After resetting the pool (specifically releasing the pool's resources) we may
                // have called a client callback proc which may have disconnected the GrVkGpu. In
                // that case we do not want to push the pool back onto the cache, but instead just
                // drop the pool.
                if (fGpu->disconnected()) {
                    pool->unref();
                    return;
                }
                fAvailableCommandPools.push_back(pool);
            }
        }
    }
}

destroyResources()

void GrVkResourceProvider::destroyResources

(

)

Definition at line 480 of file GrVkResourceProvider.cpp.

                                            {
    SkTaskGroup* taskGroup = fGpu->getContext()->priv().getTaskGroup();
    if (taskGroup) {
        taskGroup->wait();
    }
 
    // Release all msaa load pipelines
    fMSAALoadPipelines.clear();
 
    // loop over all render pass sets to make sure we destroy all the internal VkRenderPasses
    for (int i = 0; i < fRenderPassArray.size(); ++i) {
        fRenderPassArray[i].releaseResources();
    }
    fRenderPassArray.clear();
 
    for (int i = 0; i < fExternalRenderPasses.size(); ++i) {
        fExternalRenderPasses[i]->unref();
    }
    fExternalRenderPasses.clear();
 
    // Iterate through all store GrVkSamplers and unref them before resetting the hash table.
    fSamplers.foreach([&](auto* elt) { elt->unref(); });
    fSamplers.reset();
 
    fYcbcrConversions.foreach([&](auto* elt) { elt->unref(); });
    fYcbcrConversions.reset();
 
    fPipelineStateCache->release();
 
    GR_VK_CALL(fGpu->vkInterface(), DestroyPipelineCache(fGpu->device(), fPipelineCache, nullptr));
    fPipelineCache = VK_NULL_HANDLE;
 
    for (GrVkCommandPool* pool : fActiveCommandPools) {
        SkASSERT(pool->unique());
        pool->unref();
    }
    fActiveCommandPools.clear();
 
    for (GrVkCommandPool* pool : fAvailableCommandPools) {
        SkASSERT(pool->unique());
        pool->unref();
    }
    fAvailableCommandPools.clear();
 
    // We must release/destroy all command buffers and pipeline states before releasing the
    // GrVkDescriptorSetManagers. Additionally, we must release all uniform buffers since they hold
    // refs to GrVkDescriptorSets.
    for (int i = 0; i < fDescriptorSetManagers.size(); ++i) {
        fDescriptorSetManagers[i]->release(fGpu);
    }
    fDescriptorSetManagers.clear();
 
}

findCompatibleExternalRenderPass()

const GrVkRenderPass * GrVkResourceProvider::findCompatibleExternalRenderPass	(	VkRenderPass	renderPass,
		uint32_t	colorAttachmentIndex
	)

Definition at line 161 of file GrVkResourceProvider.cpp.

                                                                {
    for (int i = 0; i < fExternalRenderPasses.size(); ++i) {
        if (fExternalRenderPasses[i]->isCompatibleExternalRP(renderPass)) {
            fExternalRenderPasses[i]->ref();
#ifdef SK_DEBUG
            uint32_t cachedColorIndex;
            SkASSERT(fExternalRenderPasses[i]->colorAttachmentIndex(&cachedColorIndex));
            SkASSERT(cachedColorIndex == colorAttachmentIndex);
#endif
            return fExternalRenderPasses[i];
        }
    }
 
    const GrVkRenderPass* newRenderPass = new GrVkRenderPass(fGpu, renderPass,
                                                             colorAttachmentIndex);
    fExternalRenderPasses.push_back(newRenderPass);
    newRenderPass->ref();
    return newRenderPass;
}

findCompatibleRenderPass() [1/2]

const GrVkRenderPass * GrVkResourceProvider::findCompatibleRenderPass	(	GrVkRenderPass::AttachmentsDescriptor *	desc,
		GrVkRenderPass::AttachmentFlags	attachmentFlags,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve,
		CompatibleRPHandle *	compatibleHandle = nullptr
	)

Definition at line 131 of file GrVkResourceProvider.cpp.

                                                                                     {
    for (int i = 0; i < fRenderPassArray.size(); ++i) {
        if (fRenderPassArray[i].isCompatible(*desc, attachmentFlags, selfDepFlags,
                                             loadFromResolve)) {
            const GrVkRenderPass* renderPass = fRenderPassArray[i].getCompatibleRenderPass();
            renderPass->ref();
            if (compatibleHandle) {
                *compatibleHandle = CompatibleRPHandle(i);
            }
            return renderPass;
        }
    }
 
    GrVkRenderPass* renderPass = GrVkRenderPass::CreateSimple(fGpu, desc, attachmentFlags,
                                                              selfDepFlags, loadFromResolve);
    if (!renderPass) {
        return nullptr;
    }
    fRenderPassArray.emplace_back(renderPass);
 
    if (compatibleHandle) {
        *compatibleHandle = CompatibleRPHandle(fRenderPassArray.size() - 1);
    }
    return renderPass;
}

findCompatibleRenderPass() [2/2]

const GrVkRenderPass * GrVkResourceProvider::findCompatibleRenderPass	(	GrVkRenderTarget *	target,
		CompatibleRPHandle *	compatibleHandle,
		bool	withResolve,
		bool	withStencil,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve
	)

Definition at line 111 of file GrVkResourceProvider.cpp.

                                                                                {
    // Get attachment information from render target. This includes which attachments the render
    // target has (color, stencil) and the attachments format and sample count.
    GrVkRenderPass::AttachmentFlags attachmentFlags;
    GrVkRenderPass::AttachmentsDescriptor attachmentsDesc;
    if (!target->getAttachmentsDescriptor(&attachmentsDesc, &attachmentFlags,
                                          withResolve, withStencil)) {
        return nullptr;
    }
 
    return this->findCompatibleRenderPass(&attachmentsDesc, attachmentFlags, selfDepFlags,
                                          loadFromResolve, compatibleHandle);
}

findOrCreateCommandPool()

GrVkCommandPool * GrVkResourceProvider::findOrCreateCommandPool

(

)

Definition at line 403 of file GrVkResourceProvider.cpp.

                                                               {
    GrVkCommandPool* result;
    if (!fAvailableCommandPools.empty()) {
        result = fAvailableCommandPools.back();
        fAvailableCommandPools.pop_back();
    } else {
        result = GrVkCommandPool::Create(fGpu);
        if (!result) {
            return nullptr;
        }
    }
    SkASSERT(result->unique());
    SkDEBUGCODE(
        for (const GrVkCommandPool* pool : fActiveCommandPools) {
            SkASSERT(pool != result);
        }
        for (const GrVkCommandPool* pool : fAvailableCommandPools) {
            SkASSERT(pool != result);
        }
    )
    fActiveCommandPools.push_back(result);
    result->ref();
    return result;
}

findOrCreateCompatibleDescriptorPool()

GrVkDescriptorPool * GrVkResourceProvider::findOrCreateCompatibleDescriptorPool	(	VkDescriptorType	type,
		uint32_t	count
	)

Definition at line 222 of file GrVkResourceProvider.cpp.

                                                                                                   {
    return GrVkDescriptorPool::Create(fGpu, type, count);
}

findOrCreateCompatiblePipelineState() [1/2]

GrVkPipelineState * GrVkResourceProvider::findOrCreateCompatiblePipelineState	(	const GrProgramDesc &	desc,
		const GrProgramInfo &	programInfo,
		VkRenderPass	compatibleRenderPass,
		GrThreadSafePipelineBuilder::Stats::ProgramCacheResult *	stat
	)

Definition at line 268 of file GrVkResourceProvider.cpp.

                                                                  {
 
    auto tmp =  fPipelineStateCache->findOrCreatePipelineState(desc, programInfo,
                                                               compatibleRenderPass, stat);
    if (!tmp) {
        fPipelineStateCache->stats()->incNumPreCompilationFailures();
    } else {
        fPipelineStateCache->stats()->incNumPreProgramCacheResult(*stat);
    }
 
    return tmp;
}

findOrCreateCompatiblePipelineState() [2/2]

GrVkPipelineState * GrVkResourceProvider::findOrCreateCompatiblePipelineState	(	GrRenderTarget *	renderTarget,
		const GrProgramInfo &	programInfo,
		VkRenderPass	compatibleRenderPass,
		bool	overrideSubpassForResolveLoad
	)

Definition at line 258 of file GrVkResourceProvider.cpp.

                                            {
    return fPipelineStateCache->findOrCreatePipelineState(renderTarget, programInfo,
                                                          compatibleRenderPass,
                                                          overrideSubpassForResolveLoad);
}

findOrCreateCompatibleSampler()

GrVkSampler * GrVkResourceProvider::findOrCreateCompatibleSampler	(	GrSamplerState	params,
		const skgpu::VulkanYcbcrConversionInfo &	ycbcrInfo
	)

Definition at line 227 of file GrVkResourceProvider.cpp.

                                                                                {
    GrVkSampler* sampler = fSamplers.find(GrVkSampler::GenerateKey(params, ycbcrInfo));
    if (!sampler) {
        sampler = GrVkSampler::Create(fGpu, params, ycbcrInfo);
        if (!sampler) {
            return nullptr;
        }
        fSamplers.add(sampler);
    }
    SkASSERT(sampler);
    sampler->ref();
    return sampler;
}

findOrCreateCompatibleSamplerYcbcrConversion()

GrVkSamplerYcbcrConversion * GrVkResourceProvider::findOrCreateCompatibleSamplerYcbcrConversion

(

const skgpu::VulkanYcbcrConversionInfo &

ycbcrInfo

)

Definition at line 242 of file GrVkResourceProvider.cpp.

                                                         {
    GrVkSamplerYcbcrConversion* ycbcrConversion =
            fYcbcrConversions.find(GrVkSamplerYcbcrConversion::GenerateKey(ycbcrInfo));
    if (!ycbcrConversion) {
        ycbcrConversion = GrVkSamplerYcbcrConversion::Create(fGpu, ycbcrInfo);
        if (!ycbcrConversion) {
            return nullptr;
        }
        fYcbcrConversions.add(ycbcrConversion);
    }
    SkASSERT(ycbcrConversion);
    ycbcrConversion->ref();
    return ycbcrConversion;
}

findOrCreateMSAALoadPipeline()

sk_sp< const GrVkPipeline > GrVkResourceProvider::findOrCreateMSAALoadPipeline	(	const GrVkRenderPass &	renderPass,
		int	numSamples,
		VkPipelineShaderStageCreateInfo *	shaderStageInfo,
		VkPipelineLayout	pipelineLayout
	)

Definition at line 285 of file GrVkResourceProvider.cpp.

                                         {
    // Find or Create a compatible pipeline
    sk_sp<const GrVkPipeline> pipeline;
    for (int i = 0; i < fMSAALoadPipelines.size() && !pipeline; ++i) {
        if (fMSAALoadPipelines[i].fRenderPass->isCompatible(renderPass)) {
            pipeline = fMSAALoadPipelines[i].fPipeline;
        }
    }
    if (!pipeline) {
        pipeline = GrVkPipeline::Make(
                fGpu,
                /*vertexAttribs=*/GrGeometryProcessor::AttributeSet(),
                /*instanceAttribs=*/GrGeometryProcessor::AttributeSet(),
                GrPrimitiveType::kTriangleStrip,
                kTopLeft_GrSurfaceOrigin,
                GrStencilSettings(),
                numSamples,
                /*isHWantialiasState=*/false,
                skgpu::BlendInfo(),
                /*isWireframe=*/false,
                /*useConservativeRaster=*/false,
                /*subpass=*/0,
                shaderStageInfo,
                /*shaderStageCount=*/2,
                renderPass.vkRenderPass(),
                pipelineLayout,
                /*ownsLayout=*/false,
                this->pipelineCache());
        if (!pipeline) {
            return nullptr;
        }
        fMSAALoadPipelines.push_back({pipeline, &renderPass});
    }
    SkASSERT(pipeline);
    return pipeline;
}

findRenderPass() [1/2]

const GrVkRenderPass * GrVkResourceProvider::findRenderPass	(	const CompatibleRPHandle &	compatibleHandle,
		const GrVkRenderPass::LoadStoreOps &	colorOps,
		const GrVkRenderPass::LoadStoreOps &	resolveOps,
		const GrVkRenderPass::LoadStoreOps &	stencilOps
	)

Definition at line 205 of file GrVkResourceProvider.cpp.

                                                                                   {
    SkASSERT(compatibleHandle.isValid() && compatibleHandle.toIndex() < fRenderPassArray.size());
    CompatibleRenderPassSet& compatibleSet = fRenderPassArray[compatibleHandle.toIndex()];
    const GrVkRenderPass* renderPass = compatibleSet.getRenderPass(fGpu,
                                                                   colorOps,
                                                                   resolveOps,
                                                                   stencilOps);
    if (!renderPass) {
        return nullptr;
    }
    renderPass->ref();
    return renderPass;
}

findRenderPass() [2/2]

const GrVkRenderPass * GrVkResourceProvider::findRenderPass	(	GrVkRenderTarget *	target,
		const GrVkRenderPass::LoadStoreOps &	colorOps,
		const GrVkRenderPass::LoadStoreOps &	resolveOps,
		const GrVkRenderPass::LoadStoreOps &	stencilOps,
		CompatibleRPHandle *	compatibleHandle,
		bool	withResolve,
		bool	withStencil,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve
	)

Definition at line 182 of file GrVkResourceProvider.cpp.

                                         {
    GrVkResourceProvider::CompatibleRPHandle tempRPHandle;
    GrVkResourceProvider::CompatibleRPHandle* pRPHandle = compatibleHandle ? compatibleHandle
                                                                           : &tempRPHandle;
    *pRPHandle = target->compatibleRenderPassHandle(withResolve, withStencil, selfDepFlags,
                                                    loadFromResolve);
    if (!pRPHandle->isValid()) {
        return nullptr;
    }
 
    return this->findRenderPass(*pRPHandle, colorOps, resolveOps, stencilOps);
}

forceSyncAllCommandBuffers()

void GrVkResourceProvider::forceSyncAllCommandBuffers

(

)

Definition at line 461 of file GrVkResourceProvider.cpp.

                                                      {
    for (int i = fActiveCommandPools.size() - 1; !fActiveCommandPools.empty() && i >= 0; --i) {
        GrVkCommandPool* pool = fActiveCommandPools[i];
        if (!pool->isOpen()) {
            GrVkPrimaryCommandBuffer* buffer = pool->getPrimaryCommandBuffer();
            buffer->forceSync(fGpu);
        }
    }
}

getInputDescriptorSet()

const GrVkDescriptorSet * GrVkResourceProvider::getInputDescriptorSet

(

)

Definition at line 383 of file GrVkResourceProvider.cpp.

                                                                     {
    SkASSERT(fInputDSHandle.isValid());
    return fDescriptorSetManagers[fInputDSHandle.toIndex()]->getDescriptorSet(fGpu, fInputDSHandle);
}

getInputDSLayout()

VkDescriptorSetLayout GrVkResourceProvider::getInputDSLayout

(

)

const

Definition at line 366 of file GrVkResourceProvider.cpp.

                                                                   {
    SkASSERT(fInputDSHandle.isValid());
    return fDescriptorSetManagers[fInputDSHandle.toIndex()]->layout();
}

getSamplerDescriptorSet()

const GrVkDescriptorSet * GrVkResourceProvider::getSamplerDescriptorSet

(

const GrVkDescriptorSetManager::Handle &

handle

)

Definition at line 388 of file GrVkResourceProvider.cpp.

                                                      {
    SkASSERT(handle.isValid());
    return fDescriptorSetManagers[handle.toIndex()]->getDescriptorSet(fGpu, handle);
}

getSamplerDescriptorSetHandle()

void GrVkResourceProvider::getSamplerDescriptorSetHandle	(	VkDescriptorType	type,
		const GrVkUniformHandler &	uniformHandler,
		GrVkDescriptorSetManager::Handle *	handle
	)

Definition at line 342 of file GrVkResourceProvider.cpp.

                                                                                                 {
    SkASSERT(handle);
    SkASSERT(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == type ||
             VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == type);
    for (int i = 0; i < fDescriptorSetManagers.size(); ++i) {
        if (fDescriptorSetManagers[i]->isCompatible(type, &uniformHandler)) {
           *handle = GrVkDescriptorSetManager::Handle(i);
           return;
        }
    }
 
    GrVkDescriptorSetManager* dsm = GrVkDescriptorSetManager::CreateSamplerManager(fGpu, type,
                                                                                   uniformHandler);
    fDescriptorSetManagers.emplace_back(dsm);
    *handle = GrVkDescriptorSetManager::Handle(fDescriptorSetManagers.size() - 1);
}

getSamplerDSLayout()

VkDescriptorSetLayout GrVkResourceProvider::getSamplerDSLayout

(

const GrVkDescriptorSetManager::Handle &

handle

)

const

Definition at line 371 of file GrVkResourceProvider.cpp.

                                                            {
    SkASSERT(handle.isValid());
    return fDescriptorSetManagers[handle.toIndex()]->layout();
}

getUniformDescriptorSet()

const GrVkDescriptorSet * GrVkResourceProvider::getUniformDescriptorSet

(

)

Definition at line 377 of file GrVkResourceProvider.cpp.

                                                                       {
    SkASSERT(fUniformDSHandle.isValid());
    return fDescriptorSetManagers[fUniformDSHandle.toIndex()]->getDescriptorSet(fGpu,
                                                                                fUniformDSHandle);
}

getUniformDSLayout()

VkDescriptorSetLayout GrVkResourceProvider::getUniformDSLayout

(

)

const

Definition at line 361 of file GrVkResourceProvider.cpp.

                                                                     {
    SkASSERT(fUniformDSHandle.isValid());
    return fDescriptorSetManagers[fUniformDSHandle.toIndex()]->layout();
}

getZeroSamplerDescriptorSetHandle()

void GrVkResourceProvider::getZeroSamplerDescriptorSetHandle

(

GrVkDescriptorSetManager::Handle *

handle

)

Definition at line 326 of file GrVkResourceProvider.cpp.

                                                {
    SkASSERT(handle);
    for (int i = 0; i < fDescriptorSetManagers.size(); ++i) {
        if (fDescriptorSetManagers[i]->isZeroSampler()) {
            *handle = GrVkDescriptorSetManager::Handle(i);
            return;
        }
    }
 
    GrVkDescriptorSetManager* dsm =
            GrVkDescriptorSetManager::CreateZeroSamplerManager(fGpu);
    fDescriptorSetManagers.emplace_back(dsm);
    *handle = GrVkDescriptorSetManager::Handle(fDescriptorSetManagers.size() - 1);
}

init()

void GrVkResourceProvider::init

(

)

Definition at line 84 of file GrVkResourceProvider.cpp.

                                {
    // Init uniform descriptor objects
    GrVkDescriptorSetManager* dsm = GrVkDescriptorSetManager::CreateUniformManager(fGpu);
    fDescriptorSetManagers.emplace_back(dsm);
    SkASSERT(1 == fDescriptorSetManagers.size());
    fUniformDSHandle = GrVkDescriptorSetManager::Handle(0);
    dsm = GrVkDescriptorSetManager::CreateInputManager(fGpu);
    fDescriptorSetManagers.emplace_back(dsm);
    SkASSERT(2 == fDescriptorSetManagers.size());
    fInputDSHandle = GrVkDescriptorSetManager::Handle(1);
}

makePipeline()

sk_sp< const GrVkPipeline > GrVkResourceProvider::makePipeline	(	const GrProgramInfo &	programInfo,
		VkPipelineShaderStageCreateInfo *	shaderStageInfo,
		int	shaderStageCount,
		VkRenderPass	compatibleRenderPass,
		VkPipelineLayout	layout,
		uint32_t	subpass
	)

Definition at line 96 of file GrVkResourceProvider.cpp.

                          {
    return GrVkPipeline::Make(fGpu, programInfo, shaderStageInfo, shaderStageCount,
                              compatibleRenderPass, layout, this->pipelineCache(), subpass);
}

pipelineStateCache()

GrThreadSafePipelineBuilder * GrVkResourceProvider::pipelineStateCache ( )

inline

Definition at line 45 of file GrVkResourceProvider.h.

                                                      {
        return fPipelineStateCache.get();
    }

recycleDescriptorSet()

void GrVkResourceProvider::recycleDescriptorSet	(	const GrVkDescriptorSet *	descSet,
		const GrVkDescriptorSetManager::Handle &	handle
	)

Definition at line 394 of file GrVkResourceProvider.cpp.

                                                                                              {
    SkASSERT(descSet);
    SkASSERT(handle.isValid());
    int managerIdx = handle.toIndex();
    SkASSERT(managerIdx < fDescriptorSetManagers.size());
    fDescriptorSetManagers[managerIdx]->recycleDescriptorSet(descSet);
}

refPipelineStateCache()

sk_sp< GrThreadSafePipelineBuilder > GrVkResourceProvider::refPipelineStateCache ( )

inline

Definition at line 49 of file GrVkResourceProvider.h.

                                                               {
        return fPipelineStateCache;
    }

releaseUnlockedBackendObjects()

void GrVkResourceProvider::releaseUnlockedBackendObjects

(

)

Definition at line 534 of file GrVkResourceProvider.cpp.

                                                         {
    for (GrVkCommandPool* pool : fAvailableCommandPools) {
        SkASSERT(pool->unique());
        pool->unref();
    }
    fAvailableCommandPools.clear();
}

storePipelineCacheData()

void GrVkResourceProvider::storePipelineCacheData

(

)

Definition at line 542 of file GrVkResourceProvider.cpp.

                                                  {
    if (this->pipelineCache() == VK_NULL_HANDLE) {
        return;
    }
    size_t dataSize = 0;
    VkResult result;
    GR_VK_CALL_RESULT(fGpu, result, GetPipelineCacheData(fGpu->device(), this->pipelineCache(),
                                                         &dataSize, nullptr));
    if (result != VK_SUCCESS) {
        return;
    }
 
    std::unique_ptr<uint8_t[]> data(new uint8_t[dataSize]);
 
    GR_VK_CALL_RESULT(fGpu, result, GetPipelineCacheData(fGpu->device(), this->pipelineCache(),
                                                         &dataSize, (void*)data.get()));
    if (result != VK_SUCCESS) {
        return;
    }
 
    uint32_t key = GrVkGpu::kPipelineCache_PersistentCacheKeyType;
    sk_sp<SkData> keyData = SkData::MakeWithoutCopy(&key, sizeof(uint32_t));
 
    fGpu->getContext()->priv().getPersistentCache()->store(
            *keyData, *SkData::MakeWithoutCopy(data.get(), dataSize), SkString("VkPipelineCache"));
}

---

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

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