Revert "Cleanup program building a bit"
This reverts commit 4777e3addec478786dcbb68035c5e11c82479b9f.
Reason for revert: This CL is breaking the build on Linux FYI SkiaRenderer Dawn Release
Original change's description:
> Cleanup program building a bit
>
> This CL:
> now passes the GrProgramDesc as a const&
> returns GrGLProgram as an sk_sp
> makes the parameter ordering more consistent
> makes GrVkPipelineState no longer ref-counted
>
> This is pulled out of the DDL pre-compile CL which touches this portion of the code.
>
> Bug: skia:9455
> Change-Id: Id4d06f93450e276de5a2662be330ae9523026244
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/268777
> Reviewed-by: Greg Daniel <egdaniel@google.com>
> Commit-Queue: Robert Phillips <robertphillips@google.com>
TBR=egdaniel@google.com,robertphillips@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: skia:9455
Change-Id: I7019d9876b68576274e87c3b2e6bbbf9695522ba
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/269261
Reviewed-by: Austin Eng <enga@google.com>
Reviewed-by: Kenneth Russell <kbr@google.com>
Reviewed-by: Stephen White <senorblanco@chromium.org>
Commit-Queue: Stephen White <senorblanco@chromium.org>
Auto-Submit: Austin Eng <enga@google.com>
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 2f033f8..aa8498c 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -1817,7 +1817,7 @@
bool GrGLGpu::flushGLState(GrRenderTarget* renderTarget, const GrProgramInfo& programInfo) {
- sk_sp<GrGLProgram> program(fProgramCache->findOrCreateProgram(renderTarget, programInfo));
+ sk_sp<GrGLProgram> program(fProgramCache->refProgram(this, renderTarget, programInfo));
if (!program) {
GrCapsDebugf(this->caps(), "Failed to create program!\n");
return false;
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 3f63fb6..748eb34 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -316,7 +316,7 @@
void abandon();
void reset();
- sk_sp<GrGLProgram> findOrCreateProgram(GrRenderTarget*, const GrProgramInfo&);
+ GrGLProgram* refProgram(GrGLGpu*, GrRenderTarget*, const GrProgramInfo&);
bool precompileShader(const SkData& key, const SkData& data);
private:
diff --git a/src/gpu/gl/GrGLGpuProgramCache.cpp b/src/gpu/gl/GrGLGpuProgramCache.cpp
index 6453bde..c5f9f2a 100644
--- a/src/gpu/gl/GrGLGpuProgramCache.cpp
+++ b/src/gpu/gl/GrGLGpuProgramCache.cpp
@@ -45,13 +45,14 @@
fMap.reset();
}
-sk_sp<GrGLProgram> GrGLGpu::ProgramCache::findOrCreateProgram(GrRenderTarget* renderTarget,
- const GrProgramInfo& programInfo) {
- const GrCaps& caps = *fGpu->caps();
+GrGLProgram* GrGLGpu::ProgramCache::refProgram(GrGLGpu* gpu,
+ GrRenderTarget* renderTarget,
+ const GrProgramInfo& programInfo) {
+ const GrCaps& caps = *gpu->caps();
GrProgramDesc desc = caps.makeDesc(renderTarget, programInfo);
if (!desc.isValid()) {
- GrCapsDebugf(fGpu->caps(), "Failed to gl program descriptor!\n");
+ GrCapsDebugf(gpu->caps(), "Failed to gl program descriptor!\n");
return nullptr;
}
@@ -60,24 +61,26 @@
// We've pre-compiled the GL program, but don't have the GrGLProgram scaffolding
const GrGLPrecompiledProgram* precompiledProgram = &((*entry)->fPrecompiledProgram);
SkASSERT(precompiledProgram->fProgramID != 0);
- (*entry)->fProgram = GrGLProgramBuilder::CreateProgram(fGpu, renderTarget, desc,
- programInfo, precompiledProgram);
- if (!(*entry)->fProgram) {
+ GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, programInfo,
+ &desc, fGpu,
+ precompiledProgram);
+ if (nullptr == program) {
// Should we purge the program ID from the cache at this point?
SkDEBUGFAIL("Couldn't create program from precompiled program");
return nullptr;
}
+ (*entry)->fProgram.reset(program);
} else if (!entry) {
// We have a cache miss
- sk_sp<GrGLProgram> program = GrGLProgramBuilder::CreateProgram(fGpu, renderTarget,
- desc, programInfo);
- if (!program) {
+ GrGLProgram* program = GrGLProgramBuilder::CreateProgram(renderTarget, programInfo,
+ &desc, fGpu);
+ if (nullptr == program) {
return nullptr;
}
- entry = fMap.insert(desc, std::unique_ptr<Entry>(new Entry(std::move(program))));
+ entry = fMap.insert(desc, std::unique_ptr<Entry>(new Entry(sk_sp<GrGLProgram>(program))));
}
- return (*entry)->fProgram;
+ return SkRef((*entry)->fProgram.get());
}
bool GrGLGpu::ProgramCache::precompileShader(const SkData& key, const SkData& data) {
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index 012140f..6c12794 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -45,22 +45,21 @@
cleanup_shaders(gpu, shaderIDs);
}
-sk_sp<GrGLProgram> GrGLProgramBuilder::CreateProgram(
- GrGLGpu* gpu,
- GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
+GrGLProgram* GrGLProgramBuilder::CreateProgram(GrRenderTarget* renderTarget,
const GrProgramInfo& programInfo,
+ GrProgramDesc* desc,
+ GrGLGpu* gpu,
const GrGLPrecompiledProgram* precompiledProgram) {
ATRACE_ANDROID_FRAMEWORK_ALWAYS("shader_compile");
GrAutoLocaleSetter als("C");
// create a builder. This will be handed off to effects so they can use it to add
// uniforms, varyings, textures, etc
- GrGLProgramBuilder builder(gpu, renderTarget, desc, programInfo);
+ GrGLProgramBuilder builder(gpu, renderTarget, programInfo, desc);
auto persistentCache = gpu->getContext()->priv().getPersistentCache();
if (persistentCache && !precompiledProgram) {
- sk_sp<SkData> key = SkData::MakeWithoutCopy(desc.asKey(), desc.keyLength());
+ sk_sp<SkData> key = SkData::MakeWithoutCopy(desc->asKey(), desc->keyLength());
builder.fCached = persistentCache->load(*key);
// the eventual end goal is to completely skip emitAndInstallProcs on a cache hit, but it's
// doing necessary setup in addition to generating the SkSL code. Currently we are only able
@@ -76,9 +75,9 @@
GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu,
GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
- const GrProgramInfo& programInfo)
- : INHERITED(renderTarget, desc, programInfo)
+ const GrProgramInfo& programInfo,
+ GrProgramDesc* desc)
+ : INHERITED(renderTarget, programInfo, desc)
, fGpu(gpu)
, fVaryingHandler(this)
, fUniformHandler(this)
@@ -160,7 +159,7 @@
if (!this->gpu()->getContext()->priv().getPersistentCache()) {
return;
}
- sk_sp<SkData> key = SkData::MakeWithoutCopy(this->desc().asKey(), this->desc().keyLength());
+ sk_sp<SkData> key = SkData::MakeWithoutCopy(this->desc()->asKey(), this->desc()->keyLength());
if (fGpu->glCaps().programBinarySupport()) {
// binary cache
GrGLsizei length = 0;
@@ -199,7 +198,7 @@
}
}
-sk_sp<GrGLProgram> GrGLProgramBuilder::finalize(const GrGLPrecompiledProgram* precompiledProgram) {
+GrGLProgram* GrGLProgramBuilder::finalize(const GrGLPrecompiledProgram* precompiledProgram) {
TRACE_EVENT0("skia.gpu", TRACE_FUNC);
// verify we can get a program id
@@ -542,22 +541,22 @@
}
}
-sk_sp<GrGLProgram> GrGLProgramBuilder::createProgram(GrGLuint programID) {
- return sk_sp<GrGLProgram>(new GrGLProgram(fGpu,
- fUniformHandles,
- programID,
- fUniformHandler.fUniforms,
- fUniformHandler.fSamplers,
- fVaryingHandler.fPathProcVaryingInfos,
- std::move(fGeometryProcessor),
- std::move(fXferProcessor),
- std::move(fFragmentProcessors),
- fFragmentProcessorCnt,
- std::move(fAttributes),
- fVertexAttributeCnt,
- fInstanceAttributeCnt,
- fVertexStride,
- fInstanceStride));
+GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) {
+ return new GrGLProgram(fGpu,
+ fUniformHandles,
+ programID,
+ fUniformHandler.fUniforms,
+ fUniformHandler.fSamplers,
+ fVaryingHandler.fPathProcVaryingInfos,
+ std::move(fGeometryProcessor),
+ std::move(fXferProcessor),
+ std::move(fFragmentProcessors),
+ fFragmentProcessorCnt,
+ std::move(fAttributes),
+ fVertexAttributeCnt,
+ fInstanceAttributeCnt,
+ fVertexStride,
+ fInstanceStride);
}
bool GrGLProgramBuilder::PrecompileProgram(GrGLPrecompiledProgram* precompiledProgram,
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
index baf319d..800c64a 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -40,15 +40,18 @@
* The program implements what is specified in the stages given as input.
* After successful generation, the builder result objects are available
* to be used.
+ * This function may modify the GrProgramDesc by setting the surface origin
+ * key to 0 (unspecified) if it turns out the program does not care about
+ * the surface origin.
* If a GL program has already been created, the program ID and inputs can
* be supplied to skip the shader compilation.
- * @return the created program if generation was successful.
+ * @return true if generation was successful.
*/
- static sk_sp<GrGLProgram> CreateProgram(GrGLGpu*,
- GrRenderTarget*,
- const GrProgramDesc&,
- const GrProgramInfo&,
- const GrGLPrecompiledProgram* = nullptr);
+ static GrGLProgram* CreateProgram(GrRenderTarget*,
+ const GrProgramInfo&,
+ GrProgramDesc*,
+ GrGLGpu*,
+ const GrGLPrecompiledProgram* = nullptr);
static bool PrecompileProgram(GrGLPrecompiledProgram*, GrGLGpu*, const SkData&);
@@ -57,7 +60,7 @@
GrGLGpu* gpu() const { return fGpu; }
private:
- GrGLProgramBuilder(GrGLGpu*, GrRenderTarget*, const GrProgramDesc&, const GrProgramInfo&);
+ GrGLProgramBuilder(GrGLGpu*, GrRenderTarget*, const GrProgramInfo&, GrProgramDesc*);
void addInputVars(const SkSL::Program::Inputs& inputs);
bool compileAndAttachShaders(const SkSL::String& glsl,
@@ -71,14 +74,14 @@
void storeShaderInCache(const SkSL::Program::Inputs& inputs, GrGLuint programID,
const SkSL::String shaders[], bool isSkSL,
SkSL::Program::Settings* settings);
- sk_sp<GrGLProgram> finalize(const GrGLPrecompiledProgram*);
+ GrGLProgram* finalize(const GrGLPrecompiledProgram*);
void bindProgramResourceLocations(GrGLuint programID);
bool checkLinkStatus(GrGLuint programID, GrContextOptions::ShaderErrorHandler* errorHandler,
SkSL::String* sksl[], const SkSL::String glsl[]);
void resolveProgramResourceLocations(GrGLuint programID, bool force);
// Subclasses create different programs
- sk_sp<GrGLProgram> createProgram(GrGLuint programID);
+ GrGLProgram* createProgram(GrGLuint programID);
GrGLSLUniformHandler* uniformHandler() override { return &fUniformHandler; }
const GrGLSLUniformHandler* uniformHandler() const override { return &fUniformHandler; }
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.cpp b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
index 8cc1f06..54b97fd 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
@@ -21,15 +21,15 @@
const int GrGLSLProgramBuilder::kVarsPerBlock = 8;
GrGLSLProgramBuilder::GrGLSLProgramBuilder(GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
- const GrProgramInfo& programInfo)
+ const GrProgramInfo& programInfo,
+ const GrProgramDesc* desc)
: fVS(this)
, fGS(this)
, fFS(this)
, fStageIndex(-1)
, fRenderTarget(renderTarget)
- , fDesc(desc)
, fProgramInfo(programInfo)
+ , fDesc(desc)
, fGeometryProcessor(nullptr)
, fXferProcessor(nullptr)
, fNumFragmentSamplers(0) {}
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.h b/src/gpu/glsl/GrGLSLProgramBuilder.h
index de28bbd..99d6f8bc 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.h
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.h
@@ -57,7 +57,7 @@
return fRenderTarget->renderTargetPriv().getSampleLocations();
}
- const GrProgramDesc& desc() const { return fDesc; }
+ const GrProgramDesc* desc() const { return fDesc; }
void appendUniformDecls(GrShaderFlags visibility, SkString*) const;
@@ -104,9 +104,10 @@
int fStageIndex;
const GrRenderTarget* fRenderTarget; // TODO: remove this
- const GrProgramDesc& fDesc;
const GrProgramInfo& fProgramInfo;
+ const GrProgramDesc* fDesc;
+
GrGLSLBuiltinUniformHandles fUniformHandles;
std::unique_ptr<GrGLSLPrimitiveProcessor> fGeometryProcessor;
@@ -115,7 +116,7 @@
int fFragmentProcessorCnt;
protected:
- explicit GrGLSLProgramBuilder(GrRenderTarget*, const GrProgramDesc&, const GrProgramInfo&);
+ explicit GrGLSLProgramBuilder(GrRenderTarget*, const GrProgramInfo&, const GrProgramDesc*);
void addFeature(GrShaderFlags shaders, uint32_t featureBit, const char* extensionName);
diff --git a/src/gpu/mtl/GrMtlPipelineStateBuilder.h b/src/gpu/mtl/GrMtlPipelineStateBuilder.h
index cd1d102..8a44de7 100644
--- a/src/gpu/mtl/GrMtlPipelineStateBuilder.h
+++ b/src/gpu/mtl/GrMtlPipelineStateBuilder.h
@@ -29,19 +29,19 @@
*
* The GrMtlPipelineState implements what is specified in the GrPipeline and
* GrPrimitiveProcessor as input. After successful generation, the builder result objects are
- * available to be used.
- * @return the created pipeline if generation was successful; nullptr otherwise
+ * available to be used. This function may modify the program key by setting the surface origin
+ * key to 0 (unspecified) if it turns out the program does not care about the surface origin.
+ * @return true if generation was successful.
*/
static GrMtlPipelineState* CreatePipelineState(GrMtlGpu*,
GrRenderTarget*,
- const GrProgramDesc&,
- const GrProgramInfo&);
+ const GrProgramInfo&,
+ GrProgramDesc*);
private:
- GrMtlPipelineStateBuilder(GrMtlGpu*, GrRenderTarget*,
- const GrProgramDesc&, const GrProgramInfo&);
+ GrMtlPipelineStateBuilder(GrMtlGpu*, GrRenderTarget*, const GrProgramInfo&, GrProgramDesc*);
- GrMtlPipelineState* finalize(GrRenderTarget*, const GrProgramDesc&, const GrProgramInfo&);
+ GrMtlPipelineState* finalize(GrRenderTarget*, const GrProgramInfo&, GrProgramDesc*);
const GrCaps* caps() const override;
@@ -52,6 +52,7 @@
id<MTLLibrary> generateMtlShaderLibrary(const SkSL::String& sksl,
SkSL::Program::Kind kind,
const SkSL::Program::Settings& settings,
+ GrProgramDesc* desc,
SkSL::String* msl,
SkSL::Program::Inputs* inputs);
id<MTLLibrary> compileMtlShaderLibrary(const SkSL::String& shader,
diff --git a/src/gpu/mtl/GrMtlPipelineStateBuilder.mm b/src/gpu/mtl/GrMtlPipelineStateBuilder.mm
index 300d346..4c209ec 100644
--- a/src/gpu/mtl/GrMtlPipelineStateBuilder.mm
+++ b/src/gpu/mtl/GrMtlPipelineStateBuilder.mm
@@ -25,25 +25,24 @@
#error This file must be compiled with Arc. Use -fobjc-arc flag
#endif
-GrMtlPipelineState* GrMtlPipelineStateBuilder::CreatePipelineState(
- GrMtlGpu* gpu,
- GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
- const GrProgramInfo& programInfo) {
+GrMtlPipelineState* GrMtlPipelineStateBuilder::CreatePipelineState(GrMtlGpu* gpu,
+ GrRenderTarget* renderTarget,
+ const GrProgramInfo& programInfo,
+ GrProgramDesc* desc) {
GrAutoLocaleSetter als("C");
- GrMtlPipelineStateBuilder builder(gpu, renderTarget, desc, programInfo);
+ GrMtlPipelineStateBuilder builder(gpu, renderTarget, programInfo, desc);
if (!builder.emitAndInstallProcs()) {
return nullptr;
}
- return builder.finalize(renderTarget, desc, programInfo);
+ return builder.finalize(renderTarget, programInfo, desc);
}
GrMtlPipelineStateBuilder::GrMtlPipelineStateBuilder(GrMtlGpu* gpu,
GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
- const GrProgramInfo& programInfo)
- : INHERITED(renderTarget, desc, programInfo)
+ const GrProgramInfo& programInfo,
+ GrProgramDesc* desc)
+ : INHERITED(renderTarget, programInfo, desc)
, fGpu(gpu)
, fUniformHandler(this)
, fVaryingHandler(this) {
@@ -92,8 +91,8 @@
// Here we shear off the Mtl-specific portion of the Desc in order to create the
// persistent key. This is because Mtl only caches the MSL code, not the fully compiled
// program, and that only depends on the base GrProgramDesc data.
- sk_sp<SkData> key = SkData::MakeWithoutCopy(this->desc().asKey(),
- this->desc().initialKeyLength());
+ sk_sp<SkData> key = SkData::MakeWithoutCopy(this->desc()->asKey(),
+ this->desc()->initialKeyLength());
sk_sp<SkData> data = GrPersistentCacheUtils::PackCachedShaders(isSkSL ? kSKSL_Tag : kMSL_Tag,
shaders,
inputs, kGrShaderTypeCount);
@@ -104,6 +103,7 @@
const SkSL::String& shader,
SkSL::Program::Kind kind,
const SkSL::Program::Settings& settings,
+ GrProgramDesc* desc,
SkSL::String* msl,
SkSL::Program::Inputs* inputs) {
id<MTLLibrary> shaderLibrary = GrGenerateMtlShaderLibrary(fGpu, shader,
@@ -388,8 +388,8 @@
}
GrMtlPipelineState* GrMtlPipelineStateBuilder::finalize(GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
- const GrProgramInfo& programInfo) {
+ const GrProgramInfo& programInfo,
+ GrProgramDesc* desc) {
auto pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
id<MTLLibrary> shaderLibraries[kGrShaderTypeCount];
@@ -414,7 +414,7 @@
// Here we shear off the Mtl-specific portion of the Desc in order to create the
// persistent key. This is because Mtl only caches the MSL code, not the fully compiled
// program, and that only depends on the base GrProgramDesc data.
- sk_sp<SkData> key = SkData::MakeWithoutCopy(desc.asKey(), desc.initialKeyLength());
+ sk_sp<SkData> key = SkData::MakeWithoutCopy(desc->asKey(), desc->initialKeyLength());
cached = persistentCache->load(*key);
if (cached) {
reader.setMemory(cached->data(), cached->size());
@@ -446,12 +446,14 @@
*sksl[kVertex_GrShaderType],
SkSL::Program::kVertex_Kind,
settings,
+ desc,
&shaders[kVertex_GrShaderType],
&inputs[kVertex_GrShaderType]);
shaderLibraries[kFragment_GrShaderType] = this->generateMtlShaderLibrary(
*sksl[kFragment_GrShaderType],
SkSL::Program::kFragment_Kind,
settings,
+ desc,
&shaders[kFragment_GrShaderType],
&inputs[kFragment_GrShaderType]);
diff --git a/src/gpu/mtl/GrMtlResourceProvider.mm b/src/gpu/mtl/GrMtlResourceProvider.mm
index 230aa69..5fc220d 100644
--- a/src/gpu/mtl/GrMtlResourceProvider.mm
+++ b/src/gpu/mtl/GrMtlResourceProvider.mm
@@ -153,7 +153,7 @@
++fCacheMisses;
#endif
GrMtlPipelineState* pipelineState(GrMtlPipelineStateBuilder::CreatePipelineState(
- fGpu, renderTarget, desc, programInfo));
+ fGpu, renderTarget, programInfo, &desc));
if (!pipelineState) {
return nullptr;
}
diff --git a/src/gpu/vk/GrVkPipelineState.h b/src/gpu/vk/GrVkPipelineState.h
index fbf50bd..20943e5 100644
--- a/src/gpu/vk/GrVkPipelineState.h
+++ b/src/gpu/vk/GrVkPipelineState.h
@@ -32,7 +32,7 @@
* and other similar objects that are used along with the VkPipeline in the draw. This includes both
* allocating and freeing these objects, as well as updating their values.
*/
-class GrVkPipelineState {
+class GrVkPipelineState : public SkRefCnt {
public:
using UniformInfoArray = GrVkPipelineStateDataManager::UniformInfoArray;
using UniformHandle = GrGLSLProgramDataManager::UniformHandle;
diff --git a/src/gpu/vk/GrVkPipelineStateBuilder.cpp b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
index aee60b8..41dca29 100644
--- a/src/gpu/vk/GrVkPipelineStateBuilder.cpp
+++ b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
@@ -23,28 +23,28 @@
GrVkPipelineState* GrVkPipelineStateBuilder::CreatePipelineState(
GrVkGpu* gpu,
GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
const GrProgramInfo& programInfo,
+ GrProgramDesc* desc,
VkRenderPass compatibleRenderPass) {
// ensure that we use "." as a decimal separator when creating SkSL code
GrAutoLocaleSetter als("C");
// create a builder. This will be handed off to effects so they can use it to add
// uniforms, varyings, textures, etc
- GrVkPipelineStateBuilder builder(gpu, renderTarget, desc, programInfo);
+ GrVkPipelineStateBuilder builder(gpu, renderTarget, programInfo, desc);
if (!builder.emitAndInstallProcs()) {
return nullptr;
}
- return builder.finalize(desc, compatibleRenderPass);
+ return builder.finalize(compatibleRenderPass, desc);
}
GrVkPipelineStateBuilder::GrVkPipelineStateBuilder(GrVkGpu* gpu,
GrRenderTarget* renderTarget,
- const GrProgramDesc& desc,
- const GrProgramInfo& programInfo)
- : INHERITED(renderTarget, desc, programInfo)
+ const GrProgramInfo& programInfo,
+ GrProgramDesc* desc)
+ : INHERITED(renderTarget, programInfo, desc)
, fGpu(gpu)
, fVaryingHandler(this)
, fUniformHandler(this) {}
@@ -66,6 +66,7 @@
VkShaderModule* shaderModule,
VkPipelineShaderStageCreateInfo* stageInfo,
const SkSL::Program::Settings& settings,
+ GrProgramDesc* desc,
SkSL::String* outSPIRV,
SkSL::Program::Inputs* outInputs) {
if (!GrCompileVkShaderModule(fGpu, sksl, stage, shaderModule,
@@ -139,8 +140,8 @@
// program, and that only depends on the base GrProgramDesc data.
// The +4 is to include the kShader_PersistentCacheKeyType code the Vulkan backend adds
// to the key right after the base key.
- sk_sp<SkData> key = SkData::MakeWithoutCopy(this->desc().asKey(),
- this->desc().initialKeyLength()+4);
+ sk_sp<SkData> key = SkData::MakeWithoutCopy(this->desc()->asKey(),
+ this->desc()->initialKeyLength()+4);
sk_sp<SkData> data = GrPersistentCacheUtils::PackCachedShaders(isSkSL ? kSKSL_Tag : kSPIRV_Tag,
shaders,
@@ -148,8 +149,8 @@
this->gpu()->getContext()->priv().getPersistentCache()->store(*key, *data);
}
-GrVkPipelineState* GrVkPipelineStateBuilder::finalize(const GrProgramDesc& desc,
- VkRenderPass compatibleRenderPass) {
+GrVkPipelineState* GrVkPipelineStateBuilder::finalize(VkRenderPass compatibleRenderPass,
+ GrProgramDesc* desc) {
VkDescriptorSetLayout dsLayout[2];
VkPipelineLayout pipelineLayout;
VkShaderModule shaderModules[kGrShaderTypeCount] = { VK_NULL_HANDLE,
@@ -213,7 +214,7 @@
// program, and that only depends on the base GrProgramDesc data.
// The +4 is to include the kShader_PersistentCacheKeyType code the Vulkan backend adds
// to the key right after the base key.
- sk_sp<SkData> key = SkData::MakeWithoutCopy(desc.asKey(), desc.initialKeyLength()+4);
+ sk_sp<SkData> key = SkData::MakeWithoutCopy(desc->asKey(), desc->initialKeyLength()+4);
cached = persistentCache->load(*key);
if (cached) {
reader.setMemory(cached->data(), cached->size());
@@ -248,6 +249,7 @@
&shaderModules[kVertex_GrShaderType],
&shaderStageInfo[0],
settings,
+ desc,
&shaders[kVertex_GrShaderType],
&inputs[kVertex_GrShaderType]);
@@ -256,6 +258,7 @@
&shaderModules[kFragment_GrShaderType],
&shaderStageInfo[1],
settings,
+ desc,
&shaders[kFragment_GrShaderType],
&inputs[kFragment_GrShaderType]);
@@ -265,6 +268,7 @@
&shaderModules[kGeometry_GrShaderType],
&shaderStageInfo[2],
settings,
+ desc,
&shaders[kGeometry_GrShaderType],
&inputs[kGeometry_GrShaderType]);
++numShaderStages;
diff --git a/src/gpu/vk/GrVkPipelineStateBuilder.h b/src/gpu/vk/GrVkPipelineStateBuilder.h
index 1eb5290..b09b939 100644
--- a/src/gpu/vk/GrVkPipelineStateBuilder.h
+++ b/src/gpu/vk/GrVkPipelineStateBuilder.h
@@ -27,12 +27,14 @@
*
* The GrVkPipelineState implements what is specified in the GrPipeline and GrPrimitiveProcessor
* as input. After successful generation, the builder result objects are available to be used.
- * @return the created pipeline if generation was successful; nullptr otherwise
+ * This function may modify the program key by setting the surface origin key to 0 (unspecified)
+ * if it turns out the program does not care about the surface origin.
+ * @return true if generation was successful.
*/
static GrVkPipelineState* CreatePipelineState(GrVkGpu*,
GrRenderTarget*,
- const GrProgramDesc&,
const GrProgramInfo&,
+ GrProgramDesc*,
VkRenderPass compatibleRenderPass);
const GrCaps* caps() const override;
@@ -43,9 +45,9 @@
void finalizeFragmentSecondaryColor(GrShaderVar& outputColor) override;
private:
- GrVkPipelineStateBuilder(GrVkGpu*, GrRenderTarget*, const GrProgramDesc&, const GrProgramInfo&);
+ GrVkPipelineStateBuilder(GrVkGpu*, GrRenderTarget*, const GrProgramInfo&, GrProgramDesc*);
- GrVkPipelineState* finalize(const GrProgramDesc&, VkRenderPass compatibleRenderPass);
+ GrVkPipelineState* finalize(VkRenderPass compatibleRenderPass, GrProgramDesc*);
// returns number of shader stages
int loadShadersFromCache(SkReader32* cached, VkShaderModule outShaderModules[],
@@ -59,6 +61,7 @@
VkShaderModule* shaderModule,
VkPipelineShaderStageCreateInfo* stageInfo,
const SkSL::Program::Settings& settings,
+ GrProgramDesc* desc,
SkSL::String* outSPIRV,
SkSL::Program::Inputs* outInputs);
diff --git a/src/gpu/vk/GrVkPipelineStateCache.cpp b/src/gpu/vk/GrVkPipelineStateCache.cpp
index a0f5ff4..5e93eb0 100644
--- a/src/gpu/vk/GrVkPipelineStateCache.cpp
+++ b/src/gpu/vk/GrVkPipelineStateCache.cpp
@@ -68,7 +68,7 @@
fMap.reset();
}
-GrVkPipelineState* GrVkResourceProvider::PipelineStateCache::findOrCreatePipelineState(
+GrVkPipelineState* GrVkResourceProvider::PipelineStateCache::refPipelineState(
GrRenderTarget* renderTarget,
const GrProgramInfo& programInfo,
VkRenderPass compatibleRenderPass) {
@@ -95,7 +95,7 @@
++fCacheMisses;
#endif
GrVkPipelineState* pipelineState(GrVkPipelineStateBuilder::CreatePipelineState(
- fGpu, renderTarget, desc, programInfo, compatibleRenderPass));
+ fGpu, renderTarget, programInfo, &desc, compatibleRenderPass));
if (!pipelineState) {
return nullptr;
}
diff --git a/src/gpu/vk/GrVkResourceProvider.cpp b/src/gpu/vk/GrVkResourceProvider.cpp
index 2166f16..0416fa6 100644
--- a/src/gpu/vk/GrVkResourceProvider.cpp
+++ b/src/gpu/vk/GrVkResourceProvider.cpp
@@ -232,8 +232,7 @@
GrRenderTarget* renderTarget,
const GrProgramInfo& programInfo,
VkRenderPass compatibleRenderPass) {
- return fPipelineStateCache->findOrCreatePipelineState(renderTarget, programInfo,
- compatibleRenderPass);
+ return fPipelineStateCache->refPipelineState(renderTarget, programInfo, compatibleRenderPass);
}
void GrVkResourceProvider::getSamplerDescriptorSetHandle(VkDescriptorType type,
diff --git a/src/gpu/vk/GrVkResourceProvider.h b/src/gpu/vk/GrVkResourceProvider.h
index 64b4f93..7c24d51 100644
--- a/src/gpu/vk/GrVkResourceProvider.h
+++ b/src/gpu/vk/GrVkResourceProvider.h
@@ -184,9 +184,9 @@
~PipelineStateCache();
void release();
- GrVkPipelineState* findOrCreatePipelineState(GrRenderTarget*,
- const GrProgramInfo&,
- VkRenderPass compatibleRenderPass);
+ GrVkPipelineState* refPipelineState(GrRenderTarget*,
+ const GrProgramInfo&,
+ VkRenderPass compatibleRenderPass);
private:
struct Entry;