Inheritance diagram for skgpu::graphite::FileBoundsManagerBench:

Public Member Functions
	FileBoundsManagerBench (std::unique_ptr< BoundsManager > manager, const char *managerName)

Public Member Functions inherited from skgpu::graphite::BoundsManagerBench
	BoundsManagerBench (std::unique_ptr< BoundsManager > manager)

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

Private Member Functions
bool	isSuitableFor (Backend backend) final

void	gatherRects (TArray< SkRect > *rects) override

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

Protected Member Functions inherited from skgpu::graphite::BoundsManagerBench
const char *	onGetName () final

void	onDelayedSetup () final

void	onDraw (int loops, SkCanvas *) final

void	onPerCanvasPostDraw (SkCanvas *) override

void	doBench ()

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	onPreDraw (SkCanvas *)

virtual void	onPostDraw (SkCanvas *)

virtual SkISize	onGetSize ()

Protected Attributes inherited from skgpu::graphite::BoundsManagerBench
std::unique_ptr< BoundsManager >	fManager

SkString	fName

SkArenaAlloc	fAlignedAllocator {0}

int	fRectCount

Rect *	fRects

CompressedPaintersOrder	fMaxRead

Detailed Description

Definition at line 114 of file BoundsManagerBench.cpp.

Constructor & Destructor Documentation

◆ FileBoundsManagerBench()

skgpu::graphite::FileBoundsManagerBench::FileBoundsManagerBench	(	std::unique_ptr< BoundsManager >	manager,
		const char *	managerName
	)

inline

Definition at line 116 of file BoundsManagerBench.cpp.

            : BoundsManagerBench(std::move(manager)) {
        if (!FLAGS_boundsManagerFile.isEmpty()) {
            const char* filename = strrchr(FLAGS_boundsManagerFile[0], '/');
            if (filename) {
                ++filename;
            } else {
                filename = FLAGS_boundsManagerFile[0];
            }
            fName.printf("BoundsManager_file_%s_%s", filename, managerName);
        }
    }

Member Function Documentation

◆ gatherRects()

void skgpu::graphite::FileBoundsManagerBench::gatherRects ( TArray< SkRect > * rects )

inlineoverrideprivatevirtual

Implements skgpu::graphite::BoundsManagerBench.

Definition at line 138 of file BoundsManagerBench.cpp.

                                                     {
        if (FLAGS_boundsManagerFile.isEmpty()) {
            return;
        }
        SkRect fileBounds = SkRect::MakeEmpty();
        auto callback = [&](const SkMatrix& matrix,
                            const SkPath& path,
                            const SkPaint& paint) {
            if (!paint.canComputeFastBounds() || path.isInverseFillType()) {
                // These would pessimistically cover the entire canvas, but we don't have enough
                // info in the benchmark to handle that, so just skip these draws.
                return;
            }
 
            SkRect bounds = path.getBounds();
            SkRect drawBounds = matrix.mapRect(paint.computeFastBounds(bounds, &bounds));
            rects->push_back(drawBounds);
 
            fileBounds.join(drawBounds);
        };
 
        const char* path = FLAGS_boundsManagerFile[0];
        if (const char* ext = strrchr(path, '.'); ext && !strcmp(ext, ".svg")) {
#if defined(SK_ENABLE_SVG)
            ToolUtils::ExtractPathsFromSVG(path, callback);
#else
            SK_ABORT("must compile with svg backend to process svgs");
#endif
        } else {
            ToolUtils::ExtractPathsFromSKP(path, callback);
        }
 
#if PRINT_DRAWSET_COUNT
        SkDebugf("%s bounds are [%f %f %f %f]\n",
            FLAGS_boundsManagerFile[0],
            fileBounds.fLeft, fileBounds.fTop, fileBounds.fRight, fileBounds.fBottom);
#endif
    }

◆ isSuitableFor()

bool skgpu::graphite::FileBoundsManagerBench::isSuitableFor ( Backend backend )

inlinefinalprivatevirtual

Reimplemented from skgpu::graphite::BoundsManagerBench.

Definition at line 131 of file BoundsManagerBench.cpp.

                                              {
        if (FLAGS_boundsManagerFile.isEmpty()) {
            return false;
        }
        return BoundsManagerBench::isSuitableFor(backend);
    }

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

third_party/skia/bench/graphite/BoundsManagerBench.cpp

Public Member Functions