FourByteInterpBench< kFast, kScale > Class Template Reference

Inheritance diagram for FourByteInterpBench< kFast, kScale >:

Public Member Functions
	FourByteInterpBench ()
bool	isSuitableFor (Backend backend) override
const char *	onGetName () override
void	onDelayedSetup () override
void	onDraw (int loops, SkCanvas *) override
Public Member Functions inherited from Benchmark
	Benchmark ()
const char *	getName ()
const char *	getUniqueName ()
SkISize	getSize ()
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

Additional Inherited Members
Public Types inherited from Benchmark
enum class	Backend {   kNonRendering , kRaster , kGanesh , kGraphite ,   kPDF , kHWUI }
Protected Member Functions inherited from Benchmark
void	setUnits (int units)
virtual void	setupPaint (SkPaint *paint)
virtual const char *	onGetUniqueName ()
virtual void	onPerCanvasPreDraw (SkCanvas *)
virtual void	onPerCanvasPostDraw (SkCanvas *)
virtual void	onPreDraw (SkCanvas *)
virtual void	onPostDraw (SkCanvas *)
virtual SkISize	onGetSize ()

Detailed Description

template<bool kFast, bool kScale>
class FourByteInterpBench< kFast, kScale >

Definition at line 13 of file ColorPrivBench.cpp.

Constructor & Destructor Documentation

FourByteInterpBench()

template<bool kFast, bool kScale>

FourByteInterpBench< kFast, kScale >::FourByteInterpBench ( )

inline

Definition at line 15 of file ColorPrivBench.cpp.

                          {
        fName.set("four_byte_interp");
        fName.append(kFast ? "_fast" : "_slow");
        fName.append(kScale ? "_255" : "_256");
    }

Member Function Documentation

isSuitableFor()

template<bool kFast, bool kScale>

bool FourByteInterpBench< kFast, kScale >::isSuitableFor ( Backend  backend )

inlineoverridevirtual

Reimplemented from Benchmark.

Definition at line 21 of file ColorPrivBench.cpp.

                                                 {
        return backend == Backend::kNonRendering;
    }

onDelayedSetup()

template<bool kFast, bool kScale>

void FourByteInterpBench< kFast, kScale >::onDelayedSetup ( )

inlineoverridevirtual

Reimplemented from Benchmark.

Definition at line 27 of file ColorPrivBench.cpp.

                                   {
        // A handful of random srcs and dsts.
        SkRandom rand;
        for (int i = 0; i < kInputs; i++) {
            fSrcs[i] = SkPreMultiplyColor(rand.nextU());
            fDsts[i] = SkPreMultiplyColor(rand.nextU());
        }
 
        // We'll exhaustively test all scales instead of using random numbers.
        for (int i = 0; i <= 256; i++) {
            fScales[i] = i;
        }
        if (kScale) fScales[256] = 255;  // We'll just do 255 twice if we're limited to [0,255].
    }

onDraw()

template<bool kFast, bool kScale>

void FourByteInterpBench< kFast, kScale >::onDraw ( int  loops, SkCanvas *    )

inlineoverridevirtual

Implements Benchmark.

Definition at line 42 of file ColorPrivBench.cpp.

                                               {
        // We xor results of FourByteInterp into junk to make sure the function runs.
        [[maybe_unused]] volatile SkPMColor junk = 0;
 
        for (int loop = 0; loop < loops; loop++) {
            for (int i = 0; i < kInputs; i++) {
                for (size_t j = 0; j <= 256; j++) {
                    // Note: we really want to load src and dst here and not outside in the i-loop.
                    // If we put the loads there, a clever compiler will do the not-insignificant
                    // work in the FourByteInterps that depends only on src and dst outside this
                    // loop, so we'd only be benchmarking the back half of those functions that also
                    // depends on scale.  Even here, these must be volatile arrays to prevent that
                    // clever compiler from hoisting the loads out of the loop on its own.
                    const SkPMColor src = fSrcs[i];
                    const SkPMColor dst = fDsts[i];
 
                    const unsigned scale = fScales[j];
 
                    if (kFast && kScale) {
                        junk = SkFastFourByteInterp(src, dst, scale);
                    } else if (kFast) {
                        junk = SkFastFourByteInterp256(src, dst, scale);
                    } else if (kScale) {
                        junk = SkFourByteInterp(src, dst, scale);
                    } else {
                        junk = SkFourByteInterp256(src, dst, scale);
                    }
                }
            }
        }
    }

onGetName()

template<bool kFast, bool kScale>

const char * FourByteInterpBench< kFast, kScale >::onGetName ( )

inlineoverridevirtual

Implements Benchmark.

Definition at line 25 of file ColorPrivBench.cpp.

{ return fName.c_str(); }

---

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

• third_party/skia/bench/ColorPrivBench.cpp