skgpu::graphite::GlobalCache Class Reference

#include <GlobalCache.h>

Public Member Functions
	GlobalCache ()
	~GlobalCache ()
void	deleteResources ()
sk_sp< GraphicsPipeline >	findGraphicsPipeline (const UniqueKey &) SK_EXCLUDES(fSpinLock)
sk_sp< GraphicsPipeline >	addGraphicsPipeline (const UniqueKey &, sk_sp< GraphicsPipeline >) SK_EXCLUDES(fSpinLock)
sk_sp< ComputePipeline >	findComputePipeline (const UniqueKey &) SK_EXCLUDES(fSpinLock)
sk_sp< ComputePipeline >	addComputePipeline (const UniqueKey &, sk_sp< ComputePipeline >) SK_EXCLUDES(fSpinLock)
void	addStaticResource (sk_sp< Resource >) SK_EXCLUDES(fSpinLock)

Detailed Description

GlobalCache holds GPU resources that should be shared by every Recorder. The common requirement of these resources are they are static/read-only, have long lifetimes, and are likely to be used by multiple Recorders. The canonical example of this are pipelines.

GlobalCache is thread safe, but intentionally splits queries and storing operations so that they are not atomic. The pattern is to query for a resource, which has a high likelihood of a cache hit. If it's not found, the Recorder creates the resource on its own, without locking the GlobalCache. After the resource is created, it is added to the GlobalCache, atomically returning the winning Resource in the event of a race between Recorders for the same UniqueKey.

Definition at line 37 of file GlobalCache.h.

Constructor & Destructor Documentation

GlobalCache()

skgpu::graphite::GlobalCache::GlobalCache

(

)

Definition at line 17 of file GlobalCache.cpp.

        : fGraphicsPipelineCache(256)  // TODO: find a good value for these limits
        , fComputePipelineCache(256) {}

~GlobalCache()

skgpu::graphite::GlobalCache::~GlobalCache

(

)

Definition at line 21 of file GlobalCache.cpp.

                          {
    // These should have been cleared out earlier by deleteResources().
    SkDEBUGCODE(SkAutoSpinlock lock{ fSpinLock });
    SkASSERT(fGraphicsPipelineCache.count() == 0);
    SkASSERT(fComputePipelineCache.count() == 0);
    SkASSERT(fStaticResource.size() == 0);
}

Member Function Documentation

addComputePipeline()

sk_sp< ComputePipeline > skgpu::graphite::GlobalCache::addComputePipeline	(	const UniqueKey &	key,
		sk_sp< ComputePipeline >	pipeline
	)

Definition at line 87 of file GlobalCache.cpp.

                                                                                        {
    SkAutoSpinlock lock{fSpinLock};
    sk_sp<ComputePipeline>* entry = fComputePipelineCache.find(key);
    if (!entry) {
        entry = fComputePipelineCache.insert(key, std::move(pipeline));
    }
    return *entry;
}

addGraphicsPipeline()

sk_sp< GraphicsPipeline > skgpu::graphite::GlobalCache::addGraphicsPipeline	(	const UniqueKey &	key,
		sk_sp< GraphicsPipeline >	pipeline
	)

Definition at line 44 of file GlobalCache.cpp.

                                                                                           {
    SkAutoSpinlock lock{fSpinLock};
 
    sk_sp<GraphicsPipeline>* entry = fGraphicsPipelineCache.find(key);
    if (!entry) {
        // No equivalent pipeline was stored in the cache between a previous call to
        // findGraphicsPipeline() that returned null (triggering the pipeline creation) and this
        // later adding to the cache.
        entry = fGraphicsPipelineCache.insert(key, std::move(pipeline));
    } // else there was a race creating the same pipeline and this thread lost, so return the winner
    return *entry;
}

addStaticResource()

void skgpu::graphite::GlobalCache::addStaticResource

(

sk_sp< Resource >

resource

)

Definition at line 97 of file GlobalCache.cpp.

                                                            {
    SkAutoSpinlock lock{fSpinLock};
    fStaticResource.push_back(std::move(resource));
}

deleteResources()

void skgpu::graphite::GlobalCache::deleteResources

(

)

Definition at line 29 of file GlobalCache.cpp.

                                  {
    SkAutoSpinlock lock{ fSpinLock };
 
    fGraphicsPipelineCache.reset();
    fComputePipelineCache.reset();
    fStaticResource.clear();
}

findComputePipeline()

sk_sp< ComputePipeline > skgpu::graphite::GlobalCache::findComputePipeline

(

const UniqueKey &

key

)

Definition at line 81 of file GlobalCache.cpp.

                                                                            {
    SkAutoSpinlock lock{fSpinLock};
    sk_sp<ComputePipeline>* entry = fComputePipelineCache.find(key);
    return entry ? *entry : nullptr;
}

findGraphicsPipeline()

sk_sp< GraphicsPipeline > skgpu::graphite::GlobalCache::findGraphicsPipeline

(

const UniqueKey &

key

)

Definition at line 37 of file GlobalCache.cpp.

                                                                              {
    SkAutoSpinlock lock{fSpinLock};
 
    sk_sp<GraphicsPipeline>* entry = fGraphicsPipelineCache.find(key);
    return entry ? *entry : nullptr;
}

---

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

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