Inheritance diagram for skgpu::graphite::FileIntersectionBench:

Public Member Functions
	FileIntersectionBench ()

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

void	onPerCanvasPostDraw (SkCanvas *) 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::IntersectionTreeBench
const char *	onGetName () final

bool	isSuitableFor (Backend backend) override

void	onDelayedSetup () final

void	onDraw (int loops, SkCanvas *) final

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::IntersectionTreeBench
SkString	fName

SkArenaAlloc	fAlignedAllocator {0}

int	fRectCount

Rect *	fRects

Rect *	fRectBufferA

Rect *	fRectBufferB

int	fNumTrees = 0

Detailed Description

Definition at line 106 of file IntersectionTreeBench.cpp.

Constructor & Destructor Documentation

◆ FileIntersectionBench()

skgpu::graphite::FileIntersectionBench::FileIntersectionBench ( )

inline

Definition at line 108 of file IntersectionTreeBench.cpp.

                            {
        if (FLAGS_intersectionTreeFile.isEmpty()) {
            return;
        }
        const char* filename = strrchr(FLAGS_intersectionTreeFile[0], '/');
        if (filename) {
            ++filename;
        } else {
            filename = FLAGS_intersectionTreeFile[0];
        }
        fName.printf("IntersectionTree_file_%s", filename);
    }

Member Function Documentation

◆ gatherRects()

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

inlineoverrideprivatevirtual

Implements skgpu::graphite::IntersectionTreeBench.

Definition at line 129 of file IntersectionTreeBench.cpp.

                                                     {
        if (FLAGS_intersectionTreeFile.isEmpty()) {
            return;
        }
        auto callback = [&](const SkMatrix& matrix,
                            const SkPath& path,
                            const SkPaint& paint) {
            if (paint.getStyle() == SkPaint::kStroke_Style) {
                return;  // Goes to stroker.
            }
            if (path.isConvex()) {
                return;  // Goes to convex renderer.
            }
            int numVerbs = path.countVerbs();
            SkRect drawBounds = matrix.mapRect(path.getBounds());
            float gpuFragmentWork = drawBounds.height() * drawBounds.width();
            float cpuTessellationWork = numVerbs * SkNextLog2(numVerbs);  // N log N.
            constexpr static float kCpuWeight = 512;
            constexpr static float kMinNumPixelsToTriangulate = 256 * 256;
            if (cpuTessellationWork * kCpuWeight + kMinNumPixelsToTriangulate < gpuFragmentWork) {
                return;  // Goes to inner triangulator.
            }
            rects->push_back(drawBounds);
        };
        const char* path = FLAGS_intersectionTreeFile[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);
        }
        SkDebugf(">> Found %i stencil/cover paths in %s <<\n",
                 rects->size(), FLAGS_intersectionTreeFile[0]);
    }

◆ isSuitableFor()

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

inlinefinalprivatevirtual

Reimplemented from Benchmark.

Definition at line 122 of file IntersectionTreeBench.cpp.

                                              {
        if (FLAGS_intersectionTreeFile.isEmpty()) {
            return false;
        }
        return IntersectionTreeBench::isSuitableFor(backend);
    }

◆ onPerCanvasPostDraw()

void skgpu::graphite::FileIntersectionBench::onPerCanvasPostDraw ( SkCanvas * )

inlineoverrideprivatevirtual

Reimplemented from Benchmark.

Definition at line 167 of file IntersectionTreeBench.cpp.

                                                 {
        if (FLAGS_intersectionTreeFile.isEmpty()) {
            return;
        }
        SkDebugf(">> Reordered %s into %i different stencil/cover draws <<\n",
                 FLAGS_intersectionTreeFile[0], fNumTrees);
    }

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

third_party/skia/bench/graphite/IntersectionTreeBench.cpp

Public Member Functions

Private Member Functions