Reduce arbitrary opList splitting when sorting

Change-Id: I49a47672600f72dc46f27462a2c344e77a06a659
Reviewed-on: https://skia-review.googlesource.com/141243
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

1 files changed, 66 insertions, 5 deletions

diff --git a/src/gpu/GrOpList.cpp b/src/gpu/GrOpList.cpp
index b9f425576e..12d15afe6a 100644
--- a/src/gpu/GrOpList.cpp
+++ b/src/gpu/GrOpList.cpp
@@ -96,6 +96,9 @@ void GrOpList::addDependency(GrOpList* dependedOn) {
     }
 
     fDependencies.push_back(dependedOn);
+    dependedOn->addDependent(this);
+
+    SkDEBUGCODE(this->validate());
 }
 
 // Convert from a GrSurface-based dependency to a GrOpList one
@@ -106,11 +109,13 @@ void GrOpList::addDependency(GrSurfaceProxy* dependedOn, const GrCaps& caps) {
 
         GrOpList* opList = dependedOn->getLastOpList();
         if (opList == this) {
-            // self-read - presumably for dst reads
+            // self-read - presumably for dst reads. We can't make it closed in the self-read case.
         } else {
             this->addDependency(opList);
 
-            // Can't make it closed in the self-read case
+            // We are closing 'opList' here bc the current contents of it are what 'this' opList
+            // depends on. We need a break in 'opList' so that the usage of that state has a
+            // chance to execute.
             opList->makeClosed(caps);
         }
     }
@@ -122,22 +127,78 @@ void GrOpList::addDependency(GrSurfaceProxy* dependedOn, const GrCaps& caps) {
     }
 }
 
+bool GrOpList::dependsOn(const GrOpList* dependedOn) const {
+    for (int i = 0; i < fDependencies.count(); ++i) {
+        if (fDependencies[i] == dependedOn) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void GrOpList::addDependent(GrOpList* dependent) {
+    fDependents.push_back(dependent);
+}
+
+#ifdef SK_DEBUG
+bool GrOpList::isDependedent(const GrOpList* dependent) const {
+    for (int i = 0; i < fDependents.count(); ++i) {
+        if (fDependents[i] == dependent) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void GrOpList::validate() const {
+    // TODO: check for loops and duplicates
+
+    for (int i = 0; i < fDependencies.count(); ++i) {
+        SkASSERT(fDependencies[i]->isDependedent(this));
+    }
+}
+#endif
+
+void GrOpList::closeThoseWhoDependOnMe(const GrCaps& caps) {
+    for (int i = 0; i < fDependents.count(); ++i) {
+        if (!fDependents[i]->isClosed()) {
+            fDependents[i]->makeClosed(caps);
+        }
+    }
+}
+
 bool GrOpList::isInstantiated() const {
     return fTarget.get()->priv().isInstantiated();
 }
 
 #ifdef SK_DEBUG
+static const char* op_to_name(GrLoadOp op) {
+    return GrLoadOp::kLoad == op ? "load" : GrLoadOp::kClear == op ? "clear" : "discard";
+}
+
 void GrOpList::dump(bool printDependencies) const {
     SkDebugf("--------------------------------------------------------------\n");
-    SkDebugf("opList: %d -> RT: %d\n", fUniqueID, fTarget.get() ? fTarget.get()->uniqueID().asUInt()
-                                                                : -1);
+    SkDebugf("opListID: %d -> proxyID: %d\n", fUniqueID,
+             fTarget.get() ? fTarget.get()->uniqueID().asUInt() : -1);
+    SkDebugf("ColorLoadOp: %s %x StencilLoadOp: %s\n",
+             op_to_name(fColorLoadOp),
+             GrLoadOp::kClear == fColorLoadOp ? fLoadClearColor : 0x0,
+             op_to_name(fStencilLoadOp));
 
     if (printDependencies) {
-        SkDebugf("relies On (%d): ", fDependencies.count());
+        SkDebugf("I rely On (%d): ", fDependencies.count());
         for (int i = 0; i < fDependencies.count(); ++i) {
             SkDebugf("%d, ", fDependencies[i]->fUniqueID);
         }
         SkDebugf("\n");
+
+        SkDebugf("(%d) Rely On Me: ", fDependents.count());
+        for (int i = 0; i < fDependents.count(); ++i) {
+            SkDebugf("%d, ", fDependents[i]->fUniqueID);
+        }
+        SkDebugf("\n");
     }
 }
 #endif