fCurrentStackTrace.push_back(SkString(framename));
}
- void addOp(const GrOp*,
- GrGpuResource::UniqueID resourceID,
- GrRenderTargetProxy::UniqueID proxyID);
+ void addOp(const GrOp*, GrRenderTargetProxy::UniqueID proxyID);
void opsCombined(const GrOp* consumer, const GrOp* consumed);
// We could just return our internal bookkeeping struct if copying the data out becomes
// a performance issue, but until then its nice to decouple
struct OpInfo {
- // Will the resourceID comparison yield the same decision as the proxyID comparison?
- bool sameDecision(GrGpuResource::UniqueID resourceUniqueID,
- GrSurfaceProxy::UniqueID proxyUniqueID) const {
- return (fResourceUniqueID == resourceUniqueID) ==
- (fProxyUniqueID == proxyUniqueID);
- }
-
struct Op {
int fClientID;
SkRect fBounds;
};
SkRect fBounds;
- // MDB TODO: remove fResourceUniqueID
- GrGpuResource::UniqueID fResourceUniqueID;
GrSurfaceProxy::UniqueID fProxyUniqueID;
SkTArray<Op> fOps;
};
typedef SkTArray<Op*> Ops;
struct OpNode {
- OpNode(const GrGpuResource::UniqueID& resourceID, const GrSurfaceProxy::UniqueID& proxyID)
- : fResourceUniqueID(resourceID)
- , fProxyUniqueID(proxyID) {
- }
+ OpNode(const GrSurfaceProxy::UniqueID& proxyID) : fProxyUniqueID(proxyID) { }
SkString toJson() const;
SkRect fBounds;
Ops fChildren;
- const GrGpuResource::UniqueID fResourceUniqueID;
const GrSurfaceProxy::UniqueID fProxyUniqueID;
};
typedef SkTArray<std::unique_ptr<OpNode>, true> OpList;
#define GR_AUDIT_TRAIL_RESET(audit_trail) \
//GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, fullReset);
-#define GR_AUDIT_TRAIL_ADD_OP(audit_trail, op, resource_id, proxy_id) \
- GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, addOp, op, resource_id, proxy_id);
+#define GR_AUDIT_TRAIL_ADD_OP(audit_trail, op, proxy_id) \
+ GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, addOp, op, proxy_id);
#define GR_AUDIT_TRAIL_OPS_RESULT_COMBINED(audit_trail, combineWith, op) \
GR_AUDIT_TRAIL_INVOKE_GUARD(audit_trail, opsCombined, combineWith, op);
const int GrAuditTrail::kGrAuditTrailInvalidID = -1;
-void GrAuditTrail::addOp(const GrOp* op,
- GrGpuResource::UniqueID resourceID,
- GrRenderTargetProxy::UniqueID proxyID) {
+void GrAuditTrail::addOp(const GrOp* op, GrRenderTargetProxy::UniqueID proxyID) {
SkASSERT(fEnabled);
Op* auditOp = new Op;
fOpPool.emplace_back(auditOp);
// We use the op pointer as a key to find the OpNode we are 'glomming' ops onto
fIDLookup.set(op->uniqueID(), auditOp->fOpListID);
- OpNode* opNode = new OpNode(resourceID, proxyID);
+ OpNode* opNode = new OpNode(proxyID);
opNode->fBounds = op->bounds();
opNode->fChildren.push_back(auditOp);
fOpList.emplace_back(opNode);
const OpNode* bn = fOpList[opListID].get();
SkASSERT(bn);
outOpInfo->fBounds = bn->fBounds;
- outOpInfo->fResourceUniqueID = bn->fResourceUniqueID;
outOpInfo->fProxyUniqueID = bn->fProxyUniqueID;
for (int j = 0; j < bn->fChildren.count(); j++) {
OpInfo::Op& outOp = outOpInfo->fOps.push_back();
SkString GrAuditTrail::OpNode::toJson() const {
SkString json;
json.append("{");
- json.appendf("\"ResourceID\": \"%u\",", fResourceUniqueID.asUInt());
json.appendf("\"ProxyID\": \"%u\",", fProxyUniqueID.asUInt());
skrect_to_json(&json, "Bounds", fBounds);
JsonifyTArray(&json, "Ops", fChildren, true);
// but need to be flushed anyway. Closing such GrOpLists here will mean new
// GrOpLists will be created to replace them if the SkGpuDevice(s) write to them again.
fOpLists[i]->makeClosed(*fContext->caps());
- SkDEBUGCODE(fOpLists[i]->validateTargetsSingleRenderTarget());
}
#ifdef ENABLE_MDB
continue; // Odd - but not a big deal
}
opList->makeClosed(*fContext->caps());
- SkDEBUGCODE(opList->validateTargetsSingleRenderTarget());
opList->prepareOps(&fFlushState);
if (!opList->executeOps(&fFlushState)) {
continue; // This is bad
}
}
- for (int i = 0; i < fOpLists.count(); ++i) {
- fOpLists[i]->prepareOps(&fFlushState);
- }
-
#if 0
// Enable this to print out verbose GrOp information
for (int i = 0; i < fOpLists.count(); ++i) {
}
#endif
+ for (int i = 0; i < fOpLists.count(); ++i) {
+ if (!fOpLists[i]->instantiate(fContext->resourceProvider())) {
+ fOpLists[i] = nullptr;
+ continue;
+ }
+
+ fOpLists[i]->prepareOps(&fFlushState);
+ }
+
// Upload all data to the GPU
fFlushState.preIssueDraws();
for (int i = 0; i < fOpLists.count(); ++i) {
+ if (!fOpLists[i]) {
+ continue;
+ }
+
if (fOpLists[i]->executeOps(&fFlushState)) {
flushed = true;
}
}
}
+bool GrOpList::instantiate(GrResourceProvider* resourceProvider) {
+ return SkToBool(fTarget.get()->instantiate(resourceProvider));
+}
+
void GrOpList::reset() {
if (fTarget.get() && this == fTarget.get()->getLastOpList()) {
fTarget.get()->setLastOpList(nullptr);
class GrCaps;
class GrOpFlushState;
class GrRenderTargetOpList;
+class GrResourceProvider;
class GrSurfaceProxy;
class GrTextureOpList;
GrOpList(GrSurfaceProxy*, GrAuditTrail*);
~GrOpList() override;
- // These two methods are invoked as flush time
+ // These three methods are invoked at flush time
+ bool instantiate(GrResourceProvider* resourceProvider);
virtual void prepareOps(GrOpFlushState* flushState) = 0;
virtual bool executeOps(GrOpFlushState* flushState) = 0;
*/
SkDEBUGCODE(virtual void dump() const;)
- SkDEBUGCODE(virtual void validateTargetsSingleRenderTarget() const = 0;)
-
SkDEBUGCODE(virtual int numOps() const = 0;)
SkDEBUGCODE(virtual int numClips() const { return 0; })
}
}
}
-
-void GrRenderTargetOpList::validateTargetsSingleRenderTarget() const {
- GrRenderTarget* rt = nullptr;
- for (int i = 0; i < fRecordedOps.count(); ++i) {
- if (!fRecordedOps[i].fOp) {
- continue; // combined forward
- }
-
- if (!rt) {
- rt = fRecordedOps[i].fRenderTarget.get();
- } else {
- SkASSERT(fRecordedOps[i].fRenderTarget.get() == rt);
- }
- }
-}
#endif
void GrRenderTargetOpList::prepareOps(GrOpFlushState* flushState) {
+ SkASSERT(fTarget.get()->priv().peekRenderTarget());
SkASSERT(this->isClosed());
// Loop over the ops that haven't yet been prepared.
for (int i = 0; i < fRecordedOps.count(); ++i) {
if (fRecordedOps[i].fOp) {
- GrOpFlushState::DrawOpArgs opArgs;
- if (fRecordedOps[i].fRenderTarget) {
- opArgs = {
- fRecordedOps[i].fRenderTarget.get(),
- fRecordedOps[i].fAppliedClip,
- fRecordedOps[i].fDstTexture
- };
- }
+ GrOpFlushState::DrawOpArgs opArgs = {
+ fTarget.get()->priv().peekRenderTarget(),
+ fRecordedOps[i].fAppliedClip,
+ fRecordedOps[i].fDstTexture
+ };
+
flushState->setDrawOpArgs(&opArgs);
fRecordedOps[i].fOp->prepare(flushState);
flushState->setDrawOpArgs(nullptr);
return false;
}
-#ifdef SK_DEBUG
- GrSurface* target = fTarget.get()->instantiate(flushState->resourceProvider());
- if (!target) {
- return false;
- }
- const GrRenderTarget* currentRenderTarget = target->asRenderTarget();
- SkASSERT(currentRenderTarget);
-#endif
+ SkASSERT(fTarget.get()->priv().peekRenderTarget());
std::unique_ptr<GrGpuCommandBuffer> commandBuffer = create_command_buffer(flushState->gpu());
flushState->setCommandBuffer(commandBuffer.get());
continue;
}
- SkASSERT(fRecordedOps[i].fRenderTarget.get() == currentRenderTarget);
-
if (fRecordedOps[i].fOp->needsCommandBufferIsolation()) {
// This op is a special snowflake and must occur between command buffers
// TODO: make this go through the command buffer
}
GrOpFlushState::DrawOpArgs opArgs {
- fRecordedOps[i].fRenderTarget.get(),
+ fTarget.get()->priv().peekRenderTarget(),
fRecordedOps[i].fAppliedClip,
fRecordedOps[i].fDstTexture
};
GrRenderTargetContext* renderTargetContext,
GrAppliedClip* clip,
const DstTexture* dstTexture) {
- GrRenderTarget* renderTarget = renderTargetContext->accessRenderTarget();
- if (!renderTarget) {
- SkASSERT(false);
- return nullptr;
- }
-
+ SkASSERT(fTarget.get());
const GrCaps* caps = renderTargetContext->caps();
-#ifdef SK_DEBUG
- if (!fRecordedOps.empty()) {
- GrRenderTargetOpList::RecordedOp& back = fRecordedOps.back();
- SkASSERT(back.fRenderTarget == renderTarget);
- }
-#endif
-
// A closed GrOpList should never receive new/more ops
SkASSERT(!this->isClosed());
// 1) check every op
// 2) intersect with something
// 3) find a 'blocker'
- GR_AUDIT_TRAIL_ADD_OP(fAuditTrail, op.get(), renderTarget->uniqueID(),
+ GR_AUDIT_TRAIL_ADD_OP(fAuditTrail, op.get(),
renderTargetContext->asRenderTargetProxy()->uniqueID());
GrOP_INFO("opList: %d Recording (%s, opID: %u)\n"
"\tBounds [L: %.2f, T: %.2f R: %.2f B: %.2f]\n",
GrOP_INFO("\tOutcome:\n");
int maxCandidates = SkTMin(kMaxOpLookback, fRecordedOps.count());
// If we don't have a valid destination render target then we cannot reorder.
- if (maxCandidates && renderTarget) {
+ if (maxCandidates) {
int i = 0;
while (true) {
const RecordedOp& candidate = fRecordedOps.fromBack(i);
- // We cannot continue to search backwards if the render target changes
- if (candidate.fRenderTarget.get() != renderTarget) {
- GrOP_INFO("\t\tBackward: Breaking because of (%s, opID: %u) Rendertarget mismatch\n",
- candidate.fOp->name(),
- candidate.fOp->uniqueID());
- break;
- }
+
if (this->combineIfPossible(candidate, op.get(), clip, dstTexture, *caps)) {
GrOP_INFO("\t\tBackward: Combining with (%s, opID: %u)\n", candidate.fOp->name(),
candidate.fOp->uniqueID());
clip = fClipAllocator.make<GrAppliedClip>(std::move(*clip));
SkDEBUGCODE(fNumClips++;)
}
- fRecordedOps.emplace_back(std::move(op), renderTarget, clip, dstTexture);
+ fRecordedOps.emplace_back(std::move(op), clip, dstTexture);
fRecordedOps.back().fOp->wasRecorded(this);
fLastFullClearOp = nullptr;
fLastFullClearResourceID.makeInvalid();
for (int i = 0; i < fRecordedOps.count() - 1; ++i) {
GrOp* op = fRecordedOps[i].fOp.get();
- GrRenderTarget* renderTarget = fRecordedOps[i].fRenderTarget.get();
- SkASSERT(renderTarget);
- // If we don't have a valid destination render target ID then we cannot reorder.
- if (!renderTarget) {
- continue;
- }
+
int maxCandidateIdx = SkTMin(i + kMaxOpLookahead, fRecordedOps.count() - 1);
int j = i + 1;
while (true) {
const RecordedOp& candidate = fRecordedOps[j];
- // We cannot continue to search if the render target changes
- if (candidate.fRenderTarget.get() != renderTarget) {
- GrOP_INFO("\t\tForward: Breaking because of (%s, opID: %u) Rendertarget\n",
- candidate.fOp->name(),
- candidate.fOp->uniqueID());
- break;
- }
+
if (this->combineIfPossible(fRecordedOps[i], candidate.fOp.get(),
candidate.fAppliedClip, &candidate.fDstTexture, caps)) {
GrOP_INFO("\t\tForward: Combining with (%s, opID: %u)\n", candidate.fOp->name(),
SkDEBUGCODE(void dump() const override;)
- SkDEBUGCODE(void validateTargetsSingleRenderTarget() const override;)
-
SkDEBUGCODE(int numOps() const override { return fRecordedOps.count(); })
SkDEBUGCODE(int numClips() const override { return fNumClips; })
struct RecordedOp {
RecordedOp(std::unique_ptr<GrOp> op,
- GrRenderTarget* rt,
const GrAppliedClip* appliedClip,
const DstTexture* dstTexture)
: fOp(std::move(op))
- , fRenderTarget(rt)
, fAppliedClip(appliedClip) {
if (dstTexture) {
fDstTexture = *dstTexture;
}
}
std::unique_ptr<GrOp> fOp;
- // TODO: These ops will all to target the same render target and this won't be needed.
- GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
DstTexture fDstTexture;
const GrAppliedClip* fAppliedClip;
};
return fProxy->fTarget ? fProxy->fTarget->asTexture() : nullptr;
}
+ GrRenderTarget* peekRenderTarget() const {
+ return fProxy->fTarget ? fProxy->fTarget->asRenderTarget() : nullptr;
+ }
+
// Beware! This call is only guaranteed to tell you if the proxy in question has
// any pending IO in its current state. It won't tell you about the IO state in the
// future when the proxy is actually used/instantiated.
}
}
-void GrTextureOpList::validateTargetsSingleRenderTarget() const {
- SkASSERT(1 == fRecordedOps.count() || 0 == fRecordedOps.count());
-}
-
#endif
void GrTextureOpList::prepareOps(GrOpFlushState* flushState) {
this->addDependency(src);
#endif
- // See the comment in GrRenderTargetOpList about why we pass the invalid ID here.
- this->recordOp(std::move(op),
- GrGpuResource::UniqueID::InvalidID(),
- GrSurfaceProxy::UniqueID::InvalidID());
+ this->recordOp(std::move(op));
return true;
}
-void GrTextureOpList::recordOp(std::unique_ptr<GrOp> op,
- GrGpuResource::UniqueID resourceUniqueID,
- GrSurfaceProxy::UniqueID proxyUniqueID) {
+void GrTextureOpList::recordOp(std::unique_ptr<GrOp> op) {
+ SkASSERT(fTarget.get());
// A closed GrOpList should never receive new/more ops
SkASSERT(!this->isClosed());
- GR_AUDIT_TRAIL_ADD_OP(fAuditTrail, op.get(), resourceUniqueID, proxyUniqueID);
+ GR_AUDIT_TRAIL_ADD_OP(fAuditTrail, op.get(), fTarget.get()->uniqueID());
GrOP_INFO("Re-Recording (%s, opID: %u)\n"
"\tBounds LRTB (%f, %f, %f, %f)\n",
op->name(),
SkDEBUGCODE(void dump() const override;)
- SkDEBUGCODE(virtual void validateTargetsSingleRenderTarget() const override;)
-
SkDEBUGCODE(int numOps() const override { return fRecordedOps.count(); })
private:
- // MDB TODO: The unique IDs are only needed for the audit trail. There should only be one
- // on the opList itself.
- void recordOp(std::unique_ptr<GrOp>,
- GrGpuResource::UniqueID resourceUniqueID,
- GrSurfaceProxy::UniqueID proxyUniqueID);
+ void recordOp(std::unique_ptr<GrOp>);
SkSTArray<2, std::unique_ptr<GrOp>, true> fRecordedOps;
// drawn offscreen
GrRenderTargetContext* rtc =
originalCanvas->internal_private_accessTopLayerRenderTargetContext();
- GrGpuResource::UniqueID rtID = rtc->accessRenderTarget()->uniqueID();
+ GrSurfaceProxy::UniqueID proxyID = rtc->asSurfaceProxy()->uniqueID();
// get the bounding boxes to draw
SkTArray<GrAuditTrail::OpInfo> childrenBounds;
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(1);
for (int i = 0; i < childrenBounds.count(); i++) {
- SkASSERT(childrenBounds[i].sameDecision(rtID, rtc->asSurfaceProxy()->uniqueID()));
- if (childrenBounds[i].fResourceUniqueID != rtID) {
+ if (childrenBounds[i].fProxyUniqueID != proxyID) {
// offscreen draw, ignore for now
continue;
}
projects / platform / upstream / libSkiaSharp.git / commitdiff