BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode > Class Template Reference

Inheritance diagram for BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >:

Public Member Functions
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

Static Public Attributes
static constexpr int	kWidth = 1024
static constexpr int	kHeight = 1024
static constexpr int	kImageCount

Protected Types
using	INHERITED = Benchmark

Protected Member Functions
void	computeName ()
void	drawImagesBatch (SkCanvas *canvas) const
void	drawImagesRef (SkCanvas *canvas) const
void	drawSolidColorsBatch (SkCanvas *canvas) const
void	drawSolidColorsRef (SkCanvas *canvas) const
const char *	onGetName () override
void	onDelayedSetup () override
void	onPerCanvasPreDraw (SkCanvas *canvas) override
void	onPerCanvasPostDraw (SkCanvas *canvas) override
void	onDraw (int loops, SkCanvas *canvas) override
SkISize	onGetSize () 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 ()

Protected Attributes
SkRect	fRects [kRectCount]
sk_sp< SkImage >	fImages [kImageCount > 0 ? kImageCount :1]
SkColor4f	fColors [kRectCount]
SkString	fName

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

Detailed Description

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>
class BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >

Definition at line 42 of file BulkRectBench.cpp.

Member Typedef Documentation

INHERITED

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

using BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::INHERITED = Benchmark

protected

Definition at line 269 of file BulkRectBench.cpp.

Member Function Documentation

computeName()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::computeName ( )

inlineprotected

Definition at line 70 of file BulkRectBench.cpp.

                        {
        fName = "bulkrect";
        fName.appendf("_%d", kRectCount);
        if (kLayout == RectangleLayout::kRandom) {
            fName.append("_random");
        } else {
            fName.append("_grid");
        }
        if (kImageMode == ImageMode::kShared) {
            fName.append("_sharedimage");
        } else if (kImageMode == ImageMode::kUnique) {
            fName.append("_uniqueimages");
        } else {
            fName.append("_solidcolor");
        }
        if (kDrawMode == DrawMode::kBatch) {
            fName.append("_batch");
        } else if (kDrawMode == DrawMode::kRef) {
            fName.append("_ref");
        } else {
            fName.append("_quad");
        }
    }

drawImagesBatch()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::drawImagesBatch ( SkCanvas *  canvas ) const

inlineprotected

Definition at line 94 of file BulkRectBench.cpp.

                                                 {
        SkASSERT(kImageMode != ImageMode::kNone);
        SkASSERT(kDrawMode == DrawMode::kBatch);
 
        SkCanvas::ImageSetEntry batch[kRectCount];
        for (int i = 0; i < kRectCount; ++i) {
            int imageIndex = kImageMode == ImageMode::kShared ? 0 : i;
            batch[i].fImage = fImages[imageIndex];
            batch[i].fSrcRect = SkRect::MakeIWH(fImages[imageIndex]->width(),
                                                fImages[imageIndex]->height());
            batch[i].fDstRect = fRects[i];
            batch[i].fAAFlags = SkCanvas::kAll_QuadAAFlags;
        }
 
        SkPaint paint;
        paint.setAntiAlias(true);
 
        canvas->experimental_DrawEdgeAAImageSet(batch, kRectCount, nullptr, nullptr,
                                                SkSamplingOptions(SkFilterMode::kLinear), &paint,
                                                SkCanvas::kFast_SrcRectConstraint);
    }

drawImagesRef()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::drawImagesRef ( SkCanvas *  canvas ) const

inlineprotected

Definition at line 116 of file BulkRectBench.cpp.

                                               {
        SkASSERT(kImageMode != ImageMode::kNone);
        SkASSERT(kDrawMode == DrawMode::kRef);
 
        SkPaint paint;
        paint.setAntiAlias(true);
 
        for (int i = 0; i < kRectCount; ++i) {
            int imageIndex = kImageMode == ImageMode::kShared ? 0 : i;
            SkRect srcRect = SkRect::MakeIWH(fImages[imageIndex]->width(),
                                             fImages[imageIndex]->height());
            canvas->drawImageRect(fImages[imageIndex].get(), srcRect, fRects[i],
                                  SkSamplingOptions(SkFilterMode::kLinear), &paint,
                                  SkCanvas::kFast_SrcRectConstraint);
        }
    }

drawSolidColorsBatch()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::drawSolidColorsBatch ( SkCanvas *  canvas ) const

inlineprotected

Definition at line 133 of file BulkRectBench.cpp.

                                                      {
        SkASSERT(kImageMode == ImageMode::kNone);
        SkASSERT(kDrawMode == DrawMode::kBatch);
 
        auto context = canvas->recordingContext();
        SkASSERT(context);
 
        GrQuadSetEntry batch[kRectCount];
        for (int i = 0; i < kRectCount; ++i) {
            batch[i].fRect = fRects[i];
            batch[i].fColor = fColors[i].premul();
            batch[i].fLocalMatrix = SkMatrix::I();
            batch[i].fAAFlags = GrQuadAAFlags::kAll;
        }
 
        SkPaint paint;
        paint.setColor(SK_ColorWHITE);
        paint.setAntiAlias(true);
 
        auto sdc = skgpu::ganesh::TopDeviceSurfaceDrawContext(canvas);
        SkMatrix view = canvas->getLocalToDeviceAs3x3();
        SkSurfaceProps props;
        GrPaint grPaint;
        SkPaintToGrPaint(context, sdc->colorInfo(), paint, view, props, &grPaint);
        sdc->drawQuadSet(nullptr, std::move(grPaint), view, batch, kRectCount);
    }

drawSolidColorsRef()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::drawSolidColorsRef ( SkCanvas *  canvas ) const

inlineprotected

Definition at line 160 of file BulkRectBench.cpp.

                                                    {
        SkASSERT(kImageMode == ImageMode::kNone);
        SkASSERT(kDrawMode == DrawMode::kRef || kDrawMode == DrawMode::kQuad);
 
        SkPaint paint;
        paint.setAntiAlias(true);
        for (int i = 0; i < kRectCount; ++i) {
            if (kDrawMode == DrawMode::kRef) {
                paint.setColor4f(fColors[i]);
                canvas->drawRect(fRects[i], paint);
            } else {
                canvas->experimental_DrawEdgeAAQuad(fRects[i], nullptr, SkCanvas::kAll_QuadAAFlags,
                                                    fColors[i], SkBlendMode::kSrcOver);
            }
        }
    }

isSuitableFor()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

bool BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::isSuitableFor ( Backend  backend )

inlineoverridevirtual

Reimplemented from Benchmark.

Definition at line 54 of file BulkRectBench.cpp.

                                                 {
        if (kDrawMode == DrawMode::kBatch && kImageMode == ImageMode::kNone) {
            // Currently the bulk color quad API is only available on
            // skgpu::ganesh::SurfaceDrawContext
            return backend == Backend::kGanesh;
        } else {
            return this->INHERITED::isSuitableFor(backend);
        }
    }

onDelayedSetup()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::onDelayedSetup ( )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 184 of file BulkRectBench.cpp.

                                   {
        static constexpr SkScalar kMinRectSize = 0.2f;
        static constexpr SkScalar kMaxRectSize = 300.f;
 
        SkRandom rand;
        for (int i = 0; i < kRectCount; i++) {
            if (kLayout == RectangleLayout::kRandom) {
                SkScalar w = rand.nextF() * (kMaxRectSize - kMinRectSize) + kMinRectSize;
                SkScalar h = rand.nextF() * (kMaxRectSize - kMinRectSize) + kMinRectSize;
 
                SkScalar x = rand.nextF() * (kWidth - w);
                SkScalar y = rand.nextF() * (kHeight - h);
 
                fRects[i].setXYWH(x, y, w, h);
            } else {
                int gridSize = SkScalarCeilToInt(SkScalarSqrt(kRectCount));
                SkASSERT(gridSize * gridSize >= kRectCount);
 
                SkScalar w = (kWidth - 1.f) / gridSize;
                SkScalar h = (kHeight - 1.f) / gridSize;
 
                SkScalar x = (i % gridSize) * w + 0.5f; // Offset to ensure AA doesn't get disabled
                SkScalar y = (i / gridSize) * h + 0.5f;
 
                fRects[i].setXYWH(x, y, w, h);
            }
 
            // Make sure we don't extend outside the render target, don't want to include clipping
            // in the benchmark.
            SkASSERT(SkRect::MakeWH(kWidth, kHeight).contains(fRects[i]));
 
            fColors[i] = {rand.nextF(), rand.nextF(), rand.nextF(), 1.f};
        }
    }

onDraw()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::onDraw ( int  loops, SkCanvas *  canvas  )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 247 of file BulkRectBench.cpp.

                                                      {
        for (int i = 0; i < loops; i++) {
            if (kImageMode == ImageMode::kNone) {
                if (kDrawMode == DrawMode::kBatch) {
                    this->drawSolidColorsBatch(canvas);
                } else {
                    this->drawSolidColorsRef(canvas);
                }
            } else {
                if (kDrawMode == DrawMode::kBatch) {
                    this->drawImagesBatch(canvas);
                } else {
                    this->drawImagesRef(canvas);
                }
            }
        }
    }

onGetName()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

const char * BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::onGetName ( )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 177 of file BulkRectBench.cpp.

                                     {
        if (fName.isEmpty()) {
            this->computeName();
        }
        return fName.c_str();
    }

onGetSize()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

SkISize BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::onGetSize ( )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 265 of file BulkRectBench.cpp.

                                 {
        return { kWidth, kHeight };
    }

onPerCanvasPostDraw()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::onPerCanvasPostDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 238 of file BulkRectBench.cpp.

                                                        {
        for (int i = 0; i < kImageCount; ++i) {
            // For Vulkan we need to make sure the bench isn't holding onto any refs to the
            // GrContext when we go to delete the vulkan context (which happens before the bench is
            // deleted). So reset all the images here so they aren't holding GrContext refs.
            fImages[i].reset();
        }
    }

onPerCanvasPreDraw()

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

void BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::onPerCanvasPreDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 219 of file BulkRectBench.cpp.

                                                       {
        // Push the skimages to the GPU when using the GPU backend so that the texture creation is
        // not part of the bench measurements. Always remake the images since they are so simple,
        // and since they are context-specific, this works when the bench runs multiple GPU backends
        auto direct = GrAsDirectContext(canvas->recordingContext());
        for (int i = 0; i < kImageCount; ++i) {
            SkBitmap bm;
            bm.allocN32Pixels(256, 256);
            bm.eraseColor(fColors[i].toSkColor());
            auto image = bm.asImage();
 
            if (direct) {
                fImages[i] = SkImages::TextureFromImage(direct, image);
            } else {
                fImages[i] = std::move(image);
            }
        }
    }

Member Data Documentation

fColors

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

SkColor4f BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::fColors[kRectCount]

protected

Definition at line 67 of file BulkRectBench.cpp.

fImages

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

sk_sp<SkImage> BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::fImages[kImageCount > 0 ? kImageCount :1]

protected

Definition at line 66 of file BulkRectBench.cpp.

fName

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

SkString BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::fName

protected

Definition at line 68 of file BulkRectBench.cpp.

fRects

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

SkRect BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::fRects[kRectCount]

protected

Definition at line 65 of file BulkRectBench.cpp.

kHeight

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

constexpr int BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::kHeight = 1024

inlinestaticconstexpr

Definition at line 48 of file BulkRectBench.cpp.

kImageCount

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

constexpr int BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::kImageCount

inlinestaticconstexpr

Initial value:

= kImageMode == ImageMode::kShared ?
            1 : (kImageMode == ImageMode::kNone ? 0 : kRectCount)

Definition at line 51 of file BulkRectBench.cpp.

kWidth

template<int kRectCount, RectangleLayout kLayout, ImageMode kImageMode, DrawMode kDrawMode>

constexpr int BulkRectBench< kRectCount, kLayout, kImageMode, kDrawMode >::kWidth = 1024

inlinestaticconstexpr

Definition at line 47 of file BulkRectBench.cpp.

---

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

• third_party/skia/bench/BulkRectBench.cpp