RasterBenchmarkTarget Class Reference

Inheritance diagram for RasterBenchmarkTarget:

Public Member Functions
	RasterBenchmarkTarget (std::unique_ptr< SurfaceManager > surfaceManager, Benchmark *benchmark)
Benchmark::Backend	getBackend () const override
std::tuple< int, bool >	autoTuneLoops () const override
Public Member Functions inherited from BenchmarkTarget
virtual	~BenchmarkTarget ()=default
virtual Benchmark::Backend	getBackend () const =0
virtual void	setup () const
virtual std::tuple< int, bool >	autoTuneLoops () const =0
virtual void	warmUp (int loops) const
double	time (int loops) const
void	tearDown () const
virtual void	dumpStats (skia_private::TArray< SkString > *keys, skia_private::TArray< double > *values) const
virtual void	printStats () const
SkCanvas *	getCanvas () const
Benchmark *	getBenchmark () const
virtual std::map< std::string, std::string >	getKeyValuePairs (std::string cpuName, std::string gpuName) const
virtual SurfaceManager::CpuOrGpu	isCpuOrGpuBound () const

Additional Inherited Members
Static Public Member Functions inherited from BenchmarkTarget
static std::unique_ptr< BenchmarkTarget >	FromConfig (std::string surfaceConfig, Benchmark *benchmark)
static void	printGlobalStats ()
Protected Member Functions inherited from BenchmarkTarget
	BenchmarkTarget (std::unique_ptr< SurfaceManager > surfaceManager, Benchmark *benchmark)
virtual SkCanvas *	onBeforeDraw (SkCanvas *canvas) const
virtual void	onAfterDraw () const
double	nowMs () const
Protected Attributes inherited from BenchmarkTarget
std::unique_ptr< SurfaceManager >	fSurfaceManager
Benchmark *	fBenchmark

Detailed Description

Definition at line 27 of file RasterBenchmarkTarget.cpp.

Constructor & Destructor Documentation

RasterBenchmarkTarget()

RasterBenchmarkTarget::RasterBenchmarkTarget ( std::unique_ptr< SurfaceManager >  surfaceManager, Benchmark *  benchmark  )

inline

Definition at line 29 of file RasterBenchmarkTarget.cpp.

            : BenchmarkTarget(std::move(surfaceManager), benchmark) {}

Member Function Documentation

autoTuneLoops()

std::tuple< int, bool > RasterBenchmarkTarget::autoTuneLoops ( ) const

inlineoverridevirtual

Implements BenchmarkTarget.

Definition at line 36 of file RasterBenchmarkTarget.cpp.

                                                       {
        // Estimate timer overhead. Based on:
        // https://skia.googlesource.com/skia/+/a063eaeaf1e09e4d6f42e0f44a5723622a46d21c/bench/nanobench.cpp#402.
        double overhead = 0;
        for (int i = 0; i < FLAGS_overheadLoops; i++) {
            double start = nowMs();
            overhead += nowMs() - start;
        }
        overhead /= FLAGS_overheadLoops;
 
        // First figure out approximately how many loops of bench it takes to make overhead
        // negligible.
        double bench_plus_overhead = 0.0;
        int round = 0;
        while (bench_plus_overhead < overhead) {
            if (round++ == FLAGS_maxCalibrationAttempts) {
                TestRunner::Log("Warning: Cannot estimate loops for %s (%s vs. %s); skipping.",
                                fBenchmark->getUniqueName(),
                                humanize(bench_plus_overhead).c_str(),
                                humanize(overhead).c_str());
                return std::make_tuple(0, false);
            }
            bench_plus_overhead = time(1);
        }
 
        // Later we'll just start and stop the timer once but loop N times.
        // We'll pick N to make timer overhead negligible:
        //
        //          overhead
        //  -------------------------  < FLAGS_overheadGoal
        //  overhead + N * Bench Time
        //
        // where bench_plus_overhead ~=~ overhead + Bench Time.
        //
        // Doing some math, we get:
        //
        //  (overhead / FLAGS_overheadGoal) - overhead
        //  ------------------------------------------  < N
        //       bench_plus_overhead - overhead)
        //
        // Luckily, this also works well in practice. :)
        const double numer = overhead / FLAGS_overheadGoal - overhead;
        const double denom = bench_plus_overhead - overhead;
        int loops = (int)ceil(numer / denom);
 
        return std::make_tuple(loops, true);
    }

getBackend()

Benchmark::Backend RasterBenchmarkTarget::getBackend ( ) const

inlineoverridevirtual

Implements BenchmarkTarget.

Reimplemented in NonRenderingBenchmarkTarget.

Definition at line 32 of file RasterBenchmarkTarget.cpp.

{ return Benchmark::Backend::kRaster; }

---

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

• third_party/skia/tools/testrunners/benchmark/target/RasterBenchmarkTarget.cpp