ImageCacheBudgetDynamicBench Class Reference

Inheritance diagram for ImageCacheBudgetDynamicBench:

Public Types
enum class	Mode { kPingPong , kFlipFlop }
Public Types inherited from Benchmark
enum class	Backend {   kNonRendering , kRaster , kGanesh , kGraphite ,   kPDF , kHWUI }

Public Member Functions
	ImageCacheBudgetDynamicBench (Mode mode)
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 ()

Detailed Description

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.

Definition at line 183 of file ImageCacheBudgetBench.cpp.

Member Enumeration Documentation

Mode

enum class ImageCacheBudgetDynamicBench::Mode

strong

Enumerator
kPingPong
kFlipFlop

Definition at line 185 of file ImageCacheBudgetBench.cpp.

                    {
        // 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
    };

Constructor & Destructor Documentation

ImageCacheBudgetDynamicBench()

ImageCacheBudgetDynamicBench::ImageCacheBudgetDynamicBench ( Mode  mode )

inline

Definition at line 192 of file ImageCacheBudgetBench.cpp.

: fMode(mode) {}

Member Function Documentation

isSuitableFor()

bool ImageCacheBudgetDynamicBench::isSuitableFor ( Backend  backend )

inlineoverridevirtual

Reimplemented from Benchmark.

Definition at line 194 of file ImageCacheBudgetBench.cpp.

{ return Backend::kGanesh == backend; }

onDraw()

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

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 224 of file ImageCacheBudgetBench.cpp.

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

onGetName()

const char * ImageCacheBudgetDynamicBench::onGetName ( )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 197 of file ImageCacheBudgetBench.cpp.

                                     {
        switch (fMode) {
            case Mode::kPingPong:
                return "image_cache_budget_dynamic_ping_pong";
            case Mode::kFlipFlop:
                return "image_cache_budget_dynamic_flip_flop";
        }
        return "";
    }

onPerCanvasPostDraw()

void ImageCacheBudgetDynamicBench::onPerCanvasPostDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 215 of file ImageCacheBudgetBench.cpp.

                                                        {
        auto context = canvas->recordingContext()->asDirectContext();
        SkASSERT(context);
        context->setResourceCacheLimits(fOldCount, fOldBytes);
        for (int i = 0; i < kMaxImagesToDraw; ++i) {
            fImages[i].reset();
        }
    }

onPerCanvasPreDraw()

void ImageCacheBudgetDynamicBench::onPerCanvasPreDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 207 of file ImageCacheBudgetBench.cpp.

                                                       {
        auto context = canvas->recordingContext()->asDirectContext();
        SkASSERT(context);
        context->getResourceCacheLimits(&fOldCount, &fOldBytes);
        make_images(fImages, kMaxImagesToDraw);
        set_cache_budget(canvas, kImagesInBudget);
    }

---

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

• third_party/skia/bench/ImageCacheBudgetBench.cpp