Adjust number of jobs based on number of render paths

Renderer currently creates a large number of jobs, most of them
doing nothing, this quickly adds up when we have lots of branches.
To keep those down, we adjust the number based as estimate of branches
that have work to do (no draw detection will fail if it's not the
leaf node).

Also make RenderViewCommandBuilder and MaterialParameterGathererJob
only run if necessary (and reset instance counter on each frame).

Finally, only create the right number of MaterialParameterGathererJobs
for the amount of updates required.

Change-Id: I2d38c72589a38445d0110fc22a472fb9482d1a03
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

2 files changed, 18 insertions, 9 deletions

diff --git a/tests/auto/render/opengl/renderer/tst_renderer.cpp b/tests/auto/render/opengl/renderer/tst_renderer.cpp
index 3deb9dc6b..8749d2e33 100644
--- a/tests/auto/render/opengl/renderer/tst_renderer.cpp
+++ b/tests/auto/render/opengl/renderer/tst_renderer.cpp
@@ -37,6 +37,7 @@
 #include <Qt3DRender/private/viewportnode_p.h>
 #include <Qt3DRender/private/offscreensurfacehelper_p.h>
 #include <Qt3DRender/private/qrenderaspect_p.h>
+#include <Qt3DRender/qmaterial.h>
 
 #include "testaspect.h"
 
@@ -115,6 +116,10 @@ private Q_SLOTS:
         Qt3DRender::Render::ViewportNode *fgRoot = new Qt3DRender::Render::ViewportNode();
         const Qt3DCore::QNodeId fgRootId = Qt3DCore::QNodeId::createId();
 
+        // Create fake material so that we crean materialGathererJobs
+        const Qt3DCore::QNodeId materialId = Qt3DCore::QNodeId::createId();
+        nodeManagers.materialManager()->getOrCreateResource(materialId);
+
         nodeManagers.frameGraphManager()->appendNode(fgRootId, fgRoot);
         settings.setActiveFrameGraphId(fgRootId);
 
@@ -129,16 +134,16 @@ private Q_SLOTS:
         // NOTE: FilterCompatibleTechniqueJob and ShaderGathererJob cannot run because the context
         // is not initialized in this test
 
-        const int renderViewBuilderMaterialCacheJobCount = 1 + Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount();
+        const int renderViewBuilderMaterialCacheJobCount = 1 + 1;
         // syncMaterialGathererJob
-        // n * materialGathererJob
+        // n * materialGathererJob (where n depends on the numbers of available threads and the number of materials)
         const int layerCacheJobCount = 2;
         // filterEntityByLayerJob,
         // syncFilterEntityByLayerJob
 
-        const int singleRenderViewCommandRebuildJobCount  = 1 + Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount();
+        const int singleRenderViewCommandRebuildJobCount  = 1 + Qt3DRender::Render::OpenGL::RenderViewBuilder::defaultJobCount();
 
-        const int singleRenderViewJobCount = 8 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount();
+        const int singleRenderViewJobCount = 8 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::defaultJobCount();
         // RenderViewBuilder renderViewJob,
         //                   syncRenderViewInitializationJob,
         //                   syncFrustumCullingJob,
diff --git a/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp b/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp
index 19ab51c8c..f092795e3 100644
--- a/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp
+++ b/tests/auto/render/opengl/renderviewbuilder/tst_renderviewbuilder.cpp
@@ -248,14 +248,15 @@ private Q_SLOTS:
             QVERIFY(renderViewBuilder.filterEntityByLayerJob().isNull());
             QVERIFY(renderViewBuilder.syncFilterEntityByLayerJob().isNull());
 
-            QCOMPARE(renderViewBuilder.renderViewCommandUpdaterJobs().size(), Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.renderViewCommandUpdaterJobs().size(), Qt3DRender::Render::OpenGL::RenderViewBuilder::defaultJobCount());
             QCOMPARE(renderViewBuilder.materialGathererJobs().size(), 0);
-            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 8 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 8 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::defaultJobCount());
         }
 
         {
             // WHEN
             Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            renderViewBuilder.setOptimalJobCount(2);
             renderViewBuilder.setLayerCacheNeedsToBeRebuilt(true);
             renderViewBuilder.prepareJobs();
 
@@ -265,22 +266,25 @@ private Q_SLOTS:
             QVERIFY(!renderViewBuilder.syncFilterEntityByLayerJob().isNull());
 
             // mark jobs dirty and recheck
-            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 10 + 1 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 10 + renderViewBuilder.optimalJobCount());
         }
 
         {
             // WHEN
             Qt3DRender::Render::OpenGL::RenderViewBuilder renderViewBuilder(leafNode, 0, testAspect.renderer());
+            renderViewBuilder.setOptimalJobCount(2);
             renderViewBuilder.setMaterialGathererCacheNeedsToBeRebuilt(true);
             renderViewBuilder.prepareJobs();
 
             // THEN
             QCOMPARE(renderViewBuilder.materialGathererCacheNeedsToBeRebuilt(), true);
-            QCOMPARE(renderViewBuilder.materialGathererJobs().size(), Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
+            // We have elementsPerJob = qMax(materialHandles.size() / m_optimalParallelJobCount, 1)
+            // Given we have 2 materials -> 1 element per job -> so we need 2 jobs
+            QCOMPARE(renderViewBuilder.materialGathererJobs().size(), 2);
             QVERIFY(!renderViewBuilder.syncMaterialGathererJob().isNull());
 
             // mark jobs dirty and recheck
-            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 9 + 2 * Qt3DRender::Render::OpenGL::RenderViewBuilder::optimalJobCount());
+            QCOMPARE(renderViewBuilder.buildJobHierachy().size(), 13);
         }
     }