[graphite] Add a non-threaded PipelineManager

This CL introduces simplified versions of the three main parts of the threaded compilation system:
  GraphicsPipelineHandle - a proxy for a Pipeline/Creation Task
  PipelineCreationTask - a task that can be run to build a Pipeline
  PipelineManager - orchestrates the creation of Pipelines

This CL doesn't change a lot of behavior but just adds overhead.

In DrawPass::prepareResources we create GraphicsPipelineHandles from the GraphicsPipelineDescs and then, immediately, resolve them to GraphicsPipelines.

If the GraphicsPipeline already exists in the cache, it is found and
returned w/in the Handle.

If the GraphicsPipeline doesn't exist then we will create a Task, put it in the TaskMap, blindly execute it in-line, then try to remove it from the TaskMap. This causes a bit of thread-safety danger since, if another Recording is being snapped at the same time or a Precompile is happening (with the same Pipeline), the two threads could share the same task, both race to complete it and then both attempt to remove it from the map. The race to Pipeline completion already currently exists so the main thread-safety risk is in the TaskMap's state.


Bug: b/434712686
Change-Id: Id2a329e598d5e20c561838e53d88e6cd459deda6
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/1046996
Reviewed-by: Thomas Smith <[email protected]>
Reviewed-by: Michael Ludwig <[email protected]>
Commit-Queue: Robert Phillips <[email protected]>

Author: rphilli

gn/graphite.gni

@@ -117,6 +117,7 @@ skia_graphite_sources = [
   "$_src/gpu/graphite/GraphicsPipeline.cpp",
   "$_src/gpu/graphite/GraphicsPipeline.h",
   "$_src/gpu/graphite/GraphicsPipelineDesc.h",
+  "$_src/gpu/graphite/GraphicsPipelineHandle.h",
   "$_src/gpu/graphite/GraphiteResourceKey.cpp",
   "$_src/gpu/graphite/GraphiteResourceKey.h",
   "$_src/gpu/graphite/ImageFactories.cpp",
@@ -138,7 +139,10 @@ skia_graphite_sources = [
   "$_src/gpu/graphite/PaintParamsKey.h",
   "$_src/gpu/graphite/PathAtlas.cpp",
   "$_src/gpu/graphite/PathAtlas.h",
+  "$_src/gpu/graphite/PipelineCreationTask.h",
   "$_src/gpu/graphite/PipelineData.h",
+  "$_src/gpu/graphite/PipelineManager.cpp",
+  "$_src/gpu/graphite/PipelineManager.h",
   "$_src/gpu/graphite/PrecompileContext.cpp",
   "$_src/gpu/graphite/PrecompileContextPriv.h",
   "$_src/gpu/graphite/ProxyCache.cpp",

src/gpu/graphite/BUILD.bazel

@@ -65,6 +65,7 @@ GRAPHITE_FILES = [
     "GraphicsPipeline.cpp",
     "GraphicsPipeline.h",
     "GraphicsPipelineDesc.h",
+    "GraphicsPipelineHandle.h",
     "GraphiteResourceKey.cpp",
     "GraphiteResourceKey.h",
     "ImageFactories.cpp",
@@ -86,7 +87,10 @@ GRAPHITE_FILES = [
     "PaintParamsKey.h",
     "PathAtlas.cpp",
     "PathAtlas.h",
+    "PipelineCreationTask.h",
     "PipelineData.h",
+    "PipelineManager.cpp",
+    "PipelineManager.h",
     "ProxyCache.cpp",
     "ProxyCache.h",
     "QueueManager.cpp",

src/gpu/graphite/DrawPass.cpp

@@ -8,6 +8,7 @@
 
 #include "src/core/SkTraceEvent.h"
 #include "src/gpu/graphite/Log.h"
+#include "src/gpu/graphite/PipelineCreationTask.h"
 #include "src/gpu/graphite/PipelineData.h"
 #include "src/gpu/graphite/Resource.h"  // IWYU pragma: keep
 #include "src/gpu/graphite/ResourceProvider.h"
@@ -41,24 +42,30 @@ bool DrawPass::prepareResources(ResourceProvider* resourceProvider,
                                 const RenderPassDesc& renderPassDesc) {
     TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
-    const Caps* caps = resourceProvider->caps();
-
-    fFullPipelines.reserve(fPipelineDescs.size());
+    fPipelineHandles.reserve(fPipelineDescs.size());
     for (const GraphicsPipelineDesc& pipelineDesc : fPipelineDescs) {
-        UniqueKey pipelineKey = caps->makeGraphicsPipelineKey(pipelineDesc, renderPassDesc);
-        auto pipeline = resourceProvider->findOrCreateGraphicsPipeline(runtimeDict.get(),
-                                                                       pipelineKey,
-                                                                       pipelineDesc,
-                                                                       renderPassDesc);
+        fPipelineHandles.push_back(
+                resourceProvider->createGraphicsPipelineHandle(pipelineDesc,
+                                                               renderPassDesc,
+                                                               PipelineCreationFlags::kNone));
+        resourceProvider->startPipelineCreationTask(runtimeDict, fPipelineHandles.back());
+    }
+
+    // The DrawPass may be long lived on a Recording and we no longer need the GraphicPipelineDescs
+    // once we've created pipeline handles, so we drop the storage for them here.
+    fPipelineDescs.clear();
+
+    // TODO(robertphillips): move this resolvePipeline loop to addResourceRefs
+    fFullPipelines.reserve(fPipelineHandles.size());
+    for (const GraphicsPipelineHandle& handle : fPipelineHandles) {
+        sk_sp<GraphicsPipeline> pipeline = resourceProvider->resolveHandle(handle);
         if (!pipeline) {
             SKGPU_LOG_W("Failed to create GraphicsPipeline for draw in RenderPass. Dropping pass!");
             return false;
         }
         fFullPipelines.push_back(std::move(pipeline));
     }
-    // The DrawPass may be long lived on a Recording and we no longer need the GraphicPipelineDescs
-    // once we've created pipelines, so we drop the storage for them here.
-    fPipelineDescs.clear();
+    fPipelineHandles.clear();
 
     for (int i = 0; i < fSampledTextures.size(); ++i) {
         // It should not have been possible to draw an Image that has an invalid texture info

src/gpu/graphite/DrawPass.h

@@ -13,6 +13,7 @@
 #include "include/private/base/SkTArray.h"
 #include "src/gpu/graphite/DrawCommands.h"
 #include "src/gpu/graphite/GraphicsPipelineDesc.h"
+#include "src/gpu/graphite/GraphicsPipelineHandle.h"
 
 struct SkImageInfo;
 
@@ -98,14 +99,17 @@ class DrawPass {
     std::pair<LoadOp, StoreOp> fOps;
     std::array<float, 4> fClearColor;
 
-    // The pipelines are referenced by index in BindGraphicsPipeline, but that will index into a
-    // an array of actual GraphicsPipelines.
+    // The pipelines are referenced by index in BindGraphicsPipeline, but that will index into
+    // an array of actual GraphicsPipelines (i.e., fFullPipelines).
     skia_private::TArray<GraphicsPipelineDesc> fPipelineDescs;
 
     // These resources all get instantiated during prepareResources.
-    skia_private::TArray<sk_sp<GraphicsPipeline>> fFullPipelines;
+    skia_private::TArray<GraphicsPipelineHandle> fPipelineHandles;
     skia_private::TArray<sk_sp<TextureProxy>> fSampledTextures;
 
+    // These get resolved (from the GraphicsPipelineHandles) in prepareResources
+    skia_private::TArray<sk_sp<GraphicsPipeline>> fFullPipelines;
+
     sk_sp<FloatStorageManager> fFloatStorageManager;
 
 #if defined(SK_TRACE_GRAPHITE_PIPELINE_USE)

src/gpu/graphite/GraphicsPipelineHandle.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_GraphicsPipelineHandle_DEFINED
+#define skgpu_graphite_GraphicsPipelineHandle_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+#include <variant>
+
+namespace skgpu::graphite {
+
+class GraphicsPipeline;
+class PipelineCreationTask;
+
+/*
+ * The PipelineHandle holds a ref to either a Pipeline or the Task that will create the Pipeline.
+ * In the latter case, ResourceProvider::resolveHandle can be used to wait for the Task to
+ * complete. How this works is:
+ *   At Recorder::snap time, the DrawPass will create GraphicsPipelineHandles and will
+ *       kick off all the tasks (using ResourceProvider::kickOffTask)
+ *   Upon Context::insertRecording, all the Handles will be exchanged for GraphicsPipelines in
+ *       the DrawPass::addResourceRefs. This will also release any Tasks being held by the Handles.
+ *
+ * Note that the Tasks lock the generated Pipelines in the cache until they are deleted. This avoids
+ * any race conditions where a Pipeline could be purged between when it was created on a thread
+ * and when it was actually requested by a DrawPass.
+ */
+class GraphicsPipelineHandle {
+private:
+    friend class PipelineManager;  // for ctors
+
+    GraphicsPipelineHandle(sk_sp<PipelineCreationTask> task);
+
+    GraphicsPipelineHandle(sk_sp<GraphicsPipeline> pipeline);
+
+    std::variant<sk_sp<PipelineCreationTask>, sk_sp<GraphicsPipeline>> fTaskOrPipeline;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_GraphicsPipelineHandle_DEFINED

src/gpu/graphite/PipelineCreationTask.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_PipelineCreationTask_DEFINED
+#define skgpu_graphite_PipelineCreationTask_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "src/gpu/graphite/GraphicsPipeline.h"
+#include "src/gpu/graphite/GraphicsPipelineDesc.h"
+#include "src/gpu/graphite/RenderPassDesc.h"
+
+namespace skgpu::graphite {
+
+// Once completed, the PipelineTask will lock the created Pipeline in the cache (via 'fPipeline')
+// until the PipelineTask is deleted.
+// Note that this is not a task in the sense of the Task class. It is a task in the sense that
+// it is a unit of work possibly delegated to a thread. PipelineCreationTasks are also only
+// known and handled by the PipelineManager vs being added to TaskLists (as Task-derived classes
+// are).
+class PipelineCreationTask : public SkRefCnt {
+private:
+    friend class PipelineManager; // for entire API and fPipeline
+
+    PipelineCreationTask(const UniqueKey& pipelineKey,
+                         const GraphicsPipelineDesc& graphicsPipelineDesc,
+                         const RenderPassDesc& renderPassDesc,
+                         SkEnumBitMask<PipelineCreationFlags> pipelineCreationFlags)
+            : fPipelineKey(pipelineKey)
+            , fGraphicsPipelineDesc(graphicsPipelineDesc)
+            , fRenderPassDesc(renderPassDesc)
+            , fPipelineCreationFlags(pipelineCreationFlags) {}
+
+    const UniqueKey fPipelineKey;  // used to track this task in the PipelineManager
+    const GraphicsPipelineDesc fGraphicsPipelineDesc;
+    const RenderPassDesc fRenderPassDesc;
+    const SkEnumBitMask<PipelineCreationFlags> fPipelineCreationFlags;
+
+    // Once completed, this task will have filled in 'fPipeline' (if compilation succeeded).
+    // This also serves to lock the pipeline in the cache.
+    sk_sp<GraphicsPipeline> fPipeline;
+
+    std::atomic<bool> fCompleted = false;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_PipelineCreationTask_DEFINED

src/gpu/graphite/PipelineManager.cpp

@@ -0,0 +1,172 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/graphite/PipelineManager.h"
+
+#include "src/core/SkTaskGroup.h"
+#include "src/gpu/graphite/GraphicsPipelineDesc.h"
+#include "src/gpu/graphite/GraphicsPipelineHandle.h"
+#include "src/gpu/graphite/Log.h"
+#include "src/gpu/graphite/PipelineCreationTask.h"
+#include "src/gpu/graphite/RenderPassDesc.h"
+#include "src/gpu/graphite/ResourceProvider.h"
+#include "src/gpu/graphite/RuntimeEffectDictionary.h"
+
+namespace skgpu::graphite {
+
+GraphicsPipelineHandle::GraphicsPipelineHandle(sk_sp<PipelineCreationTask> task)
+    : fTaskOrPipeline(std::move(task)) {}
+
+GraphicsPipelineHandle::GraphicsPipelineHandle(sk_sp<GraphicsPipeline> pipeline)
+    : fTaskOrPipeline(std::move(pipeline)) {}
+
+PipelineManager::PipelineManager() {}
+PipelineManager::~PipelineManager() {}
+
+const UniqueKey& PipelineManager::Traits::GetKey(const sk_sp<PipelineCreationTask>& task) {
+    return task->fPipelineKey;
+}
+
+uint32_t PipelineManager::Traits::Hash(const UniqueKey& pipelineKey) {
+    return pipelineKey.hash();
+}
+
+GraphicsPipelineHandle PipelineManager::createHandle(
+        ResourceProvider* resourceProvider,
+        const GraphicsPipelineDesc& pipelineDesc,
+        const RenderPassDesc& renderPassDesc,
+        SkEnumBitMask<PipelineCreationFlags> pipelineCreationFlags) {
+    const Caps* caps = resourceProvider->caps();
+
+    UniqueKey pipelineKey = caps->makeGraphicsPipelineKey(pipelineDesc, renderPassDesc);
+
+    if (sk_sp<PipelineCreationTask> task = this->findTask(pipelineKey)) {
+        // There is a task in progress to compile this Pipeline so it can't be ready yet (i.e.,
+        // it isn't in the Pipeline Cache).
+        return GraphicsPipelineHandle(std::move(task));
+    }
+
+    sk_sp<GraphicsPipeline> pipeline = resourceProvider->findGraphicsPipeline(
+            pipelineKey,
+            pipelineCreationFlags);
+    if (pipeline) {
+        return GraphicsPipelineHandle(std::move(pipeline));
+    }
+
+    sk_sp<PipelineCreationTask> task = this->findOrCreateTask(pipelineKey,
+                                                              pipelineDesc,
+                                                              renderPassDesc,
+                                                              pipelineCreationFlags);
+    return GraphicsPipelineHandle(std::move(task));
+}
+
+void PipelineManager::startPipelineCreationTask(ResourceProvider* resourceProvider,
+                                                sk_sp<const RuntimeEffectDictionary> runtimeDict,
+                                                const GraphicsPipelineHandle& handle) {
+    if (std::holds_alternative<sk_sp<GraphicsPipeline>>(handle.fTaskOrPipeline)) {
+        return;
+    }
+
+    sk_sp<PipelineCreationTask> task =
+            std::get<sk_sp<PipelineCreationTask>>(handle.fTaskOrPipeline);
+
+    task->fPipeline = resourceProvider->findOrCreateGraphicsPipeline(
+            runtimeDict.get(),
+            task->fPipelineKey,
+            task->fGraphicsPipelineDesc,
+            task->fRenderPassDesc,
+            task->fPipelineCreationFlags);
+
+    if (!task->fPipeline) {
+        SKGPU_LOG_W("Failed to create GraphicsPipeline!");
+    }
+
+    task->fCompleted = true;
+
+    this->removeTask(task.get());
+}
+
+sk_sp<GraphicsPipeline> PipelineManager::resolveHandle(const GraphicsPipelineHandle& handle) {
+    if (std::holds_alternative<sk_sp<GraphicsPipeline>>(handle.fTaskOrPipeline)) {
+        return std::get<sk_sp<GraphicsPipeline>>(handle.fTaskOrPipeline);
+    }
+
+    // Since 'fTaskOrPipeline' doesn't hold a pipeline the pipeline must not have existed when
+    // the handle was created so a compilation task must've been created to compile it
+    sk_sp<PipelineCreationTask> task =
+            std::get<sk_sp<PipelineCreationTask>>(handle.fTaskOrPipeline);
+
+    // For the non-threaded version of the PipelineManager, whenever a thread gets here it
+    // will already have blindly executed the task (in DrawPass::prepareResources).
+    SkASSERT(task->fCompleted);
+    return task->fPipeline;
+}
+
+#if defined(GPU_TEST_UTILS)
+PipelineManager::Stats PipelineManager::getStats() const {
+    SkAutoSpinlock lock{fSpinLock};
+
+    return fStats;
+}
+#endif
+
+sk_sp<PipelineCreationTask> PipelineManager::findTask(const UniqueKey& pipelineKey) {
+    SkAutoSpinlock lock{fSpinLock};
+
+    sk_sp<PipelineCreationTask> task = fActiveTasks.findOrNull(pipelineKey);
+
+#if defined(GPU_TEST_UTILS)
+    if (task) {
+        fStats.fNumPreemptivelyFoundTasks++;
+    }
+#endif
+
+    return task;
+}
+
+sk_sp<PipelineCreationTask> PipelineManager::findOrCreateTask(
+        const UniqueKey& pipelineKey,
+        const GraphicsPipelineDesc& pipelineDesc,
+        const RenderPassDesc& renderPassDesc,
+        SkEnumBitMask<PipelineCreationFlags> pipelineCreationFlags) {
+    SkAutoSpinlock lock{fSpinLock};
+
+    sk_sp<PipelineCreationTask>* task = fActiveTasks.find(pipelineKey);
+    if (task) {
+        // There is a race in createHandle from when we first check for a task; then, failing that,
+        // check for an existing pipeline; then, failing that, try to create a new task. Thus,
+        // we can sometimes find our task here.
+#if defined(GPU_TEST_UTILS)
+        fStats.fNumTaskCreationRaces++;
+#endif
+        return *task;
+    }
+
+#if defined(GPU_TEST_UTILS)
+    fStats.fNumTasksCreated++;
+#endif
+
+    sk_sp<PipelineCreationTask> newTask = sk_sp<PipelineCreationTask>(
+            new PipelineCreationTask(pipelineKey,
+                                     pipelineDesc,
+                                     renderPassDesc,
+                                     pipelineCreationFlags));
+    fActiveTasks.set(newTask);
+    return newTask;
+}
+
+void PipelineManager::removeTask(PipelineCreationTask* task) {
+    SkAutoSpinlock lock{fSpinLock};
+
+    // TODO(robertphillips): this guard is only necessary in the non-threaded version of
+    // the PipelineManager
+    if (fActiveTasks.findOrNull(task->fPipelineKey)) {
+        fActiveTasks.remove(task->fPipelineKey);
+    }
+}
+
+} // namespace skgpu::graphite