skgpu::graphite::ResourceProvider Class Reference

#include <ResourceProvider.h>

Inheritance diagram for skgpu::graphite::ResourceProvider:

Public Member Functions
virtual	~ResourceProvider ()
sk_sp< GraphicsPipeline >	findOrCreateGraphicsPipeline (const RuntimeEffectDictionary *, const GraphicsPipelineDesc &, const RenderPassDesc &)
sk_sp< ComputePipeline >	findOrCreateComputePipeline (const ComputePipelineDesc &)
sk_sp< Texture >	findOrCreateScratchTexture (SkISize, const TextureInfo &, skgpu::Budgeted)
virtual sk_sp< Texture >	createWrappedTexture (const BackendTexture &)=0
sk_sp< Texture >	findOrCreateDepthStencilAttachment (SkISize dimensions, const TextureInfo &)
sk_sp< Texture >	findOrCreateDiscardableMSAAAttachment (SkISize dimensions, const TextureInfo &)
sk_sp< Buffer >	findOrCreateBuffer (size_t size, BufferType type, AccessPattern, std::string_view label)
sk_sp< Sampler >	findOrCreateCompatibleSampler (const SamplerDesc &)
BackendTexture	createBackendTexture (SkISize dimensions, const TextureInfo &)
void	deleteBackendTexture (const BackendTexture &)
ProxyCache *	proxyCache ()
size_t	getResourceCacheLimit () const
size_t	getResourceCacheCurrentBudgetedBytes () const
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
void	freeGpuResources ()
void	purgeResourcesNotUsedSince (StdSteadyClock::time_point purgeTime)

Protected Member Functions
	ResourceProvider (SharedContext *sharedContext, SingleOwner *singleOwner, uint32_t recorderID, size_t resourceBudget)

Protected Attributes
SharedContext *	fSharedContext
sk_sp< ResourceCache >	fResourceCache

Private Member Functions
virtual sk_sp< GraphicsPipeline >	createGraphicsPipeline (const RuntimeEffectDictionary *, const GraphicsPipelineDesc &, const RenderPassDesc &)=0
virtual sk_sp< ComputePipeline >	createComputePipeline (const ComputePipelineDesc &)=0
virtual sk_sp< Texture >	createTexture (SkISize, const TextureInfo &, skgpu::Budgeted)=0
virtual sk_sp< Buffer >	createBuffer (size_t size, BufferType type, AccessPattern, std::string_view label)=0
virtual sk_sp< Sampler >	createSampler (const SamplerDesc &)=0
virtual BackendTexture	onCreateBackendTexture (SkISize dimensions, const TextureInfo &)=0
virtual void	onDeleteBackendTexture (const BackendTexture &)=0

Detailed Description

Definition at line 50 of file ResourceProvider.h.

Constructor & Destructor Documentation

~ResourceProvider()

skgpu::graphite::ResourceProvider::~ResourceProvider ( )

virtual

Definition at line 50 of file ResourceProvider.cpp.

                                    {
    fResourceCache->shutdown();
}

ResourceProvider()

skgpu::graphite::ResourceProvider::ResourceProvider ( SharedContext *  sharedContext, SingleOwner *  singleOwner, uint32_t  recorderID, size_t  resourceBudget  )

protected

Definition at line 43 of file ResourceProvider.cpp.

        : fSharedContext(sharedContext)
        , fResourceCache(ResourceCache::Make(singleOwner, recorderID, resourceBudget)) {}

Member Function Documentation

createBackendTexture()

BackendTexture skgpu::graphite::ResourceProvider::createBackendTexture	(	SkISize	dimensions,
		const TextureInfo &	info
	)

Definition at line 245 of file ResourceProvider.cpp.

                                                                                                 {
    if (!dimensions_are_valid(fSharedContext->caps()->maxTextureSize(), dimensions)) {
        return {};
    }
    return this->onCreateBackendTexture(dimensions, info);
}

createBuffer()

virtual sk_sp< Buffer > skgpu::graphite::ResourceProvider::createBuffer ( size_t  size, BufferType  type, AccessPattern  , std::string_view  label  )

privatepure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

createComputePipeline()

virtual sk_sp< ComputePipeline > skgpu::graphite::ResourceProvider::createComputePipeline ( const ComputePipelineDesc &  )

privatepure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

createGraphicsPipeline()

virtual sk_sp< GraphicsPipeline > skgpu::graphite::ResourceProvider::createGraphicsPipeline ( const RuntimeEffectDictionary *  , const GraphicsPipelineDesc &  , const RenderPassDesc &    )

privatepure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

createSampler()

virtual sk_sp< Sampler > skgpu::graphite::ResourceProvider::createSampler ( const SamplerDesc &  )

privatepure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

createTexture()

virtual sk_sp< Texture > skgpu::graphite::ResourceProvider::createTexture ( SkISize  , const TextureInfo &  , skgpu::Budgeted    )

privatepure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

createWrappedTexture()

virtual sk_sp< Texture > skgpu::graphite::ResourceProvider::createWrappedTexture ( const BackendTexture &  )

pure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

deleteBackendTexture()

void skgpu::graphite::ResourceProvider::deleteBackendTexture

(

const BackendTexture &

texture

)

Definition at line 277 of file ResourceProvider.cpp.

                                                                         {
    this->onDeleteBackendTexture(texture);
}

dumpMemoryStatistics()

void skgpu::graphite::ResourceProvider::dumpMemoryStatistics ( SkTraceMemoryDump *  traceMemoryDump ) const

inline

Definition at line 88 of file ResourceProvider.h.

                                                                        {
        fResourceCache->dumpMemoryStatistics(traceMemoryDump);
    }

findOrCreateBuffer()

sk_sp< Buffer > skgpu::graphite::ResourceProvider::findOrCreateBuffer	(	size_t	size,
		BufferType	type,
		AccessPattern	accessPattern,
		std::string_view	label
	)

Definition at line 184 of file ResourceProvider.cpp.

                                                                         {
    static const ResourceType kType = GraphiteResourceKey::GenerateResourceType();
 
    GraphiteResourceKey key;
    {
        // For the key we need ((sizeof(size_t) + (sizeof(uint32_t) - 1)) / (sizeof(uint32_t))
        // uint32_t's for the size and one uint32_t for the rest.
        static_assert(sizeof(uint32_t) == 4);
        static const int kSizeKeyNum32DataCnt = (sizeof(size_t) + 3) / 4;
        static const int kKeyNum32DataCnt =  kSizeKeyNum32DataCnt + 1;
 
        SkASSERT(static_cast<uint32_t>(type) < (1u << 4));
        SkASSERT(static_cast<uint32_t>(accessPattern) < (1u << 1));
 
        GraphiteResourceKey::Builder builder(&key, kType, kKeyNum32DataCnt, Shareable::kNo);
        builder[0] = (static_cast<uint32_t>(type) << 0) |
                     (static_cast<uint32_t>(accessPattern) << 4);
        size_t szKey = size;
        for (int i = 0; i < kSizeKeyNum32DataCnt; ++i) {
            builder[i + 1] = (uint32_t) szKey;
 
            // If size_t is 4 bytes, we cannot do a shift of 32 or else we get a warning/error that
            // shift amount is >= width of the type.
            if constexpr(kSizeKeyNum32DataCnt > 1) {
                szKey = szKey >> 32;
            }
        }
    }
 
    skgpu::Budgeted budgeted = skgpu::Budgeted::kYes;
    if (Resource* resource = fResourceCache->findAndRefResource(key, budgeted)) {
        resource->setLabel(std::move(label));
        return sk_sp<Buffer>(static_cast<Buffer*>(resource));
    }
    auto buffer = this->createBuffer(size, type, accessPattern, std::move(label));
    if (!buffer) {
        return nullptr;
    }
 
    buffer->setKey(key);
    fResourceCache->insertResource(buffer.get());
    return buffer;
}

findOrCreateCompatibleSampler()

sk_sp< Sampler > skgpu::graphite::ResourceProvider::findOrCreateCompatibleSampler

(

const SamplerDesc &

desc

)

Definition at line 167 of file ResourceProvider.cpp.

                                                                                      {
    GraphiteResourceKey key = fSharedContext->caps()->makeSamplerKey(desc);
 
    if (Resource* resource = fResourceCache->findAndRefResource(key, skgpu::Budgeted::kYes)) {
        return sk_sp<Sampler>(static_cast<Sampler*>(resource));
    }
 
    sk_sp<Sampler> sampler = this->createSampler(desc);
    if (!sampler) {
        return nullptr;
    }
 
    sampler->setKey(key);
    fResourceCache->insertResource(sampler.get());
    return sampler;
}

findOrCreateComputePipeline()

sk_sp< ComputePipeline > skgpu::graphite::ResourceProvider::findOrCreateComputePipeline

(

const ComputePipelineDesc &

pipelineDesc

)

Definition at line 82 of file ResourceProvider.cpp.

                                                 {
    auto globalCache = fSharedContext->globalCache();
    UniqueKey pipelineKey = fSharedContext->caps()->makeComputePipelineKey(pipelineDesc);
    sk_sp<ComputePipeline> pipeline = globalCache->findComputePipeline(pipelineKey);
    if (!pipeline) {
        pipeline = this->createComputePipeline(pipelineDesc);
        if (pipeline) {
            pipeline = globalCache->addComputePipeline(pipelineKey, std::move(pipeline));
        }
    }
    return pipeline;
}

findOrCreateDepthStencilAttachment()

sk_sp< Texture > skgpu::graphite::ResourceProvider::findOrCreateDepthStencilAttachment	(	SkISize	dimensions,
		const TextureInfo &	info
	)

Definition at line 112 of file ResourceProvider.cpp.

                                                                                             {
    SkASSERT(info.isValid());
 
    static const ResourceType kType = GraphiteResourceKey::GenerateResourceType();
 
    GraphiteResourceKey key;
    // We always make depth and stencil attachments shareable. Between any render pass the values
    // are reset. Thus it is safe to be used by multiple different render passes without worry of
    // stomping on each other's data.
    fSharedContext->caps()->buildKeyForTexture(dimensions, info, kType, Shareable::kYes, &key);
 
    return this->findOrCreateTextureWithKey(dimensions, info, key, skgpu::Budgeted::kYes);
}

findOrCreateDiscardableMSAAAttachment()

sk_sp< Texture > skgpu::graphite::ResourceProvider::findOrCreateDiscardableMSAAAttachment	(	SkISize	dimensions,
		const TextureInfo &	info
	)

Definition at line 127 of file ResourceProvider.cpp.

                                                                                                {
    SkASSERT(info.isValid());
 
    static const ResourceType kType = GraphiteResourceKey::GenerateResourceType();
 
    GraphiteResourceKey key;
    // We always make discardable msaa attachments shareable. Between any render pass we discard
    // the values of the MSAA texture. Thus it is safe to be used by multiple different render
    // passes without worry of stomping on each other's data. It is the callings code's
    // responsibility to populate the discardable MSAA texture with data at the start of the
    // render pass.
    fSharedContext->caps()->buildKeyForTexture(dimensions, info, kType, Shareable::kYes, &key);
 
    return this->findOrCreateTextureWithKey(dimensions, info, key, skgpu::Budgeted::kYes);
}

findOrCreateGraphicsPipeline()

sk_sp< GraphicsPipeline > skgpu::graphite::ResourceProvider::findOrCreateGraphicsPipeline	(	const RuntimeEffectDictionary *	runtimeDict,
		const GraphicsPipelineDesc &	pipelineDesc,
		const RenderPassDesc &	renderPassDesc
	)

Definition at line 54 of file ResourceProvider.cpp.

                                              {
    auto globalCache = fSharedContext->globalCache();
    UniqueKey pipelineKey = fSharedContext->caps()->makeGraphicsPipelineKey(pipelineDesc,
                                                                            renderPassDesc);
    sk_sp<GraphicsPipeline> pipeline = globalCache->findGraphicsPipeline(pipelineKey);
    if (!pipeline) {
        // Haven't encountered this pipeline, so create a new one. Since pipelines are shared
        // across Recorders, we could theoretically create equivalent pipelines on different
        // threads. If this happens, GlobalCache returns the first-through-gate pipeline and we
        // discard the redundant pipeline. While this is wasted effort in the rare event of a race,
        // it allows pipeline creation to be performed without locking the global cache.
        // NOTE: The parameters to TRACE_EVENT are only evaluated inside an if-block when the
        // category is enabled.
        TRACE_EVENT1("skia.shaders", "createGraphicsPipeline", "desc",
                     TRACE_STR_COPY(to_str(fSharedContext, pipelineDesc, renderPassDesc).c_str()));
        pipeline = this->createGraphicsPipeline(runtimeDict, pipelineDesc, renderPassDesc);
        if (pipeline) {
            // TODO: Should we store a null pipeline if we failed to create one so that subsequent
            // usage immediately sees that the pipeline cannot be created, vs. retrying every time?
            pipeline = globalCache->addGraphicsPipeline(pipelineKey, std::move(pipeline));
        }
    }
    return pipeline;
}

findOrCreateScratchTexture()

sk_sp< Texture > skgpu::graphite::ResourceProvider::findOrCreateScratchTexture	(	SkISize	dimensions,
		const TextureInfo &	info,
		skgpu::Budgeted	budgeted
	)

Definition at line 98 of file ResourceProvider.cpp.

                                                                                    {
    SkASSERT(info.isValid());
 
    static const ResourceType kType = GraphiteResourceKey::GenerateResourceType();
 
    GraphiteResourceKey key;
    // Scratch textures are not shareable
    fSharedContext->caps()->buildKeyForTexture(dimensions, info, kType, Shareable::kNo, &key);
 
    return this->findOrCreateTextureWithKey(dimensions, info, key, budgeted);
}

freeGpuResources()

void skgpu::graphite::ResourceProvider::freeGpuResources

(

)

Definition at line 281 of file ResourceProvider.cpp.

                                        {
    // TODO: Are there Resources that are ref'd by the ResourceProvider or its subclasses that need
    // be released? If we ever find that we're holding things directly on the ResourceProviders we
    // call down into the subclasses to allow them to release things.
 
    fResourceCache->purgeResources();
}

getResourceCacheCurrentBudgetedBytes()

size_t skgpu::graphite::ResourceProvider::getResourceCacheCurrentBudgetedBytes ( ) const

inline

Definition at line 84 of file ResourceProvider.h.

                                                        {
        return fResourceCache->currentBudgetedBytes();
    }

getResourceCacheLimit()

size_t skgpu::graphite::ResourceProvider::getResourceCacheLimit ( ) const

inline

Definition at line 83 of file ResourceProvider.h.

{ return fResourceCache->getMaxBudget(); }

onCreateBackendTexture()

virtual BackendTexture skgpu::graphite::ResourceProvider::onCreateBackendTexture ( SkISize  dimensions, const TextureInfo &    )

privatepure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

onDeleteBackendTexture()

virtual void skgpu::graphite::ResourceProvider::onDeleteBackendTexture ( const BackendTexture &  )

privatepure virtual

Implemented in skgpu::graphite::DawnResourceProvider, skgpu::graphite::MtlResourceProvider, and skgpu::graphite::VulkanResourceProvider.

proxyCache()

ProxyCache * skgpu::graphite::ResourceProvider::proxyCache ( )

inline

Definition at line 81 of file ResourceProvider.h.

{ return fResourceCache->proxyCache(); }

purgeResourcesNotUsedSince()

void skgpu::graphite::ResourceProvider::purgeResourcesNotUsedSince

(

StdSteadyClock::time_point

purgeTime

)

Definition at line 289 of file ResourceProvider.cpp.

                                                                                    {
    fResourceCache->purgeResourcesNotUsedSince(purgeTime);
}

Member Data Documentation

fResourceCache

sk_sp<ResourceCache> skgpu::graphite::ResourceProvider::fResourceCache

protected

Definition at line 117 of file ResourceProvider.h.

fSharedContext

SharedContext* skgpu::graphite::ResourceProvider::fSharedContext

protected

Definition at line 114 of file ResourceProvider.h.

---

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

• third_party/skia/src/gpu/graphite/ResourceProvider.h
• third_party/skia/src/gpu/graphite/ResourceProvider.cpp