bench/ImageCacheBudgetBench.cpp - platform/external/skqp - Gitiles

 /*
  * Copyright 2016 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 "sk_tool_utils.h"
 #include "SkCanvas.h"
 #include "SkImage.h"
 #include "SkSurface.h"

 #if SK_SUPPORT_GPU

 #include "GrContext.h"

 /** These benchmarks were designed to measure changes to GrResourceCache's replacement policy */

 //////////////////////////////////////////////////////////////////////////////

 // The width/height of the images to draw. The small size underestimates the value of a good
 // replacement strategy since the texture uploads are quite small. However, the effects are still
 // significant and this lets the benchmarks complete a lot faster, especially on mobile.
 static constexpr int kS = 25;

 static void make_images(sk_sp<SkImage> imgs[], int cnt) {
     for (int i = 0; i < cnt; ++i) {
         SkBitmap bmp = sk_tool_utils::create_checkerboard_bitmap(kS, kS, SK_ColorBLACK,
                                                                  SK_ColorCYAN, 10);
         imgs[i] = SkImage::MakeFromBitmap(bmp);
     }
 }

 static void draw_image(SkCanvas* canvas, SkImage* img) {
     // Make the paint transparent to avoid any issues of deferred tiler blending
     // optmizations
     SkPaint paint;
     paint.setAlpha(0x10);
     canvas->drawImage(img, 0, 0, &paint);
 }

 void set_cache_budget(SkCanvas* canvas, int approxImagesInBudget) {
     // This is inexact but we attempt to figure out a baseline number of resources GrContext needs
     // to render an SkImage and add one additional resource for each image we'd like to fit.
     GrContext* context =  canvas->getGrContext();
     SkASSERT(context);
     context->flush();
     context->purgeAllUnlockedResources();
     sk_sp<SkImage> image;
     make_images(&image, 1);
     draw_image(canvas, image.get());
     context->flush();
     int baselineCount;
     context->getResourceCacheUsage(&baselineCount, nullptr);
     baselineCount -= 1; // for the image's textures.
     context->setResourceCacheLimits(baselineCount + approxImagesInBudget, 1 << 30);
     context->purgeAllUnlockedResources();
 }

 //////////////////////////////////////////////////////////////////////////////

 /**
  * Tests repeatedly drawing the same set of images in each frame. Different instances of the bench
  * run with different cache sizes and either repeat the image order each frame or use a random
  * order. Every variation of this bench draws the same image set, only the budget and order of
  * images differs. Since the total fill is the same they can be cross-compared.
  */
 class ImageCacheBudgetBench : public Benchmark {
 public:
     /** budgetSize is the number of images that can fit in the cache. 100 images will be drawn. */
     ImageCacheBudgetBench(int budgetSize, bool shuffle)
             : fBudgetSize(budgetSize)
             , fShuffle(shuffle)
             , fIndices(nullptr) {
         float imagesOverBudget = float(kImagesToDraw) / budgetSize;
         // Make the benchmark name contain the percentage of the budget that is used in each
         // simulated frame.
         fName.printf("image_cache_budget_%.0f%s", imagesOverBudget * 100,
                      (shuffle ? "_shuffle" : ""));
     }

     bool isSuitableFor(Backend backend) override { return kGPU_Backend == backend; }

 protected:
     const char* onGetName() override {
         return fName.c_str();
     }

     void onPerCanvasPreDraw(SkCanvas* canvas) override {
         GrContext* context = canvas->getGrContext();
         SkASSERT(context);
         context->getResourceCacheLimits(&fOldCount, &fOldBytes);
         set_cache_budget(canvas, fBudgetSize);
         make_images(fImages, kImagesToDraw);
         if (fShuffle) {
             SkRandom random;
             fIndices.reset(new int[kSimulatedFrames * kImagesToDraw]);
             for (int frame = 0; frame < kSimulatedFrames; ++frame) {
                 int* base = fIndices.get() + frame * kImagesToDraw;
                 for (int i = 0; i < kImagesToDraw; ++i) {
                     base[i] = i;
                 }
                 for (int i = 0; i < kImagesToDraw - 1; ++i) {
                     int other = random.nextULessThan(kImagesToDraw - i) + i;
                     SkTSwap(base[i], base[other]);
                 }
             }
         }
     }

     void onPerCanvasPostDraw(SkCanvas* canvas) override {
         GrContext* context =  canvas->getGrContext();
         SkASSERT(context);
         context->setResourceCacheLimits(fOldCount, fOldBytes);
         for (int i = 0; i < kImagesToDraw; ++i) {
             fImages[i].reset();
         }
         fIndices.reset(nullptr);
     }

     void onDraw(int loops, SkCanvas* canvas) override {
         for (int i = 0; i < loops; ++i) {
             for (int frame = 0; frame < kSimulatedFrames; ++frame) {
                 for (int j = 0; j < kImagesToDraw; ++j) {
                     int idx;
                     if (fShuffle) {
                         idx = fIndices[frame * kImagesToDraw + j];
                     } else {
                         idx = j;
                     }
                     draw_image(canvas, fImages[idx].get());
                 }
                 // Simulate a frame boundary by flushing. This should notify GrResourceCache.
                 canvas->flush();
            }
         }
     }

 private:
     static constexpr int kImagesToDraw = 100;
     static constexpr int kSimulatedFrames = 5;

     int                         fBudgetSize;
     bool                        fShuffle;
     SkString                    fName;
     sk_sp<SkImage>              fImages[kImagesToDraw];
     std::unique_ptr<int[]>      fIndices;
     size_t                      fOldBytes;
     int                         fOldCount;

     typedef Benchmark INHERITED;
 };

 DEF_BENCH( return new ImageCacheBudgetBench(105, false); )

 DEF_BENCH( return new ImageCacheBudgetBench(90, false); )

 DEF_BENCH( return new ImageCacheBudgetBench(80, false); )

 DEF_BENCH( return new ImageCacheBudgetBench(50, false); )

 DEF_BENCH( return new ImageCacheBudgetBench(105, true); )

 DEF_BENCH( return new ImageCacheBudgetBench(90, true); )

 DEF_BENCH( return new ImageCacheBudgetBench(80, true); )

 DEF_BENCH( return new ImageCacheBudgetBench(50, true); )

 //////////////////////////////////////////////////////////////////////////////

 /**
  * Similar to above but changes between being over and under budget by varying the number of images
  * rendered. This is not directly comparable to the non-dynamic benchmarks.
  */
 class ImageCacheBudgetDynamicBench : public Benchmark {
 public:
     enum class Mode {
         // Increase from min to max images drawn gradually over simulated frames and then back.
         kPingPong,
         // Alternate between under and over budget every other simulated frame.
         kFlipFlop
     };

     ImageCacheBudgetDynamicBench(Mode mode) : fMode(mode) {}

     bool isSuitableFor(Backend backend) override { return kGPU_Backend == backend; }

 protected:
     const char* onGetName() override {
         switch (fMode) {
             case Mode::kPingPong:
                 return "image_cache_budget_dynamic_ping_pong";
             case Mode::kFlipFlop:
                 return "image_cache_budget_dynamic_flip_flop";
         }
         return "";
     }

     void onPerCanvasPreDraw(SkCanvas* canvas) override {
         GrContext* context =  canvas->getGrContext();
         SkASSERT(context);
         context->getResourceCacheLimits(&fOldCount, &fOldBytes);
         make_images(fImages, kMaxImagesToDraw);
         set_cache_budget(canvas, kImagesInBudget);
     }

     void onPerCanvasPostDraw(SkCanvas* canvas) override {
         GrContext* context =  canvas->getGrContext();
         SkASSERT(context);
         context->setResourceCacheLimits(fOldCount, fOldBytes);
         for (int i = 0; i < kMaxImagesToDraw; ++i) {
             fImages[i].reset();
         }
     }

     void onDraw(int loops, SkCanvas* canvas) override {
         int delta = 0;
         switch (fMode) {
             case Mode::kPingPong:
                 delta = 1;
                 break;
             case Mode::kFlipFlop:
                 delta = kMaxImagesToDraw - kMinImagesToDraw;
                 break;
         }
         for (int i = 0; i < loops; ++i) {
             int imgsToDraw = kMinImagesToDraw;
             for (int frame = 0; frame < kSimulatedFrames; ++frame) {
                 for (int j = 0; j < imgsToDraw; ++j) {
                     draw_image(canvas, fImages[j].get());
                 }
                 imgsToDraw += delta;
                 if (imgsToDraw > kMaxImagesToDraw || imgsToDraw < kMinImagesToDraw) {
                     delta = -delta;
                     imgsToDraw += 2 * delta;
                 }
                 // Simulate a frame boundary by flushing. This should notify GrResourceCache.
                 canvas->flush();
             }
         }
     }

 private:
     static constexpr int kImagesInBudget  = 25;
     static constexpr int kMinImagesToDraw = 15;
     static constexpr int kMaxImagesToDraw = 35;
     static constexpr int kSimulatedFrames = 80;

     Mode                        fMode;
     sk_sp<SkImage>              fImages[kMaxImagesToDraw];
     size_t                      fOldBytes;
     int                         fOldCount;

     typedef Benchmark INHERITED;
 };

 DEF_BENCH( return new ImageCacheBudgetDynamicBench(ImageCacheBudgetDynamicBench::Mode::kPingPong); )
 DEF_BENCH( return new ImageCacheBudgetDynamicBench(ImageCacheBudgetDynamicBench::Mode::kFlipFlop); )

 #endif
	/*
	* Copyright 2016 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 "sk_tool_utils.h"
	#include "SkCanvas.h"
	#include "SkImage.h"
	#include "SkSurface.h"

	#if SK_SUPPORT_GPU

	#include "GrContext.h"

	/** These benchmarks were designed to measure changes to GrResourceCache's replacement policy */

	//////////////////////////////////////////////////////////////////////////////

	// The width/height of the images to draw. The small size underestimates the value of a good
	// replacement strategy since the texture uploads are quite small. However, the effects are still
	// significant and this lets the benchmarks complete a lot faster, especially on mobile.
	static constexpr int kS = 25;

	static void make_images(sk_sp<SkImage> imgs[], int cnt) {
	for (int i = 0; i < cnt; ++i) {
	SkBitmap bmp = sk_tool_utils::create_checkerboard_bitmap(kS, kS, SK_ColorBLACK,
	SK_ColorCYAN, 10);
	imgs[i] = SkImage::MakeFromBitmap(bmp);
	}
	}

	static void draw_image(SkCanvas* canvas, SkImage* img) {
	// Make the paint transparent to avoid any issues of deferred tiler blending
	// optmizations
	SkPaint paint;
	paint.setAlpha(0x10);
	canvas->drawImage(img, 0, 0, &paint);
	}

	void set_cache_budget(SkCanvas* canvas, int approxImagesInBudget) {
	// This is inexact but we attempt to figure out a baseline number of resources GrContext needs
	// to render an SkImage and add one additional resource for each image we'd like to fit.
	GrContext* context = canvas->getGrContext();
	SkASSERT(context);
	context->flush();
	context->purgeAllUnlockedResources();
	sk_sp<SkImage> image;
	make_images(&image, 1);
	draw_image(canvas, image.get());
	context->flush();
	int baselineCount;
	context->getResourceCacheUsage(&baselineCount, nullptr);
	baselineCount -= 1; // for the image's textures.
	context->setResourceCacheLimits(baselineCount + approxImagesInBudget, 1 << 30);
	context->purgeAllUnlockedResources();
	}

	//////////////////////////////////////////////////////////////////////////////

	/**
	* Tests repeatedly drawing the same set of images in each frame. Different instances of the bench
	* run with different cache sizes and either repeat the image order each frame or use a random
	* order. Every variation of this bench draws the same image set, only the budget and order of
	* images differs. Since the total fill is the same they can be cross-compared.
	*/
	class ImageCacheBudgetBench : public Benchmark {
	public:
	/** budgetSize is the number of images that can fit in the cache. 100 images will be drawn. */
	ImageCacheBudgetBench(int budgetSize, bool shuffle)
	: fBudgetSize(budgetSize)
	, fShuffle(shuffle)
	, fIndices(nullptr) {
	float imagesOverBudget = float(kImagesToDraw) / budgetSize;
	// Make the benchmark name contain the percentage of the budget that is used in each
	// simulated frame.
	fName.printf("image_cache_budget_%.0f%s", imagesOverBudget * 100,
	(shuffle ? "_shuffle" : ""));
	}

	bool isSuitableFor(Backend backend) override { return kGPU_Backend == backend; }

	protected:
	const char* onGetName() override {
	return fName.c_str();
	}

	void onPerCanvasPreDraw(SkCanvas* canvas) override {
	GrContext* context = canvas->getGrContext();
	SkASSERT(context);
	context->getResourceCacheLimits(&fOldCount, &fOldBytes);
	set_cache_budget(canvas, fBudgetSize);
	make_images(fImages, kImagesToDraw);
	if (fShuffle) {
	SkRandom random;
	fIndices.reset(new int[kSimulatedFrames * kImagesToDraw]);
	for (int frame = 0; frame < kSimulatedFrames; ++frame) {
	int* base = fIndices.get() + frame * kImagesToDraw;
	for (int i = 0; i < kImagesToDraw; ++i) {
	base[i] = i;
	}
	for (int i = 0; i < kImagesToDraw - 1; ++i) {
	int other = random.nextULessThan(kImagesToDraw - i) + i;
	SkTSwap(base[i], base[other]);
	}
	}
	}
	}

	void onPerCanvasPostDraw(SkCanvas* canvas) override {
	GrContext* context = canvas->getGrContext();
	SkASSERT(context);
	context->setResourceCacheLimits(fOldCount, fOldBytes);
	for (int i = 0; i < kImagesToDraw; ++i) {
	fImages[i].reset();
	}
	fIndices.reset(nullptr);
	}

	void onDraw(int loops, SkCanvas* canvas) override {
	for (int i = 0; i < loops; ++i) {
	for (int frame = 0; frame < kSimulatedFrames; ++frame) {
	for (int j = 0; j < kImagesToDraw; ++j) {
	int idx;
	if (fShuffle) {
	idx = fIndices[frame * kImagesToDraw + j];
	} else {
	idx = j;
	}
	draw_image(canvas, fImages[idx].get());
	}
	// Simulate a frame boundary by flushing. This should notify GrResourceCache.
	canvas->flush();
	}
	}
	}

	private:
	static constexpr int kImagesToDraw = 100;
	static constexpr int kSimulatedFrames = 5;

	int fBudgetSize;
	bool fShuffle;
	SkString fName;
	sk_sp<SkImage> fImages[kImagesToDraw];
	std::unique_ptr<int[]> fIndices;
	size_t fOldBytes;
	int fOldCount;

	typedef Benchmark INHERITED;
	};

	DEF_BENCH( return new ImageCacheBudgetBench(105, false); )

	DEF_BENCH( return new ImageCacheBudgetBench(90, false); )

	DEF_BENCH( return new ImageCacheBudgetBench(80, false); )

	DEF_BENCH( return new ImageCacheBudgetBench(50, false); )

	DEF_BENCH( return new ImageCacheBudgetBench(105, true); )

	DEF_BENCH( return new ImageCacheBudgetBench(90, true); )

	DEF_BENCH( return new ImageCacheBudgetBench(80, true); )

	DEF_BENCH( return new ImageCacheBudgetBench(50, true); )

	//////////////////////////////////////////////////////////////////////////////

	/**
	* Similar to above but changes between being over and under budget by varying the number of images
	* rendered. This is not directly comparable to the non-dynamic benchmarks.
	*/
	class ImageCacheBudgetDynamicBench : public Benchmark {
	public:
	enum class Mode {
	// Increase from min to max images drawn gradually over simulated frames and then back.
	kPingPong,
	// Alternate between under and over budget every other simulated frame.
	kFlipFlop
	};

	ImageCacheBudgetDynamicBench(Mode mode) : fMode(mode) {}

	bool isSuitableFor(Backend backend) override { return kGPU_Backend == backend; }

	protected:
	const char* onGetName() override {
	switch (fMode) {
	case Mode::kPingPong:
	return "image_cache_budget_dynamic_ping_pong";
	case Mode::kFlipFlop:
	return "image_cache_budget_dynamic_flip_flop";
	}
	return "";
	}

	void onPerCanvasPreDraw(SkCanvas* canvas) override {
	GrContext* context = canvas->getGrContext();
	SkASSERT(context);
	context->getResourceCacheLimits(&fOldCount, &fOldBytes);
	make_images(fImages, kMaxImagesToDraw);
	set_cache_budget(canvas, kImagesInBudget);
	}

	void onPerCanvasPostDraw(SkCanvas* canvas) override {
	GrContext* context = canvas->getGrContext();
	SkASSERT(context);
	context->setResourceCacheLimits(fOldCount, fOldBytes);
	for (int i = 0; i < kMaxImagesToDraw; ++i) {
	fImages[i].reset();
	}
	}

	void onDraw(int loops, SkCanvas* canvas) override {
	int delta = 0;
	switch (fMode) {
	case Mode::kPingPong:
	delta = 1;
	break;
	case Mode::kFlipFlop:
	delta = kMaxImagesToDraw - kMinImagesToDraw;
	break;
	}
	for (int i = 0; i < loops; ++i) {
	int imgsToDraw = kMinImagesToDraw;
	for (int frame = 0; frame < kSimulatedFrames; ++frame) {
	for (int j = 0; j < imgsToDraw; ++j) {
	draw_image(canvas, fImages[j].get());
	}
	imgsToDraw += delta;
	if (imgsToDraw > kMaxImagesToDraw \|\| imgsToDraw < kMinImagesToDraw) {
	delta = -delta;
	imgsToDraw += 2 * delta;
	}
	// Simulate a frame boundary by flushing. This should notify GrResourceCache.
	canvas->flush();
	}
	}
	}

	private:
	static constexpr int kImagesInBudget = 25;
	static constexpr int kMinImagesToDraw = 15;
	static constexpr int kMaxImagesToDraw = 35;
	static constexpr int kSimulatedFrames = 80;

	Mode fMode;
	sk_sp<SkImage> fImages[kMaxImagesToDraw];
	size_t fOldBytes;
	int fOldCount;

	typedef Benchmark INHERITED;
	};

	DEF_BENCH( return new ImageCacheBudgetDynamicBench(ImageCacheBudgetDynamicBench::Mode::kPingPong); )
	DEF_BENCH( return new ImageCacheBudgetDynamicBench(ImageCacheBudgetDynamicBench::Mode::kFlipFlop); )

	#endif