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#include "GrContext.h"
13#include "GrRenderTarget.h"
14
15#include "SkBenchmark.h"
16#include "SkCanvas.h"
17#include "SkColorPriv.h"
18#include "SkGpuDevice.h"
19#include "SkGraphics.h"
20#include "SkImageEncoder.h"
21#include "gl/SkNativeGLContext.h"
22#include "gl/SkNullGLContext.h"
23#include "SkNWayCanvas.h"
24#include "SkPicture.h"
25#include "SkString.h"
26
27#ifdef SK_BUILD_FOR_ANDROID
28static void log_error(const char msg[]) { SkDebugf("%s", msg); }
29static void log_progress(const char msg[]) { SkDebugf("%s", msg); }
30#else
31static void log_error(const char msg[]) { fprintf(stderr, "%s", msg); }
32static void log_progress(const char msg[]) { printf("%s", msg); }
33#endif
34
35static void log_error(const SkString& str) { log_error(str.c_str()); }
36static void log_progress(const SkString& str) { log_progress(str.c_str()); }
37
38///////////////////////////////////////////////////////////////////////////////
39
40static void erase(SkBitmap& bm) {
41    if (bm.config() == SkBitmap::kA8_Config) {
42        bm.eraseColor(0);
43    } else {
44        bm.eraseColor(SK_ColorWHITE);
45    }
46}
47
48#if 0
49static bool equal(const SkBitmap& bm1, const SkBitmap& bm2) {
50    if (bm1.width() != bm2.width() ||
51        bm1.height() != bm2.height() ||
52        bm1.config() != bm2.config()) {
53        return false;
54    }
55
56    size_t pixelBytes = bm1.width() * bm1.bytesPerPixel();
57    for (int y = 0; y < bm1.height(); y++) {
58        if (memcmp(bm1.getAddr(0, y), bm2.getAddr(0, y), pixelBytes)) {
59            return false;
60        }
61    }
62    return true;
63}
64#endif
65
66class Iter {
67public:
68    Iter(void* param) {
69        fBench = BenchRegistry::Head();
70        fParam = param;
71    }
72
73    SkBenchmark* next() {
74        if (fBench) {
75            BenchRegistry::Factory f = fBench->factory();
76            fBench = fBench->next();
77            return f(fParam);
78        }
79        return NULL;
80    }
81
82private:
83    const BenchRegistry* fBench;
84    void* fParam;
85};
86
87static void make_filename(const char name[], SkString* path) {
88    path->set(name);
89    for (int i = 0; name[i]; i++) {
90        switch (name[i]) {
91            case '/':
92            case '\\':
93            case ' ':
94            case ':':
95                path->writable_str()[i] = '-';
96                break;
97            default:
98                break;
99        }
100    }
101}
102
103static void saveFile(const char name[], const char config[], const char dir[],
104                     const SkBitmap& bm) {
105    SkBitmap copy;
106    if (!bm.copyTo(&copy, SkBitmap::kARGB_8888_Config)) {
107        return;
108    }
109
110    if (bm.config() == SkBitmap::kA8_Config) {
111        // turn alpha into gray-scale
112        size_t size = copy.getSize() >> 2;
113        SkPMColor* p = copy.getAddr32(0, 0);
114        for (size_t i = 0; i < size; i++) {
115            int c = (*p >> SK_A32_SHIFT) & 0xFF;
116            c = 255 - c;
117            c |= (c << 24) | (c << 16) | (c << 8);
118            *p++ = c | (SK_A32_MASK << SK_A32_SHIFT);
119        }
120    }
121
122    SkString str;
123    make_filename(name, &str);
124    str.appendf("_%s.png", config);
125    str.prepend(dir);
126    ::remove(str.c_str());
127    SkImageEncoder::EncodeFile(str.c_str(), copy, SkImageEncoder::kPNG_Type,
128                               100);
129}
130
131static void performClip(SkCanvas* canvas, int w, int h) {
132    SkRect r;
133
134    r.set(SkIntToScalar(10), SkIntToScalar(10),
135          SkIntToScalar(w*2/3), SkIntToScalar(h*2/3));
136    canvas->clipRect(r, SkRegion::kIntersect_Op);
137
138    r.set(SkIntToScalar(w/3), SkIntToScalar(h/3),
139          SkIntToScalar(w-10), SkIntToScalar(h-10));
140    canvas->clipRect(r, SkRegion::kXOR_Op);
141}
142
143static void performRotate(SkCanvas* canvas, int w, int h) {
144    const SkScalar x = SkIntToScalar(w) / 2;
145    const SkScalar y = SkIntToScalar(h) / 2;
146
147    canvas->translate(x, y);
148    canvas->rotate(SkIntToScalar(35));
149    canvas->translate(-x, -y);
150}
151
152static void performScale(SkCanvas* canvas, int w, int h) {
153    const SkScalar x = SkIntToScalar(w) / 2;
154    const SkScalar y = SkIntToScalar(h) / 2;
155
156    canvas->translate(x, y);
157    // just enough so we can't take the sprite case
158    canvas->scale(SK_Scalar1 * 99/100, SK_Scalar1 * 99/100);
159    canvas->translate(-x, -y);
160}
161
162static bool parse_bool_arg(char * const* argv, char* const* stop, bool* var) {
163    if (argv < stop) {
164        *var = atoi(*argv) != 0;
165        return true;
166    }
167    return false;
168}
169
170enum Backend {
171    kRaster_Backend,
172    kGPU_Backend,
173    kPDF_Backend,
174};
175
176class GLHelper {
177public:
178    GLHelper() {
179    }
180
181    bool init(SkGLContext* glCtx, int width, int height) {
182        GrContext* grCtx;
183        GrRenderTarget* rt;
184        if (glCtx->init(width, height)) {
185            GrPlatform3DContext ctx =
186                reinterpret_cast<GrPlatform3DContext>(glCtx->gl());
187            grCtx = GrContext::Create(kOpenGL_Shaders_GrEngine, ctx);
188            if (NULL != grCtx) {
189                GrPlatformRenderTargetDesc desc;
190                desc.fConfig = kSkia8888_PM_GrPixelConfig;
191                desc.fWidth = width;
192                desc.fHeight = height;
193                desc.fStencilBits = 8;
194                desc.fRenderTargetHandle = glCtx->getFBOID();
195                rt = grCtx->createPlatformRenderTarget(desc);
196                if (NULL == rt) {
197                    grCtx->unref();
198                    return false;
199                }
200            }
201        } else {
202            return false;
203        }
204        glCtx->ref();
205        fGLContext.reset(glCtx);
206        fGrContext.reset(grCtx);
207        fRenderTarget.reset(rt);
208        return true;
209    }
210
211    bool isValid() {
212        return NULL != fGLContext.get();
213    }
214
215    SkGLContext* glContext() {
216        return fGLContext.get();
217    }
218
219    GrRenderTarget* renderTarget() {
220        return fRenderTarget.get();
221    }
222
223    GrContext* grContext() {
224        return fGrContext.get();
225    }
226private:
227    SkAutoTUnref<SkGLContext> fGLContext;
228    SkAutoTUnref<GrContext> fGrContext;
229    SkAutoTUnref<GrRenderTarget> fRenderTarget;
230};
231
232static GLHelper gRealGLHelper;
233static GLHelper gNullGLHelper;
234
235static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
236                             Backend backend, GLHelper* glHelper) {
237    SkDevice* device = NULL;
238    SkBitmap bitmap;
239    bitmap.setConfig(config, size.fX, size.fY);
240
241    switch (backend) {
242        case kRaster_Backend:
243            bitmap.allocPixels();
244            erase(bitmap);
245            device = new SkDevice(bitmap);
246            break;
247        case kGPU_Backend:
248            device = new SkGpuDevice(glHelper->grContext(),
249                                     glHelper->renderTarget());
250            break;
251        case kPDF_Backend:
252        default:
253            SkASSERT(!"unsupported");
254    }
255    return device;
256}
257
258static const struct {
259    SkBitmap::Config    fConfig;
260    const char*         fName;
261    Backend             fBackend;
262    GLHelper*           fGLHelper;
263} gConfigs[] = {
264    { SkBitmap::kARGB_8888_Config,  "8888",     kRaster_Backend, NULL },
265    { SkBitmap::kRGB_565_Config,    "565",      kRaster_Backend, NULL },
266    { SkBitmap::kARGB_8888_Config,  "GPU",      kGPU_Backend, &gRealGLHelper },
267    { SkBitmap::kARGB_8888_Config,  "NULLGPU",  kGPU_Backend, &gNullGLHelper },
268};
269
270static int findConfig(const char config[]) {
271    for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) {
272        if (!strcmp(config, gConfigs[i].fName)) {
273            return i;
274        }
275    }
276    return -1;
277}
278
279static void determine_gpu_context_size(SkTDict<const char*>& defineDict,
280                                       int* contextWidth,
281                                       int* contextHeight) {
282    Iter iter(&defineDict);
283    SkBenchmark* bench;
284    while ((bench = iter.next()) != NULL) {
285        SkIPoint dim = bench->getSize();
286        if (*contextWidth < dim.fX) {
287            *contextWidth = dim.fX;
288        }
289        if (*contextHeight < dim.fY) {
290            *contextHeight = dim.fY;
291        }
292    }
293}
294
295static bool skip_name(const SkTDArray<const char*> array, const char name[]) {
296    if (0 == array.count()) {
297        // no names, so don't skip anything
298        return false;
299    }
300    for (int i = 0; i < array.count(); ++i) {
301        if (strstr(name, array[i])) {
302            // found the name, so don't skip
303            return false;
304        }
305    }
306    return true;
307}
308
309int main (int argc, char * const argv[]) {
310    SkAutoGraphics ag;
311
312    SkTDict<const char*> defineDict(1024);
313    int repeatDraw = 1;
314    int forceAlpha = 0xFF;
315    bool forceAA = true;
316    bool forceFilter = false;
317    SkTriState::State forceDither = SkTriState::kDefault;
318    bool timerWall = false;
319    bool timerCpu = true;
320    bool timerGpu = true;
321    bool doScale = false;
322    bool doRotate = false;
323    bool doClip = false;
324    bool hasStrokeWidth = false;
325    float strokeWidth;
326    SkTDArray<const char*> fMatches;
327
328    SkString outDir;
329    SkBitmap::Config outConfig = SkBitmap::kNo_Config;
330    GLHelper* glHelper = NULL;
331    const char* configName = "";
332    Backend backend = kRaster_Backend;  // for warning
333    int configCount = SK_ARRAY_COUNT(gConfigs);
334
335    char* const* stop = argv + argc;
336    for (++argv; argv < stop; ++argv) {
337        if (strcmp(*argv, "-o") == 0) {
338            argv++;
339            if (argv < stop && **argv) {
340                outDir.set(*argv);
341                if (outDir.c_str()[outDir.size() - 1] != '/') {
342                    outDir.append("/");
343                }
344            }
345        } else if (strcmp(*argv, "-repeat") == 0) {
346            argv++;
347            if (argv < stop) {
348                repeatDraw = atoi(*argv);
349                if (repeatDraw < 1) {
350                    repeatDraw = 1;
351                }
352            } else {
353                log_error("missing arg for -repeat\n");
354                return -1;
355            }
356        } else if (strcmp(*argv, "-timers") == 0) {
357            argv++;
358            if (argv < stop) {
359                timerWall = false;
360                timerCpu = false;
361                timerGpu = false;
362                for (char* t = *argv; *t; ++t) {
363                    switch (*t) {
364                    case 'w': timerWall = true; break;
365                    case 'c': timerCpu = true; break;
366                    case 'g': timerGpu = true; break;
367                    }
368                }
369            } else {
370                log_error("missing arg for -timers\n");
371                return -1;
372            }
373        } else if (!strcmp(*argv, "-rotate")) {
374            doRotate = true;
375        } else if (!strcmp(*argv, "-scale")) {
376            doScale = true;
377        } else if (!strcmp(*argv, "-clip")) {
378            doClip = true;
379        } else if (strcmp(*argv, "-forceAA") == 0) {
380            if (!parse_bool_arg(++argv, stop, &forceAA)) {
381                log_error("missing arg for -forceAA\n");
382                return -1;
383            }
384        } else if (strcmp(*argv, "-forceFilter") == 0) {
385            if (!parse_bool_arg(++argv, stop, &forceFilter)) {
386                log_error("missing arg for -forceFilter\n");
387                return -1;
388            }
389        } else if (strcmp(*argv, "-forceDither") == 0) {
390            bool tmp;
391            if (!parse_bool_arg(++argv, stop, &tmp)) {
392                log_error("missing arg for -forceDither\n");
393                return -1;
394            }
395            forceDither = tmp ? SkTriState::kTrue : SkTriState::kFalse;
396        } else if (strcmp(*argv, "-forceBlend") == 0) {
397            bool wantAlpha = false;
398            if (!parse_bool_arg(++argv, stop, &wantAlpha)) {
399                log_error("missing arg for -forceBlend\n");
400                return -1;
401            }
402            forceAlpha = wantAlpha ? 0x80 : 0xFF;
403        } else if (strcmp(*argv, "-strokeWidth") == 0) {
404            argv++;
405            if (argv < stop) {
406                const char *strokeWidthStr = *argv;
407                if (sscanf(strokeWidthStr, "%f", &strokeWidth) != 1) {
408                  log_error("bad arg for -strokeWidth\n");
409                  return -1;
410                }
411                hasStrokeWidth = true;
412            } else {
413                log_error("missing arg for -strokeWidth\n");
414                return -1;
415            }
416        } else if (strcmp(*argv, "-match") == 0) {
417            argv++;
418            if (argv < stop) {
419                *fMatches.append() = *argv;
420            } else {
421                log_error("missing arg for -match\n");
422                return -1;
423            }
424        } else if (strcmp(*argv, "-config") == 0) {
425            argv++;
426            if (argv < stop) {
427                int index = findConfig(*argv);
428                if (index >= 0) {
429                    outConfig = gConfigs[index].fConfig;
430                    configName = gConfigs[index].fName;
431                    backend = gConfigs[index].fBackend;
432                    glHelper = gConfigs[index].fGLHelper;
433                    configCount = 1;
434                } else {
435                    SkString str;
436                    str.printf("unrecognized config %s\n", *argv);
437                    log_error(str);
438                    return -1;
439                }
440            } else {
441                log_error("missing arg for -config\n");
442                return -1;
443            }
444        } else if (strlen(*argv) > 2 && strncmp(*argv, "-D", 2) == 0) {
445            argv++;
446            if (argv < stop) {
447                defineDict.set(argv[-1] + 2, *argv);
448            } else {
449                log_error("incomplete '-Dfoo bar' definition\n");
450                return -1;
451            }
452        } else {
453            SkString str;
454            str.printf("unrecognized arg %s\n", *argv);
455            log_error(str);
456            return -1;
457        }
458    }
459
460    // report our current settings
461    {
462        SkString str;
463        str.printf("skia bench: alpha=0x%02X antialias=%d filter=%d",
464                   forceAlpha, forceAA, forceFilter);
465        str.appendf(" rotate=%d scale=%d clip=%d",
466                   doRotate, doScale, doClip);
467
468        const char * ditherName;
469        switch (forceDither) {
470            case SkTriState::kDefault: ditherName = "default"; break;
471            case SkTriState::kTrue: ditherName = "true"; break;
472            case SkTriState::kFalse: ditherName = "false"; break;
473            default: ditherName = "<invalid>"; break;
474        }
475        str.appendf(" dither=%s", ditherName);
476
477        if (hasStrokeWidth) {
478            str.appendf(" strokeWidth=%f", strokeWidth);
479        } else {
480            str.append(" strokeWidth=none");
481        }
482
483#if defined(SK_SCALAR_IS_FLOAT)
484        str.append(" scalar=float");
485#elif defined(SK_SCALAR_IS_FIXED)
486        str.append(" scalar=fixed");
487#endif
488
489#if defined(SK_BUILD_FOR_WIN32)
490        str.append(" system=WIN32");
491#elif defined(SK_BUILD_FOR_MAC)
492        str.append(" system=MAC");
493#elif defined(SK_BUILD_FOR_ANDROID)
494        str.append(" system=ANDROID");
495#elif defined(SK_BUILD_FOR_UNIX)
496        str.append(" system=UNIX");
497#else
498        str.append(" system=other");
499#endif
500
501#if defined(SK_DEBUG)
502        str.append(" DEBUG");
503#endif
504        str.append("\n");
505        log_progress(str);
506    }
507
508    //Don't do GL when fixed.
509#if !defined(SK_SCALAR_IS_FIXED)
510    int contextWidth = 1024;
511    int contextHeight = 1024;
512    determine_gpu_context_size(defineDict, &contextWidth, &contextHeight);
513    SkAutoTUnref<SkGLContext> realGLCtx(new SkNativeGLContext);
514    SkAutoTUnref<SkGLContext> nullGLCtx(new SkNullGLContext);
515    gRealGLHelper.init(realGLCtx.get(), contextWidth, contextHeight);
516    gNullGLHelper.init(nullGLCtx.get(), contextWidth, contextHeight);
517#endif
518    BenchTimer timer = BenchTimer(gRealGLHelper.glContext());
519
520    Iter iter(&defineDict);
521    SkBenchmark* bench;
522    while ((bench = iter.next()) != NULL) {
523        SkIPoint dim = bench->getSize();
524        if (dim.fX <= 0 || dim.fY <= 0) {
525            continue;
526        }
527
528        bench->setForceAlpha(forceAlpha);
529        bench->setForceAA(forceAA);
530        bench->setForceFilter(forceFilter);
531        bench->setDither(forceDither);
532        if (hasStrokeWidth) {
533            bench->setStrokeWidth(strokeWidth);
534        }
535
536        // only run benchmarks if their name contains matchStr
537        if (skip_name(fMatches, bench->getName())) {
538            continue;
539        }
540
541        {
542            SkString str;
543            str.printf("running bench [%d %d] %28s", dim.fX, dim.fY,
544                       bench->getName());
545            log_progress(str);
546        }
547
548        for (int configIndex = 0; configIndex < configCount; configIndex++) {
549            if (configCount > 1) {
550                outConfig = gConfigs[configIndex].fConfig;
551                configName = gConfigs[configIndex].fName;
552                backend = gConfigs[configIndex].fBackend;
553                glHelper = gConfigs[configIndex].fGLHelper;
554            }
555
556            if (kGPU_Backend == backend &&
557                (NULL == glHelper || !glHelper->isValid())) {
558                continue;
559            }
560
561            SkDevice* device = make_device(outConfig, dim, backend, glHelper);
562            SkCanvas canvas(device);
563            device->unref();
564
565            if (doClip) {
566                performClip(&canvas, dim.fX, dim.fY);
567            }
568            if (doScale) {
569                performScale(&canvas, dim.fX, dim.fY);
570            }
571            if (doRotate) {
572                performRotate(&canvas, dim.fX, dim.fY);
573            }
574
575            //warm up caches if needed
576            if (repeatDraw > 1) {
577                SkAutoCanvasRestore acr(&canvas, true);
578                bench->draw(&canvas);
579                if (glHelper) {
580                    glHelper->grContext()->flush();
581                    SK_GL(*glHelper->glContext(), Finish());
582                }
583            }
584
585            timer.start();
586            for (int i = 0; i < repeatDraw; i++) {
587                SkAutoCanvasRestore acr(&canvas, true);
588                bench->draw(&canvas);
589                if (glHelper) {
590                    glHelper->grContext()->flush();
591                }
592            }
593           if (glHelper) {
594                SK_GL(*glHelper->glContext(), Finish());
595           }
596           timer.end();
597
598            if (repeatDraw > 1) {
599                SkString str;
600                str.printf("  %4s:", configName);
601                if (timerWall) {
602                    str.appendf(" msecs = %6.2f", timer.fWall / repeatDraw);
603                }
604                if (timerCpu) {
605                    str.appendf(" cmsecs = %6.2f", timer.fCpu / repeatDraw);
606                }
607                if (timerGpu && glHelper && timer.fGpu > 0) {
608                    str.appendf(" gmsecs = %6.2f", timer.fGpu / repeatDraw);
609                }
610                log_progress(str);
611            }
612            if (outDir.size() > 0) {
613                saveFile(bench->getName(), configName, outDir.c_str(),
614                         device->accessBitmap(false));
615            }
616        }
617        log_progress("\n");
618    }
619
620    return 0;
621}
622