rhi: Pipeline cache load/save

Add QRhi APIs to retrieve and reload the contents of the "pipeline
cache".

The only API where there is a true pipeline cache is object is Vulkan
(VkPipelineCache). For OpenGL, the other backend where we support this,
it is simulated with program binaries. The Qt 5 style OpenGL program
binary disk cache continues to work like before, but one has now the
option to do things in a more modern, graphics API agnostic way, that
leads to generating a single blob instead of a large set of files in
some system location, allowing easier "pre-baking" of the cache content.

It is expected that Qt Quick exposes the two new functions in form
if QSG_RHI_ environment variables, thus allowing easy testing and
cache file generation.

As an example for the performance improvements this can give, consider
Vulkan, where we do not have any existing persistent caching mechanism
in place:

Running BenchmarkDemoQt6.exe --scene flythrough --mode demo creates 18
QRhiGraphicsPipeline objects from Qt Quick and Qt Quick 3D.

The total time spent in QRhiGraphicsPipeline::create() during application
startup for these 18 pipelines is 35-40 ms on a given Windows (NVIDIA)
system.

When exporting the pipeline cache contents to a file, and then, in a
subsequent run, reloading the cache contents, this is reduced to 5-7 ms
on the same system, meaning we get a 6-7x improvement.

The generated data is always specific to a given Qt version, RHI
backend, graphics device, and driver version. Much of the implementation
consists of adding and verifying the appropriate header to the blobs
retrieved from the driver, to allow gracefully ignoring data that was
generated with a device or driver that differs from the one used at
run time. This should provide robustness, even if the Vulkan or OpenGL
implementation is for some reason not prepared to identity and reject
incompatible cache/program blobs.

Fixes: QTBUG-90398
Change-Id: I67b197f393562434f372c7b7377f638abab85cb3
Reviewed-by: Andy Nichols <andy.nichols@qt.io>

1 files changed, 82 insertions, 1 deletions

diff --git a/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp b/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp
index 1b473ed023..84a2cddc93 100644
--- a/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp
+++ b/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp
@@ -121,6 +121,9 @@ private slots:
     void finishWithinSwapchainFrame_data();
     void finishWithinSwapchainFrame();
 
+    void pipelineCache_data();
+    void pipelineCache();
+
 private:
     void setWindowType(QWindow *window, QRhi::Implementation impl);
 
@@ -337,7 +340,11 @@ void tst_QRhi::create()
             QRhi::ReadBackNonUniformBuffer,
             QRhi::ReadBackNonBaseMipLevel,
             QRhi::TexelFetch,
-            QRhi::RenderToNonBaseMipLevel
+            QRhi::RenderToNonBaseMipLevel,
+            QRhi::IntAttributes,
+            QRhi::ScreenSpaceDerivatives,
+            QRhi::ReadBackAnyTextureFormat,
+            QRhi::PipelineCacheDataLoadSave
         };
         for (size_t i = 0; i <sizeof(features) / sizeof(QRhi::Feature); ++i)
             rhi->isFeatureSupported(features[i]);
@@ -3383,5 +3390,79 @@ void tst_QRhi::renderPassDescriptorCompatibility()
     }
 }
 
+void tst_QRhi::pipelineCache_data()
+{
+    rhiTestData();
+}
+
+void tst_QRhi::pipelineCache()
+{
+    QFETCH(QRhi::Implementation, impl);
+    QFETCH(QRhiInitParams *, initParams);
+
+    QByteArray pcd;
+    QShader vs = loadShader(":/data/simple.vert.qsb");
+    QVERIFY(vs.isValid());
+    QShader fs = loadShader(":/data/simple.frag.qsb");
+    QVERIFY(fs.isValid());
+    QRhiVertexInputLayout inputLayout;
+    inputLayout.setBindings({ { 2 * sizeof(float) } });
+    inputLayout.setAttributes({ { 0, 0, QRhiVertexInputAttribute::Float2, 0 } });
+
+    {
+        QScopedPointer<QRhi> rhi(QRhi::create(impl, initParams, QRhi::EnablePipelineCacheDataSave));
+        if (!rhi)
+            QSKIP("QRhi could not be created, skipping testing (set)pipelineCacheData()");
+
+        if (!rhi->isFeatureSupported(QRhi::PipelineCacheDataLoadSave))
+            QSKIP("PipelineCacheDataLoadSave is not supported with this backend, skipping test");
+
+        QScopedPointer<QRhiTexture> texture(rhi->newTexture(QRhiTexture::RGBA8, QSize(256, 256), 1, QRhiTexture::RenderTarget));
+        QVERIFY(texture->create());
+        QScopedPointer<QRhiTextureRenderTarget> rt(rhi->newTextureRenderTarget({ texture.data() }));
+        QScopedPointer<QRhiRenderPassDescriptor> rpDesc(rt->newCompatibleRenderPassDescriptor());
+        rt->setRenderPassDescriptor(rpDesc.data());
+        QVERIFY(rt->create());
+        QScopedPointer<QRhiShaderResourceBindings> srb(rhi->newShaderResourceBindings());
+        QVERIFY(srb->create());
+        QScopedPointer<QRhiGraphicsPipeline> pipeline(rhi->newGraphicsPipeline());
+        pipeline->setShaderStages({ { QRhiShaderStage::Vertex, vs }, { QRhiShaderStage::Fragment, fs } });
+        pipeline->setVertexInputLayout(inputLayout);
+        pipeline->setShaderResourceBindings(srb.data());
+        pipeline->setRenderPassDescriptor(rpDesc.data());
+        QVERIFY(pipeline->create());
+
+        // This cannot be more than a basic smoketest: ensure that passing
+        // in the data we retrieve still gives us successful pipeline
+        // creation. What happens internally we cannot check.
+        pcd = rhi->pipelineCacheData();
+        rhi->setPipelineCacheData(pcd);
+        QVERIFY(pipeline->create());
+    }
+
+    {
+        // Now from scratch, with seeding the cache right from the start,
+        // presumably leading to a cache hit when creating the pipeline.
+        QScopedPointer<QRhi> rhi(QRhi::create(impl, initParams, QRhi::EnablePipelineCacheDataSave));
+        QVERIFY(rhi);
+        rhi->setPipelineCacheData(pcd);
+
+        QScopedPointer<QRhiTexture> texture(rhi->newTexture(QRhiTexture::RGBA8, QSize(256, 256), 1, QRhiTexture::RenderTarget));
+        QVERIFY(texture->create());
+        QScopedPointer<QRhiTextureRenderTarget> rt(rhi->newTextureRenderTarget({ texture.data() }));
+        QScopedPointer<QRhiRenderPassDescriptor> rpDesc(rt->newCompatibleRenderPassDescriptor());
+        rt->setRenderPassDescriptor(rpDesc.data());
+        QVERIFY(rt->create());
+        QScopedPointer<QRhiShaderResourceBindings> srb(rhi->newShaderResourceBindings());
+        QVERIFY(srb->create());
+        QScopedPointer<QRhiGraphicsPipeline> pipeline(rhi->newGraphicsPipeline());
+        pipeline->setShaderStages({ { QRhiShaderStage::Vertex, vs }, { QRhiShaderStage::Fragment, fs } });
+        pipeline->setVertexInputLayout(inputLayout);
+        pipeline->setShaderResourceBindings(srb.data());
+        pipeline->setRenderPassDescriptor(rpDesc.data());
+        QVERIFY(pipeline->create());
+    }
+}
+
 #include <tst_qrhi.moc>
 QTEST_MAIN(tst_QRhi)