GLProgramsTest can now randomly create a tree of GrFragmentProcessors instead of a linear pipeline

tests/GLProgramsTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
 
 #include "GrAutoLocaleSetter.h"
 #include "GrBatchTest.h"
 #include "GrContextFactory.h"
 #include "GrInvariantOutput.h"
 #include "GrPipeline.h"
 #include "GrResourceProvider.h"
 #include "GrTest.h"
 #include "GrXferProcessor.h"
 #include "SkChecksum.h"
 #include "SkRandom.h"
+#include "SkComposeShader.h"
 #include "Test.h"
 
 #include "batches/GrDrawBatch.h"
 
 #include "effects/GrConfigConversionEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLPathRendering.h"
 #include "gl/builders/GrGLProgramBuilder.h"
@@ skipping 94 matching lines @@
     }
     return texture ? texture->asRenderTarget() : NULL;
 }
 
 static void set_random_xpf(GrPipelineBuilder* pipelineBuilder, GrProcessorTestData* d) {
     SkAutoTUnref<const GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::CreateStage(d));
     SkASSERT(xpf);
     pipelineBuilder->setXPFactory(xpf.get());
 }
 
+static GrFragmentProcessor* create_random_proc_tree(GrProcessorTestData* d,

[tomhudson, 2015/08/25 19:29:24]

So what's d really doing here? Looks like it's carrying a random number
generator around, and otherwise unused? The while() loop with
GrProcessorTestFactory::CreateStage() is really obscure and hard to trust.

+                                                    int minLevels, int maxLevels) {
+    SkASSERT(1 <= minLevels);
+    SkASSERT(minLevels <= maxLevels);
+
+    // Return a leaf node if maxLevels is 1 or if we randomly chose to terminate.
+    // If returning a leaf node, make sure that it doesn't have children (e.g. another
+    // GrComposeEffect)
+    const float terminateProbability = 0.3f;
+    if (1 == minLevels) {
+        bool terminate = (1 == maxLevels) || (d->fRandom->nextF() < terminateProbability);
+        if (terminate) {
+            GrFragmentProcessor* fp;
+            while (true) {
+                fp = GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d);
+                SkASSERT(fp);
+                if (0 == fp->numChildProcessors()) {
+                    break;
+                }
+                fp->unref();
+            }
+            return fp;
+        }
+    }
+    // If we didn't terminate, choose either the left or right subtree to fulfill
+    // the minLevels requirement of this tree; the other child can have as few levels as it wants.
+    // Also choose a random xfer mode that's supported by GrComposeEffect.
+    if (minLevels > 1) {
+        --minLevels;
+    }
+    SkAutoTUnref<GrFragmentProcessor> minLevelsChild(
+            create_random_proc_tree(d, minLevels, maxLevels - 1));
+    SkAutoTUnref<GrFragmentProcessor> otherChild(
+            create_random_proc_tree(d, 1, maxLevels - 1));
+    SkXfermode::Mode mode;
+    do {
+        mode = static_cast<SkXfermode::Mode>(
+                                d->fRandom->nextRangeU(0, SkXfermode::Mode::kLastCoeffMode));
+    } while (mode == SkXfermode::Mode::kClear_Mode);
+
+    GrFragmentProcessor* fp;
+    if (d->fRandom->nextF() < 0.5f) {
+        fp = GrComposeEffect::Create(minLevelsChild, otherChild, mode);
+    } else {
+        fp = GrComposeEffect::Create(otherChild, minLevelsChild, mode);
+    }
+    return fp;
+}
+
 static void set_random_color_coverage_stages(GrPipelineBuilder* pipelineBuilder,
                                              GrProcessorTestData* d, int maxStages) {
-    int numProcs = d->fRandom->nextULessThan(maxStages + 1);
-    int numColorProcs = d->fRandom->nextULessThan(numProcs + 1);
+    // Randomly choose to either create a linear pipeline of procs, or create one proc
+    // tree.
+    const float procTreeProbability = 0.5f;
+    if (d->fRandom->nextF() < procTreeProbability) {
+        // A full tree with 5 levels (31 nodes) may exceed the max allowed length of the gl
+        // processor key; maxTreeLevels should be a number from 1 to 4 inclusive.

[tomhudson, 2015/08/25 19:29:24]

A one-level tree will just be a leaf node with no ComposeEffect,
meaning we've got an effective 0.625f chance of a linear pipeline and a 0.475f
chance of a tree?

[wangyix, 2015/08/25 19:48:01]

Good point. It may be better to have create_random_proc_tree() always return a
tree with 2 or more levels.  This may also address your comment about the
while-loop with GrProcessorTestFactory::CreateStage() above: we can make the
base case return a two-level tree by calling GrComposeEffect::TestCreate()
instead of having the base case return a random non-compose processor.  This
lets us reuse the code within GrComposeEffect::TestCreate() that searchs for
non-compose procs to use as children.

+        const int maxTreeLevels = 4;
+        SkAutoTUnref<const GrFragmentProcessor> fp(
+                                        create_random_proc_tree(d, 1, maxTreeLevels));
+        pipelineBuilder->addColorProcessor(fp);

[tomhudson, 2015/08/25 19:29:24]

No coverage? Or am I missing something?

+    } else {
+        int numProcs = d->fRandom->nextULessThan(maxStages + 1);
+        int numColorProcs = d->fRandom->nextULessThan(numProcs + 1);
 
-    for (int s = 0; s < numProcs;) {
-        SkAutoTUnref<const GrFragmentProcessor> fp(
-                GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d));
-        SkASSERT(fp);
+        for (int s = 0; s < numProcs;) {
+            SkAutoTUnref<const GrFragmentProcessor> fp(
+                    GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d));
+            SkASSERT(fp);
 
-        // finally add the stage to the correct pipeline in the drawstate
-        if (s < numColorProcs) {
-            pipelineBuilder->addColorProcessor(fp);
-        } else {
-            pipelineBuilder->addCoverageProcessor(fp);
+            // finally add the stage to the correct pipeline in the drawstate
+            if (s < numColorProcs) {
+                pipelineBuilder->addColorProcessor(fp);
+            } else {
+                pipelineBuilder->addCoverageProcessor(fp);
+            }
+            ++s;
         }
-        ++s;
     }
 }
 
 static void set_random_state(GrPipelineBuilder* pipelineBuilder, SkRandom* random) {
     int state = 0;
     for (int i = 1; i <= GrPipelineBuilder::kLast_Flag; i <<= 1) {
         state |= random->nextBool() * i;
     }
 
     // If we don't have an MSAA rendertarget then we have to disable useHWAA
@@ skipping 130 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(context, maxStages));
         }
     }
 }
 
 #endif