Specify bench_type & source_type for image benches

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"
@@ skipping 772 matching lines @@
 
                 fCurrentAnimSKP++;
                 SkString name = SkOSPath::Basename(path.c_str());
                 SkAutoTUnref<SKPAnimationBench::Animation> animation(
                     SKPAnimationBench::CreateZoomAnimation(fZoomMax, fZoomPeriodMs));
                 return new SKPAnimationBench(name.c_str(), pic.get(), fClip, animation,
                                              FLAGS_loopSKP);
             }
         }
 
-
         for (; fCurrentCodec < fImages.count(); fCurrentCodec++) {
+            fSourceType = "image";
+            fBenchType = "skcodec";
             const SkString& path = fImages[fCurrentCodec];
             SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
             SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
             if (!codec) {
                 // Nothing to time.
                 SkDebugf("Cannot find codec for %s\n", path.c_str());
                 continue;
             }
 
             while (fCurrentColorType < fColorTypes.count()) {
@@ skipping 33 matching lines @@
                         // This represents some sort of failure.
                         SkASSERT(false);
                         break;
                 }
             }
             fCurrentColorType = 0;
         }
 
         // Run the DecodingBenches
         while (fCurrentImage < fImages.count()) {
+            fSourceType = "image";
+            fBenchType = "skimagedecoder";
             while (fCurrentColorType < fColorTypes.count()) {
                 const SkString& path = fImages[fCurrentImage];
                 SkColorType colorType = fColorTypes[fCurrentColorType];
                 fCurrentColorType++;
                 // Check if the image decodes to the right color type
                 // before creating the benchmark
                 SkBitmap bitmap;
                 if (SkImageDecoder::DecodeFile(path.c_str(), &bitmap,
                         colorType, SkImageDecoder::kDecodePixels_Mode)
                         && bitmap.colorType() == colorType) {
                     return new DecodingBench(path, colorType);
                 }
             }
             fCurrentColorType = 0;
             fCurrentImage++;
         }
 
         // Run the SubsetBenches
         bool useCodecOpts[] = { true, false };
         while (fUseCodec < 2) {
             bool useCodec = useCodecOpts[fUseCodec];
+            fSourceType = "image";
+            fBenchType = useCodec ? "skcodec" : "skimagedecoder";
             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) {
@@ skipping 28 matching lines @@
                 }
                 fCurrentColorType = 0;
                 fCurrentSubsetImage++;
             }
             fCurrentSubsetImage = 0;
             fUseCodec++;
         }
 
         // Run the BRDBenches
         // We will benchmark multiple BRD strategies.
-        const SkBitmapRegionDecoderInterface::Strategy strategies[] = {
-                SkBitmapRegionDecoderInterface::kOriginal_Strategy,
-                SkBitmapRegionDecoderInterface::kCanvas_Strategy,
+        static const struct {
+            SkBitmapRegionDecoderInterface::Strategy    fStrategy;
+            const char*                                 fName;
+        } strategies[] = {
+            { SkBitmapRegionDecoderInterface::kOriginal_Strategy,   "BRD" },
+            { SkBitmapRegionDecoderInterface::kCanvas_Strategy,     "BRD_canvas" },
         };
 
         // We intend to create benchmarks that model the use cases in
         // android/libraries/social/tiledimage.  In this library, an image is decoded in 512x512
         // tiles.  The image can be translated freely, so the location of a tile may be anywhere in
         // the image.  For that reason, we will benchmark decodes in five representative locations
         // in the image.  Additionally, this use case utilizes power of two scaling, so we will
         // test on power of two sample sizes.  The output tile is always 512x512, so, when a
         // sampleSize is used, the size of the subset that is decoded is always
         // (sampleSize*512)x(sampleSize*512).
         // There are a few good reasons to only test on power of two sample sizes at this time:
         //     JPEG decodes using kOriginal_Strategy are broken for non-powers of two.
         //         skbug.com/4319
         //     All use cases we are aware of only scale by powers of two.
         //     PNG decodes use the indicated sampling strategy regardless of the sample size, so
         //         these tests are sufficient to provide good coverage of our scaling options.
         const uint32_t sampleSizes[] = { 1, 2, 4, 8, 16 };
         const uint32_t minOutputSize = 512;
         while (fCurrentBRDImage < fImages.count()) {
             while (fCurrentBRDStrategy < (int) SK_ARRAY_COUNT(strategies)) {
+                fSourceType = "image";
+                fBenchType = strategies[fCurrentBRDStrategy].fName;
                 while (fCurrentColorType < fColorTypes.count()) {
                     while (fCurrentBRDSampleSize < (int) SK_ARRAY_COUNT(sampleSizes)) {
                         while (fCurrentSubsetType <= kLastSingle_SubsetType) {
                             const SkString& path = fImages[fCurrentBRDImage];
                             const SkBitmapRegionDecoderInterface::Strategy strategy =
-                                    strategies[fCurrentBRDStrategy];
+                                    strategies[fCurrentBRDStrategy].fStrategy;
                             SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
                             const SkColorType colorType = fColorTypes[fCurrentColorType];
                             uint32_t sampleSize = sampleSizes[fCurrentBRDSampleSize];
                             int currentSubsetType = fCurrentSubsetType++;
 
                             int width = 0;
                             int height = 0;
                             if (!valid_brd_bench(encoded.get(), strategy, colorType, sampleSize,
                                     minOutputSize, &width, &height)) {
                                 break;
@@ skipping 336 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif