ImageCycle Class Reference

Inheritance diagram for ImageCycle:

Public Member Functions
	ImageCycle (int imageCnt, int repeatCnt)
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 *) 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

Draws a small set of small images multiple times each with no overlaps so that each image could be batched. This was originally added to detect regressions as TextureOp is refactored to use "dynamic state" for texture bindings. Everything is kept small as we're mostly interested in CPU overhead.

Definition at line 25 of file ImageCycleBench.cpp.

Constructor & Destructor Documentation

ImageCycle()

ImageCycle::ImageCycle ( int  imageCnt, int  repeatCnt  )

inline

imageCnt is the number of images and repeat cnt is how many times each image is drawn per logical "frame."

Definition at line 31 of file ImageCycleBench.cpp.

                                            : fImageCnt(imageCnt), fRepeatCnt(repeatCnt) {
        fName.appendf("image_cycle_image_cnt_%d_repeat_cnt_%d", fImageCnt, fRepeatCnt);
    }

Member Function Documentation

isSuitableFor()

bool ImageCycle::isSuitableFor ( Backend  backend )

inlineoverridevirtual

Reimplemented from Benchmark.

Definition at line 35 of file ImageCycleBench.cpp.

{ return Backend::kGanesh == backend; }

onDraw()

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

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 60 of file ImageCycleBench.cpp.

                                                      {
        SkPaint paint;
        paint.setAntiAlias(true);
        static constexpr SkScalar kPad = 2;
        // To avoid tripping up bounds tracking we position the draws such that all the
        // draws of image 0 are above those of image 1, etc.
        static const int imagesPerRow =
                SkScalarFloorToInt(kDeviceSize.fWidth / (kImageSize.fWidth + kPad));
        int rowsPerImage = SkScalarCeilToInt((SkScalar)fRepeatCnt / imagesPerRow);
        for (int l = 0; l < loops; ++l) {
            for (int r = 0; r < fRepeatCnt; ++r) {
                for (int i = 0; i < fImageCnt; ++i) {
                    SkScalar imageYOffset = i * rowsPerImage * (kImageSize.fHeight + kPad);
                    SkScalar rowYOffset = (r / imagesPerRow) * (kImageSize.fHeight + kPad);
                    SkScalar x = (r % imagesPerRow) * (kImageSize.fWidth + kPad);
                    canvas->drawImage(fImages[i].get(), x, imageYOffset + rowYOffset,
                                      SkSamplingOptions(), &paint);
                }
            }
            // Prevent any batching between "frames".
            skgpu::FlushAndSubmit(canvas->getSurface());
        }
    }

onGetName()

const char * ImageCycle::onGetName ( )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 38 of file ImageCycleBench.cpp.

{ return fName.c_str(); }

onPerCanvasPostDraw()

void ImageCycle::onPerCanvasPostDraw ( SkCanvas *  )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 58 of file ImageCycleBench.cpp.

{ fImages.reset(); }

onPerCanvasPreDraw()

void ImageCycle::onPerCanvasPreDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 40 of file ImageCycleBench.cpp.

                                                       {
        auto ii = SkImageInfo::Make(kImageSize.fWidth, kImageSize.fHeight, kRGBA_8888_SkColorType,
                                    kPremul_SkAlphaType, nullptr);
        SkRandom random;
        fImages = std::make_unique<sk_sp<SkImage>[]>(fImageCnt);
        for (int i = 0; i < fImageCnt; ++i) {
            auto surf = canvas->makeSurface(ii);
            SkColor color = random.nextU();
            surf->getCanvas()->clear(color);
            SkPaint paint;
            paint.setColor(~color);
            paint.setBlendMode(SkBlendMode::kSrc);
            surf->getCanvas()->drawRect(
                    SkRect::MakeLTRB(1, 1, kImageSize.fWidth - 1, kImageSize.fHeight - 1), paint);
            fImages[i] = surf->makeImageSnapshot();
        }
    }

---

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

• third_party/skia/bench/ImageCycleBench.cpp