Change UnrefDDLTask to just be the DDLTask

Change-Id: Ib5ff9f3f3d9cbc8860e3a2ba74e6da4355197662
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/332600
Commit-Queue: Robert Phillips <[email protected]>
Reviewed-by: Greg Daniel <[email protected]>

Author: rphilli

gn/gpu.gni

@@ -78,6 +78,8 @@ skia_gpu_sources = [
   "$_src/gpu/GrCopyRenderTask.h",
   "$_src/gpu/GrCpuBuffer.h",
   "$_src/gpu/GrDDLContext.cpp",
+  "$_src/gpu/GrDDLTask.cpp",
+  "$_src/gpu/GrDDLTask.h",
   "$_src/gpu/GrDataUtils.cpp",
   "$_src/gpu/GrDataUtils.h",
   "$_src/gpu/GrDefaultGeoProcFactory.cpp",
@@ -258,7 +260,6 @@ skia_gpu_sources = [
   "$_src/gpu/GrTriangulator.h",
   "$_src/gpu/GrUniformDataManager.cpp",
   "$_src/gpu/GrUniformDataManager.h",
-  "$_src/gpu/GrUnrefDDLTask.h",
   "$_src/gpu/GrUserStencilSettings.h",
   "$_src/gpu/GrUtil.cpp",
   "$_src/gpu/GrUtil.h",

src/core/SkDeferredDisplayListPriv.h

@@ -33,6 +33,10 @@ class SkDeferredDisplayListPriv {
     const SkTArray<GrRecordingContext::ProgramData>& programData() const {
         return fDDL->programData();
     }
+
+    const SkTArray<sk_sp<GrRenderTask>>& renderTasks() const {
+        return fDDL->fRenderTasks;
+    }
 #endif
 
 private:

src/gpu/GrDDLTask.cpp

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/GrDDLTask.h"
+
+#include "include/core/SkDeferredDisplayList.h"
+#include "src/core/SkDeferredDisplayListPriv.h"
+#include "src/gpu/GrResourceAllocator.h"
+
+GrDDLTask::GrDDLTask(GrDrawingManager* drawingMgr,
+                     sk_sp<GrRenderTargetProxy> ddlTarget,
+                     sk_sp<const SkDeferredDisplayList> ddl)
+        : fDDL(std::move(ddl))
+        , fDDLTarget(std::move(ddlTarget)) {
+    for (auto& task : fDDL->priv().renderTasks()) {
+        SkASSERT(task->isClosed());
+
+        for (int i = 0; i < task->numTargets(); ++i) {
+            this->addTarget(drawingMgr, task->target(i));
+        }
+    }
+
+    // The DDL task never accepts additional tasks
+    this->setFlag(kClosed_Flag);
+}
+
+GrDDLTask::~GrDDLTask() { }
+
+void GrDDLTask::endFlush(GrDrawingManager* drawingManager) {
+    for (auto& task : fDDL->priv().renderTasks()) {
+        task->endFlush(drawingManager);
+    }
+
+    INHERITED::endFlush(drawingManager);
+}
+
+void GrDDLTask::disown(GrDrawingManager* drawingManager) {
+    for (auto& task : fDDL->priv().renderTasks()) {
+        task->disown(drawingManager);
+    }
+
+    INHERITED::disown(drawingManager);
+}
+
+bool GrDDLTask::onIsUsed(GrSurfaceProxy* proxy) const {
+    // In the ctor we've added all the targets from the sub-renderTasks into the targets list
+    // of the this task. The base class' 'isUsed' call checks those so we don't want to check
+    // them again here. The following 'onIsUsed' methods just check the other (non-target) proxies.
+    for (auto& task : fDDL->priv().renderTasks()) {
+        if (task->onIsUsed(proxy)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void GrDDLTask::handleInternalAllocationFailure() {
+    for (auto& task : fDDL->priv().renderTasks()) {
+        task->handleInternalAllocationFailure();
+    }
+}
+
+void GrDDLTask::gatherProxyIntervals(GrResourceAllocator* alloc) const {
+    // We don't have any proxies, but the resource allocator will still bark
+    // if a task doesn't claim any op indices, so we oblige it.
+    alloc->incOps();
+
+    for (auto& task : fDDL->priv().renderTasks()) {
+        task->gatherProxyIntervals(alloc);
+    }
+}
+
+GrRenderTask::ExpectedOutcome GrDDLTask::onMakeClosed(const GrCaps& caps,
+                                                      SkIRect* targetUpdateBounds) {
+    SkASSERT(0);
+    return ExpectedOutcome::kTargetUnchanged;
+}
+
+void GrDDLTask::gatherIDs(SkSTArray<8, uint32_t, true>* idArray) const {
+    for (auto& task : fDDL->priv().renderTasks()) {
+        task->gatherIDs(idArray);
+    }
+}
+
+void GrDDLTask::onPrepare(GrOpFlushState* flushState) {
+    for (auto& task : fDDL->priv().renderTasks()) {
+        task->prepare(flushState);
+    }
+}
+
+bool GrDDLTask::onExecute(GrOpFlushState* flushState) {
+    bool anyCommandsIssued = false;
+    for (auto& task : fDDL->priv().renderTasks()) {
+        if (task->execute(flushState)) {
+            anyCommandsIssued = true;
+        }
+    }
+
+    return anyCommandsIssued;
+}

src/gpu/GrDDLTask.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDDLTask_DEFINED
+#define GrDDLTask_DEFINED
+
+#include "src/gpu/GrRenderTask.h"
+
+class GrRenderTargetProxy;
+
+/**
+ * This render task isolates the DDL's tasks from the rest of the DAG. This means that
+ * the DDL's tasks cannot be reordered by the topological sort and are always executed
+ * as a single block.
+ * It almost entirely just forwards calls down to the DDL's render tasks.
+ */
+class GrDDLTask final : public GrRenderTask {
+public:
+    GrDDLTask(GrDrawingManager*,
+              sk_sp<GrRenderTargetProxy> ddlTarget,
+              sk_sp<const SkDeferredDisplayList>);
+
+    ~GrDDLTask() override;
+
+    // The render tasks w/in the DDL don't appear in the DAG so need explicit notification
+    // when they can free their contents.
+    bool requiresExplicitCleanup() const override { return true; }
+
+    void endFlush(GrDrawingManager*) override;
+
+    void disown(GrDrawingManager*) override;
+
+private:
+    bool onIsUsed(GrSurfaceProxy* proxy) const override;
+
+    void handleInternalAllocationFailure() override;
+
+    void gatherProxyIntervals(GrResourceAllocator*) const override;
+
+    ExpectedOutcome onMakeClosed(const GrCaps&, SkIRect* targetUpdateBounds) override;
+
+    void gatherIDs(SkSTArray<8, uint32_t, true>* idArray) const override;
+
+    void onPrePrepare(GrRecordingContext*) override {
+        // This entry point is only called when a DDL is snapped off of a recorder.
+        // Since DDL tasks should never recursively appear within a DDL this should never
+        // be called.
+        SkASSERT(0);
+    }
+
+    void onPrepare(GrOpFlushState*) override;
+
+    bool onExecute(GrOpFlushState*) override;
+
+#if GR_TEST_UTILS
+    const char* name() const final { return "DDL"; }
+#endif
+#ifdef SK_DEBUG
+    void visitProxies_debugOnly(const GrOp::VisitProxyFunc& fn) const override {}
+#endif
+
+    sk_sp<const SkDeferredDisplayList> fDDL;
+    sk_sp<GrRenderTargetProxy>         fDDLTarget;
+
+    typedef GrRenderTask INHERITED;
+};
+
+#endif

src/gpu/GrDirectContextPriv.cpp

@@ -59,9 +59,9 @@ void GrDirectContextPriv::flushSurface(GrSurfaceProxy* proxy) {
     this->flushSurfaces({&proxy, size}, {});
 }
 
-void GrDirectContextPriv::copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList> ddl,
-                                                 GrRenderTargetProxy* newDest) {
-    fContext->drawingManager()->copyRenderTasksFromDDL(std::move(ddl), newDest);
+void GrDirectContextPriv::createDDLTask(sk_sp<const SkDeferredDisplayList> ddl,
+                                        GrRenderTargetProxy* newDest) {
+    fContext->drawingManager()->createDDLTask(std::move(ddl), newDest);
 }
 
 bool GrDirectContextPriv::compile(const GrProgramDesc& desc, const GrProgramInfo& info) {

src/gpu/GrDirectContextPriv.h

@@ -120,7 +120,7 @@ class GrDirectContextPriv {
         return fContext->onGetSmallPathAtlasMgr();
     }
 
-    void copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList>, GrRenderTargetProxy* newDest);
+    void createDDLTask(sk_sp<const SkDeferredDisplayList>, GrRenderTargetProxy* newDest);
 
     bool compile(const GrProgramDesc&, const GrProgramInfo&);
 

src/gpu/GrDrawingManager.cpp

@@ -19,6 +19,7 @@
 #include "src/gpu/GrAuditTrail.h"
 #include "src/gpu/GrClientMappedBufferManager.h"
 #include "src/gpu/GrCopyRenderTask.h"
+#include "src/gpu/GrDDLTask.h"
 #include "src/gpu/GrDirectContextPriv.h"
 #include "src/gpu/GrGpu.h"
 #include "src/gpu/GrMemoryPool.h"
@@ -38,7 +39,6 @@
 #include "src/gpu/GrTextureResolveRenderTask.h"
 #include "src/gpu/GrTracing.h"
 #include "src/gpu/GrTransferFromRenderTask.h"
-#include "src/gpu/GrUnrefDDLTask.h"
 #include "src/gpu/GrWaitRenderTask.h"
 #include "src/gpu/ccpr/GrCoverageCountingPathRenderer.h"
 #include "src/gpu/text/GrSDFTOptions.h"
@@ -48,7 +48,7 @@ void GrDrawingManager::RenderTaskDAG::gatherIDs(SkSTArray<8, uint32_t, true>* id
     idArray->reset(fRenderTasks.count());
     for (int i = 0; i < fRenderTasks.count(); ++i) {
         if (fRenderTasks[i]) {
-            (*idArray)[i] = fRenderTasks[i]->uniqueID();
+            fRenderTasks[i]->gatherIDs(idArray);
         }
     }
 }
@@ -464,8 +464,10 @@ void GrDrawingManager::removeRenderTasks(int startIndex, int stopIndex) {
         if (!task) {
             continue;
         }
-        if (!task->unique()) {
-            // TODO: Eventually this should be guaranteed unique: http://skbug.com/7111
+        if (!task->unique() || task->requiresExplicitCleanup()) {
+            // TODO: Eventually uniqueness should be guaranteed: http://skbug.com/7111.
+            // DDLs, however, will always require an explicit notification for when they
+            // can clean up resources.
             task->endFlush(this);
         }
         task->disown(this);
@@ -557,8 +559,8 @@ void GrDrawingManager::testingOnly_removeOnFlushCallbackObject(GrOnFlushCallback
 
 void GrDrawingManager::setLastRenderTask(const GrSurfaceProxy* proxy, GrRenderTask* task) {
 #ifdef SK_DEBUG
-    if (GrRenderTask* prior = this->getLastRenderTask(proxy)) {
-        SkASSERT(prior->isClosed());
+    if (auto prior = this->getLastRenderTask(proxy)) {
+        SkASSERT(prior->isClosed() || prior == task);
     }
 #endif
     uint32_t key = proxy->uniqueID().asUInt();
@@ -587,6 +589,8 @@ void GrDrawingManager::moveRenderTasksToDDL(SkDeferredDisplayList* ddl) {
     fDAG.closeAll(fContext->priv().caps());
     fActiveOpsTask = nullptr;
 
+    fDAG.prepForFlush();
+
     fDAG.swap(&ddl->fRenderTasks);
     SkASSERT(!fDAG.numRenderTasks());
 
@@ -608,8 +612,8 @@ void GrDrawingManager::moveRenderTasksToDDL(SkDeferredDisplayList* ddl) {
     SkDEBUGCODE(this->validate());
 }
 
-void GrDrawingManager::copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList> ddl,
-                                              GrRenderTargetProxy* newDest) {
+void GrDrawingManager::createDDLTask(sk_sp<const SkDeferredDisplayList> ddl,
+                                     GrRenderTargetProxy* newDest) {
     SkDEBUGCODE(this->validate());
 
     if (fActiveOpsTask) {
@@ -621,7 +625,7 @@ void GrDrawingManager::copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList>
         fActiveOpsTask = nullptr;
     }
 
-    // Propagate the DDL proxy's state information to the replaying DDL.
+    // Propagate the DDL proxy's state information to the replay target.
     if (ddl->priv().targetProxy()->isMSAADirty()) {
         newDest->markMSAADirty(ddl->priv().targetProxy()->msaaDirtyRect(),
                                ddl->characterization().origin());
@@ -634,7 +638,7 @@ void GrDrawingManager::copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList>
     this->addDDLTarget(newDest, ddl->priv().targetProxy());
 
     // Here we jam the proxy that backs the current replay SkSurface into the LazyProxyData.
-    // The lazy proxy that references it (in the copied opsTasks) will steal its GrTexture.
+    // The lazy proxy that references it (in the DDL opsTasks) will then steal its GrTexture.
     ddl->fLazyProxyData->fReplayDest = newDest;
 
     if (ddl->fPendingPaths.size()) {
@@ -643,11 +647,11 @@ void GrDrawingManager::copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList>
         ccpr->mergePendingPaths(ddl->fPendingPaths);
     }
 
-    fDAG.add(ddl->fRenderTasks);
-
-    // Add a task to unref the DDL after flush.
-    GrRenderTask* unrefTask = fDAG.add(sk_make_sp<GrUnrefDDLTask>(std::move(ddl)));
-    unrefTask->makeClosed(*fContext->priv().caps());
+    // Add a task to handle drawing and lifetime management of the DDL.
+    SkDEBUGCODE(auto ddlTask =) fDAG.add(sk_make_sp<GrDDLTask>(this,
+                                                               sk_ref_sp(newDest),
+                                                               std::move(ddl)));
+    SkASSERT(ddlTask->isClosed());
 
     SkDEBUGCODE(this->validate());
 }

src/gpu/GrDrawingManager.h

@@ -117,7 +117,7 @@ class GrDrawingManager {
     void setLastRenderTask(const GrSurfaceProxy*, GrRenderTask*);
 
     void moveRenderTasksToDDL(SkDeferredDisplayList* ddl);
-    void copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList>, GrRenderTargetProxy* newDest);
+    void createDDLTask(sk_sp<const SkDeferredDisplayList>, GrRenderTargetProxy* newDest);
 
 private:
     // This class encapsulates maintenance and manipulation of the drawing manager's DAG of
@@ -204,7 +204,8 @@ class GrDrawingManager {
 
     RenderTaskDAG                     fDAG;
     GrOpsTask*                        fActiveOpsTask = nullptr;
-    // These are the IDs of the opsTask currently being flushed (in internalFlush)
+    // These are the IDs of the opsTask currently being flushed (in internalFlush). They are
+    // only stored here to prevent memory thrashing.
     SkSTArray<8, uint32_t, true>      fFlushingRenderTaskIDs;
     // These are the new renderTasks generated by the onFlush CBs
     SkSTArray<4, sk_sp<GrRenderTask>> fOnFlushRenderTasks;

src/gpu/GrOpsTask.cpp

@@ -875,8 +875,8 @@ void GrOpsTask::forwardCombine(const GrCaps& caps) {
     }
 }
 
-GrRenderTask::ExpectedOutcome GrOpsTask::onMakeClosed(
-        const GrCaps& caps, SkIRect* targetUpdateBounds) {
+GrRenderTask::ExpectedOutcome GrOpsTask::onMakeClosed(const GrCaps& caps,
+                                                      SkIRect* targetUpdateBounds) {
     this->forwardCombine(caps);
     if (!this->isNoOp()) {
         GrSurfaceProxy* proxy = this->target(0).proxy();