Add MSAA configs to bench.

bench/benchmain.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.
  */
 
 
 #include "BenchTimer.h"
@@ skipping 175 matching lines @@
 }
 
 enum Backend {
     kNonRendering_Backend,
     kRaster_Backend,
     kGPU_Backend,
     kPDF_Backend,
 };
 
 static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
-                             Backend backend, GrContext* context) {
+                             Backend backend, int sampleCount, GrContext* context) {
     SkDevice* device = NULL;
     SkBitmap bitmap;
     bitmap.setConfig(config, size.fX, size.fY);
 
     switch (backend) {
         case kRaster_Backend:
             bitmap.allocPixels();
             erase(bitmap);
             device = SkNEW_ARGS(SkDevice, (bitmap));
             break;
 #if SK_SUPPORT_GPU
         case kGPU_Backend: {
             GrTextureDesc desc;
             desc.fConfig = kSkia8888_GrPixelConfig;
             desc.fFlags = kRenderTarget_GrTextureFlagBit;
             desc.fWidth = size.fX;
             desc.fHeight = size.fY;
+            desc.fSampleCnt = sampleCount;
             SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
             if (!texture) {
                 return NULL;
             }
             device = SkNEW_ARGS(SkGpuDevice, (context, texture.get()));
             break;
         }
 #endif
         case kPDF_Backend:
         default:
             SkASSERT(!"unsupported");
     }
     return device;
 }
 
 #if SK_SUPPORT_GPU
 GrContextFactory gContextFactory;
 typedef GrContextFactory::GLContextType GLContextType;
 static const GLContextType kDontCareGLCtxType = GrContextFactory::kNative_GLContextType;
 #else
 typedef int GLContextType;
 static const GLContextType kDontCareGLCtxType = 0;
 #endif
 
 static const struct {
     SkBitmap::Config    fConfig;
     const char*         fName;
+    int                 fSampleCnt;
     Backend             fBackend;
     GLContextType       fContextType;
+    bool                fRunByDefault;
 } gConfigs[] = {
-    { SkBitmap::kNo_Config,         "NONRENDERING",    kNonRendering_Backend, kDontCareGLCtxType },
-    { SkBitmap::kARGB_8888_Config,  "8888",            kRaster_Backend, kDontCareGLCtxType },
-    { SkBitmap::kRGB_565_Config,    "565",             kRaster_Backend, kDontCareGLCtxType },
+    { SkBitmap::kNo_Config,         "NONRENDERING", 0, kNonRendering_Backend, kDontCareGLCtxType,                      true     },
+    { SkBitmap::kARGB_8888_Config,  "8888",         0, kRaster_Backend,       kDontCareGLCtxType,                      true     },
+    { SkBitmap::kRGB_565_Config,    "565",          0, kRaster_Backend,       kDontCareGLCtxType,                      true     },
 #if SK_SUPPORT_GPU
-    { SkBitmap::kARGB_8888_Config,  "GPU",             kGPU_Backend, GrContextFactory::kNative_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "GPU",          0, kGPU_Backend,          GrContextFactory::kNative_GLContextType, true     },
+    { SkBitmap::kARGB_8888_Config,  "MSAA4",        4, kGPU_Backend,          GrContextFactory::kNative_GLContextType, false    },
+    { SkBitmap::kARGB_8888_Config,  "MSAA16",      16, kGPU_Backend,          GrContextFactory::kNative_GLContextType, false    },
 #if SK_ANGLE
-    { SkBitmap::kARGB_8888_Config,  "ANGLE",           kGPU_Backend, GrContextFactory::kANGLE_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "ANGLE",        0, kGPU_Backend,          GrContextFactory::kANGLE_GLContextType,  true     },
 #endif // SK_ANGLE
 #ifdef SK_DEBUG
-    { SkBitmap::kARGB_8888_Config,  "Debug",           kGPU_Backend, GrContextFactory::kDebug_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "Debug",        0, kGPU_Backend,          GrContextFactory::kDebug_GLContextType,  GR_DEBUG },
 #endif // SK_DEBUG
-    { SkBitmap::kARGB_8888_Config,  "NULLGPU",         kGPU_Backend, GrContextFactory::kNull_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "NULLGPU",      0, kGPU_Backend,          GrContextFactory::kNull_GLContextType,   true     },
 #endif // SK_SUPPORT_GPU
 };
 
 static int findConfig(const char config[]) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) {
         if (!strcmp(config, gConfigs[i].fName)) {
             return i;
         }
     }
     return -1;
 }
 
 static bool skip_name(const SkTDArray<const char*> array, const char name[]) {
     if (0 == array.count()) {
         // no names, so don't skip anything
         return false;
     }
     for (int i = 0; i < array.count(); ++i) {
         if (strstr(name, array[i])) {
             // found the name, so don't skip
             return false;
         }
     }
     return true;
 }
 
 static void help() {
+    SkString configsStr;
+    static const size_t kConfigCount = SK_ARRAY_COUNT(gConfigs);
+    for (size_t i = 0; i < kConfigCount; ++i) {
+        configsStr.appendf("%s%s", gConfigs[i].fName, ((i == kConfigCount - 1) ? "" : "|"));
+    }
+
     SkDebugf("Usage: bench [-o outDir] [--repeat nr] [--logPerIter] "
                           "[--timers [wcgWC]*] [--rotate]\n"
              "    [--scale] [--clip] [--min] [--forceAA 1|0] [--forceFilter 1|0]\n"
              "    [--forceDither 1|0] [--forceBlend 1|0]"
 #if SK_SUPPORT_GPU
              " [--gpuCacheSize <bytes> <count>]"
 #endif
              "\n"
              "    [--strokeWidth width] [--match name]\n"
              "    [--mode normal|deferred|deferredSilent|record|picturerecord]\n"
-             "    [--config 8888|565|GPU|ANGLE|NULLGPU] [-Dfoo bar] [--logFile filename]\n"
-             "    [-h|--help]");
+             "    [--config ");
+    SkDebugf("%s]\n", configsStr.c_str());
+    SkDebugf("    [-Dfoo bar] [--logFile filename] [-h|--help]");
     SkDebugf("\n\n");
     SkDebugf("    -o outDir : Image of each bench will be put in outDir.\n");
     SkDebugf("    --repeat nr : Each bench repeats for nr times.\n");
     SkDebugf("    --logPerIter : "
              "Log each repeat timer instead of mean, default is disabled.\n");
     SkDebugf("    --timers [wcgWC]* : "
              "Display wall, cpu, gpu, truncated wall or truncated cpu time for each bench.\n");
     SkDebugf("    --rotate : Rotate before each bench runs.\n");
     SkDebugf("    --scale : Scale before each bench runs.\n");
     SkDebugf("    --clip : Clip before each bench runs.\n");
@@ skipping 15 matching lines @@
     SkDebugf("    --match name : Only run bench whose name is matched.\n");
     SkDebugf("    --mode normal|deferred|deferredSilent|record|picturerecord :\n"
              "             Run in the corresponding mode\n"
              "                 normal, Use a normal canvas to draw to;\n"
              "                 deferred, Use a deferrred canvas when drawing;\n"
              "                 deferredSilent, deferred with silent playback;\n"
              "                 record, Benchmark the time to record to an SkPicture;\n"
              "                 picturerecord, Benchmark the time to do record from a \n"
              "                                SkPicture to a SkPicture.\n");
     SkDebugf("    --logFile filename : destination for writing log output, in addition to stdout.\n");
-    SkDebugf("    --config ");
-    static const size_t kConfigCount = SK_ARRAY_COUNT(gConfigs);
-    for (size_t i = 0; i < kConfigCount; ++i) {
-        SkDebugf("%s%s", gConfigs[i].fName, ((i == kConfigCount - 1) ? "" : "|"));
-    }
-    SkDebugf(" :  Run bench in corresponding config mode.\n");
+    SkDebugf("    --config %s:\n", configsStr.c_str());
+    SkDebugf("             Run bench in corresponding config mode.\n");
     SkDebugf("    -Dfoo bar : Add extra definition to bench.\n");
     SkDebugf("    -h|--help : Show this help message.\n");
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
 #if SK_ENABLE_INST_COUNT
     gPrintInstCount = true;
 #endif
     SkAutoGraphics ag;
@@ skipping 26 matching lines @@
     float strokeWidth;
     SkTDArray<const char*> fMatches;
     benchModes benchMode = kNormal_benchModes;
     SkString perIterTimeformat("%.2f");
     SkString normalTimeFormat("%6.2f");
 
     SkString outDir;
     SkBitmap::Config outConfig = SkBitmap::kNo_Config;
     const char* configName = "";
     Backend backend = kRaster_Backend;  // for warning
+    int sampleCount = 0;
     SkTDArray<int> configs;
     bool userConfig = false;
 
     SkBenchLogger logger;
 
     char* const* stop = argv + argc;
     for (++argv; argv < stop; ++argv) {
         if (strcmp(*argv, "-o") == 0) {
             argv++;
             if (argv < stop && **argv) {
@@ skipping 189 matching lines @@
             && !outDir.isEmpty()) {
         logger.logError("'--mode record' and '--mode picturerecord' are not"
                   " compatible with -o.\n");
         return -1;
     }
     if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
         perIterTimeformat.set("%.4f");
         normalTimeFormat.set("%6.4f");
     }
     if (!userConfig) {
-        // if no config is specified by user, we add them all.
+        // if no config is specified by user, add the default configs
         for (unsigned int i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
-            *configs.append() = i;
+            if (gConfigs[i].fRunByDefault) {
+                *configs.append() = i;
+            }
         }
     }
     if (kNormal_benchModes != benchMode) {
         // Non-rendering configs only run in normal mode
         for (int i = 0; i < configs.count(); ++i) {
             int configIdx = configs[i];
             if (kNonRendering_Backend == gConfigs[configIdx].fBackend) {
                 configs.remove(i, 1);
                 --i;
             }
         }
     }
 
+#if SK_SUPPORT_GPU
+    for (int i = 0; i < configs.count(); ++i) {
+        int configIdx = configs[i];
+
+        if (kGPU_Backend == gConfigs[configIdx].fBackend && gConfigs[configIdx].fSampleCnt > 0) {
+            GrContext* context = gContextFactory.get(gConfigs[configIdx].fContextType);
+            if (NULL == context) {
+                SkString error;
+                error.printf("Error creating GrContext for config %s. Config will be skipped.\n",
+                             gConfigs[configIdx].fName);
+                logger.logError(error.c_str());
+                configs.remove(i);
+                --i;
+                continue;
+            }
+            if (gConfigs[configIdx].fSampleCnt > context->getMaxSampleCount()){
+                SkString error;
+                error.printf("Sample count (%d) for config %s is unsupported. Config will be skipped.\n",
+                             gConfigs[configIdx].fSampleCnt, gConfigs[configIdx].fName);
+                logger.logError(error.c_str());
+                configs.remove(i);
+                --i;
+                continue;
+            }
+        }
+    }
+#endif
+
     // report our current settings
     {
         SkString str;
         const char* deferredMode = benchMode == kDeferred_benchModes ? "yes" :
             (benchMode == kDeferredSilent_benchModes ? "silent" : "no");
         str.printf("skia bench: alpha=0x%02X antialias=%d filter=%d "
                    "deferred=%s logperiter=%d",
                    forceAlpha, forceAA, forceFilter, deferredMode,
                    logPerIter);
         str.appendf(" rotate=%d scale=%d clip=%d min=%d",
@@ skipping 104 matching lines @@
                 }
             } else {
                 if (!bench->isRendering()) {
                     continue;
                 }
             }
 
             outConfig = gConfigs[configIndex].fConfig;
             configName = gConfigs[configIndex].fName;
             backend = gConfigs[configIndex].fBackend;
+            sampleCount = gConfigs[configIndex].fSampleCnt;
             GrContext* context = NULL;
             BenchTimer* timer = timers[configIndex];
 
 #if SK_SUPPORT_GPU
             SkGLContextHelper* glContext = NULL;
             if (kGPU_Backend == backend) {
                 context = gContextFactory.get(gConfigs[configIndex].fContextType);
                 if (NULL == context) {
                     continue;
                 }
                 glContext = gContextFactory.getGLContext(gConfigs[configIndex].fContextType);
             }
 #endif
             SkDevice* device = NULL;
             SkCanvas* canvas = NULL;
             SkPicture pictureRecordFrom;
             SkPicture pictureRecordTo;
 
             if (kNonRendering_Backend != backend) {
-                device = make_device(outConfig, dim, backend, context);
+                device = make_device(outConfig, dim, backend, sampleCount, context);
 
                 switch(benchMode) {
                     case kDeferredSilent_benchModes:
                     case kDeferred_benchModes:
                         canvas = new SkDeferredCanvas(device);
                         break;
                     case kRecord_benchModes:
                         canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
                             SkPicture::kUsePathBoundsForClip_RecordingFlag);
                         canvas->ref();
@@ skipping 153 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif