Subset decoding benchmarks

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "nanobench.h"
 
 #include "Benchmark.h"
 #include "CodecBench.h"
 #include "CrashHandler.h"
 #include "DecodingBench.h"
-#include "DecodingSubsetBench.h"
 #include "GMBench.h"
 #include "ProcStats.h"
 #include "ResultsWriter.h"
 #include "RecordingBench.h"
 #include "SKPAnimationBench.h"
 #include "SKPBench.h"
+#include "SubsetBenchPriv.h"
+#include "SubsetDivisorBench.h"
+#include "SubsetSingleBench.h"
+#include "SubsetTranslateBench.h"
+#include "SubsetZoomBench.h"
 #include "Stats.h"
 #include "Timer.h"
 
 #include "SkBBoxHierarchy.h"
 #include "SkCanvas.h"
 #include "SkCodec.h"
 #include "SkCommonFlags.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
@@ skipping 442 matching lines @@
 static void create_targets(SkTDArray<Target*>* targets, Benchmark* b,
                            const SkTDArray<Config>& configs) {
     for (int i = 0; i < configs.count(); ++i) {
         if (Target* t = is_enabled(b, configs[i])) {
             targets->push(t);
         }
 
     }
 }
 
+/*
+ * Returns true if set up for a subset decode succeeds, false otherwise
+ * If the set-up succeeds, the width and height parameters will be set
+ */
+static bool valid_subset_bench(const SkString& path, SkColorType colorType, bool useCodec,
+        int* width, int* height) {
+    SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
+    SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
+
+    if (useCodec) {
+        SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
+        if (NULL == codec) {
+            SkDebugf("Could not create codec for %s.  Skipping bench.\n", path.c_str());
+            return false;
+        }
+
+        // These will be initialized by SkCodec if the color type is kIndex8 and
+        // unused otherwise.
+        SkPMColor colors[256];
+        int colorCount = 0;

[scroggo, 2015/06/08 18:06:42]

Why did you use a colorCount of 0?

[msarett, 2015/06/08 23:40:47]

SkCodec is required to initialize the colorCount if kIndex8 is used.  I would
agree that it's better to leave it uninitialized here.

+        const SkImageInfo info = codec->getInfo().makeColorType(colorType);
+        SkAutoTDeleteArray<uint8_t> row(SkNEW_ARRAY(uint8_t, info.minRowBytes()));
+        SkScanlineDecoder* scanlineDecoder = codec->getScanlineDecoder(info, NULL,
+                colors, &colorCount);
+        if (NULL == scanlineDecoder) {
+            SkDebugf("Could not create scanline decoder for %s with color type %s.  "
+                    "Skipping bench.\n", path.c_str(), get_color_name(colorType));
+            return false;
+        }
+        *width = info.width();
+        *height = info.height();
+    } else {
+        SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream));
+        if (NULL == decoder) {
+            SkDebugf("Could not create decoder for %s.  Skipping bench.\n", path.c_str());
+            return false;
+        }
+        if (!decoder->buildTileIndex(stream.detach(), width, height)) {
+            SkDebugf("Could not build tile index for %s.  Skipping bench.\n", path.c_str());
+            return false;
+        }
+    }
+    return true;
+}
 
 class BenchmarkStream {
 public:
     BenchmarkStream() : fBenches(BenchRegistry::Head())
                       , fGMs(skiagm::GMRegistry::Head())
                       , fCurrentRecording(0)
                       , fCurrentScale(0)
                       , fCurrentSKP(0)
                       , fCurrentUseMPD(0)
                       , fCurrentCodec(0)
                       , fCurrentImage(0)
                       , fCurrentSubsetImage(0)
                       , fCurrentColorType(0)
-                      , fCurrentAnimSKP(0)
-                      , fDivisor(2) {
+                      , fCurrentSubsetType(0)
+                      , fUseCodec(0)
+                      , fCurrentAnimSKP(0) {
         for (int i = 0; i < FLAGS_skps.count(); i++) {
             if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
                 fSKPs.push_back() = FLAGS_skps[i];
             } else {
                 SkOSFile::Iter it(FLAGS_skps[i], ".skp");
                 SkString path;
                 while (it.next(&path)) {
                     fSKPs.push_back() = SkOSPath::Join(FLAGS_skps[0], path.c_str());
                 }
             }
@@ skipping 33 matching lines @@
                     fImages.push_back() = SkOSPath::Join(flag, file.c_str());
                 }
             } else if (sk_exists(flag)) {
                 // Also add the value if it is a single image
                 fImages.push_back() = flag;
             }
         }
 
         // Choose the candidate color types for image decoding
         const SkColorType colorTypes[] =
-            { kN32_SkColorType, kRGB_565_SkColorType, kAlpha_8_SkColorType, kIndex_8_SkColorType };
+            { kN32_SkColorType,
+              kRGB_565_SkColorType,
+              kAlpha_8_SkColorType,
+              kIndex_8_SkColorType,
+              kGray_8_SkColorType };
         fColorTypes.push_back_n(SK_ARRAY_COUNT(colorTypes), colorTypes);
     }
 
     static bool ReadPicture(const char* path, SkAutoTUnref<SkPicture>* pic) {
         // Not strictly necessary, as it will be checked again later,
         // but helps to avoid a lot of pointless work if we're going to skip it.
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path)) {
             return false;
         }
 
@@ skipping 166 matching lines @@
                 if (SkImageDecoder::DecodeFile(path.c_str(), &bitmap,
                         colorType, SkImageDecoder::kDecodePixels_Mode)
                         && bitmap.colorType() == colorType) {
                     return new DecodingBench(path, colorType);
                 }
             }
             fCurrentColorType = 0;
             fCurrentImage++;
         }
 
-        // Run the DecodingSubsetBenches
-        while (fCurrentSubsetImage < fImages.count()) {
-            while (fCurrentColorType < fColorTypes.count()) {
-                const SkString& path = fImages[fCurrentSubsetImage];
-                SkColorType colorType = fColorTypes[fCurrentColorType];
-                fCurrentColorType++;
-                // Check if the image decodes before creating the benchmark
-                SkAutoTUnref<SkData> encoded(
-                        SkData::NewFromFileName(path.c_str()));
-                SkAutoTDelete<SkMemoryStream> stream(
-                        new SkMemoryStream(encoded));
-                SkAutoTDelete<SkImageDecoder>
-                    decoder(SkImageDecoder::Factory(stream.get()));
-                if (!decoder) {
-                    SkDebugf("Cannot find decoder for %s\n", path.c_str());
-                } else {
-                    stream->rewind();
-                    int w, h;
-                    bool success;
-                    if (!decoder->buildTileIndex(stream.detach(), &w, &h)
-                            || w*h == 1) {
-                        // This is not an error, but in this case we still
-                        // do not want to run the benchmark.
-                        success = false;
-                    } else if (fDivisor > w || fDivisor > h) {
-                        SkDebugf("Divisor %d is too big for %s %dx%d\n",
-                                fDivisor, path.c_str(), w, h);
-                        success = false;
-                    } else {
-                        const int sW  = w / fDivisor;
-                        const int sH = h / fDivisor;
-                        SkBitmap bitmap;
-                        success = true;
-                        for (int y = 0; y < h; y += sH) {
-                            for (int x = 0; x < w; x += sW) {
-                                SkIRect rect = SkIRect::MakeXYWH(x, y, sW, sH);
-                                success &= decoder->decodeSubset(&bitmap, rect,
-                                                                 colorType);
+        // Run the SubsetBenches
+        bool useCodecOpts[] = { true, false };
+        while (fUseCodec < 2) {
+            bool useCodec = useCodecOpts[fUseCodec];
+            while (fCurrentSubsetImage < fImages.count()) {
+                while (fCurrentColorType < fColorTypes.count()) {
+                    const SkString& path = fImages[fCurrentSubsetImage];
+                    SkColorType colorType = fColorTypes[fCurrentColorType];
+                    while (fCurrentSubsetType <= kLast_SubsetType) {
+                        int width = 0;
+                        int height = 0;
+                        int currentSubsetType = fCurrentSubsetType++;
+                        if (valid_subset_bench(path, colorType, useCodec, &width, &height)) {
+                            switch (currentSubsetType) {
+                                case kTopLeft_SubsetType:
+                                    return new SubsetSingleBench(path, colorType, width/2,
+                                            height/2, 0, 0, useCodec);
+                                case kTopRight_SubsetType:
+                                    return new SubsetSingleBench(path, colorType, width/2,
+                                            height/2, width/2, 0, useCodec);
+                                case kBottomLeft_SubsetType:
+                                    return new SubsetSingleBench(path, colorType, width/2,
+                                            height/2, 0, height/2, useCodec);
+                                case kBottomRight_SubsetType:
+                                    return new SubsetSingleBench(path, colorType, width/2,
+                                            height/2, width/2, height/2, useCodec);
+                                case k2x2_SubsetType:
+                                    return new SubsetDivisorBench(path, colorType, 2, useCodec);
+                                case k3x3_SubsetType:
+                                    return new SubsetDivisorBench(path, colorType, 3, useCodec);
+                                case kTranslate_SubsetType:
+                                    return new SubsetTranslateBench(path, colorType, 512, 512,
+                                            useCodec);
+                                case kZoom_SubsetType:
+                                    return new SubsetZoomBench(path, colorType, 512, 512,
+                                            useCodec);
                             }
+                        } else {
+                            break;
                         }
                     }
-                    // Create the benchmark if successful
-                    if (success) {
-                        return new DecodingSubsetBench(path, colorType,
-                                                       fDivisor);
-                    }
+                    fCurrentSubsetType = 0;
+                    fCurrentColorType++;
                 }
+                fCurrentColorType = 0;
+                fCurrentSubsetImage++;
             }
-            fCurrentColorType = 0;
-            fCurrentSubsetImage++;
+            fCurrentSubsetImage = 0;
+            fUseCodec++;
         }
 
         return NULL;
     }
 
     void fillCurrentOptions(ResultsWriter* log) const {
         log->configOption("source_type", fSourceType);
         log->configOption("bench_type",  fBenchType);
         if (0 == strcmp(fSourceType, "skp")) {
             log->configOption("clip",
                     SkStringPrintf("%d %d %d %d", fClip.fLeft, fClip.fTop,
                                                   fClip.fRight, fClip.fBottom).c_str());
             log->configOption("scale", SkStringPrintf("%.2g", fScales[fCurrentScale]).c_str());
             if (fCurrentUseMPD > 0) {
                 SkASSERT(1 == fCurrentUseMPD || 2 == fCurrentUseMPD);
                 log->configOption("multi_picture_draw", fUseMPDs[fCurrentUseMPD-1] ? "true" : "false");
             }
         }
         if (0 == strcmp(fBenchType, "recording")) {
             log->metric("bytes", fSKPBytes);
             log->metric("ops",   fSKPOps);
         }
     }
 
 private:
+    enum SubsetType {
+        kTopLeft_SubsetType     = 0,
+        kTopRight_SubsetType    = 1,
+        kBottomLeft_SubsetType  = 2,
+        kBottomRight_SubsetType = 3,
+        k2x2_SubsetType         = 4,
+        k3x3_SubsetType         = 5,
+        kTranslate_SubsetType   = 6,
+        kZoom_SubsetType        = 7,
+        kLast_SubsetType        = kZoom_SubsetType
+    };
+
     const BenchRegistry* fBenches;
     const skiagm::GMRegistry* fGMs;
     SkIRect            fClip;
     SkTArray<SkScalar> fScales;
     SkTArray<SkString> fSKPs;
     SkTArray<bool>     fUseMPDs;
     SkTArray<SkString> fImages;
     SkTArray<SkColorType> fColorTypes;
     SkScalar           fZoomScale;
     int                fZoomSteps;
 
     double fSKPBytes, fSKPOps;
 
     const char* fSourceType;  // What we're benching: bench, GM, SKP, ...
     const char* fBenchType;   // How we bench it: micro, recording, playback, ...
     int fCurrentRecording;
     int fCurrentScale;
     int fCurrentSKP;
     int fCurrentUseMPD;
     int fCurrentCodec;
     int fCurrentImage;
     int fCurrentSubsetImage;
     int fCurrentColorType;
+    int fCurrentSubsetType;
+    int fUseCodec;
     int fCurrentAnimSKP;
-    const int fDivisor;
 };
 
 int nanobench_main();
 int nanobench_main() {
     SetupCrashHandler();
     SkAutoGraphics ag;
     SkTaskGroup::Enabler enabled;
 
 #if SK_SUPPORT_GPU
     GrContextOptions grContextOpts;
@@ skipping 178 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif