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,
+                                                    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 (1 == minLevels) {
+        bool terminate = (1 == maxLevels) || (d->fRandom->nextF() < 0.3f);

[joshualitt, 2015/08/25 18:17:13]

we probably want to make this number and the 0.5f below named constants.

[wangyix, 2015/08/25 19:18:52]

Done.

+        if (terminate) {
+            GrFragmentProcessor* fp;

[joshualitt, 2015/08/25 18:17:13]

Can we just use SkAutoTUnref here, and then just reset it on line 151?

[wangyix, 2015/08/25 18:55:05]

This fp isn't handed off to someone else within this function, so I would have
to ref() it right before returning it so it doesn't immediately delete itself
when this function returns due to the SkAutoTUnref going out of scope.  Would
that look confusing?

[joshualitt, 2015/08/25 18:56:41]

That makes sense, lets leave it as is

[wangyix, 2015/08/25 19:18:52]

Acknowledged.

+            while (true) {
+                fp = GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d);
+                SkASSERT(fp);
+                if (0 == fp->numChildProcessors()) {

[joshualitt, 2015/08/25 18:17:13]

This seems like it could be a bit wasteful, even if this is just a test.  Maybe
we should just create compose effects directly.  In the longer term, we could
have a special CreateStage call that only returns effects with children.

[wangyix, 2015/08/25 18:36:21]

What do you mean? Here, I'm trying to return a random fp that's NOT a compose
effect.

[joshualitt, 2015/08/25 18:42:29]

whoops, I probably should have read this more carefully.  Could you add a
comment?

[wangyix, 2015/08/25 18:55:05]

Acknowledged.

+                    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;
+    }
+    GrFragmentProcessor* minLevelsChild = create_random_proc_tree(d, minLevels, maxLevels - 1);

[joshualitt, 2015/08/25 18:17:13]

These can just be SkAutoTUnref

[wangyix, 2015/08/25 19:18:52]

Done.

+    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);
+    }
+    minLevelsChild->unref();
+    otherChild->unref();
+    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.
+    if (d->fRandom->nextF() < 0.5f) {
+        int numProcs = d->fRandom->nextULessThan(maxStages + 1);
+        int numColorProcs = d->fRandom->nextULessThan(numProcs + 1);
 
-    for (int s = 0; s < numProcs;) {
+        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);
+            }
+            ++s;
+        }
+    } else {
+        // 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.
+        const int maxTreeLevels = 4;
         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);
-        }
-        ++s;
+                                        create_random_proc_tree(d, 1, maxTreeLevels));
+        pipelineBuilder->addColorProcessor(fp);
     }
 }
 
 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