SkSLCompileBench Class Reference

Inheritance diagram for SkSLCompileBench:

Public Member Functions
	SkSLCompileBench (std::string name, const char *src, bool optimize, Output output)
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 Member Functions
static const char *	output_string (Output output)

Protected Member Functions
const char *	onGetName () override
bool	isSuitableFor (Backend backend) override
bool	usesRuntimeShader () const
bool	usesGraphite () const
void	fixUpSource ()
void	onDraw (int loops, SkCanvas *canvas) 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 ()

Static Protected Member Functions
static bool	CompileToSkRP (const SkSL::Program &program)

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

Detailed Description

Definition at line 71 of file SkSLBench.cpp.

Constructor & Destructor Documentation

SkSLCompileBench()

SkSLCompileBench::SkSLCompileBench ( std::string  name, const char *  src, bool  optimize, Output  output  )

inline

Definition at line 86 of file SkSLBench.cpp.

            : fName(std::string("sksl_") + (optimize ? "" : "unoptimized_") +
                    output_string(output) + name)
            , fSrc(src)
            , fCaps(GrContextOptions(), GrMockOptions())
            , fOutput(output) {
        fSettings.fOptimize = optimize;
        // The test programs we compile don't follow Vulkan rules and thus produce invalid SPIR-V.
        // This is harmless, so long as we don't try to validate them.
        fSettings.fValidateSPIRV = false;
 
        this->fixUpSource();
    }

Member Function Documentation

CompileToSkRP()

static bool SkSLCompileBench::CompileToSkRP ( const SkSL::Program &  program )

inlinestaticprotected

Definition at line 185 of file SkSLBench.cpp.

                                                          {
        const SkSL::FunctionDeclaration* main = program.getFunction("main");
        if (!main) {
            return false;
        }
 
        // Compile our program.
        std::unique_ptr<SkSL::RP::Program> rasterProg = SkSL::MakeRasterPipelineProgram(
                program, *main->definition(), /*debugTrace=*/nullptr, /*writeTraceOps=*/false);
        if (!rasterProg) {
            return false;
        }
 
        // We need to supply a valid uniform range, but the uniform values inside don't actually
        // matter, since we aren't going to run the shader.
        float uniformBuffer[1024];
        if (rasterProg->numUniforms() > (int)std::size(uniformBuffer)) {
            return false;
        }
 
        // Append the program to a raster pipeline.
        SkSTArenaAlloc<2048> alloc;
        SkRasterPipeline pipeline(&alloc);
        rasterProg->appendStages(&pipeline,
                                 &alloc,
                                 /*callbacks=*/nullptr,
                                 /*uniforms=*/SkSpan{uniformBuffer, rasterProg->numUniforms()});
        return true;
    }

fixUpSource()

void SkSLCompileBench::fixUpSource ( )

inlineprotected

Definition at line 122 of file SkSLBench.cpp.

                       {
        auto fixup = [this](const char* input, const char* replacement) {
            fSrc = std::regex_replace(fSrc, std::regex(input), replacement);
        };
 
        // Runtime shaders have slightly different conventions than fragment shaders.
        // Perform a handful of fixups to compensate. These are hand-tuned for our current set of
        // test shaders and will probably need to be updated if we add more.
        if (this->usesRuntimeShader()) {
            fixup(R"(void main\‍(\))",                              "half4 main(float2 xy)");
            fixup(R"(sk_FragColor =)",                             "return");
            fixup(R"(sk_FragCoord)",                               "_FragCoord");
            fixup(R"(sampler2D )",                                 "uniform shader ");
            fixup(R"((flat |noperspective |)in )",                 "uniform ");
            fixup(R"(sample\‍(([A-Za-z0-9_]+), ([A-Za-z0-9_]+)\))", "$01.eval($02)");
            fSrc = "#version 300\nuniform float4 _FragCoord;\n" + fSrc;
        }
    }

isSuitableFor()

bool SkSLCompileBench::isSuitableFor ( Backend  backend )

inlineoverrideprotectedvirtual

Reimplemented from Benchmark.

Definition at line 105 of file SkSLBench.cpp.

                                                 {
#if !defined(SK_GRAPHITE)
        if (this->usesGraphite()) {
            return false;
        }
#endif
        return backend == Backend::kNonRendering;
    }

onDraw()

void SkSLCompileBench::onDraw ( int  loops, SkCanvas *  canvas  )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 141 of file SkSLBench.cpp.

                                                      {
        SkSL::ProgramKind kind;
        if (this->usesRuntimeShader()) {
            kind = SkSL::ProgramKind::kRuntimeShader;
        } else if (this->usesGraphite()) {
            kind = SkSL::ProgramKind::kGraphiteFragment;
        } else {
            kind = SkSL::ProgramKind::kFragment;
        }
        for (int i = 0; i < loops; i++) {
            std::unique_ptr<SkSL::Program> program = fCompiler.convertProgram(kind, fSrc,
                                                                              fSettings);
            if (fCompiler.errorCount()) {
                SK_ABORT("shader compilation failed: %s\n", fCompiler.errorText().c_str());
            }
            std::string result;
            switch (fOutput) {
                case Output::kNone:
                    break;
 
                case Output::kGLSL:
                    SkAssertResult(SkSL::ToGLSL(*program, fCaps.shaderCaps(), &result));
                    break;
 
                case Output::kMetal:
                case Output::kGrMtl:
                    SkAssertResult(SkSL::ToMetal(*program, fCaps.shaderCaps(), &result));
                    break;
 
                case Output::kSPIRV:
                    SkAssertResult(SkSL::ToSPIRV(*program, fCaps.shaderCaps(), &result));
                    break;
 
                case Output::kGrWGSL:
                    SkAssertResult(SkSL::ToWGSL(*program, fCaps.shaderCaps(), &result));
                    break;
 
                case Output::kSkRP:
                    SkAssertResult(CompileToSkRP(*program));
                    break;
            }
        }
    }

onGetName()

const char * SkSLCompileBench::onGetName ( )

inlineoverrideprotectedvirtual

Implements Benchmark.

Definition at line 101 of file SkSLBench.cpp.

                                     {
        return fName.c_str();
    }

output_string()

static const char * SkSLCompileBench::output_string ( Output  output )

inlinestatic

Definition at line 73 of file SkSLBench.cpp.

                                                    {
        switch (output) {
            case Output::kNone:    return "";
            case Output::kGLSL:    return "glsl_";
            case Output::kMetal:   return "metal_";
            case Output::kSPIRV:   return "spirv_";
            case Output::kGrMtl:   return "grmtl_";
            case Output::kGrWGSL:  return "grwgsl_";
            case Output::kSkRP:    return "skrp_";
        }
        SkUNREACHABLE;
    }

usesGraphite()

bool SkSLCompileBench::usesGraphite ( ) const

inlineprotected

Definition at line 118 of file SkSLBench.cpp.

                              {
        return fOutput == Output::kGrMtl || fOutput == Output::kGrWGSL;
    }

usesRuntimeShader()

bool SkSLCompileBench::usesRuntimeShader ( ) const

inlineprotected

Definition at line 114 of file SkSLBench.cpp.

                                   {
        return fOutput == Output::kSkRP;
    }

---

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

• third_party/skia/bench/SkSLBench.cpp