GrAuditTrail Class Reference

#include <GrAuditTrail.h>

Classes
class	AutoCollectOps
class	AutoEnable
class	AutoManageOpsTask
struct	OpInfo

Public Member Functions
	GrAuditTrail ()
void	pushFrame (const char *framename)
void	addOp (const GrOp *, GrRenderTargetProxy::UniqueID proxyID)
void	opsCombined (const GrOp *consumer, const GrOp *consumed)
void	toJson (SkJSONWriter &writer) const
void	toJson (SkJSONWriter &writer, int clientID) const
bool	isEnabled ()
void	setEnabled (bool enabled)
void	setClientID (int clientID)
void	getBoundsByClientID (skia_private::TArray< OpInfo > *outInfo, int clientID)
void	getBoundsByOpsTaskID (OpInfo *outInfo, int opsTaskID)
void	fullReset ()

Static Public Attributes
static const int	kGrAuditTrailInvalidID = -1

Detailed Description

Definition at line 31 of file GrAuditTrail.h.

Constructor & Destructor Documentation

GrAuditTrail()

GrAuditTrail::GrAuditTrail ( )

inline

Definition at line 33 of file GrAuditTrail.h.

: fClientID(kGrAuditTrailInvalidID), fEnabled(false) {}

Member Function Documentation

addOp()

void GrAuditTrail::addOp	(	const GrOp *	op,
		GrRenderTargetProxy::UniqueID	proxyID
	)

Definition at line 15 of file GrAuditTrail.cpp.

                                                                            {
    SkASSERT(fEnabled);
    Op* auditOp = new Op;
    fOpPool.emplace_back(auditOp);
    auditOp->fName = op->name();
    auditOp->fBounds = op->bounds();
    auditOp->fClientID = kGrAuditTrailInvalidID;
    auditOp->fOpsTaskID = kGrAuditTrailInvalidID;
    auditOp->fChildID = kGrAuditTrailInvalidID;
 
    // consume the current stack trace if any
    auditOp->fStackTrace = fCurrentStackTrace;
    fCurrentStackTrace.clear();
 
    if (fClientID != kGrAuditTrailInvalidID) {
        auditOp->fClientID = fClientID;
        Ops** opsLookup = fClientIDLookup.find(fClientID);
        Ops* ops = nullptr;
        if (!opsLookup) {
            ops = new Ops;
            fClientIDLookup.set(fClientID, ops);
        } else {
            ops = *opsLookup;
        }
 
        ops->push_back(auditOp);
    }
 
    // Our algorithm doesn't bother to reorder inside of an OpNode so the ChildID will start at 0
    auditOp->fOpsTaskID = fOpsTask.size();
    auditOp->fChildID = 0;
 
    // We use the op pointer as a key to find the OpNode we are 'glomming' ops onto
    fIDLookup.set(op->uniqueID(), auditOp->fOpsTaskID);
    OpNode* opNode = new OpNode(proxyID);
    opNode->fBounds = op->bounds();
    opNode->fChildren.push_back(auditOp);
    fOpsTask.emplace_back(opNode);
}

fullReset()

void GrAuditTrail::fullReset

(

)

Definition at line 130 of file GrAuditTrail.cpp.

                             {
    SkASSERT(fEnabled);
    fOpsTask.clear();
    fIDLookup.reset();
    // free all client ops
    fClientIDLookup.foreach ([](const int&, Ops** ops) { delete *ops; });
    fClientIDLookup.reset();
    fOpPool.clear();  // must be last, frees all of the memory
}

getBoundsByClientID()

void GrAuditTrail::getBoundsByClientID	(	skia_private::TArray< OpInfo > *	outInfo,
		int	clientID
	)

Definition at line 103 of file GrAuditTrail.cpp.

                                                                            {
    Ops** opsLookup = fClientIDLookup.find(clientID);
    if (opsLookup) {
        // We track which oplistID we're currently looking at.  If it changes, then we need to push
        // back a new op info struct.  We happen to know that ops are in sequential order in the
        // oplist, otherwise we'd have to do more bookkeeping
        int currentOpsTaskID = kGrAuditTrailInvalidID;
        for (int i = 0; i < (*opsLookup)->size(); i++) {
            const Op* op = (**opsLookup)[i];
 
            // Because we will copy out all of the ops associated with a given op list id everytime
            // the id changes, we only have to update our struct when the id changes.
            if (kGrAuditTrailInvalidID == currentOpsTaskID || op->fOpsTaskID != currentOpsTaskID) {
                OpInfo& outOpInfo = outInfo->push_back();
 
                // copy out all of the ops so the client can display them even if they have a
                // different clientID
                this->copyOutFromOpsTask(&outOpInfo, op->fOpsTaskID);
            }
        }
    }
}

getBoundsByOpsTaskID()

void GrAuditTrail::getBoundsByOpsTaskID	(	OpInfo *	outInfo,
		int	opsTaskID
	)

Definition at line 126 of file GrAuditTrail.cpp.

                                                                      {
    this->copyOutFromOpsTask(outInfo, opsTaskID);
}

isEnabled()

bool GrAuditTrail::isEnabled ( )

inline

Definition at line 98 of file GrAuditTrail.h.

{ return fEnabled; }

opsCombined()

void GrAuditTrail::opsCombined	(	const GrOp *	consumer,
		const GrOp *	consumed
	)

Definition at line 55 of file GrAuditTrail.cpp.

                                                                         {
    // Look up the op we are going to glom onto
    int* indexPtr = fIDLookup.find(consumer->uniqueID());
    SkASSERT(indexPtr);
    int index = *indexPtr;
    SkASSERT(index < fOpsTask.size() && fOpsTask[index]);
    OpNode& consumerOp = *fOpsTask[index];
 
    // Look up the op which will be glommed
    int* consumedPtr = fIDLookup.find(consumed->uniqueID());
    SkASSERT(consumedPtr);
    int consumedIndex = *consumedPtr;
    SkASSERT(consumedIndex < fOpsTask.size() && fOpsTask[consumedIndex]);
    OpNode& consumedOp = *fOpsTask[consumedIndex];
 
    // steal all of consumed's ops
    for (int i = 0; i < consumedOp.fChildren.size(); i++) {
        Op* childOp = consumedOp.fChildren[i];
 
        // set the ids for the child op
        childOp->fOpsTaskID = index;
        childOp->fChildID = consumerOp.fChildren.size();
        consumerOp.fChildren.push_back(childOp);
    }
 
    // Update the bounds for the combineWith node
    consumerOp.fBounds = consumer->bounds();
 
    // remove the old node from our opsTask and clear the combinee's lookup
    // NOTE: because we can't change the shape of the oplist, we use a sentinel
    fOpsTask[consumedIndex].reset(nullptr);
    fIDLookup.remove(consumed->uniqueID());
}

pushFrame()

void GrAuditTrail::pushFrame ( const char *  framename )

inline

Definition at line 78 of file GrAuditTrail.h.

                                          {
        SkASSERT(fEnabled);
        fCurrentStackTrace.push_back(SkString(framename));
    }

setClientID()

void GrAuditTrail::setClientID ( int  clientID )

inline

Definition at line 101 of file GrAuditTrail.h.

{ fClientID = clientID; }

setEnabled()

void GrAuditTrail::setEnabled ( bool  enabled )

inline

Definition at line 99 of file GrAuditTrail.h.

{ fEnabled = enabled; }

toJson() [1/2]

void GrAuditTrail::toJson

(

SkJSONWriter &

writer

)

const

Definition at line 208 of file GrAuditTrail.cpp.

{}

toJson() [2/2]

void GrAuditTrail::toJson	(	SkJSONWriter &	writer,
		int	clientID
	)		const

Definition at line 209 of file GrAuditTrail.cpp.

{}

Member Data Documentation

kGrAuditTrailInvalidID

const int GrAuditTrail::kGrAuditTrailInvalidID = -1

static

Definition at line 121 of file GrAuditTrail.h.

---

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

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