1
2/*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10#include "BenchTimer.h"
11
12#if SK_SUPPORT_GPU
13#include "GrContext.h"
14#include "GrContextFactory.h"
15#include "gl/GrGLDefines.h"
16#include "GrRenderTarget.h"
17#include "SkGpuDevice.h"
18#else
19class GrContext;
20#endif // SK_SUPPORT_GPU
21
22#include "SkBenchLogger.h"
23#include "SkBenchmark.h"
24#include "SkCanvas.h"
25#include "SkCommandLineFlags.h"
26#include "SkDeferredCanvas.h"
27#include "SkDevice.h"
28#include "SkColorPriv.h"
29#include "SkGraphics.h"
30#include "SkImageEncoder.h"
31#include "SkNWayCanvas.h"
32#include "SkPicture.h"
33#include "SkString.h"
34#include "SkTArray.h"
35#include "TimerData.h"
36
37enum benchModes {
38    kNormal_benchModes,
39    kDeferred_benchModes,
40    kDeferredSilent_benchModes,
41    kRecord_benchModes,
42    kPictureRecord_benchModes
43};
44
45///////////////////////////////////////////////////////////////////////////////
46
47static void erase(SkBitmap& bm) {
48    if (bm.config() == SkBitmap::kA8_Config) {
49        bm.eraseColor(SK_ColorTRANSPARENT);
50    } else {
51        bm.eraseColor(SK_ColorWHITE);
52    }
53}
54
55#if 0
56static bool equal(const SkBitmap& bm1, const SkBitmap& bm2) {
57    if (bm1.width() != bm2.width() ||
58        bm1.height() != bm2.height() ||
59        bm1.config() != bm2.config()) {
60        return false;
61    }
62
63    size_t pixelBytes = bm1.width() * bm1.bytesPerPixel();
64    for (int y = 0; y < bm1.height(); y++) {
65        if (memcmp(bm1.getAddr(0, y), bm2.getAddr(0, y), pixelBytes)) {
66            return false;
67        }
68    }
69    return true;
70}
71#endif
72
73class Iter {
74public:
75    Iter(void* param) {
76        fBench = BenchRegistry::Head();
77        fParam = param;
78    }
79
80    SkBenchmark* next() {
81        if (fBench) {
82            BenchRegistry::Factory f = fBench->factory();
83            fBench = fBench->next();
84            return f(fParam);
85        }
86        return NULL;
87    }
88
89private:
90    const BenchRegistry* fBench;
91    void* fParam;
92};
93
94class AutoPrePostDraw {
95public:
96    AutoPrePostDraw(SkBenchmark* bench) : fBench(bench) {
97        fBench->preDraw();
98    }
99    ~AutoPrePostDraw() {
100        fBench->postDraw();
101    }
102private:
103    SkBenchmark* fBench;
104};
105
106static void make_filename(const char name[], SkString* path) {
107    path->set(name);
108    for (int i = 0; name[i]; i++) {
109        switch (name[i]) {
110            case '/':
111            case '\\':
112            case ' ':
113            case ':':
114                path->writable_str()[i] = '-';
115                break;
116            default:
117                break;
118        }
119    }
120}
121
122static void saveFile(const char name[], const char config[], const char dir[],
123                     const SkBitmap& bm) {
124    SkBitmap copy;
125    if (!bm.copyTo(&copy, SkBitmap::kARGB_8888_Config)) {
126        return;
127    }
128
129    if (bm.config() == SkBitmap::kA8_Config) {
130        // turn alpha into gray-scale
131        size_t size = copy.getSize() >> 2;
132        SkPMColor* p = copy.getAddr32(0, 0);
133        for (size_t i = 0; i < size; i++) {
134            int c = (*p >> SK_A32_SHIFT) & 0xFF;
135            c = 255 - c;
136            c |= (c << 24) | (c << 16) | (c << 8);
137            *p++ = c | (SK_A32_MASK << SK_A32_SHIFT);
138        }
139    }
140
141    SkString str;
142    make_filename(name, &str);
143    str.appendf("_%s.png", config);
144    str.prepend(dir);
145    ::remove(str.c_str());
146    SkImageEncoder::EncodeFile(str.c_str(), copy, SkImageEncoder::kPNG_Type,
147                               100);
148}
149
150static void performClip(SkCanvas* canvas, int w, int h) {
151    SkRect r;
152
153    r.set(SkIntToScalar(10), SkIntToScalar(10),
154          SkIntToScalar(w*2/3), SkIntToScalar(h*2/3));
155    canvas->clipRect(r, SkRegion::kIntersect_Op);
156
157    r.set(SkIntToScalar(w/3), SkIntToScalar(h/3),
158          SkIntToScalar(w-10), SkIntToScalar(h-10));
159    canvas->clipRect(r, SkRegion::kXOR_Op);
160}
161
162static void performRotate(SkCanvas* canvas, int w, int h) {
163    const SkScalar x = SkIntToScalar(w) / 2;
164    const SkScalar y = SkIntToScalar(h) / 2;
165
166    canvas->translate(x, y);
167    canvas->rotate(SkIntToScalar(35));
168    canvas->translate(-x, -y);
169}
170
171static void performScale(SkCanvas* canvas, int w, int h) {
172    const SkScalar x = SkIntToScalar(w) / 2;
173    const SkScalar y = SkIntToScalar(h) / 2;
174
175    canvas->translate(x, y);
176    // just enough so we can't take the sprite case
177    canvas->scale(SK_Scalar1 * 99/100, SK_Scalar1 * 99/100);
178    canvas->translate(-x, -y);
179}
180
181static bool parse_bool_arg(char * const* argv, char* const* stop, bool* var) {
182    if (argv < stop) {
183        *var = atoi(*argv) != 0;
184        return true;
185    }
186    return false;
187}
188
189enum Backend {
190    kNonRendering_Backend,
191    kRaster_Backend,
192    kGPU_Backend,
193    kPDF_Backend,
194};
195
196static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
197                             Backend backend, int sampleCount, GrContext* context) {
198    SkDevice* device = NULL;
199    SkBitmap bitmap;
200    bitmap.setConfig(config, size.fX, size.fY);
201
202    switch (backend) {
203        case kRaster_Backend:
204            bitmap.allocPixels();
205            erase(bitmap);
206            device = SkNEW_ARGS(SkDevice, (bitmap));
207            break;
208#if SK_SUPPORT_GPU
209        case kGPU_Backend: {
210            GrTextureDesc desc;
211            desc.fConfig = kSkia8888_GrPixelConfig;
212            desc.fFlags = kRenderTarget_GrTextureFlagBit;
213            desc.fWidth = size.fX;
214            desc.fHeight = size.fY;
215            desc.fSampleCnt = sampleCount;
216            SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
217            if (!texture) {
218                return NULL;
219            }
220            device = SkNEW_ARGS(SkGpuDevice, (context, texture.get()));
221            break;
222        }
223#endif
224        case kPDF_Backend:
225        default:
226            SkASSERT(!"unsupported");
227    }
228    return device;
229}
230
231#if SK_SUPPORT_GPU
232GrContextFactory gContextFactory;
233typedef GrContextFactory::GLContextType GLContextType;
234static const GLContextType kDontCareGLCtxType = GrContextFactory::kNative_GLContextType;
235#else
236typedef int GLContextType;
237static const GLContextType kDontCareGLCtxType = 0;
238#endif
239
240static const struct {
241    SkBitmap::Config    fConfig;
242    const char*         fName;
243    int                 fSampleCnt;
244    Backend             fBackend;
245    GLContextType       fContextType;
246    bool                fRunByDefault;
247} gConfigs[] = {
248    { SkBitmap::kNo_Config,         "NONRENDERING", 0, kNonRendering_Backend, kDontCareGLCtxType,                      true     },
249    { SkBitmap::kARGB_8888_Config,  "8888",         0, kRaster_Backend,       kDontCareGLCtxType,                      true     },
250    { SkBitmap::kRGB_565_Config,    "565",          0, kRaster_Backend,       kDontCareGLCtxType,                      true     },
251#if SK_SUPPORT_GPU
252    { SkBitmap::kARGB_8888_Config,  "GPU",          0, kGPU_Backend,          GrContextFactory::kNative_GLContextType, true     },
253    { SkBitmap::kARGB_8888_Config,  "MSAA4",        4, kGPU_Backend,          GrContextFactory::kNative_GLContextType, false    },
254    { SkBitmap::kARGB_8888_Config,  "MSAA16",      16, kGPU_Backend,          GrContextFactory::kNative_GLContextType, false    },
255#if SK_ANGLE
256    { SkBitmap::kARGB_8888_Config,  "ANGLE",        0, kGPU_Backend,          GrContextFactory::kANGLE_GLContextType,  true     },
257#endif // SK_ANGLE
258#ifdef SK_DEBUG
259    { SkBitmap::kARGB_8888_Config,  "Debug",        0, kGPU_Backend,          GrContextFactory::kDebug_GLContextType,  GR_DEBUG },
260#endif // SK_DEBUG
261    { SkBitmap::kARGB_8888_Config,  "NULLGPU",      0, kGPU_Backend,          GrContextFactory::kNull_GLContextType,   true     },
262#endif // SK_SUPPORT_GPU
263};
264
265static int findConfig(const char config[]) {
266    for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) {
267        if (!strcmp(config, gConfigs[i].fName)) {
268            return i;
269        }
270    }
271    return -1;
272}
273
274static void help() {
275    SkString configsStr;
276    static const size_t kConfigCount = SK_ARRAY_COUNT(gConfigs);
277    for (size_t i = 0; i < kConfigCount; ++i) {
278        configsStr.appendf("%s%s", gConfigs[i].fName, ((i == kConfigCount - 1) ? "" : "|"));
279    }
280
281    SkDebugf("Usage: bench [-o outDir] [--repeat nr] [--logPerIter] "
282                          "[--timers [wcgWC]*] [--rotate]\n"
283             "    [--scale] [--clip] [--min] [--forceAA 1|0] [--forceFilter 1|0]\n"
284             "    [--forceDither 1|0] [--forceBlend 1|0]"
285#if SK_SUPPORT_GPU
286             " [--gpuCacheSize <bytes> <count>]"
287#endif
288             "\n"
289             "    [--strokeWidth width] [--match name]\n"
290             "    [--mode normal|deferred|deferredSilent|record|picturerecord]\n"
291             "    [--config ");
292    SkDebugf("%s]\n", configsStr.c_str());
293    SkDebugf("    [-Dfoo bar] [--logFile filename] [-h|--help]");
294    SkDebugf("\n\n");
295    SkDebugf("    -o outDir : Image of each bench will be put in outDir.\n");
296    SkDebugf("    --repeat nr : Each bench repeats for nr times.\n");
297    SkDebugf("    --logPerIter : "
298             "Log each repeat timer instead of mean, default is disabled.\n");
299    SkDebugf("    --timers [wcgWC]* : "
300             "Display wall, cpu, gpu, truncated wall or truncated cpu time for each bench.\n");
301    SkDebugf("    --rotate : Rotate before each bench runs.\n");
302    SkDebugf("    --scale : Scale before each bench runs.\n");
303    SkDebugf("    --clip : Clip before each bench runs.\n");
304    SkDebugf("    --min : Print the minimum times (instead of average).\n");
305    SkDebugf("    --forceAA 1|0 : "
306             "Enable/disable anti-aliased, default is enabled.\n");
307    SkDebugf("    --forceFilter 1|0 : "
308             "Enable/disable bitmap filtering, default is disabled.\n");
309    SkDebugf("    --forceDither 1|0 : "
310             "Enable/disable dithering, default is disabled.\n");
311    SkDebugf("    --forceBlend 1|0 : "
312             "Enable/disable dithering, default is disabled.\n");
313#if SK_SUPPORT_GPU
314    SkDebugf("    --gpuCacheSize <bytes> <count>: "
315             "limits gpu cache to  bytes size or object count.\n");
316    SkDebugf("      -1 for either value means use the default. 0 for either disables the cache.\n");
317#endif
318    SkDebugf("    --strokeWidth width : The width for path stroke.\n");
319    SkDebugf("    --match [~][^]substring[$] [...] of test name to run.\n"
320             "             Multiple matches may be separated by spaces.\n"
321             "             ~ causes a matching test to always be skipped\n"
322             "             ^ requires the start of the test to match\n"
323             "             $ requires the end of the test to match\n"
324             "             ^ and $ requires an exact match\n"
325             "             If a test does not match any list entry,\n"
326             "             it is skipped unless some list entry starts with ~\n");
327    SkDebugf("    --mode normal|deferred|deferredSilent|record|picturerecord :\n"
328             "             Run in the corresponding mode\n"
329             "                 normal, Use a normal canvas to draw to;\n"
330             "                 deferred, Use a deferrred canvas when drawing;\n"
331             "                 deferredSilent, deferred with silent playback;\n"
332             "                 record, Benchmark the time to record to an SkPicture;\n"
333             "                 picturerecord, Benchmark the time to do record from a \n"
334             "                                SkPicture to a SkPicture.\n");
335    SkDebugf("    --logFile filename : destination for writing log output, in addition to stdout.\n");
336    SkDebugf("    --config %s:\n", configsStr.c_str());
337    SkDebugf("             Run bench in corresponding config mode.\n");
338    SkDebugf("    -Dfoo bar : Add extra definition to bench.\n");
339    SkDebugf("    -h|--help : Show this help message.\n");
340}
341
342int tool_main(int argc, char** argv);
343int tool_main(int argc, char** argv) {
344#if SK_ENABLE_INST_COUNT
345    gPrintInstCount = true;
346#endif
347    SkAutoGraphics ag;
348
349    SkTDict<const char*> defineDict(1024);
350    int repeatDraw = 1;
351
352    int forceAlpha = 0xFF;
353    bool forceAA = true;
354    bool forceFilter = false;
355    SkTriState::State forceDither = SkTriState::kDefault;
356
357    static const uint32_t kDefaultTimerTypes = TimerData::kCpu_Flag | TimerData::kGpu_Flag;
358    static const TimerData::Result kDefaultTimerResult = TimerData::kAvg_Result;
359    uint32_t timerTypes = kDefaultTimerTypes;
360    TimerData::Result timerResult = kDefaultTimerResult;
361
362    bool doScale = false;
363    bool doRotate = false;
364    bool doClip = false;
365    bool hasStrokeWidth = false;
366
367#if SK_SUPPORT_GPU
368    struct {
369        int     fBytes;
370        int     fCount;
371    } gpuCacheSize = { -1, -1 }; // -1s mean use the default
372#endif
373
374    float strokeWidth;
375    SkTDArray<const char*> fMatches;
376    benchModes benchMode = kNormal_benchModes;
377    SkString perIterTimeformat("%.2f");
378    SkString normalTimeFormat("%6.2f");
379
380    SkString outDir;
381    SkBitmap::Config outConfig = SkBitmap::kNo_Config;
382    const char* configName = "";
383    Backend backend = kRaster_Backend;  // for warning
384    int sampleCount = 0;
385    SkTDArray<int> configs;
386    bool userConfig = false;
387
388    SkBenchLogger logger;
389
390    char* const* stop = argv + argc;
391    for (++argv; argv < stop; ++argv) {
392        if (strcmp(*argv, "-o") == 0) {
393            argv++;
394            if (argv < stop && **argv) {
395                outDir.set(*argv);
396                if (outDir.c_str()[outDir.size() - 1] != '/') {
397                    outDir.append("/");
398                }
399            }
400        } else if (strcmp(*argv, "--repeat") == 0) {
401            argv++;
402            if (argv < stop) {
403                repeatDraw = atoi(*argv);
404                if (repeatDraw < 1) {
405                    repeatDraw = 1;
406                }
407            } else {
408                logger.logError("missing arg for --repeat\n");
409                help();
410                return -1;
411            }
412        } else if (strcmp(*argv, "--logPerIter") == 0) {
413            timerResult = TimerData::kPerIter_Result;
414        } else if (strcmp(*argv, "--timers") == 0) {
415            argv++;
416            if (argv < stop) {
417                timerTypes = 0;
418                for (char* t = *argv; *t; ++t) {
419                    switch (*t) {
420                    case 'w': timerTypes |= TimerData::kWall_Flag; break;
421                    case 'c': timerTypes |= TimerData::kCpu_Flag; break;
422                    case 'W': timerTypes |= TimerData::kTruncatedWall_Flag; break;
423                    case 'C': timerTypes |= TimerData::kTruncatedCpu_Flag; break;
424                    case 'g': timerTypes |= TimerData::kGpu_Flag; break;
425                    }
426                }
427            } else {
428                logger.logError("missing arg for --timers\n");
429                help();
430                return -1;
431            }
432        } else if (!strcmp(*argv, "--rotate")) {
433            doRotate = true;
434        } else if (!strcmp(*argv, "--scale")) {
435            doScale = true;
436        } else if (!strcmp(*argv, "--clip")) {
437            doClip = true;
438        } else if (!strcmp(*argv, "--min")) {
439            timerResult = TimerData::kMin_Result;
440        } else if (strcmp(*argv, "--forceAA") == 0) {
441            if (!parse_bool_arg(++argv, stop, &forceAA)) {
442                logger.logError("missing arg for --forceAA\n");
443                help();
444                return -1;
445            }
446        } else if (strcmp(*argv, "--forceFilter") == 0) {
447            if (!parse_bool_arg(++argv, stop, &forceFilter)) {
448                logger.logError("missing arg for --forceFilter\n");
449                help();
450                return -1;
451            }
452        } else if (strcmp(*argv, "--forceDither") == 0) {
453            bool tmp;
454            if (!parse_bool_arg(++argv, stop, &tmp)) {
455                logger.logError("missing arg for --forceDither\n");
456                help();
457                return -1;
458            }
459            forceDither = tmp ? SkTriState::kTrue : SkTriState::kFalse;
460        } else if (strcmp(*argv, "--forceBlend") == 0) {
461            bool wantAlpha = false;
462            if (!parse_bool_arg(++argv, stop, &wantAlpha)) {
463                logger.logError("missing arg for --forceBlend\n");
464                help();
465                return -1;
466            }
467            forceAlpha = wantAlpha ? 0x80 : 0xFF;
468#if SK_SUPPORT_GPU
469        } else if (strcmp(*argv, "--gpuCacheSize") == 0) {
470            if (stop - argv > 2) {
471                gpuCacheSize.fBytes = atoi(*++argv);
472                gpuCacheSize.fCount = atoi(*++argv);
473            } else {
474                SkDebugf("missing arg for --gpuCacheSize\n");
475                help();
476                return -1;
477            }
478#endif
479        } else if (strcmp(*argv, "--mode") == 0) {
480            argv++;
481            if (argv < stop) {
482                if (strcmp(*argv, "normal") == 0) {
483                    benchMode = kNormal_benchModes;
484                } else if (strcmp(*argv, "deferred") == 0) {
485                    benchMode = kDeferred_benchModes;
486                } else if (strcmp(*argv, "deferredSilent") == 0) {
487                    benchMode = kDeferredSilent_benchModes;
488                } else if (strcmp(*argv, "record") == 0) {
489                    benchMode = kRecord_benchModes;
490                } else if (strcmp(*argv, "picturerecord") == 0) {
491                    benchMode = kPictureRecord_benchModes;
492                } else {
493                    logger.logError("bad arg for --mode\n");
494                    help();
495                    return -1;
496                }
497            } else {
498                logger.logError("missing arg for --mode\n");
499                help();
500                return -1;
501            }
502        } else if (strcmp(*argv, "--strokeWidth") == 0) {
503            argv++;
504            if (argv < stop) {
505                const char *strokeWidthStr = *argv;
506                if (sscanf(strokeWidthStr, "%f", &strokeWidth) != 1) {
507                  logger.logError("bad arg for --strokeWidth\n");
508                  help();
509                  return -1;
510                }
511                hasStrokeWidth = true;
512            } else {
513                logger.logError("missing arg for --strokeWidth\n");
514                help();
515                return -1;
516            }
517        } else if (strcmp(*argv, "--match") == 0) {
518            argv++;
519            while (argv < stop && (*argv)[0] != '-') {
520                *fMatches.append() = *argv++;
521            }
522            argv--;
523            if (!fMatches.count()) {
524                logger.logError("missing arg for --match\n");
525                help();
526                return -1;
527            }
528        } else if (strcmp(*argv, "--config") == 0) {
529            argv++;
530            if (argv < stop) {
531                int index = findConfig(*argv);
532                if (index >= 0) {
533                    *configs.append() = index;
534                    userConfig = true;
535                } else {
536                    SkString str;
537                    str.printf("unrecognized config %s\n", *argv);
538                    logger.logError(str);
539                    help();
540                    return -1;
541                }
542            } else {
543                logger.logError("missing arg for --config\n");
544                help();
545                return -1;
546            }
547        } else if (strcmp(*argv, "--logFile") == 0) {
548            argv++;
549            if (argv < stop) {
550                if (!logger.SetLogFile(*argv)) {
551                    SkString str;
552                    str.printf("Could not open %s for writing.", *argv);
553                    logger.logError(str);
554                    return -1;
555                }
556            } else {
557                logger.logError("missing arg for --logFile\n");
558                help();
559                return -1;
560            }
561        } else if (strlen(*argv) > 2 && strncmp(*argv, "-D", 2) == 0) {
562            argv++;
563            if (argv < stop) {
564                defineDict.set(argv[-1] + 2, *argv);
565            } else {
566                logger.logError("incomplete '-Dfoo bar' definition\n");
567                help();
568                return -1;
569            }
570        } else if (strcmp(*argv, "--help") == 0 || strcmp(*argv, "-h") == 0) {
571            help();
572            return 0;
573        } else {
574            SkString str;
575            str.printf("unrecognized arg %s\n", *argv);
576            logger.logError(str);
577            help();
578            return -1;
579        }
580    }
581    if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)
582            && !outDir.isEmpty()) {
583        logger.logError("'--mode record' and '--mode picturerecord' are not"
584                  " compatible with -o.\n");
585        return -1;
586    }
587    if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
588        perIterTimeformat.set("%.4f");
589        normalTimeFormat.set("%6.4f");
590    }
591    if (!userConfig) {
592        // if no config is specified by user, add the default configs
593        for (unsigned int i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
594            if (gConfigs[i].fRunByDefault) {
595                *configs.append() = i;
596            }
597        }
598    }
599    if (kNormal_benchModes != benchMode) {
600        // Non-rendering configs only run in normal mode
601        for (int i = 0; i < configs.count(); ++i) {
602            int configIdx = configs[i];
603            if (kNonRendering_Backend == gConfigs[configIdx].fBackend) {
604                configs.remove(i, 1);
605                --i;
606            }
607        }
608    }
609
610#if SK_SUPPORT_GPU
611    for (int i = 0; i < configs.count(); ++i) {
612        int configIdx = configs[i];
613
614        if (kGPU_Backend == gConfigs[configIdx].fBackend && gConfigs[configIdx].fSampleCnt > 0) {
615            GrContext* context = gContextFactory.get(gConfigs[configIdx].fContextType);
616            if (NULL == context) {
617                SkString error;
618                error.printf("Error creating GrContext for config %s. Config will be skipped.\n",
619                             gConfigs[configIdx].fName);
620                logger.logError(error.c_str());
621                configs.remove(i);
622                --i;
623                continue;
624            }
625            if (gConfigs[configIdx].fSampleCnt > context->getMaxSampleCount()){
626                SkString error;
627                error.printf("Sample count (%d) for config %s is unsupported. "
628                             "Config will be skipped.\n",
629                             gConfigs[configIdx].fSampleCnt, gConfigs[configIdx].fName);
630                logger.logError(error.c_str());
631                configs.remove(i);
632                --i;
633                continue;
634            }
635        }
636    }
637#endif
638
639    // report our current settings
640    {
641        SkString str;
642        const char* deferredMode = benchMode == kDeferred_benchModes ? "yes" :
643            (benchMode == kDeferredSilent_benchModes ? "silent" : "no");
644        str.printf("skia bench: alpha=0x%02X antialias=%d filter=%d "
645                   "deferred=%s logperiter=%d",
646                   forceAlpha, forceAA, forceFilter, deferredMode,
647                   TimerData::kPerIter_Result == timerResult);
648        str.appendf(" rotate=%d scale=%d clip=%d min=%d",
649                   doRotate, doScale, doClip, TimerData::kMin_Result == timerResult);
650        str.appendf(" record=%d picturerecord=%d",
651                    benchMode == kRecord_benchModes,
652                    benchMode == kPictureRecord_benchModes);
653        const char * ditherName;
654        switch (forceDither) {
655            case SkTriState::kDefault: ditherName = "default"; break;
656            case SkTriState::kTrue: ditherName = "true"; break;
657            case SkTriState::kFalse: ditherName = "false"; break;
658            default: ditherName = "<invalid>"; break;
659        }
660        str.appendf(" dither=%s", ditherName);
661
662        if (hasStrokeWidth) {
663            str.appendf(" strokeWidth=%f", strokeWidth);
664        } else {
665            str.append(" strokeWidth=none");
666        }
667
668#if defined(SK_SCALAR_IS_FLOAT)
669        str.append(" scalar=float");
670#elif defined(SK_SCALAR_IS_FIXED)
671        str.append(" scalar=fixed");
672#endif
673
674#if defined(SK_BUILD_FOR_WIN32)
675        str.append(" system=WIN32");
676#elif defined(SK_BUILD_FOR_MAC)
677        str.append(" system=MAC");
678#elif defined(SK_BUILD_FOR_ANDROID)
679        str.append(" system=ANDROID");
680#elif defined(SK_BUILD_FOR_UNIX)
681        str.append(" system=UNIX");
682#else
683        str.append(" system=other");
684#endif
685
686#if defined(SK_DEBUG)
687        str.append(" DEBUG");
688#endif
689        str.append("\n");
690        logger.logProgress(str);
691    }
692
693    SkTArray<BenchTimer*> timers(SK_ARRAY_COUNT(gConfigs));
694    for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
695#if SK_SUPPORT_GPU
696        SkGLContextHelper* glCtx = NULL;
697        if (kGPU_Backend == gConfigs[i].fBackend) {
698            GrContext* context = gContextFactory.get(gConfigs[i].fContextType);
699            if (NULL != context) {
700                // Set the user specified cache limits if non-default.
701                size_t bytes;
702                int count;
703                context->getTextureCacheLimits(&count, &bytes);
704                if (-1 != gpuCacheSize.fBytes) {
705                    bytes = static_cast<size_t>(gpuCacheSize.fBytes);
706                }
707                if (-1 != gpuCacheSize.fCount) {
708                    count = gpuCacheSize.fCount;
709                }
710                context->setTextureCacheLimits(count, bytes);
711            }
712            glCtx = gContextFactory.getGLContext(gConfigs[i].fContextType);
713        }
714        timers.push_back(SkNEW_ARGS(BenchTimer, (glCtx)));
715#else
716        timers.push_back(SkNEW(BenchTimer));
717#endif
718    }
719
720    Iter iter(&defineDict);
721    SkBenchmark* bench;
722    while ((bench = iter.next()) != NULL) {
723        SkAutoTUnref<SkBenchmark> benchUnref(bench);
724
725        SkIPoint dim = bench->getSize();
726        if (dim.fX <= 0 || dim.fY <= 0) {
727            continue;
728        }
729
730        bench->setForceAlpha(forceAlpha);
731        bench->setForceAA(forceAA);
732        bench->setForceFilter(forceFilter);
733        bench->setDither(forceDither);
734        if (hasStrokeWidth) {
735            bench->setStrokeWidth(strokeWidth);
736        }
737
738        // only run benchmarks if their name contains matchStr
739        if (SkCommandLineFlags::ShouldSkip(fMatches, bench->getName())) {
740            continue;
741        }
742
743        bool loggedBenchStart = false;
744
745        AutoPrePostDraw appd(bench);
746
747        for (int x = 0; x < configs.count(); ++x) {
748            int configIndex = configs[x];
749
750            bool setupFailed = false;
751
752            if (kNonRendering_Backend == gConfigs[configIndex].fBackend) {
753                if (bench->isRendering()) {
754                    continue;
755                }
756            } else {
757                if (!bench->isRendering()) {
758                    continue;
759                }
760            }
761
762            outConfig = gConfigs[configIndex].fConfig;
763            configName = gConfigs[configIndex].fName;
764            backend = gConfigs[configIndex].fBackend;
765            sampleCount = gConfigs[configIndex].fSampleCnt;
766            GrContext* context = NULL;
767            BenchTimer* timer = timers[configIndex];
768
769#if SK_SUPPORT_GPU
770            SkGLContextHelper* glContext = NULL;
771            if (kGPU_Backend == backend) {
772                context = gContextFactory.get(gConfigs[configIndex].fContextType);
773                if (NULL == context) {
774                    continue;
775                }
776                glContext = gContextFactory.getGLContext(gConfigs[configIndex].fContextType);
777            }
778#endif
779            SkDevice* device = NULL;
780            SkCanvas* canvas = NULL;
781            SkPicture pictureRecordFrom;
782            SkPicture pictureRecordTo;
783
784            if (kNonRendering_Backend != backend) {
785                device = make_device(outConfig, dim, backend, sampleCount, context);
786                if (NULL == device) {
787                    SkString error;
788                    error.printf("Device creation failure for config %s. Will skip.\n", configName);
789                    logger.logError(error.c_str());
790                    setupFailed = true;
791                } else {
792                    switch(benchMode) {
793                        case kDeferredSilent_benchModes:
794                        case kDeferred_benchModes:
795                            canvas = SkDeferredCanvas::Create(device);
796                            break;
797                        case kRecord_benchModes:
798                            canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
799                                SkPicture::kUsePathBoundsForClip_RecordingFlag);
800                            canvas->ref();
801                            break;
802                        case kPictureRecord_benchModes: {
803                            // This sets up picture-to-picture recording.
804                            // The C++ drawing calls for the benchmark are recorded into
805                            // pictureRecordFrom. As the benchmark, we will time how
806                            // long it takes to playback pictureRecordFrom into
807                            // pictureRecordTo.
808                            SkCanvas* tempCanvas = pictureRecordFrom.beginRecording(dim.fX, dim.fY,
809                                SkPicture::kUsePathBoundsForClip_RecordingFlag);
810                            bench->draw(tempCanvas);
811                            pictureRecordFrom.endRecording();
812                            canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
813                                SkPicture::kUsePathBoundsForClip_RecordingFlag);
814                            canvas->ref();
815                            break;
816                        }
817                        case kNormal_benchModes:
818                            canvas = new SkCanvas(device);
819                            break;
820                        default:
821                            SkASSERT(0);
822                    }
823                    device->unref();
824                    canvas->clear(SK_ColorWHITE);
825                }
826            }
827            SkAutoUnref canvasUnref(canvas);
828            if (!setupFailed) {
829                if (NULL != canvas) {
830                    if (doClip) {
831                        performClip(canvas, dim.fX, dim.fY);
832                    }
833                    if (doScale) {
834                        performScale(canvas, dim.fX, dim.fY);
835                    }
836                    if (doRotate) {
837                        performRotate(canvas, dim.fX, dim.fY);
838                    }
839                }
840
841                if (!loggedBenchStart) {
842                    loggedBenchStart = true;
843                    SkString str;
844                    str.printf("running bench [%d %d] %28s", dim.fX, dim.fY, bench->getName());
845                    logger.logProgress(str);
846                }
847
848                // warm up caches if needed
849                if (repeatDraw > 1 && NULL != canvas) {
850#if SK_SUPPORT_GPU
851                    // purge the GPU resources to reduce variance
852                    if (NULL != context) {
853                        context->freeGpuResources();
854                    }
855#endif
856                    SkAutoCanvasRestore acr(canvas, true);
857                    if (benchMode == kPictureRecord_benchModes) {
858                        pictureRecordFrom.draw(canvas);
859                    } else {
860                        bench->draw(canvas);
861                    }
862
863                    if (kDeferredSilent_benchModes == benchMode) {
864                        static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
865                    } else {
866                        canvas->flush();
867                    }
868#if SK_SUPPORT_GPU
869                    if (NULL != context) {
870                        context->flush();
871                        SK_GL(*glContext, Finish());
872                    }
873#endif
874                }
875
876                // record timer values for each repeat, and their sum
877                TimerData timerData(repeatDraw);
878                for (int i = 0; i < repeatDraw; i++) {
879                    if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
880                        // This will clear the recorded commands so that they do not
881                        // accumulate.
882                        canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
883                            SkPicture::kUsePathBoundsForClip_RecordingFlag);
884                    }
885
886                    timer->start(bench->getDurationScale());
887                    if (NULL != canvas) {
888                        canvas->save();
889                    }
890                    if (benchMode == kPictureRecord_benchModes) {
891                        pictureRecordFrom.draw(canvas);
892                    } else {
893                        bench->draw(canvas);
894                    }
895
896                    if (kDeferredSilent_benchModes == benchMode) {
897                        static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
898                    } else if (NULL != canvas) {
899                        canvas->flush();
900                    }
901
902                    if (NULL != canvas) {
903                        canvas->restore();
904                    }
905
906                    // stop the truncated timer after the last canvas call but
907                    // don't wait for all the GL calls to complete
908                    timer->truncatedEnd();
909#if SK_SUPPORT_GPU
910                    if (NULL != glContext) {
911                        context->flush();
912                        SK_GL(*glContext, Finish());
913                    }
914#endif
915                    // stop the inclusive and gpu timers once all the GL calls
916                    // have completed
917                    timer->end();
918
919                    SkAssertResult(timerData.appendTimes(timer));
920
921                }
922                if (repeatDraw > 1) {
923                    const char* timeFormat;
924                    if (TimerData::kPerIter_Result == timerResult) {
925                        timeFormat = perIterTimeformat.c_str();
926                    } else {
927                        timeFormat = normalTimeFormat.c_str();
928                    }
929                    uint32_t filteredTimerTypes = timerTypes;
930                    if (NULL == context) {
931                        filteredTimerTypes &= ~TimerData::kGpu_Flag;
932                    }
933                    SkString result = timerData.getResult(timeFormat,
934                                        timerResult,
935                                        configName,
936                                        filteredTimerTypes);
937                    logger.logProgress(result);
938                }
939                if (outDir.size() > 0 && kNonRendering_Backend != backend) {
940                    saveFile(bench->getName(), configName, outDir.c_str(),
941                             device->accessBitmap(false));
942                }
943            }
944        }
945        if (loggedBenchStart) {
946            logger.logProgress(SkString("\n"));
947        }
948    }
949#if SK_SUPPORT_GPU
950#if GR_CACHE_STATS
951    for (int i = 0; i <= GrContextFactory::kLastGLContextType; ++i) {
952        GrContextFactory::GLContextType ctxType = (GrContextFactory::GLContextType)i;
953        GrContext* context = gContextFactory.get(ctxType);
954        if (NULL != context) {
955            SkDebugf("Cache Stats for %s context:\n", GrContextFactory::GLContextTypeName(ctxType));
956            context->printCacheStats();
957            SkDebugf("\n");
958        }
959    }
960#endif
961    // Destroy the GrContext before the inst tracking printing at main() exit occurs.
962    gContextFactory.destroyContexts();
963#endif
964    for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
965        SkDELETE(timers[i]);
966    }
967
968    return 0;
969}
970
971#if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
972int main(int argc, char * const argv[]) {
973    return tool_main(argc, (char**) argv);
974}
975#endif
976