ImageCacheBudgetBench Class Reference

Inheritance diagram for ImageCacheBudgetBench:

Public Member Functions
	ImageCacheBudgetBench (int budgetSize, bool shuffle)
bool	isSuitableFor (Backend backend) override
Public Member Functions inherited from Benchmark
	Benchmark ()
const char *	getName ()
const char *	getUniqueName ()
SkISize	getSize ()
virtual bool	isSuitableFor (Backend backend)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual bool	shouldLoop () const
void	delayedSetup ()
void	perCanvasPreDraw (SkCanvas *)
void	perCanvasPostDraw (SkCanvas *)
void	preDraw (SkCanvas *)
void	postDraw (SkCanvas *)
void	draw (int loops, SkCanvas *)
virtual void	getGpuStats (SkCanvas *, skia_private::TArray< SkString > *keys, skia_private::TArray< double > *values)
virtual bool	getDMSAAStats (GrRecordingContext *)
int	getUnits () const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Protected Member Functions
const char *	onGetName () override
void	onPerCanvasPreDraw (SkCanvas *canvas) override
void	onPerCanvasPostDraw (SkCanvas *canvas) override
void	onDraw (int loops, SkCanvas *canvas) override
Protected Member Functions inherited from Benchmark
void	setUnits (int units)
virtual void	setupPaint (SkPaint *paint)
virtual const char *	onGetName ()=0
virtual const char *	onGetUniqueName ()
virtual void	onDelayedSetup ()
virtual void	onPerCanvasPreDraw (SkCanvas *)
virtual void	onPerCanvasPostDraw (SkCanvas *)
virtual void	onPreDraw (SkCanvas *)
virtual void	onPostDraw (SkCanvas *)
virtual void	onDraw (int loops, SkCanvas *)=0
virtual SkISize	onGetSize ()

Additional Inherited Members
Public Types inherited from Benchmark
enum class	Backend {   kNonRendering , kRaster , kGanesh , kGraphite ,   kPDF , kHWUI }

Detailed Description

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.

Definition at line 71 of file ImageCacheBudgetBench.cpp.

Constructor & Destructor Documentation

ImageCacheBudgetBench()

ImageCacheBudgetBench::ImageCacheBudgetBench ( int  budgetSize, bool  shuffle  )

inline

budgetSize is the number of images that can fit in the cache. 100 images will be drawn.

Definition at line 74 of file ImageCacheBudgetBench.cpp.

            : 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" : ""));
    }

Member Function Documentation

isSuitableFor()

bool ImageCacheBudgetBench::isSuitableFor ( Backend  backend )

inlineoverridevirtual

Reimplemented from Benchmark.

Definition at line 85 of file ImageCacheBudgetBench.cpp.

{ return Backend::kGanesh == backend; }

onDraw()

void ImageCacheBudgetBench::onDraw ( int  loops, SkCanvas *  canvas  )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 125 of file ImageCacheBudgetBench.cpp.

                                                      {
        auto dContext = GrAsDirectContext(canvas->recordingContext());
 
        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.
                if (dContext) {
                    dContext->flush();
                }
           }
        }
    }

onGetName()

const char * ImageCacheBudgetBench::onGetName ( )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 88 of file ImageCacheBudgetBench.cpp.

                                     {
        return fName.c_str();
    }

onPerCanvasPostDraw()

void ImageCacheBudgetBench::onPerCanvasPostDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 115 of file ImageCacheBudgetBench.cpp.

                                                        {
        auto context =  canvas->recordingContext()->asDirectContext();
        SkASSERT(context);
        context->setResourceCacheLimit(fOldBytes);
        for (int i = 0; i < kImagesToDraw; ++i) {
            fImages[i].reset();
        }
        fIndices.reset(nullptr);
    }

onPerCanvasPreDraw()

void ImageCacheBudgetBench::onPerCanvasPreDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 92 of file ImageCacheBudgetBench.cpp.

                                                       {
        auto context = canvas->recordingContext()->asDirectContext();
        SkASSERT(context);
        fOldBytes = context->getResourceCacheLimit();
        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;
                    using std::swap;
                    swap(base[i], base[other]);
                }
            }
        }
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/bench/ImageCacheBudgetBench.cpp