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"

[scroggo, 2015/06/02 13:45:57]

If this is no longer used, can we remove this class entirely?

[msarett, 2015/06/02 17:14:10]

Done.

 #include "GMBench.h"
 #include "ProcStats.h"
 #include "ResultsWriter.h"
 #include "RecordingBench.h"
 #include "SKPAnimationBench.h"
 #include "SKPBench.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;
+        }
+
+        const SkImageInfo info = codec->getInfo();

[scroggo, 2015/06/02 13:45:57]

don't we need to convert to colorType?

[msarett, 2015/06/02 17:14:10]

Done.

+        SkAutoTDeleteArray<uint8_t> row(SkNEW_ARRAY(uint8_t, info.minRowBytes()));
+        SkScanlineDecoder* scanlineDecoder = codec->getScanlineDecoder(info);
+        if (NULL == scanlineDecoder) {
+            SkDebugf("Could not create scanline decoder for %s.  Skipping bench.\n", path.c_str());

[scroggo, 2015/06/02 13:45:57]

We might want to also report the colortype, since maybe that is why the scanline
decoder failed.

[msarett, 2015/06/02 17:14:10]

Done.

+            return false;
+        }
+        *width = info.width();
+        *height = info.height();
+    } else {
+        SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream.detach()));

[scroggo, 2015/06/02 13:45:57]

For legacy reasons, SkImageDecoder::Factory does not take ownership of the
stream, so you do not want to detach here. buildTileIndex, below, *will* take
ownership, so you can call detach there.

[msarett, 2015/06/02 17:14:10]

Nice catch, thanks!

+        if (NULL == decoder) {
+            SkDebugf("Could not create decoder for %s.  Skipping bench.\n", path.c_str());
+            return false;
+        }
+        if (!decoder->buildTileIndex(stream->duplicate(), 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)
+                      , fCurrentSubsetType(0)
                       , fCurrentAnimSKP(0)
-                      , fDivisor(2) {
+                      , fUseCodec(true) {
         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 220 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
+        // Reset the SubsetBenches for ImageDecoder after they have run for Codec
+        if (fCurrentSubsetImage == fImages.count() && fCurrentColorType == fColorTypes.count() &&
+                fCurrentSubsetType > kLast_SubsetType && fUseCodec) {
+            fUseCodec = false;
+            fCurrentSubsetImage = 0;
+            fCurrentColorType = 0;
+            fCurrentSubsetType = 0;
+        }
+
+        // Run the SubsetBenches
         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;
+                while (fCurrentSubsetType <= kLast_SubsetType) {
+                    int width = 0;
+                    int height = 0;
+                    if (valid_subset_bench(path, colorType, fUseCodec, &width, &height)) {
+                      int currentSubsetType = fCurrentSubsetType++;

[scroggo, 2015/06/02 13:45:57]

nit: 4 space indent

[msarett, 2015/06/02 17:14:10]

Done.

+                      switch (currentSubsetType) {
+                          case kTopLeft_SubsetType:
+                              return new SubsetSingleBench(path, colorType, width/2, height/2,
+                                      0, 0, fUseCodec);
+                          case kTopRight_SubsetType:
+                              return new SubsetSingleBench(path, colorType, width/2, height/2,
+                                      width/2, 0, fUseCodec);
+                          case kBottomLeft_SubsetType:
+                              return new SubsetSingleBench(path, colorType, width/2, height/2,
+                                      0, height/2, fUseCodec);
+                          case kBottomRight_SubsetType:
+                              return new SubsetSingleBench(path, colorType, width/2, height/2,
+                                      0, 0, fUseCodec);
+                          case k2x2_SubsetType:
+                              return new SubsetDivisorBench(path, colorType, 2, fUseCodec);
+                          case k3x3_SubsetType:
+                              return new SubsetDivisorBench(path, colorType, 3, fUseCodec);
+                          case kTranslate_SubsetType:
+                              return new SubsetTranslateBench(path, colorType, 512, 512, fUseCodec);
+                          case kZoom_SubsetType:
+                              return new SubsetZoomBench(path, colorType, 512, 512, fUseCodec);
+                      }
                     } 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);
-                            }
-                        }
-                    }
-                    // Create the benchmark if successful
-                    if (success) {
-                        return new DecodingSubsetBench(path, colorType,
-                                                       fDivisor);
+                        fCurrentSubsetType = 0;

[scroggo, 2015/06/02 13:45:57]

Don't we need to reset this when we reach kLast_SubsetType?

[msarett, 2015/06/02 17:14:10]

Yes for sure!  It appears I should have tested this for more than one image.

+                        break;
                     }
                 }
+                fCurrentColorType++;
             }
             fCurrentColorType = 0;
             fCurrentSubsetImage++;
         }
 
         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 fCurrentAnimSKP;
-    const int fDivisor;
+    bool fUseCodec;
 };
 
 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