GrResourceAllocator Class Reference

#include <GrResourceAllocator.h>

Public Types
enum class	ActualUse : bool { kNo = false , kYes = true }
enum class	AllowRecycling : bool { kNo = false , kYes = true }

Public Member Functions
	GrResourceAllocator (GrDirectContext *dContext)
	~GrResourceAllocator ()
unsigned int	curOp () const
void	incOps ()
void	addInterval (GrSurfaceProxy *, unsigned int start, unsigned int end, ActualUse actualUse, AllowRecycling SkDEBUGCODE(, bool isDirectDstRead=false))
bool	failedInstantiation () const
bool	planAssignment ()
bool	makeBudgetHeadroom ()
void	reset ()
bool	assign ()

Detailed Description

Definition at line 78 of file GrResourceAllocator.h.

Member Enumeration Documentation

ActualUse

enum class GrResourceAllocator::ActualUse : bool

strong

Indicates whether a given call to addInterval represents an actual usage of the provided proxy. This is mainly here to accommodate deferred proxies attached to opsTasks. In that case we need to create an extra long interval for them (due to the upload) but don't want to count that usage/reference towards the proxy's recyclability.

Enumerator
kNo
kYes

Definition at line 93 of file GrResourceAllocator.h.

                         : bool {
        kNo  = false,
        kYes = true
    };

AllowRecycling

enum class GrResourceAllocator::AllowRecycling : bool

strong

Indicates whether we allow a gpu texture assigned to a register to be recycled or not. This comes up when dealing with with Vulkan Secondary CommandBuffers since offscreens sampled into the scb will all be drawn before being sampled in the scb. This is because the scb will get submitted in a later command buffer. Thus offscreens cannot share an allocation or later reuses will overwrite earlier ones.

Enumerator
kNo
kYes

Definition at line 104 of file GrResourceAllocator.h.

                              : bool {
        kNo  = false,
        kYes = true
    };

Constructor & Destructor Documentation

GrResourceAllocator()

GrResourceAllocator::GrResourceAllocator ( GrDirectContext *  dContext )

inline

Definition at line 80 of file GrResourceAllocator.h.

            : fDContext(dContext) {}

~GrResourceAllocator()

GrResourceAllocator::~GrResourceAllocator

(

)

Definition at line 41 of file GrResourceAllocator.cpp.

                                          {
    SkASSERT(fFailedInstantiation || fIntvlList.empty());
    SkASSERT(fActiveIntvls.empty());
    SkASSERT(!fIntvlHash.count());
}

Member Function Documentation

addInterval()

void GrResourceAllocator::addInterval	(	GrSurfaceProxy *	,
		unsigned int	start,
		unsigned int	end,
		ActualUse	actualUse,
		AllowRecycling	SkDEBUGCODE, bool isDirectDstRead=false
	)

Definition at line 47 of file GrResourceAllocator.cpp.

                                                                           {
    SkASSERT(start <= end);
    SkASSERT(!fAssigned);  // We shouldn't be adding any intervals after (or during) assignment
 
    if (proxy->canSkipResourceAllocator()) {
        return;
    }
 
    // If a proxy is read only it must refer to a texture with specific content that cannot be
    // recycled. We don't need to assign a texture to it and no other proxy can be instantiated
    // with the same texture.
    if (proxy->readOnly()) {
        auto resourceProvider = fDContext->priv().resourceProvider();
        if (proxy->isLazy() && !proxy->priv().doLazyInstantiation(resourceProvider)) {
            fFailedInstantiation = true;
        } else {
            // Since we aren't going to add an interval we won't revisit this proxy in assign(). So
            // must already be instantiated or it must be a lazy proxy that we instantiated above.
            SkASSERT(proxy->isInstantiated());
        }
        return;
    }
    uint32_t proxyID = proxy->uniqueID().asUInt();
    if (Interval** intvlPtr = fIntvlHash.find(proxyID)) {
        // Revise the interval for an existing use
        Interval* intvl = *intvlPtr;
#ifdef SK_DEBUG
        if (0 == start && 0 == end) {
            // This interval is for the initial upload to a deferred proxy. Due to the vagaries
            // of how deferred proxies are collected they can appear as uploads multiple times
            // in a single opsTasks' list and as uploads in several opsTasks.
            SkASSERT(0 == intvl->start());
        } else if (isDirectDstRead) {
            // Direct reads from the render target itself should occur w/in the existing
            // interval
            SkASSERT(intvl->start() <= start && intvl->end() >= end);
        } else {
            SkASSERT(intvl->end() <= start && intvl->end() <= end);
        }
#endif
        if (ActualUse::kYes == actualUse) {
            intvl->addUse();
        }
        if (allowRecycling == AllowRecycling::kNo) {
            // In this case, a preexisting interval is made non-reuseable since its proxy is sampled
            // into a secondary command buffer.
            intvl->disallowRecycling();
        }
        intvl->extendEnd(end);
        return;
    }
    Interval* newIntvl = fInternalAllocator.make<Interval>(proxy, start, end);
 
    if (ActualUse::kYes == actualUse) {
        newIntvl->addUse();
    }
    if (allowRecycling == AllowRecycling::kNo) {
        newIntvl->disallowRecycling();
    }
    fIntvlList.insertByIncreasingStart(newIntvl);
    fIntvlHash.set(proxyID, newIntvl);
}

assign()

bool GrResourceAllocator::assign

(

)

Definition at line 423 of file GrResourceAllocator.cpp.

                                 {
    if (fFailedInstantiation) {
        return false;
    }
    SkASSERT(fPlanned && !fAssigned);
    SkDEBUGCODE(fAssigned = true;)
    auto resourceProvider = fDContext->priv().resourceProvider();
    while (Interval* cur = fFinishedIntvls.popHead()) {
        if (fFailedInstantiation) {
            break;
        }
        if (cur->proxy()->isInstantiated()) {
            continue;
        }
        if (cur->proxy()->isLazy()) {
            fFailedInstantiation = !cur->proxy()->priv().doLazyInstantiation(resourceProvider);
            continue;
        }
        Register* r = cur->getRegister();
        SkASSERT(r);
        fFailedInstantiation = !r->instantiateSurface(cur->proxy(), resourceProvider);
    }
    return !fFailedInstantiation;
}

curOp()

unsigned int GrResourceAllocator::curOp ( ) const

inline

Definition at line 85 of file GrResourceAllocator.h.

{ return fNumOps; }

failedInstantiation()

bool GrResourceAllocator::failedInstantiation ( ) const

inline

Definition at line 114 of file GrResourceAllocator.h.

{ return fFailedInstantiation; }

incOps()

void GrResourceAllocator::incOps ( )

inline

Definition at line 86 of file GrResourceAllocator.h.

{ fNumOps++; }

makeBudgetHeadroom()

bool GrResourceAllocator::makeBudgetHeadroom

(

)

Definition at line 383 of file GrResourceAllocator.cpp.

                                             {
    SkASSERT(fPlanned);
    SkASSERT(!fFailedInstantiation);
    size_t additionalBytesNeeded = 0;
    for (Interval* cur = fFinishedIntvls.peekHead(); cur; cur = cur->next()) {
        GrSurfaceProxy* proxy = cur->proxy();
        if (skgpu::Budgeted::kNo == proxy->isBudgeted() || proxy->isInstantiated()) {
            continue;
        }
 
        // N.B Fully-lazy proxies were already instantiated in planAssignment
        if (proxy->isLazy()) {
            additionalBytesNeeded += proxy->gpuMemorySize();
        } else {
            Register* r = cur->getRegister();
            SkASSERT(r);
            if (!r->accountedForInBudget() && !r->existingSurface()) {
                additionalBytesNeeded += proxy->gpuMemorySize();
            }
            r->setAccountedForInBudget();
        }
    }
    return fDContext->priv().getResourceCache()->purgeToMakeHeadroom(additionalBytesNeeded);
}

planAssignment()

bool GrResourceAllocator::planAssignment

(

)

Definition at line 336 of file GrResourceAllocator.cpp.

                                         {
    fIntvlHash.reset(); // we don't need the interval hash anymore
 
    SkASSERT(!fPlanned && !fAssigned);
    SkDEBUGCODE(fPlanned = true;)
 
#if GR_ALLOCATION_SPEW
    SkDebugf("assigning %d ops\n", fNumOps);
    this->dumpIntervals();
#endif
 
    auto resourceProvider = fDContext->priv().resourceProvider();
    while (Interval* cur = fIntvlList.popHead()) {
        this->expire(cur->start());
        fActiveIntvls.insertByIncreasingEnd(cur);
 
        // Already-instantiated proxies and lazy proxies don't use registers.
        if (cur->proxy()->isInstantiated()) {
            continue;
        }
 
        // Instantiate fully-lazy proxies immediately. Ignore other lazy proxies at this stage.
        if (cur->proxy()->isLazy()) {
            if (cur->proxy()->isFullyLazy()) {
                fFailedInstantiation = !cur->proxy()->priv().doLazyInstantiation(resourceProvider);
                if (fFailedInstantiation) {
                    break;
                }
            }
            continue;
        }
 
        Register* r = this->findOrCreateRegisterFor(cur->proxy());
#if GR_ALLOCATION_SPEW
        SkDebugf("Assigning register %d to %d\n",
             r->uniqueID(),
             cur->proxy()->uniqueID().asUInt());
#endif
        SkASSERT(!cur->proxy()->peekSurface());
        cur->setRegister(r);
    }
 
    // expire all the remaining intervals to drain the active interval list
    this->expire(std::numeric_limits<unsigned int>::max());
    return !fFailedInstantiation;
}

reset()

void GrResourceAllocator::reset

(

)

Definition at line 408 of file GrResourceAllocator.cpp.

                                {
    // NOTE: We do not reset the failedInstantiation flag because we currently do not attempt
    // to recover from failed instantiations. The user is responsible for checking this flag and
    // bailing early.
    SkDEBUGCODE(fPlanned = false;)
    SkDEBUGCODE(fAssigned = false;)
    SkASSERT(fActiveIntvls.empty());
    fFinishedIntvls = IntervalList();
    fIntvlList = IntervalList();
    fIntvlHash.reset();
    fUniqueKeyRegisters.reset();
    fFreePool.reset();
    fInternalAllocator.reset();
}

---

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

• third_party/skia/src/gpu/ganesh/GrResourceAllocator.h
• third_party/skia/src/gpu/ganesh/GrResourceAllocator.cpp