Add thread pool to VulkanPipelineCache

Also add callback manager. Instantiate, and add method for checking if
prewarming is supported and enabled on the current device / instance.

Author: anishmgoyal

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -232,7 +232,7 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext& context,
               mPlatform->getGraphicsQueueFamilyIndex(), mPlatform->getProtectedGraphicsQueue(),
               mPlatform->getProtectedGraphicsQueueFamilyIndex(), mContext, &mSemaphoreManager),
       mPipelineLayoutCache(mPlatform->getDevice()),
-      mPipelineCache(mPlatform->getDevice(), mContext),
+      mPipelineCache(*this, mPlatform->getDevice(), mContext),
       mStagePool(mAllocator, &mResourceManager, &mCommands, &mContext.getPhysicalDeviceLimits()),
       mBufferCache(mContext, mResourceManager, mAllocator),
       mFramebufferCache(mPlatform->getDevice()),

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -16,6 +16,7 @@
 
 #include "VulkanPipelineCache.h"
 
+#include <utils/JobSystem.h>
 #include <utils/Log.h>
 #include <utils/Panic.h>
 
@@ -36,6 +37,8 @@ namespace filament::backend {
 
 namespace {
 
+using utils::JobSystem;
+
 #if FVK_ENABLED(FVK_DEBUG_SHADER_MODULE)
 void printPipelineFeedbackInfo(VkPipelineCreationFeedbackCreateInfo const& feedbackInfo) {
     VkPipelineCreationFeedback const& pipelineInfo = *feedbackInfo.pPipelineCreationFeedback;
@@ -66,13 +69,26 @@ void printPipelineFeedbackInfo(VkPipelineCreationFeedbackCreateInfo const& feedb
 
 } // namespace
 
-VulkanPipelineCache::VulkanPipelineCache(VkDevice device, VulkanContext const& context)
+VulkanPipelineCache::VulkanPipelineCache(DriverBase& driver, VkDevice device, VulkanContext const& context)
         : mDevice(device),
+          mCallbackManager(driver),
           mContext(context) {
     VkPipelineCacheCreateInfo createInfo = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
     };
     bluevk::vkCreatePipelineCache(mDevice, &createInfo, VKALLOC, &mPipelineCache);
+
+    if (isAsyncPrewarmingSupported(context)) {
+        mCompilerThreadPool.init(
+            /*threadCount=*/1,
+            []() {
+                JobSystem::setThreadName("CompilerThreadPool");
+                // This thread should be lower priority than the main thread.
+                JobSystem::setThreadPriority(JobSystem::Priority::DISPLAY);
+            }, []() {
+                // No cleanup required.
+            });
+    }
 }
 
 void VulkanPipelineCache::bindLayout(VkPipelineLayout layout) noexcept {
@@ -88,8 +104,8 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::getOrCreatePipelin
         return &pipeline;
     }
     PipelineCacheEntry cacheEntry {
-        .lastUsed = mCurrentTime,
         .handle = createPipeline(mPipelineRequirements),
+        .lastUsed = mCurrentTime,
     };
     return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first.value();
 }

filament/backend/src/vulkan/VulkanPipelineCache.h

@@ -17,6 +17,8 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANPIPELINECACHE_H
 #define TNT_FILAMENT_BACKEND_VULKANPIPELINECACHE_H
 
+#include "CallbackManager.h"
+#include "CompilerThreadPool.h"
 #include "VulkanCommands.h"
 
 #include <backend/DriverEnums.h>
@@ -46,6 +48,12 @@ class VulkanPipelineCache {
     VulkanPipelineCache(VulkanPipelineCache const&) = delete;
     VulkanPipelineCache& operator=(VulkanPipelineCache const&) = delete;
 
+    static inline bool isAsyncPrewarmingSupported(VulkanContext const& context) {
+        return context.asyncPipelineCachePrewarmingEnabled() &&
+               context.isDynamicRenderingSupported() &&
+               context.isVertexInputDynamicStateSupported();
+    }
+
     static constexpr uint32_t SHADER_MODULE_COUNT = 2;
     static constexpr uint32_t VERTEX_ATTRIBUTE_COUNT = MAX_VERTEX_ATTRIBUTE_COUNT;
 
@@ -86,14 +94,21 @@ class VulkanPipelineCache {
 
     static_assert(sizeof(RasterState) == 16, "RasterState must not have implicit padding.");
 
-    VulkanPipelineCache(VkDevice device, VulkanContext const& context);
+    VulkanPipelineCache(DriverBase& driver, VkDevice device, VulkanContext const& context);
 
-    void bindLayout(VkPipelineLayout layout) noexcept;
+    // Loads a fake pipeline into memory on a separate thread, with the intent of
+    // preloading the Vulkan cache with enough information to have a cache hit when
+    // compiling the pipeline on the main thread at draw time. This is very dependent
+    // on the implementation of the driver on the current device; it's expected to work
+    // on devices with VK_EXT_vertex_input_dynamic_state and VK_KHR_dynamic_rendering.
+    void asyncPreloadCache(fvkmemory::resource_ptr<VulkanProgram> program,
+                           VkPipelineLayout layout);
 
     // Creates a new pipeline if necessary and binds it using vkCmdBindPipeline.
     void bindPipeline(VulkanCommandBuffer* commands);
 
     // Each of the following methods are fast and do not make Vulkan calls.
+    void bindLayout(VkPipelineLayout layout) noexcept;
     void bindProgram(fvkmemory::resource_ptr<VulkanProgram> program) noexcept;
     void bindRasterState(RasterState const& rasterState) noexcept;
     void bindRenderPass(VkRenderPass renderPass, int subpassIndex) noexcept;
@@ -211,6 +226,14 @@ class VulkanPipelineCache {
     // Current bindings for the pipeline and descriptor sets.
     PipelineKey mBoundPipeline = {};
 
+    // Thread pool that allows us to "prewarm" the pipeline cache, reducing draw-time
+    // pipeline compilation time.
+    CompilerThreadPool mCompilerThreadPool;
+
+    // Callback manager that allows us to notify the frontend when a set of pipelines have
+    // been prewarmed, signifying that it is safe to compile pipelines at draw time.
+    CallbackManager mCallbackManager;
+
     [[maybe_unused]] VulkanContext const& mContext;
 };