return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
int w = 40;
int h = 40;
makebm(&fBmp, w, h);
return this->onGetSize();
}
-void Benchmark::preDraw() {
- this->onPreDraw();
+void Benchmark::delayedSetup() {
+ this->onDelayedSetup();
}
void Benchmark::perCanvasPreDraw(SkCanvas* canvas) {
this->onPerCanvasPreDraw(canvas);
}
+void Benchmark::preDraw(SkCanvas* canvas) {
+ this->onPreDraw(canvas);
+}
+
+void Benchmark::postDraw(SkCanvas* canvas) {
+ this->onPostDraw(canvas);
+}
+
void Benchmark::perCanvasPostDraw(SkCanvas* canvas) {
this->onPerCanvasPostDraw(canvas);
}
// Call before draw, allows the benchmark to do setup work outside of the
// timer. When a benchmark is repeatedly drawn, this should be called once
// before the initial draw.
- void preDraw();
+ void delayedSetup();
// Called once before and after a series of draw calls to a single canvas.
// The setup/break down in these calls is not timed.
void perCanvasPreDraw(SkCanvas*);
void perCanvasPostDraw(SkCanvas*);
+ // Called just before and after each call to draw(). Not timed.
+ void preDraw(SkCanvas*);
+ void postDraw(SkCanvas*);
+
// Bench framework can tune loops to be large enough for stable timing.
void draw(const int loops, SkCanvas*);
virtual const char* onGetName() = 0;
virtual const char* onGetUniqueName() { return this->onGetName(); }
- virtual void onPreDraw() {}
+ virtual void onDelayedSetup() {}
virtual void onPerCanvasPreDraw(SkCanvas*) {}
virtual void onPerCanvasPostDraw(SkCanvas*) {}
+ virtual void onPreDraw(SkCanvas*) {}
+ virtual void onPostDraw(SkCanvas*) {}
// Each bench should do its main work in a loop like this:
// for (int i = 0; i < loops; i++) { <work here> }
virtual void onDraw(const int loops, SkCanvas*) = 0;
return SkIPoint::Make(640, 100);
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
make_path(fPath);
}
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
SkBitmap bm;
if (kIndex_8_SkColorType == fColorType) {
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fBitmap.allocPixels();
fBitmap.setAlphaType(kOpaque_SkAlphaType);
fBitmap.eraseColor(SK_ColorBLACK);
return kNonRendering_Backend == backend;
}
-void BitmapRegionDecoderBench::onPreDraw() {
+void BitmapRegionDecoderBench::onDelayedSetup() {
SkStreamRewindable* stream = new SkMemoryStream(fData);
fBRD.reset(SkBitmapRegionDecoderInterface::CreateBitmapRegionDecoder(stream, fStrategy));
}
const char* onGetName() override;
bool isSuitableFor(Backend backend) override;
void onDraw(const int n, SkCanvas* canvas) override;
- void onPreDraw() override;
+ void onDelayedSetup() override;
private:
SkString fName;
fName.printf( "bitmap_scale_%s_%d_%d", name, fInputSize, fOutputSize );
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fInputBitmap.allocN32Pixels(fInputSize, fInputSize, true);
fInputBitmap.eraseColor(SK_ColorWHITE);
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (!fInitialized) {
make_checkerboard();
fInitialized = true;
return kNonRendering_Backend == backend;
}
-void CodecBench::onPreDraw() {
+void CodecBench::onDelayedSetup() {
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fData));
fInfo = codec->getInfo().makeColorType(fColorType);
const char* onGetName() override;
bool isSuitableFor(Backend backend) override;
void onDraw(const int n, SkCanvas* canvas) override;
- void onPreDraw() override;
+ void onDelayedSetup() override;
private:
SkString fName;
return "colorcube";
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (!SkToBool(fCubeData)) {
this->makeCubeData();
this->make_bitmap();
const char* onGetName() override { return fName.c_str(); }
- void onPreDraw() override {
+ void onDelayedSetup() override {
// A handful of random srcs and dsts.
SkRandom rand;
for (int i = 0; i < kInputs; i++) {
return kNonRendering_Backend == backend;
}
-void DecodingBench::onPreDraw() {
+void DecodingBench::onDelayedSetup() {
// Allocate the pixels now, to remove it from the loop.
SkAutoTDelete<SkStreamRewindable> stream(new SkMemoryStream(fData));
SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream));
const char* onGetName() override;
bool isSuitableFor(Backend backend) override;
void onDraw(const int n, SkCanvas* canvas) override;
- void onPreDraw() override;
+ void onDelayedSetup() override;
private:
SkString fName;
}
protected:
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (!fInitialized) {
this->makeBitmap();
this->makeCheckerboard();
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fBitmap.allocN32Pixels(200, 200);
fBitmap.eraseARGB(255, 0, 255, 0);
}
}
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (nullptr == fPKMData) {
SkDebugf("Failed to load PKM data!\n");
return;
protected:
const char* onGetName() override { return "fullscreen_rects"; }
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (!fInit) {
SkRandom rand;
static const SkScalar kMinOffset = 0;
return this->onGetGLContext(ctx);
}
-void GLBench::onPerCanvasPreDraw(SkCanvas* canvas) {
+void GLBench::onPreDraw(SkCanvas* canvas) {
// This bench exclusively tests GL calls directly
const GrGLContext* ctx = this->getGLContext(canvas);
if (!ctx) {
this->setup(ctx);
}
-void GLBench::onPerCanvasPostDraw(SkCanvas* canvas) {
+void GLBench::onPostDraw(SkCanvas* canvas) {
// This bench exclusively tests GL calls directly
const GrGLContext* ctx = this->getGLContext(canvas);
if (!ctx) {
protected:
const GrGLContext* getGLContext(SkCanvas*);
virtual const GrGLContext* onGetGLContext(const GrGLContext* ctx) { return ctx; }
- void onPerCanvasPreDraw(SkCanvas* canvas) override;
+ void onPreDraw(SkCanvas*) override;
virtual void setup(const GrGLContext*)=0;
- void onPerCanvasPostDraw(SkCanvas* canvas) override;
+ void onPostDraw(SkCanvas* canvas) override;
virtual void teardown(const GrGLInterface*)=0;
void onDraw(const int loops, SkCanvas*) override;
virtual void glDraw(const int loops, const GrGLContext*)=0;
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (!fInitialized) {
this->makeCheckerboard();
this->makeAtlas();
protected:
SkRect fRects[2048];
- virtual void onPreDraw() {
+ virtual void onDelayedSetup() {
const SkScalar min = -100;
const SkScalar max = 100;
SkRandom rand;
return fFullName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fContext.reset(GrContext::CreateMockContext());
if (!fContext) {
return;
return "image_filter_collapse_table";
}
- virtual void onPreDraw() override {
+ virtual void onDelayedSetup() override {
for (int i = 0; i < 256; ++i) {
int n = i >> 5;
table1[i] = (n << 5) | (n << 2) | (n >> 1);
return "image_filter_collapse_matrix";
}
- virtual void onPreDraw() override {
+ virtual void onDelayedSetup() override {
SkColorFilter* colorFilters[] = {
make_brightness(0.1f),
make_grayscale(),
return fIsSmall ? "magnifier_small" : "magnifier_large";
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (!fInitialized) {
make_checkerboard();
fInitialized = true;
DecomposeMatrixBench() : INHERITED("decompose") {}
protected:
- void onPreDraw() override {
+ void onDelayedSetup() override {
for (int i = 0; i < 10; ++i) {
SkScalar rot0 = (fRandom.nextBool()) ? fRandom.nextRangeF(-180, 180) : 0.0f;
SkScalar sx = fRandom.nextRangeF(-3000.f, 3000.f);
return fIsSmall ? "merge_small" : "merge_large";
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (!fInitialized) {
make_bitmap();
make_checkerboard();
const char* onGetName() override { return "mipmap_build"; }
- void onPreDraw() override {
+ void onDelayedSetup() override {
fBitmap.allocN32Pixels(1000, 1000, true);
fBitmap.eraseColor(SK_ColorWHITE); // so we don't read uninitialized memory
}
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
this->setCubics();
this->setColors();
this->setTexCoords();
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
this->setGrid();
switch (fVertexMode) {
case kTexCoords_VertexMode:
return "path_create";
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
this->createData(10, 100);
}
const char* onGetName() override {
return "path_copy";
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
this->createData(10, 100);
fPaths.reset(kPathCnt);
fCopies.reset(kPathCnt);
return fInPlace ? "path_transform_in_place" : "path_transform_copy";
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fMatrix.setScale(5 * SK_Scalar1, 6 * SK_Scalar1);
this->createData(10, 100);
fPaths.reset(kPathCnt);
return "path_equality_50%";
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fParity = 0;
this->createData(10, 100);
fPaths.reset(kPathCnt);
}
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
// reversePathTo assumes a single contour path.
bool allowMoves = kReversePathTo_AddType != fType;
this->createData(10, 100, allowMoves);
}
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fQueryRects.setCount(kQueryRectCnt);
SkRandom rand;
: INHERITED("playback", maxLevel, maxPictureLevel) {
}
protected:
- void onPreDraw() override {
- this->INHERITED::onPreDraw();
+ void onDelayedSetup() override {
+ this->INHERITED::onDelayedSetup();
SkIPoint canvasSize = onGetSize();
SkPictureRecorder recorder;
const char* onGetName() override { return fName.c_str(); }
SkIPoint onGetSize() override { return SkIPoint::Make(1024,1024); }
- void onPreDraw() override {
+ void onDelayedSetup() override {
SkAutoTDelete<SkBBHFactory> factory;
switch (fBBH) {
case kNone: break;
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
SkImageInfo info = SkImageInfo::Make(W, H, fColorType, kUnpremul_SkAlphaType);
fBmp1.allocPixels(info); // used in writePixels
const char* onGetName() override {
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
SkRandom rand;
SkAutoTMalloc<SkRect> rects(NUM_QUERY_RECTS);
for (int i = 0; i < NUM_QUERY_RECTS; ++i) {
const char* onGetName() override { return computeName("rects"); }
- void onPreDraw() override {
+ void onDelayedSetup() override {
SkRandom rand;
const SkScalar offset = SK_Scalar1/3;
for (int i = 0; i < N; i++) {
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
SkASSERT(nullptr == fRectanizer.get());
if (kPow2_RectanizerType == fRectanizerType) {
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
fBitmap.allocPixels();
fBitmap.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorWHITE : 0);
return fName.c_str();
}
- void onPreDraw() override {
+ void onDelayedSetup() override {
SkString resourcePath = GetResourcePath();
if (resourcePath.isEmpty()) {
fValid = false;
}
// Delayed initialization only done if onDraw will be called.
- void onPreDraw() override {
+ void onDelayedSetup() override {
fUnsorted.reset(N);
gRec[fType].fProc(fUnsorted.get());
}
}
protected:
- void onPreDraw() override {
+ void onDelayedSetup() override {
if (fDoColorEmoji) {
SkASSERT(kBW == fFQ);
fColorEmojiTypeface.reset(GetResourceAsTypeface("/fonts/Funkster.ttf"));
}
protected:
- void onPreDraw() override {
+ void onDelayedSetup() override {
fTypeface.reset(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal));
// make textblob
SkPaint paint;
if (canvas) {
canvas->clear(SK_ColorWHITE);
}
+ bench->preDraw(canvas);
WallTimer timer;
timer.start();
canvas = target->beginTiming(canvas);
}
target->endTiming();
timer.end();
+ bench->postDraw(canvas);
return timer.fWall;
}
if (!configs.isEmpty()) {
log->bench(bench->getUniqueName(), bench->getSize().fX, bench->getSize().fY);
- bench->preDraw();
+ bench->delayedSetup();
}
for (int i = 0; i < configs.count(); ++i) {
Target* target = is_enabled(b, configs[i]);
// clear both buffers
fOwner->clear(canvas, SK_ColorWHITE, 2);
- fBenchmark->preDraw();
+ fBenchmark->delayedSetup();
return true;
}
}
case kPreTiming_State: {
fBenchmark->perCanvasPreDraw(canvas);
+ fBenchmark->preDraw(canvas);
fCurrentFrame = 0;
fTimer.start();
fState = kTiming_State;
void VisualInteractiveModule::perCanvasPreDraw(SkCanvas* canvas, State nextState) {
fBenchmark->perCanvasPreDraw(canvas);
+ fBenchmark->preDraw(canvas);
fCurrentFrame = 0;
this->nextState(nextState);
}
}
void VisualInteractiveModule::postDraw(SkCanvas* canvas) {
+ fBenchmark->postDraw(canvas);
fBenchmark->perCanvasPostDraw(canvas);
fBenchmark.reset(nullptr);
fLoops = 1;
fOwner->clear(canvas, SK_ColorWHITE, 2);
- fBenchmark->preDraw();
+ fBenchmark->delayedSetup();
fRecords.push_back();
// Log bench name
void VisualLightweightBenchModule::perCanvasPreDraw(SkCanvas* canvas, State nextState) {
fBenchmark->perCanvasPreDraw(canvas);
+ fBenchmark->preDraw(canvas);
fCurrentFrame = 0;
this->nextState(nextState);
}
}
void VisualLightweightBenchModule::postDraw(SkCanvas* canvas) {
+ fBenchmark->postDraw(canvas);
fBenchmark->perCanvasPostDraw(canvas);
fBenchmark.reset(nullptr);
fCurrentSample = 0;