skgpu::graphite::Resource Class Reference

#include <Resource.h>

Inheritance diagram for skgpu::graphite::Resource:

Classes
class	UniqueID

Public Member Functions
	Resource (const Resource &)=delete
	Resource (Resource &&)=delete
Resource &	operator= (const Resource &)=delete
Resource &	operator= (Resource &&)=delete
void	ref () const
void	unref () const
void	refCommandBuffer () const
void	unrefCommandBuffer () const
Ownership	ownership () const
skgpu::Budgeted	budgeted () const
size_t	gpuMemorySize () const
UniqueID	uniqueID () const
virtual const char *	getResourceType () const =0
std::string	getLabel () const
void	setLabel (std::string_view label)
bool	wasDestroyed () const
const GraphiteResourceKey &	key () const
void	setKey (const GraphiteResourceKey &key)
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
virtual void	prepareForReturnToCache (const std::function< void()> &takeRef)

Protected Member Functions
	Resource (const SharedContext *, Ownership, skgpu::Budgeted, size_t gpuMemorySize, bool commandBufferRefsAsUsageRefs=false)
virtual	~Resource ()
const SharedContext *	sharedContext () const
virtual void	onDumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump, const char *dumpName) const
void	setDeleteASAP ()

Private Member Functions
virtual void	freeGpuData ()=0
virtual void	invokeReleaseProc ()
virtual void	setBackendLabel (char const *label)

Friends
class	ProxyCache

Detailed Description

Base class for objects that can be kept in the ResourceCache.

Definition at line 37 of file Resource.h.

Constructor & Destructor Documentation

Resource() [1/3]

skgpu::graphite::Resource::Resource ( const Resource &  )

delete

Resource() [2/3]

skgpu::graphite::Resource::Resource ( Resource &&  )

delete

Resource() [3/3]

skgpu::graphite::Resource::Resource ( const SharedContext *  sharedContext, Ownership  ownership, skgpu::Budgeted  budgeted, size_t  gpuMemorySize, bool  commandBufferRefsAsUsageRefs = false  )

protected

Definition at line 26 of file Resource.cpp.

        : fSharedContext(sharedContext)
        , fUsageRefCnt(1)
        , fCommandBufferRefCnt(0)
        , fCacheRefCnt(0)
        , fCommandBufferRefsAsUsageRefs(commandBufferRefsAsUsageRefs)
        , fOwnership(ownership)
        , fGpuMemorySize(gpuMemorySize)
        , fBudgeted(budgeted)
        , fUniqueID(create_unique_id()) {
    // If we don't own the resource that must mean its wrapped in a client object. Thus we should
    // not be budgeted
    SkASSERT(fOwnership == Ownership::kOwned || fBudgeted == skgpu::Budgeted::kNo);
}

~Resource()

skgpu::graphite::Resource::~Resource ( )

protectedvirtual

Definition at line 45 of file Resource.cpp.

                    {
    // The cache should have released or destroyed this resource.
    SkASSERT(this->wasDestroyed());
}

Member Function Documentation

budgeted()

skgpu::Budgeted skgpu::graphite::Resource::budgeted ( ) const

inline

Definition at line 100 of file Resource.h.

{ return fBudgeted; }

dumpMemoryStatistics()

void skgpu::graphite::Resource::dumpMemoryStatistics

(

SkTraceMemoryDump *

traceMemoryDump

)

const

Definition at line 95 of file Resource.cpp.

                                                                            {
    if (this->ownership() == Ownership::kWrapped && !traceMemoryDump->shouldDumpWrappedObjects()) {
        return;
    }
 
    if (this->budgeted() == skgpu::Budgeted::kNo &&
        !traceMemoryDump->shouldDumpUnbudgetedObjects()) {
        return;
    }
 
    size_t size = this->gpuMemorySize();
 
    // Avoid dumping objects without a size (e.g. Samplers, pipelines, etc).
    // TODO: Would a client ever actually want to see all of this? Wouldn't be hard to add it as an
    // option.
    if (size == 0) {
        return;
    }
 
    SkString resourceName("skia/gpu_resources/resource_");
    resourceName.appendU32(this->uniqueID().asUInt());
 
    traceMemoryDump->dumpNumericValue(resourceName.c_str(), "size", "bytes", size);
    traceMemoryDump->dumpStringValue(resourceName.c_str(), "type", this->getResourceType());
    traceMemoryDump->dumpStringValue(resourceName.c_str(), "label", this->getLabel().c_str());
    if (this->isPurgeable()) {
        traceMemoryDump->dumpNumericValue(resourceName.c_str(), "purgeable_size", "bytes", size);
    }
    if (traceMemoryDump->shouldDumpWrappedObjects()) {
        traceMemoryDump->dumpWrappedState(resourceName.c_str(),
                                          this->ownership() == Ownership::kWrapped);
    }
    if (traceMemoryDump->shouldDumpUnbudgetedObjects()) {
        traceMemoryDump->dumpBudgetedState(resourceName.c_str(),
                                           this->budgeted() == skgpu::Budgeted::kYes);
    }
 
    this->onDumpMemoryStatistics(traceMemoryDump, resourceName.c_str());
 
    // TODO: implement this to report real gpu id backing the resource. Will be virtual implemented
    // by backend specific resource subclasses.
    //this->setMemoryBacking(traceMemoryDump, resourceName);
}

freeGpuData()

virtual void skgpu::graphite::Resource::freeGpuData ( )

privatepure virtual

Implemented in skgpu::graphite::VulkanBuffer.

getLabel()

std::string skgpu::graphite::Resource::getLabel ( ) const

inline

Definition at line 132 of file Resource.h.

{ return fLabel; }

getResourceType()

virtual const char * skgpu::graphite::Resource::getResourceType ( ) const

pure virtual

Implemented in skgpu::graphite::Buffer, skgpu::graphite::ComputePipeline, skgpu::graphite::GraphicsPipeline, skgpu::graphite::MtlBlitCommandEncoder, skgpu::graphite::MtlComputeCommandEncoder, skgpu::graphite::MtlRenderCommandEncoder, skgpu::graphite::Sampler, skgpu::graphite::Texture, skgpu::graphite::VulkanDescriptorSet, skgpu::graphite::VulkanFramebuffer, skgpu::graphite::VulkanRenderPass, skgpu::graphite::VulkanYcbcrConversion, and skgpu::graphite::TestResource.

gpuMemorySize()

size_t skgpu::graphite::Resource::gpuMemorySize ( ) const

inline

Definition at line 104 of file Resource.h.

{ return fGpuMemorySize; }

invokeReleaseProc()

virtual void skgpu::graphite::Resource::invokeReleaseProc ( )

inlineprivatevirtual

Reimplemented in skgpu::graphite::Texture.

Definition at line 211 of file Resource.h.

{}

key()

const GraphiteResourceKey & skgpu::graphite::Resource::key ( ) const

inline

Definition at line 156 of file Resource.h.

{ return fKey; }

onDumpMemoryStatistics()

virtual void skgpu::graphite::Resource::onDumpMemoryStatistics ( SkTraceMemoryDump *  traceMemoryDump, const char *  dumpName  ) const

inlineprotectedvirtual

Reimplemented in skgpu::graphite::Texture.

Definition at line 192 of file Resource.h.

                                                                    {}

operator=() [1/2]

Resource & skgpu::graphite::Resource::operator= ( const Resource &  )

delete

operator=() [2/2]

Resource & skgpu::graphite::Resource::operator= ( Resource &&  )

delete

ownership()

Ownership skgpu::graphite::Resource::ownership ( ) const

inline

Definition at line 98 of file Resource.h.

{ return fOwnership; }

prepareForReturnToCache()

virtual void skgpu::graphite::Resource::prepareForReturnToCache ( const std::function< void()> &  takeRef )

inlinevirtual

If the resource has a non-shareable key then this gives the resource subclass an opportunity to prepare itself to re-enter the cache. The ResourceCache extends its privilege to take the first UsageRef to this function via takeRef. If takeRef is called this resource will not immediately enter the cache but will be re-reprocessed with the Usage Ref count again reaches zero.

Definition at line 173 of file Resource.h.

{}

ref()

void skgpu::graphite::Resource::ref ( ) const

inline

Definition at line 45 of file Resource.h.

                     {
        // Only the cache should be able to add the first usage ref to a resource.
        SkASSERT(this->hasUsageRef());
        // No barrier required.
        (void)fUsageRefCnt.fetch_add(+1, std::memory_order_relaxed);
    }

refCommandBuffer()

void skgpu::graphite::Resource::refCommandBuffer ( ) const

inline

Definition at line 70 of file Resource.h.

                                  {
        if (fCommandBufferRefsAsUsageRefs) {
            return this->ref();
        }
        // No barrier required.
        (void)fCommandBufferRefCnt.fetch_add(+1, std::memory_order_relaxed);
    }

setBackendLabel()

virtual void skgpu::graphite::Resource::setBackendLabel ( char const *  label )

inlineprivatevirtual

Definition at line 229 of file Resource.h.

{}

setDeleteASAP()

void skgpu::graphite::Resource::setDeleteASAP ( )

inlineprotected

Definition at line 202 of file Resource.h.

{ fDeleteASAP = DeleteASAP::kYes; }

setKey()

void skgpu::graphite::Resource::setKey ( const GraphiteResourceKey &  key )

inline

Definition at line 158 of file Resource.h.

                                                {
        SkASSERT(key.shareable() == Shareable::kNo || this->budgeted() == skgpu::Budgeted::kYes);
        fKey = key;
    }

setLabel()

void skgpu::graphite::Resource::setLabel ( std::string_view  label )

inline

Definition at line 136 of file Resource.h.

                                        {
        fLabel = label;
 
        if (!fLabel.empty()) {
            const std::string fullLabel = "Skia_" + fLabel;
            this->setBackendLabel(fullLabel.c_str());
        }
    }

sharedContext()

const SharedContext * skgpu::graphite::Resource::sharedContext ( ) const

inlineprotected

Definition at line 189 of file Resource.h.

{ return fSharedContext; }

uniqueID()

UniqueID skgpu::graphite::Resource::uniqueID ( ) const

inline

Definition at line 123 of file Resource.h.

{ return fUniqueID; }

unref()

void skgpu::graphite::Resource::unref ( ) const

inline

Definition at line 53 of file Resource.h.

                       {
        bool shouldFree = false;
        {
            SkAutoMutexExclusive locked(fUnrefMutex);
            SkASSERT(this->hasUsageRef());
            // A release here acts in place of all releases we "should" have been doing in ref().
            if (1 == fUsageRefCnt.fetch_add(-1, std::memory_order_acq_rel)) {
                shouldFree = this->notifyARefIsZero(LastRemovedRef::kUsage);
            }
        }
        if (shouldFree) {
            Resource* mutableThis = const_cast<Resource*>(this);
            mutableThis->internalDispose();
        }
    }

unrefCommandBuffer()

void skgpu::graphite::Resource::unrefCommandBuffer ( ) const

inline

Definition at line 79 of file Resource.h.

                                    {
        if (fCommandBufferRefsAsUsageRefs) {
            return this->unref();
        }
        bool shouldFree = false;
        {
            SkAutoMutexExclusive locked(fUnrefMutex);
            SkASSERT(this->hasCommandBufferRef());
            // A release here acts in place of all releases we "should" have been doing in ref().
            if (1 == fCommandBufferRefCnt.fetch_add(-1, std::memory_order_acq_rel)) {
                shouldFree = this->notifyARefIsZero(LastRemovedRef::kCommandBuffer);
            }
        }
        if (shouldFree) {
            Resource* mutableThis = const_cast<Resource*>(this);
            mutableThis->internalDispose();
        }
    }

wasDestroyed()

bool skgpu::graphite::Resource::wasDestroyed ( ) const

inline

Definition at line 154 of file Resource.h.

{ return fSharedContext == nullptr; }

Friends And Related Function Documentation

ProxyCache

friend class ProxyCache

friend

Definition at line 205 of file Resource.h.

---

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

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