Add GrThreadSafePipelineBuilder
GrThreadSafePipelineBuilder is the generic, base object the
GrContextThreadSafeProxy will hold. Each backend will create a
backend-specific version that is shared between the direct context
and the (possibly many) utility contexts.
Right now GrThreadSafePipelineBuilder just holds the pipeline
creation stats. Relatedly only GrGLGpu::ProgramCache and
GrVkResourceProvider::PipelineStateCache currently derive from
the new class (since they are the only backends that generate
pipeline stats).
Change-Id: I58f441c5c2b870bb5970c29cba19d1775864d52e
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/378320
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Jim Van Verth <jvanverth@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
diff --git a/gn/gpu.gni b/gn/gpu.gni
index 1d77327..55c7c78 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -261,6 +261,8 @@
"$_src/gpu/GrTextureResolveRenderTask.h",
"$_src/gpu/GrThreadSafeCache.cpp",
"$_src/gpu/GrThreadSafeCache.h",
+ "$_src/gpu/GrThreadSafePipelineBuilder.cpp",
+ "$_src/gpu/GrThreadSafePipelineBuilder.h",
"$_src/gpu/GrTracing.h",
"$_src/gpu/GrTransferFromRenderTask.cpp",
"$_src/gpu/GrTransferFromRenderTask.h",
diff --git a/include/gpu/GrContextThreadSafeProxy.h b/include/gpu/GrContextThreadSafeProxy.h
index ccfbefd..f645b87 100644
--- a/include/gpu/GrContextThreadSafeProxy.h
+++ b/include/gpu/GrContextThreadSafeProxy.h
@@ -23,6 +23,7 @@
class GrContextThreadSafeProxyPriv;
class GrTextBlobCache;
class GrThreadSafeCache;
+class GrThreadSafePipelineBuilder;
class SkSurfaceCharacterization;
class SkSurfaceProps;
@@ -130,15 +131,16 @@
// TODO: This should be part of the constructor but right now we have a chicken-and-egg problem
// with GrContext where we get the caps by creating a GPU which requires a context (see the
// `init` method on GrContext_Base).
- void init(sk_sp<const GrCaps>);
+ void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>);
- const GrBackendApi fBackend;
- const GrContextOptions fOptions;
- const uint32_t fContextID;
- sk_sp<const GrCaps> fCaps;
- std::unique_ptr<GrTextBlobCache> fTextBlobCache;
- std::unique_ptr<GrThreadSafeCache> fThreadSafeCache;
- std::atomic<bool> fAbandoned{false};
+ const GrBackendApi fBackend;
+ const GrContextOptions fOptions;
+ const uint32_t fContextID;
+ sk_sp<const GrCaps> fCaps;
+ std::unique_ptr<GrTextBlobCache> fTextBlobCache;
+ std::unique_ptr<GrThreadSafeCache> fThreadSafeCache;
+ sk_sp<GrThreadSafePipelineBuilder> fPipelineBuilder;
+ std::atomic<bool> fAbandoned{false};
};
#else // !SK_SUPPORT_GPU
diff --git a/src/gpu/GrContextThreadSafeProxy.cpp b/src/gpu/GrContextThreadSafeProxy.cpp
index 16b1847..2c3a221 100644
--- a/src/gpu/GrContextThreadSafeProxy.cpp
+++ b/src/gpu/GrContextThreadSafeProxy.cpp
@@ -14,6 +14,7 @@
#include "src/gpu/GrBaseContextPriv.h"
#include "src/gpu/GrCaps.h"
#include "src/gpu/GrThreadSafeCache.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/effects/GrSkSLFP.h"
#include "src/image/SkSurface_Gpu.h"
@@ -37,10 +38,12 @@
GrContextThreadSafeProxy::~GrContextThreadSafeProxy() = default;
-void GrContextThreadSafeProxy::init(sk_sp<const GrCaps> caps) {
+void GrContextThreadSafeProxy::init(sk_sp<const GrCaps> caps,
+ sk_sp<GrThreadSafePipelineBuilder> pipelineBuilder) {
fCaps = std::move(caps);
fTextBlobCache = std::make_unique<GrTextBlobCache>(fContextID);
fThreadSafeCache = std::make_unique<GrThreadSafeCache>();
+ fPipelineBuilder = std::move(pipelineBuilder);
}
SkSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization(
@@ -167,3 +170,8 @@
return sk_sp<GrContextThreadSafeProxy>(new GrContextThreadSafeProxy(backend, options));
}
+void GrContextThreadSafeProxyPriv::init(sk_sp<const GrCaps> caps,
+ sk_sp<GrThreadSafePipelineBuilder> builder) const {
+ fProxy->init(std::move(caps), std::move(builder));
+}
+
diff --git a/src/gpu/GrContextThreadSafeProxyPriv.h b/src/gpu/GrContextThreadSafeProxyPriv.h
index 606aa16..aae17e4 100644
--- a/src/gpu/GrContextThreadSafeProxyPriv.h
+++ b/src/gpu/GrContextThreadSafeProxyPriv.h
@@ -21,9 +21,7 @@
*/
class GrContextThreadSafeProxyPriv {
public:
- void init(sk_sp<const GrCaps> caps) const {
- fProxy->init(std::move(caps));
- }
+ void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>) const;
bool matches(GrContext_Base* candidate) const {
return fProxy == candidate->threadSafeProxy().get();
diff --git a/src/gpu/GrDirectContext.cpp b/src/gpu/GrDirectContext.cpp
index 3301027..42ad297 100644
--- a/src/gpu/GrDirectContext.cpp
+++ b/src/gpu/GrDirectContext.cpp
@@ -190,7 +190,7 @@
return false;
}
- fThreadSafeProxy->priv().init(fGpu->refCaps());
+ fThreadSafeProxy->priv().init(fGpu->refCaps(), fGpu->refPipelineBuilder());
if (!INHERITED::init()) {
return false;
}
diff --git a/src/gpu/GrDirectContextPriv.cpp b/src/gpu/GrDirectContextPriv.cpp
index 9d03432..cf96536 100644
--- a/src/gpu/GrDirectContextPriv.cpp
+++ b/src/gpu/GrDirectContextPriv.cpp
@@ -17,6 +17,7 @@
#include "src/gpu/GrSurfaceContext.h"
#include "src/gpu/GrSurfaceDrawContext.h"
#include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/SkGr.h"
#include "src/gpu/effects/GrSkSLFP.h"
#include "src/gpu/effects/generated/GrConfigConversionEffect.h"
@@ -112,14 +113,20 @@
void GrDirectContextPriv::dumpGpuStats(SkString* out) const {
#if GR_GPU_STATS
- return fContext->fGpu->stats()->dump(out);
+ fContext->fGpu->stats()->dump(out);
+ if (auto builder = fContext->fGpu->pipelineBuilder()) {
+ builder->stats()->dump(out);
+ }
#endif
}
void GrDirectContextPriv::dumpGpuStatsKeyValuePairs(SkTArray<SkString>* keys,
SkTArray<double>* values) const {
#if GR_GPU_STATS
- return fContext->fGpu->stats()->dumpKeyValuePairs(keys, values);
+ fContext->fGpu->stats()->dumpKeyValuePairs(keys, values);
+ if (auto builder = fContext->fGpu->pipelineBuilder()) {
+ builder->stats()->dumpKeyValuePairs(keys, values);
+ }
#endif
}
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index 43df47f..2a450f2 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -720,22 +720,9 @@
#if GR_TEST_UTILS
#if GR_GPU_STATS
-static const char* cache_result_to_str(int i) {
- const char* kCacheResultStrings[GrGpu::Stats::kNumProgramCacheResults] = {
- "hits",
- "misses",
- "partials"
- };
- static_assert(0 == (int) GrGpu::Stats::ProgramCacheResult::kHit);
- static_assert(1 == (int) GrGpu::Stats::ProgramCacheResult::kMiss);
- static_assert(2 == (int) GrGpu::Stats::ProgramCacheResult::kPartial);
- static_assert(GrGpu::Stats::kNumProgramCacheResults == 3);
- return kCacheResultStrings[i];
-}
void GrGpu::Stats::dump(SkString* out) {
out->appendf("Render Target Binds: %d\n", fRenderTargetBinds);
- out->appendf("Shader Compilations: %d\n", fShaderCompilations);
out->appendf("Textures Created: %d\n", fTextureCreates);
out->appendf("Texture Uploads: %d\n", fTextureUploads);
out->appendf("Transfers to Texture: %d\n", fTransfersToTexture);
@@ -747,26 +734,6 @@
out->appendf("Number of Scratch MSAA Attachments reused %d\n",
fNumScratchMSAAAttachmentsReused);
- SkASSERT(fNumInlineCompilationFailures == 0);
- out->appendf("Number of Inline compile failures %d\n", fNumInlineCompilationFailures);
- for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
- out->appendf("Inline Program Cache %s %d\n", cache_result_to_str(i),
- fInlineProgramCacheStats[i]);
- }
-
- SkASSERT(fNumPreCompilationFailures == 0);
- out->appendf("Number of precompile failures %d\n", fNumPreCompilationFailures);
- for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
- out->appendf("Precompile Program Cache %s %d\n", cache_result_to_str(i),
- fPreProgramCacheStats[i]);
- }
-
- SkASSERT(fNumCompilationFailures == 0);
- out->appendf("Total number of compilation failures %d\n", fNumCompilationFailures);
- out->appendf("Total number of partial compilation successes %d\n",
- fNumPartialCompilationSuccesses);
- out->appendf("Total number of compilation successes %d\n", fNumCompilationSuccesses);
-
// enable this block to output CSV-style stats for program pre-compilation
#if 0
SkASSERT(fNumInlineCompilationFailures == 0);
@@ -785,7 +752,6 @@
void GrGpu::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) {
keys->push_back(SkString("render_target_binds")); values->push_back(fRenderTargetBinds);
- keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations);
}
#endif // GR_GPU_STATS
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 90edca8..d020c42 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -43,6 +43,7 @@
class GrStencilSettings;
class GrSurface;
class GrTexture;
+class GrThreadSafePipelineBuilder;
class SkJSONWriter;
namespace SkSL {
@@ -83,6 +84,9 @@
// before GrDirectContext.
virtual void disconnect(DisconnectType);
+ virtual GrThreadSafePipelineBuilder* pipelineBuilder() = 0;
+ virtual sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() = 0;
+
// Called by GrDirectContext::isContextLost. Returns true if the backend Gpu object has gotten
// into an unrecoverable, lost state.
virtual bool isDeviceLost() const { return false; }
@@ -414,16 +418,6 @@
class Stats {
public:
- enum class ProgramCacheResult {
- kHit, // the program was found in the cache
- kMiss, // the program was not found in the cache (and was, thus, compiled)
- kPartial, // a precompiled version was found in the persistent cache
-
- kLast = kPartial
- };
-
- static const int kNumProgramCacheResults = (int)ProgramCacheResult::kLast + 1;
-
#if GR_GPU_STATS
Stats() = default;
@@ -432,9 +426,6 @@
int renderTargetBinds() const { return fRenderTargetBinds; }
void incRenderTargetBinds() { fRenderTargetBinds++; }
- int shaderCompilations() const { return fShaderCompilations; }
- void incShaderCompilations() { fShaderCompilations++; }
-
int textureCreates() const { return fTextureCreates; }
void incTextureCreates() { fTextureCreates++; }
@@ -468,42 +459,12 @@
int numScratchMSAAAttachmentsReused() const { return fNumScratchMSAAAttachmentsReused; }
void incNumScratchMSAAAttachmentsReused() { ++fNumScratchMSAAAttachmentsReused; }
- int numInlineCompilationFailures() const { return fNumInlineCompilationFailures; }
- void incNumInlineCompilationFailures() { ++fNumInlineCompilationFailures; }
-
- int numInlineProgramCacheResult(ProgramCacheResult stat) const {
- return fInlineProgramCacheStats[(int) stat];
- }
- void incNumInlineProgramCacheResult(ProgramCacheResult stat) {
- ++fInlineProgramCacheStats[(int) stat];
- }
-
- int numPreCompilationFailures() const { return fNumPreCompilationFailures; }
- void incNumPreCompilationFailures() { ++fNumPreCompilationFailures; }
-
- int numPreProgramCacheResult(ProgramCacheResult stat) const {
- return fPreProgramCacheStats[(int) stat];
- }
- void incNumPreProgramCacheResult(ProgramCacheResult stat) {
- ++fPreProgramCacheStats[(int) stat];
- }
-
- int numCompilationFailures() const { return fNumCompilationFailures; }
- void incNumCompilationFailures() { ++fNumCompilationFailures; }
-
- int numPartialCompilationSuccesses() const { return fNumPartialCompilationSuccesses; }
- void incNumPartialCompilationSuccesses() { ++fNumPartialCompilationSuccesses; }
-
- int numCompilationSuccesses() const { return fNumCompilationSuccesses; }
- void incNumCompilationSuccesses() { ++fNumCompilationSuccesses; }
-
#if GR_TEST_UTILS
void dump(SkString*);
void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values);
#endif
private:
int fRenderTargetBinds = 0;
- int fShaderCompilations = 0;
int fTextureCreates = 0;
int fTextureUploads = 0;
int fTransfersToTexture = 0;
@@ -516,16 +477,6 @@
int fNumScratchTexturesReused = 0;
int fNumScratchMSAAAttachmentsReused = 0;
- int fNumInlineCompilationFailures = 0;
- int fInlineProgramCacheStats[kNumProgramCacheResults] = { 0 };
-
- int fNumPreCompilationFailures = 0;
- int fPreProgramCacheStats[kNumProgramCacheResults] = { 0 };
-
- int fNumCompilationFailures = 0;
- int fNumPartialCompilationSuccesses = 0;
- int fNumCompilationSuccesses = 0;
-
#else
#if GR_TEST_UTILS
@@ -533,7 +484,6 @@
void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {}
#endif
void incRenderTargetBinds() {}
- void incShaderCompilations() {}
void incTextureCreates() {}
void incTextureUploads() {}
void incTransfersToTexture() {}
@@ -545,13 +495,6 @@
void incNumSubmitToGpus() {}
void incNumScratchTexturesReused() {}
void incNumScratchMSAAAttachmentsReused() {}
- void incNumInlineCompilationFailures() {}
- void incNumInlineProgramCacheResult(ProgramCacheResult stat) {}
- void incNumPreCompilationFailures() {}
- void incNumPreProgramCacheResult(ProgramCacheResult stat) {}
- void incNumCompilationFailures() {}
- void incNumPartialCompilationSuccesses() {}
- void incNumCompilationSuccesses() {}
#endif
};
diff --git a/src/gpu/GrThreadSafePipelineBuilder.cpp b/src/gpu/GrThreadSafePipelineBuilder.cpp
new file mode 100644
index 0000000..1a522ce
--- /dev/null
+++ b/src/gpu/GrThreadSafePipelineBuilder.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2021 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
+
+#if GR_GPU_STATS
+#if GR_TEST_UTILS
+#include "include/core/SkString.h"
+
+using Stats = GrThreadSafePipelineBuilder::Stats;
+
+static const char* cache_result_to_str(int i) {
+ const char* kCacheResultStrings[Stats::kNumProgramCacheResults] = {
+ "hits",
+ "misses",
+ "partials"
+ };
+ static_assert(0 == (int) Stats::ProgramCacheResult::kHit);
+ static_assert(1 == (int) Stats::ProgramCacheResult::kMiss);
+ static_assert(2 == (int) Stats::ProgramCacheResult::kPartial);
+ static_assert(Stats::kNumProgramCacheResults == 3);
+ return kCacheResultStrings[i];
+}
+
+void GrThreadSafePipelineBuilder::Stats::dump(SkString* out) {
+ out->appendf("Shader Compilations: %d\n", fShaderCompilations.load());
+
+ SkASSERT(fNumInlineCompilationFailures == 0);
+ out->appendf("Number of Inline compile failures %d\n", fNumInlineCompilationFailures.load());
+ for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
+ out->appendf("Inline Program Cache %s %d\n", cache_result_to_str(i),
+ fInlineProgramCacheStats[i].load());
+ }
+
+ SkASSERT(fNumPreCompilationFailures == 0);
+ out->appendf("Number of precompile failures %d\n", fNumPreCompilationFailures.load());
+ for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
+ out->appendf("Precompile Program Cache %s %d\n", cache_result_to_str(i),
+ fPreProgramCacheStats[i].load());
+ }
+
+ SkASSERT(fNumCompilationFailures == 0);
+ out->appendf("Total number of compilation failures %d\n", fNumCompilationFailures.load());
+ out->appendf("Total number of partial compilation successes %d\n",
+ fNumPartialCompilationSuccesses.load());
+ out->appendf("Total number of compilation successes %d\n", fNumCompilationSuccesses.load());
+}
+
+void GrThreadSafePipelineBuilder::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys,
+ SkTArray<double>* values) {
+ keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations);
+}
+
+#endif // GR_TEST_UTILS
+#endif // GR_GPU_STATS
diff --git a/src/gpu/GrThreadSafePipelineBuilder.h b/src/gpu/GrThreadSafePipelineBuilder.h
new file mode 100644
index 0000000..6d6b3a1
--- /dev/null
+++ b/src/gpu/GrThreadSafePipelineBuilder.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2021 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrThreadSafePipelineBuilder_Base_DEFINED
+#define GrThreadSafePipelineBuilder_Base_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrConfig.h"
+
+#if GR_TEST_UTILS
+#include "include/private/SkTArray.h"
+class SkString;
+#endif
+
+class GrThreadSafePipelineBuilder : public SkRefCnt {
+public:
+ GrThreadSafePipelineBuilder() = default;
+
+ class Stats {
+ public:
+ enum class ProgramCacheResult {
+ kHit, // the program was found in the cache
+ kMiss, // the program was not found in the cache (and was, thus, compiled)
+ kPartial, // a precompiled version was found in the persistent cache
+
+ kLast = kPartial
+ };
+
+#if GR_GPU_STATS
+ static const int kNumProgramCacheResults = (int)ProgramCacheResult::kLast + 1;
+
+ Stats() = default;
+
+ int shaderCompilations() const { return fShaderCompilations; }
+ void incShaderCompilations() { fShaderCompilations++; }
+
+ int numInlineCompilationFailures() const { return fNumInlineCompilationFailures; }
+ void incNumInlineCompilationFailures() { ++fNumInlineCompilationFailures; }
+
+ int numInlineProgramCacheResult(ProgramCacheResult stat) const {
+ return fInlineProgramCacheStats[(int) stat];
+ }
+ void incNumInlineProgramCacheResult(ProgramCacheResult stat) {
+ ++fInlineProgramCacheStats[(int) stat];
+ }
+
+ int numPreCompilationFailures() const { return fNumPreCompilationFailures; }
+ void incNumPreCompilationFailures() { ++fNumPreCompilationFailures; }
+
+ int numPreProgramCacheResult(ProgramCacheResult stat) const {
+ return fPreProgramCacheStats[(int) stat];
+ }
+ void incNumPreProgramCacheResult(ProgramCacheResult stat) {
+ ++fPreProgramCacheStats[(int) stat];
+ }
+
+ int numCompilationFailures() const { return fNumCompilationFailures; }
+ void incNumCompilationFailures() { ++fNumCompilationFailures; }
+
+ int numPartialCompilationSuccesses() const { return fNumPartialCompilationSuccesses; }
+ void incNumPartialCompilationSuccesses() { ++fNumPartialCompilationSuccesses; }
+
+ int numCompilationSuccesses() const { return fNumCompilationSuccesses; }
+ void incNumCompilationSuccesses() { ++fNumCompilationSuccesses; }
+
+#if GR_TEST_UTILS
+ void dump(SkString*);
+ void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values);
+#endif
+
+ private:
+ std::atomic<int> fShaderCompilations{0};
+
+ std::atomic<int> fNumInlineCompilationFailures{0};
+ std::atomic<int> fInlineProgramCacheStats[kNumProgramCacheResults]{0};
+
+ std::atomic<int> fNumPreCompilationFailures{0};
+ std::atomic<int> fPreProgramCacheStats[kNumProgramCacheResults]{0};
+
+ std::atomic<int> fNumCompilationFailures{0};
+ std::atomic<int> fNumPartialCompilationSuccesses{0};
+ std::atomic<int> fNumCompilationSuccesses{0};
+
+#else
+ void incShaderCompilations() {}
+ void incNumInlineCompilationFailures() {}
+ void incNumInlineProgramCacheResult(ProgramCacheResult stat) {}
+ void incNumPreCompilationFailures() {}
+ void incNumPreProgramCacheResult(ProgramCacheResult stat) {}
+ void incNumCompilationFailures() {}
+ void incNumPartialCompilationSuccesses() {}
+ void incNumCompilationSuccesses() {}
+
+#if GR_TEST_UTILS
+ void dump(SkString*) {}
+ void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {}
+#endif
+
+#endif // GR_GPU_STATS
+ };
+
+ Stats* stats() { return &fStats; }
+
+protected:
+ Stats fStats;
+};
+
+#endif
diff --git a/src/gpu/d3d/GrD3DGpu.cpp b/src/gpu/d3d/GrD3DGpu.cpp
index 7d76ccf..81d9ebb 100644
--- a/src/gpu/d3d/GrD3DGpu.cpp
+++ b/src/gpu/d3d/GrD3DGpu.cpp
@@ -14,6 +14,7 @@
#include "src/gpu/GrBackendUtils.h"
#include "src/gpu/GrDataUtils.h"
#include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/d3d/GrD3DAMDMemoryAllocator.h"
#include "src/gpu/d3d/GrD3DAttachment.h"
#include "src/gpu/d3d/GrD3DBuffer.h"
@@ -29,6 +30,15 @@
#include <DXProgrammableCapture.h>
#endif
+GrThreadSafePipelineBuilder* GrD3DGpu::pipelineBuilder() {
+ return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrD3DGpu::refPipelineBuilder() {
+ return nullptr;
+}
+
+
sk_sp<GrGpu> GrD3DGpu::Make(const GrD3DBackendContext& backendContext,
const GrContextOptions& contextOptions, GrDirectContext* direct) {
sk_sp<GrD3DMemoryAllocator> memoryAllocator = backendContext.fMemoryAllocator;
diff --git a/src/gpu/d3d/GrD3DGpu.h b/src/gpu/d3d/GrD3DGpu.h
index 1b0e216..9d66f15 100644
--- a/src/gpu/d3d/GrD3DGpu.h
+++ b/src/gpu/d3d/GrD3DGpu.h
@@ -36,6 +36,9 @@
GrD3DResourceProvider& resourceProvider() { return fResourceProvider; }
+ GrThreadSafePipelineBuilder* pipelineBuilder() override;
+ sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
ID3D12Device* device() const { return fDevice.get(); }
ID3D12CommandQueue* queue() const { return fQueue.get(); }
diff --git a/src/gpu/dawn/GrDawnGpu.cpp b/src/gpu/dawn/GrDawnGpu.cpp
index 9e64a05..fe635b6 100644
--- a/src/gpu/dawn/GrDawnGpu.cpp
+++ b/src/gpu/dawn/GrDawnGpu.cpp
@@ -21,6 +21,7 @@
#include "src/gpu/GrSemaphore.h"
#include "src/gpu/GrStencilSettings.h"
#include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/dawn/GrDawnAttachment.h"
#include "src/gpu/dawn/GrDawnBuffer.h"
#include "src/gpu/dawn/GrDawnCaps.h"
@@ -145,6 +146,14 @@
INHERITED::disconnect(type);
}
+GrThreadSafePipelineBuilder* GrDawnGpu::pipelineBuilder() {
+ return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrDawnGpu::refPipelineBuilder() {
+ return nullptr;
+}
+
///////////////////////////////////////////////////////////////////////////////
GrOpsRenderPass* GrDawnGpu::onGetOpsRenderPass(
diff --git a/src/gpu/dawn/GrDawnGpu.h b/src/gpu/dawn/GrDawnGpu.h
index d24ebcb..53bfc1b 100644
--- a/src/gpu/dawn/GrDawnGpu.h
+++ b/src/gpu/dawn/GrDawnGpu.h
@@ -34,6 +34,9 @@
void disconnect(DisconnectType) override;
+ GrThreadSafePipelineBuilder* pipelineBuilder() override;
+ sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
GrStagingBufferManager* stagingBufferManager() override { return &fStagingBufferManager; }
void takeOwnershipOfBuffer(sk_sp<GrGpuBuffer>) override;
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 7b43170..61d3ac1 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -387,6 +387,9 @@
fPathRendering.reset();
fCopyProgramArrayBuffer.reset();
fMipmapProgramArrayBuffer.reset();
+ if (fProgramCache) {
+ fProgramCache->reset();
+ }
fHWProgram.reset();
if (fHWProgramID) {
@@ -461,6 +464,7 @@
}
fHWProgram.reset();
+ fProgramCache->reset();
fProgramCache.reset();
fHWProgramID = 0;
@@ -482,6 +486,14 @@
fFinishCallbacks.callAll(/* doDelete */ DisconnectType::kCleanup == type);
}
+GrThreadSafePipelineBuilder* GrGLGpu::pipelineBuilder() {
+ return fProgramCache.get();
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrGLGpu::refPipelineBuilder() {
+ return fProgramCache;
+}
+
///////////////////////////////////////////////////////////////////////////////
void GrGLGpu::onResetContext(uint32_t resetBits) {
@@ -3065,15 +3077,16 @@
std::unique_ptr<SkSL::Program> program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kVertex,
sksl, settings, &glsl, errorHandler);
GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fCopyPrograms[progIdx].fProgram,
- GR_GL_VERTEX_SHADER, glsl, &fStats, errorHandler);
+ GR_GL_VERTEX_SHADER, glsl, fProgramCache->stats(),
+ errorHandler);
SkASSERT(program->fInputs.isEmpty());
sksl.assign(fshaderTxt.c_str(), fshaderTxt.size());
program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kFragment, sksl, settings, &glsl,
errorHandler);
GrGLuint fshader = GrGLCompileAndAttachShader(*fGLContext, fCopyPrograms[progIdx].fProgram,
- GR_GL_FRAGMENT_SHADER, glsl, &fStats,
- errorHandler);
+ GR_GL_FRAGMENT_SHADER, glsl,
+ fProgramCache->stats(), errorHandler);
SkASSERT(program->fInputs.isEmpty());
GL_CALL(LinkProgram(fCopyPrograms[progIdx].fProgram));
@@ -3218,15 +3231,16 @@
std::unique_ptr<SkSL::Program> program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kVertex,
sksl, settings, &glsl, errorHandler);
GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fMipmapPrograms[progIdx].fProgram,
- GR_GL_VERTEX_SHADER, glsl, &fStats, errorHandler);
+ GR_GL_VERTEX_SHADER, glsl,
+ fProgramCache->stats(), errorHandler);
SkASSERT(program->fInputs.isEmpty());
sksl.assign(fshaderTxt.c_str(), fshaderTxt.size());
program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kFragment, sksl, settings, &glsl,
errorHandler);
GrGLuint fshader = GrGLCompileAndAttachShader(*fGLContext, fMipmapPrograms[progIdx].fProgram,
- GR_GL_FRAGMENT_SHADER, glsl, &fStats,
- errorHandler);
+ GR_GL_FRAGMENT_SHADER, glsl,
+ fProgramCache->stats(), errorHandler);
SkASSERT(program->fInputs.isEmpty());
GL_CALL(LinkProgram(fMipmapPrograms[progIdx].fProgram));
@@ -3675,14 +3689,14 @@
bool GrGLGpu::compile(const GrProgramDesc& desc, const GrProgramInfo& programInfo) {
SkASSERT(!(GrProcessor::CustomFeatures::kSampleLocations & programInfo.requestedFeatures()));
- Stats::ProgramCacheResult stat;
+ GrThreadSafePipelineBuilder::Stats::ProgramCacheResult stat;
sk_sp<GrGLProgram> tmp = fProgramCache->findOrCreateProgram(desc, programInfo, &stat);
if (!tmp) {
return false;
}
- return stat != Stats::ProgramCacheResult::kHit;
+ return stat != GrThreadSafePipelineBuilder::Stats::ProgramCacheResult::kHit;
}
#if GR_TEST_UTILS
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 4a27164..16ea5e1 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -15,6 +15,7 @@
#include "src/gpu/GrGpu.h"
#include "src/gpu/GrNativeRect.h"
#include "src/gpu/GrProgramDesc.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/GrWindowRectsState.h"
#include "src/gpu/GrXferProcessor.h"
#include "src/gpu/gl/GrGLAttachment.h"
@@ -37,6 +38,9 @@
void disconnect(DisconnectType) override;
+ GrThreadSafePipelineBuilder* pipelineBuilder() override;
+ sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
const GrGLContext& glContext() const { return *fGLContext; }
const GrGLInterface* glInterface() const { return fGLContext->glInterface(); }
@@ -352,10 +356,10 @@
bool copySurfaceAsBlitFramebuffer(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
const SkIPoint& dstPoint);
- class ProgramCache : public ::SkNoncopyable {
+ class ProgramCache : public GrThreadSafePipelineBuilder {
public:
ProgramCache(GrGLGpu* gpu);
- ~ProgramCache();
+ ~ProgramCache() override;
void abandon();
void reset();
@@ -365,9 +369,9 @@
Stats::ProgramCacheResult* stat) {
sk_sp<GrGLProgram> tmp = this->findOrCreateProgram(nullptr, desc, programInfo, stat);
if (!tmp) {
- fGpu->fStats.incNumPreCompilationFailures();
+ fStats.incNumPreCompilationFailures();
} else {
- fGpu->fStats.incNumPreProgramCacheResult(*stat);
+ fStats.incNumPreProgramCacheResult(*stat);
}
return tmp;
@@ -514,7 +518,7 @@
std::unique_ptr<GrGLContext> fGLContext;
// GL program-related state
- std::unique_ptr<ProgramCache> fProgramCache;
+ sk_sp<ProgramCache> fProgramCache;
///////////////////////////////////////////////////////////////////////////
///@name Caching of GL State
diff --git a/src/gpu/gl/GrGLGpuProgramCache.cpp b/src/gpu/gl/GrGLGpuProgramCache.cpp
index 9916aaa..4bc0e78 100644
--- a/src/gpu/gl/GrGLGpuProgramCache.cpp
+++ b/src/gpu/gl/GrGLGpuProgramCache.cpp
@@ -61,9 +61,9 @@
Stats::ProgramCacheResult stat;
sk_sp<GrGLProgram> tmp = this->findOrCreateProgram(renderTarget, desc, programInfo, &stat);
if (!tmp) {
- fGpu->fStats.incNumInlineCompilationFailures();
+ fStats.incNumInlineCompilationFailures();
} else {
- fGpu->fStats.incNumInlineProgramCacheResult(stat);
+ fStats.incNumInlineProgramCacheResult(stat);
}
return tmp;
@@ -84,20 +84,20 @@
if (!(*entry)->fProgram) {
// Should we purge the program ID from the cache at this point?
SkDEBUGFAIL("Couldn't create program from precompiled program");
- fGpu->fStats.incNumCompilationFailures();
+ fStats.incNumCompilationFailures();
return nullptr;
}
- fGpu->fStats.incNumPartialCompilationSuccesses();
+ fStats.incNumPartialCompilationSuccesses();
*stat = Stats::ProgramCacheResult::kPartial;
} else if (!entry) {
// We have a cache miss
sk_sp<GrGLProgram> program = GrGLProgramBuilder::CreateProgram(fGpu, renderTarget,
desc, programInfo);
if (!program) {
- fGpu->fStats.incNumCompilationFailures();
+ fStats.incNumCompilationFailures();
return nullptr;
}
- fGpu->fStats.incNumCompilationSuccesses();
+ fStats.incNumCompilationSuccesses();
entry = fMap.insert(desc, std::make_unique<Entry>(std::move(program)));
*stat = Stats::ProgramCacheResult::kMiss;
}
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index cb14885..d0bd1f2 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -106,7 +106,7 @@
programId,
type,
glsl,
- gpu->stats(),
+ gpu->pipelineBuilder()->stats(),
errHandler);
if (!shaderId) {
return false;
@@ -614,7 +614,8 @@
}
if (GrGLuint shaderID = GrGLCompileAndAttachShader(gpu->glContext(), programID, type, glsl,
- gpu->stats(), errorHandler)) {
+ gpu->pipelineBuilder()->stats(),
+ errorHandler)) {
shadersToDelete.push_back(shaderID);
return true;
} else {
diff --git a/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp b/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
index eb32e2e..a9a9c69 100644
--- a/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
@@ -55,7 +55,7 @@
GrGLuint programId,
GrGLenum type,
const SkSL::String& glsl,
- GrGpu::Stats* stats,
+ GrThreadSafePipelineBuilder::Stats* stats,
GrContextOptions::ShaderErrorHandler* errorHandler) {
TRACE_EVENT0_ALWAYS("skia.gpu", "driver_compile_shader");
const GrGLInterface* gli = glCtx.glInterface();
diff --git a/src/gpu/gl/builders/GrGLShaderStringBuilder.h b/src/gpu/gl/builders/GrGLShaderStringBuilder.h
index 16ac700..01d31dc 100644
--- a/src/gpu/gl/builders/GrGLShaderStringBuilder.h
+++ b/src/gpu/gl/builders/GrGLShaderStringBuilder.h
@@ -25,7 +25,7 @@
GrGLuint programId,
GrGLenum type,
const SkSL::String& glsl,
- GrGpu::Stats*,
+ GrThreadSafePipelineBuilder::Stats*,
GrContextOptions::ShaderErrorHandler* errorHandler);
#endif
diff --git a/src/gpu/mock/GrMockGpu.cpp b/src/gpu/mock/GrMockGpu.cpp
index 0caa16a..1927b18 100644
--- a/src/gpu/mock/GrMockGpu.cpp
+++ b/src/gpu/mock/GrMockGpu.cpp
@@ -7,6 +7,7 @@
#include "src/gpu/mock/GrMockGpu.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/mock/GrMockAttachment.h"
#include "src/gpu/mock/GrMockBuffer.h"
#include "src/gpu/mock/GrMockCaps.h"
@@ -79,6 +80,16 @@
this->initCapsAndCompiler(sk_make_sp<GrMockCaps>(contextOptions, options));
}
+GrMockGpu::~GrMockGpu() {}
+
+GrThreadSafePipelineBuilder* GrMockGpu::pipelineBuilder() {
+ return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrMockGpu::refPipelineBuilder() {
+ return nullptr;
+}
+
void GrMockGpu::querySampleLocations(GrRenderTarget* rt, SkTArray<SkPoint>* sampleLocations) {
sampleLocations->reset();
int numRemainingSamples = rt->numSamples();
diff --git a/src/gpu/mock/GrMockGpu.h b/src/gpu/mock/GrMockGpu.h
index d77ce5b..a3e0c76 100644
--- a/src/gpu/mock/GrMockGpu.h
+++ b/src/gpu/mock/GrMockGpu.h
@@ -22,7 +22,10 @@
public:
static sk_sp<GrGpu> Make(const GrMockOptions*, const GrContextOptions&, GrDirectContext*);
- ~GrMockGpu() override {}
+ ~GrMockGpu() override;
+
+ GrThreadSafePipelineBuilder* pipelineBuilder() override;
+ sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
GrFence SK_WARN_UNUSED_RESULT insertFence() override { return 0; }
bool waitFence(GrFence) override { return true; }
diff --git a/src/gpu/mtl/GrMtlGpu.h b/src/gpu/mtl/GrMtlGpu.h
index 221273a..7d9ffd4 100644
--- a/src/gpu/mtl/GrMtlGpu.h
+++ b/src/gpu/mtl/GrMtlGpu.h
@@ -38,6 +38,9 @@
void disconnect(DisconnectType) override;
+ GrThreadSafePipelineBuilder* pipelineBuilder() override;
+ sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
const GrMtlCaps& mtlCaps() const { return *fMtlCaps.get(); }
id<MTLDevice> device() const { return fDevice; }
diff --git a/src/gpu/mtl/GrMtlGpu.mm b/src/gpu/mtl/GrMtlGpu.mm
index 48ad7a8..0537cd6 100644
--- a/src/gpu/mtl/GrMtlGpu.mm
+++ b/src/gpu/mtl/GrMtlGpu.mm
@@ -15,6 +15,7 @@
#include "src/gpu/GrDataUtils.h"
#include "src/gpu/GrRenderTarget.h"
#include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/mtl/GrMtlBuffer.h"
#include "src/gpu/mtl/GrMtlCommandBuffer.h"
#include "src/gpu/mtl/GrMtlOpsRenderPass.h"
@@ -168,6 +169,14 @@
}
}
+GrThreadSafePipelineBuilder* GrMtlGpu::pipelineBuilder() {
+ return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrMtlGpu::refPipelineBuilder() {
+ return nullptr;
+}
+
void GrMtlGpu::destroyResources() {
this->submitCommandBuffer(SyncQueue::kForce_SyncQueue);
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index 4bffecb..47de405 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -25,6 +25,7 @@
#include "src/gpu/GrRenderTarget.h"
#include "src/gpu/GrSurfaceDrawContext.h"
#include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/SkGpuDevice.h"
#include "src/gpu/SkGr.h"
#include "src/gpu/vk/GrVkAMDMemoryAllocator.h"
@@ -289,6 +290,14 @@
}
}
+GrThreadSafePipelineBuilder* GrVkGpu::pipelineBuilder() {
+ return fResourceProvider.pipelineStateCache();
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrVkGpu::refPipelineBuilder() {
+ return fResourceProvider.refPipelineStateCache();
+}
+
///////////////////////////////////////////////////////////////////////////////
GrOpsRenderPass* GrVkGpu::onGetOpsRenderPass(
@@ -1978,7 +1987,7 @@
return false;
}
- Stats::ProgramCacheResult stat;
+ GrThreadSafePipelineBuilder::Stats::ProgramCacheResult stat;
auto pipelineState = this->resourceProvider().findOrCreateCompatiblePipelineState(
desc,
@@ -1989,7 +1998,7 @@
return false;
}
- return stat != Stats::ProgramCacheResult::kHit;
+ return stat != GrThreadSafePipelineBuilder::Stats::ProgramCacheResult::kHit;
}
#if GR_TEST_UTILS
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 870d75d..e2390d8 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -43,6 +43,9 @@
void disconnect(DisconnectType) override;
bool disconnected() const { return fDisconnected; }
+ GrThreadSafePipelineBuilder* pipelineBuilder() override;
+ sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
const GrVkInterface* vkInterface() const { return fInterface.get(); }
const GrVkCaps& vkCaps() const { return *fVkCaps; }
diff --git a/src/gpu/vk/GrVkPipelineStateBuilder.cpp b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
index 52d0f34..fc77272 100644
--- a/src/gpu/vk/GrVkPipelineStateBuilder.cpp
+++ b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
@@ -29,7 +29,9 @@
VkRenderPass compatibleRenderPass,
bool overrideSubpassForResolveLoad) {
- gpu->stats()->incShaderCompilations();
+ GrVkResourceProvider& resourceProvider = gpu->resourceProvider();
+
+ resourceProvider.pipelineStateCache()->stats()->incShaderCompilations();
// ensure that we use "." as a decimal separator when creating SkSL code
GrAutoLocaleSetter als("C");
diff --git a/src/gpu/vk/GrVkPipelineStateCache.cpp b/src/gpu/vk/GrVkPipelineStateCache.cpp
index 7aa080e..3d3fb23 100644
--- a/src/gpu/vk/GrVkPipelineStateCache.cpp
+++ b/src/gpu/vk/GrVkPipelineStateCache.cpp
@@ -50,13 +50,13 @@
// dump stats
#ifdef SK_DEBUG
if (c_DisplayVkPipelineCache) {
- using CacheResult = GrGpu::Stats::ProgramCacheResult;
+ using CacheResult = Stats::ProgramCacheResult;
- int misses = fGpu->stats()->numInlineProgramCacheResult(CacheResult::kMiss) +
- fGpu->stats()->numPreProgramCacheResult(CacheResult::kMiss);
+ int misses = fStats.numInlineProgramCacheResult(CacheResult::kMiss) +
+ fStats.numPreProgramCacheResult(CacheResult::kMiss);
- int total = misses + fGpu->stats()->numInlineProgramCacheResult(CacheResult::kHit) +
- fGpu->stats()->numPreProgramCacheResult(CacheResult::kHit);
+ int total = misses + fStats.numInlineProgramCacheResult(CacheResult::kHit) +
+ fStats.numPreProgramCacheResult(CacheResult::kHit);
SkDebugf("--- Pipeline State Cache ---\n");
SkDebugf("Total requests: %d\n", total);
@@ -94,14 +94,14 @@
return nullptr;
}
- GrGpu::Stats::ProgramCacheResult stat;
+ Stats::ProgramCacheResult stat;
auto tmp = this->findOrCreatePipelineState(renderTarget, desc, programInfo,
compatibleRenderPass, overrideSubpassForResolveLoad,
&stat);
if (!tmp) {
- fGpu->stats()->incNumInlineCompilationFailures();
+ fStats.incNumInlineCompilationFailures();
} else {
- fGpu->stats()->incNumInlineProgramCacheResult(stat);
+ fStats.incNumInlineProgramCacheResult(stat);
}
return tmp;
@@ -113,15 +113,15 @@
const GrProgramInfo& programInfo,
VkRenderPass compatibleRenderPass,
bool overrideSubpassForResolveLoad,
- GrGpu::Stats::ProgramCacheResult* stat) {
+ Stats::ProgramCacheResult* stat) {
if (stat) {
- *stat = GrGpu::Stats::ProgramCacheResult::kHit;
+ *stat = Stats::ProgramCacheResult::kHit;
}
std::unique_ptr<Entry>* entry = fMap.find(desc);
if (!entry) {
if (stat) {
- *stat = GrGpu::Stats::ProgramCacheResult::kMiss;
+ *stat = Stats::ProgramCacheResult::kMiss;
}
GrVkPipelineState* pipelineState(GrVkPipelineStateBuilder::CreatePipelineState(
fGpu, renderTarget, desc, programInfo, compatibleRenderPass,
diff --git a/src/gpu/vk/GrVkResourceProvider.cpp b/src/gpu/vk/GrVkResourceProvider.cpp
index bcf2768..75f1a25 100644
--- a/src/gpu/vk/GrVkResourceProvider.cpp
+++ b/src/gpu/vk/GrVkResourceProvider.cpp
@@ -22,7 +22,7 @@
GrVkResourceProvider::GrVkResourceProvider(GrVkGpu* gpu)
: fGpu(gpu)
, fPipelineCache(VK_NULL_HANDLE) {
- fPipelineStateCache = new PipelineStateCache(gpu);
+ fPipelineStateCache = sk_make_sp<PipelineStateCache>(gpu);
}
GrVkResourceProvider::~GrVkResourceProvider() {
@@ -30,7 +30,6 @@
SkASSERT(0 == fExternalRenderPasses.count());
SkASSERT(0 == fMSAALoadPipelines.count());
SkASSERT(VK_NULL_HANDLE == fPipelineCache);
- delete fPipelineStateCache;
}
VkPipelineCache GrVkResourceProvider::pipelineCache() {
@@ -266,14 +265,14 @@
const GrProgramDesc& desc,
const GrProgramInfo& programInfo,
VkRenderPass compatibleRenderPass,
- GrGpu::Stats::ProgramCacheResult* stat) {
+ GrThreadSafePipelineBuilder::Stats::ProgramCacheResult* stat) {
auto tmp = fPipelineStateCache->findOrCreatePipelineState(desc, programInfo,
compatibleRenderPass, stat);
if (!tmp) {
- fGpu->stats()->incNumPreCompilationFailures();
+ fPipelineStateCache->stats()->incNumPreCompilationFailures();
} else {
- fGpu->stats()->incNumPreProgramCacheResult(*stat);
+ fPipelineStateCache->stats()->incNumPreProgramCacheResult(*stat);
}
return tmp;
diff --git a/src/gpu/vk/GrVkResourceProvider.h b/src/gpu/vk/GrVkResourceProvider.h
index 38b7744..0b269f1 100644
--- a/src/gpu/vk/GrVkResourceProvider.h
+++ b/src/gpu/vk/GrVkResourceProvider.h
@@ -17,6 +17,7 @@
#include "src/gpu/GrManagedResource.h"
#include "src/gpu/GrProgramDesc.h"
#include "src/gpu/GrResourceHandle.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
#include "src/gpu/vk/GrVkDescriptorPool.h"
#include "src/gpu/vk/GrVkDescriptorSetManager.h"
#include "src/gpu/vk/GrVkPipelineStateBuilder.h"
@@ -42,6 +43,14 @@
GrVkResourceProvider(GrVkGpu* gpu);
~GrVkResourceProvider();
+ GrThreadSafePipelineBuilder* pipelineStateCache() {
+ return fPipelineStateCache.get();
+ }
+
+ sk_sp<GrThreadSafePipelineBuilder> refPipelineStateCache() {
+ return fPipelineStateCache;
+ }
+
// Set up any initial vk objects
void init();
@@ -139,7 +148,7 @@
const GrProgramDesc&,
const GrProgramInfo&,
VkRenderPass compatibleRenderPass,
- GrGpu::Stats::ProgramCacheResult* stat);
+ GrThreadSafePipelineBuilder::Stats::ProgramCacheResult* stat);
sk_sp<const GrVkPipeline> findOrCreateMSAALoadPipeline(
const GrVkRenderPass& renderPass,
@@ -210,10 +219,10 @@
private:
- class PipelineStateCache : public ::SkNoncopyable {
+ class PipelineStateCache : public GrThreadSafePipelineBuilder {
public:
PipelineStateCache(GrVkGpu* gpu);
- ~PipelineStateCache();
+ ~PipelineStateCache() override;
void release();
GrVkPipelineState* findOrCreatePipelineState(GrRenderTarget*,
@@ -223,7 +232,7 @@
GrVkPipelineState* findOrCreatePipelineState(const GrProgramDesc& desc,
const GrProgramInfo& programInfo,
VkRenderPass compatibleRenderPass,
- GrGpu::Stats::ProgramCacheResult* stat) {
+ Stats::ProgramCacheResult* stat) {
return this->findOrCreatePipelineState(nullptr, desc, programInfo,
compatibleRenderPass, false, stat);
}
@@ -236,7 +245,7 @@
const GrProgramInfo&,
VkRenderPass compatibleRenderPass,
bool overrideSubpassForResolveLoad,
- GrGpu::Stats::ProgramCacheResult*);
+ Stats::ProgramCacheResult*);
struct DescHash {
uint32_t operator()(const GrProgramDesc& desc) const {
@@ -313,7 +322,7 @@
SkTDynamicHash<GrVkSamplerYcbcrConversion, GrVkSamplerYcbcrConversion::Key> fYcbcrConversions;
// Cache of GrVkPipelineStates
- PipelineStateCache* fPipelineStateCache;
+ sk_sp<PipelineStateCache> fPipelineStateCache;
SkSTArray<4, std::unique_ptr<GrVkDescriptorSetManager>> fDescriptorSetManagers;