| /* | |
| * 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 "Benchmark.h" | |
| #include "SkCanvas.h" | |
| #include "SkColor.h" | |
| #include "SkPaint.h" | |
| #include "SkPicture.h" | |
| #include "SkPictureRecorder.h" | |
| #include "SkPoint.h" | |
| #include "SkRandom.h" | |
| #include "SkRect.h" | |
| #include "SkString.h" | |
| // This is designed to emulate about 4 screens of textual content | |
| class PicturePlaybackBench : public Benchmark { | |
| public: | |
| PicturePlaybackBench(const char name[]) { | |
| fName.printf("picture_playback_%s", name); | |
| fPictureWidth = SkIntToScalar(PICTURE_WIDTH); | |
| fPictureHeight = SkIntToScalar(PICTURE_HEIGHT); | |
| fTextSize = SkIntToScalar(TEXT_SIZE); | |
| } | |
| enum { | |
| PICTURE_WIDTH = 1000, | |
| PICTURE_HEIGHT = 4000, | |
| TEXT_SIZE = 10 | |
| }; | |
| protected: | |
| virtual const char* onGetName() { | |
| return fName.c_str(); | |
| } | |
| virtual void onDraw(int loops, SkCanvas* canvas) { | |
| SkPictureRecorder recorder; | |
| SkCanvas* pCanvas = recorder.beginRecording(PICTURE_WIDTH, PICTURE_HEIGHT, nullptr, 0); | |
| this->recordCanvas(pCanvas); | |
| sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture()); | |
| const SkPoint translateDelta = getTranslateDelta(loops); | |
| for (int i = 0; i < loops; i++) { | |
| picture->playback(canvas); | |
| canvas->translate(translateDelta.fX, translateDelta.fY); | |
| } | |
| } | |
| virtual void recordCanvas(SkCanvas* canvas) = 0; | |
| virtual SkPoint getTranslateDelta(int N) { | |
| SkIPoint canvasSize = onGetSize(); | |
| return SkPoint::Make(SkIntToScalar((PICTURE_WIDTH - canvasSize.fX)/N), | |
| SkIntToScalar((PICTURE_HEIGHT- canvasSize.fY)/N)); | |
| } | |
| SkString fName; | |
| SkScalar fPictureWidth; | |
| SkScalar fPictureHeight; | |
| SkScalar fTextSize; | |
| private: | |
| typedef Benchmark INHERITED; | |
| }; | |
| class TextPlaybackBench : public PicturePlaybackBench { | |
| public: | |
| TextPlaybackBench() : INHERITED("drawText") { } | |
| protected: | |
| void recordCanvas(SkCanvas* canvas) override { | |
| SkPaint paint; | |
| paint.setTextSize(fTextSize); | |
| paint.setColor(SK_ColorBLACK); | |
| const char* text = "Hamburgefons"; | |
| size_t len = strlen(text); | |
| const SkScalar textWidth = paint.measureText(text, len); | |
| for (SkScalar x = 0; x < fPictureWidth; x += textWidth) { | |
| for (SkScalar y = 0; y < fPictureHeight; y += fTextSize) { | |
| canvas->drawText(text, len, x, y, paint); | |
| } | |
| } | |
| } | |
| private: | |
| typedef PicturePlaybackBench INHERITED; | |
| }; | |
| class PosTextPlaybackBench : public PicturePlaybackBench { | |
| public: | |
| PosTextPlaybackBench(bool drawPosH) | |
| : INHERITED(drawPosH ? "drawPosTextH" : "drawPosText") | |
| , fDrawPosH(drawPosH) { } | |
| protected: | |
| void recordCanvas(SkCanvas* canvas) override { | |
| SkPaint paint; | |
| paint.setTextSize(fTextSize); | |
| paint.setColor(SK_ColorBLACK); | |
| const char* text = "Hamburgefons"; | |
| size_t len = strlen(text); | |
| const SkScalar textWidth = paint.measureText(text, len); | |
| SkScalar* adv = new SkScalar[len]; | |
| paint.getTextWidths(text, len, adv); | |
| for (SkScalar x = 0; x < fPictureWidth; x += textWidth) { | |
| for (SkScalar y = 0; y < fPictureHeight; y += fTextSize) { | |
| SkPoint* pos = new SkPoint[len]; | |
| SkScalar advX = 0; | |
| for (size_t i = 0; i < len; i++) { | |
| if (fDrawPosH) | |
| pos[i].set(x + advX, y); | |
| else | |
| pos[i].set(x + advX, y + i); | |
| advX += adv[i]; | |
| } | |
| canvas->drawPosText(text, len, pos, paint); | |
| delete[] pos; | |
| } | |
| } | |
| delete[] adv; | |
| } | |
| private: | |
| bool fDrawPosH; | |
| typedef PicturePlaybackBench INHERITED; | |
| }; | |
| /////////////////////////////////////////////////////////////////////////////// | |
| DEF_BENCH( return new TextPlaybackBench(); ) | |
| DEF_BENCH( return new PosTextPlaybackBench(true); ) | |
| DEF_BENCH( return new PosTextPlaybackBench(false); ) | |
| // Chrome draws into small tiles with impl-side painting. | |
| // This benchmark measures the relative performance of our bounding-box hierarchies, | |
| // both when querying tiles perfectly and when not. | |
| enum BBH { kNone, kRTree }; | |
| enum Mode { kTiled, kRandom }; | |
| class TiledPlaybackBench : public Benchmark { | |
| public: | |
| TiledPlaybackBench(BBH bbh, Mode mode) : fBBH(bbh), fMode(mode), fName("tiled_playback") { | |
| switch (fBBH) { | |
| case kNone: fName.append("_none" ); break; | |
| case kRTree: fName.append("_rtree" ); break; | |
| } | |
| switch (fMode) { | |
| case kTiled: fName.append("_tiled" ); break; | |
| case kRandom: fName.append("_random"); break; | |
| } | |
| } | |
| const char* onGetName() override { return fName.c_str(); } | |
| SkIPoint onGetSize() override { return SkIPoint::Make(1024,1024); } | |
| void onDelayedSetup() override { | |
| std::unique_ptr<SkBBHFactory> factory; | |
| switch (fBBH) { | |
| case kNone: break; | |
| case kRTree: factory.reset(new SkRTreeFactory); break; | |
| } | |
| SkPictureRecorder recorder; | |
| SkCanvas* canvas = recorder.beginRecording(1024, 1024, factory.get()); | |
| SkRandom rand; | |
| for (int i = 0; i < 10000; i++) { | |
| SkScalar x = rand.nextRangeScalar(0, 1024), | |
| y = rand.nextRangeScalar(0, 1024), | |
| w = rand.nextRangeScalar(0, 128), | |
| h = rand.nextRangeScalar(0, 128); | |
| SkPaint paint; | |
| paint.setColor(rand.nextU()); | |
| paint.setAlpha(0xFF); | |
| canvas->drawRect(SkRect::MakeXYWH(x,y,w,h), paint); | |
| } | |
| fPic = recorder.finishRecordingAsPicture(); | |
| } | |
| void onDraw(int loops, SkCanvas* canvas) override { | |
| for (int i = 0; i < loops; i++) { | |
| // This inner loop guarantees we make the same choices for all bench variants. | |
| SkRandom rand; | |
| for (int j = 0; j < 10; j++) { | |
| SkScalar x = 0, y = 0; | |
| switch (fMode) { | |
| case kTiled: x = SkScalar(256 * rand.nextULessThan(4)); | |
| y = SkScalar(256 * rand.nextULessThan(4)); | |
| break; | |
| case kRandom: x = rand.nextRangeScalar(0, 768); | |
| y = rand.nextRangeScalar(0, 768); | |
| break; | |
| } | |
| SkAutoCanvasRestore ar(canvas, true/*save now*/); | |
| canvas->clipRect(SkRect::MakeXYWH(x,y,256,256)); | |
| fPic->playback(canvas); | |
| } | |
| } | |
| } | |
| private: | |
| BBH fBBH; | |
| Mode fMode; | |
| SkString fName; | |
| sk_sp<SkPicture> fPic; | |
| }; | |
| DEF_BENCH( return new TiledPlaybackBench(kNone, kRandom); ) | |
| DEF_BENCH( return new TiledPlaybackBench(kNone, kTiled ); ) | |
| DEF_BENCH( return new TiledPlaybackBench(kRTree, kRandom); ) | |
| DEF_BENCH( return new TiledPlaybackBench(kRTree, kTiled ); ) |