Fixed deadlock on graph objects. (I knew it was coming)

Author: Dandielo

source/code/iceshard/engine/private/gfx/ice_gfx_graph.cxx

@@ -214,16 +214,10 @@ namespace ice::gfx
 
     IceshardGfxGraphRuntime::~IceshardGfxGraphRuntime() noexcept
     {
-        // If there is still stages initializing we want to wait for them, so we don't end up with accessing
-        //  '_stages._ready' field after a free.
-        ice::u32 in_progress = _stages._ready.load(std::memory_order_relaxed);
-        while(in_progress > 0)
-        {
-            // Wait if we still have values in progress
-            _stages._ready.wait(in_progress, std::memory_order_relaxed);
-            // Get the new count to dobule check we are in the clear.
-            in_progress = _stages._ready.load(std::memory_order_relaxed);
-        }
+        ICE_ASSERT(
+            this->ready(),
+            "Graphics Graph destroyed before all tasks finished executing! Possible read/write memory access errors!"
+        );
 
         render::RenderDevice& device = _context.device();
 
@@ -244,18 +238,15 @@ namespace ice::gfx
         device.destroy_renderpass(_renderpass);
     }
 
+    bool IceshardGfxGraphRuntime::ready() const noexcept
+    {
+        return _stages._ready.load(std::memory_order_relaxed) == 0;
+    }
+
     auto initialize_stage(ice::Task<> init_task, std::atomic_uint32_t& ready_count) noexcept -> ice::Task<>
     {
         co_await init_task;
-
-        // If the last stage is finalized we want to send a notification. This is because the graph
-        //  could be waiting in the descrutor when a new graph want's to be initialized.
-        // This may happen during manual resizing the window, so it's probably only an issues during dev-time
-        //  since users should only resize using a in-game menu option.
-        if (ready_count.fetch_sub(1, std::memory_order_relaxed) == 1)
-        {
-            ready_count.notify_one();
-        }
+        ready_count.fetch_sub(1, std::memory_order_relaxed);
     }
 
     bool IceshardGfxGraphRuntime::prepare(

source/code/iceshard/engine/private/gfx/ice_gfx_graph_runtime.hxx

@@ -80,6 +80,8 @@ namespace ice::gfx
         ) noexcept;
         ~IceshardGfxGraphRuntime() noexcept override;
 
+        bool ready() const noexcept override;
+
         bool prepare(
             ice::gfx::GfxFrameStages& stages,
             ice::gfx::GfxStageRegistry const& stage_registry,

source/code/iceshard/engine/public/ice/gfx/gfx_graph_runtime.hxx

@@ -17,6 +17,9 @@ namespace ice::gfx
     {
         virtual ~GfxGraphRuntime() noexcept = default;
 
+        //! \brief Checks if the graph is ready and all preparation tasks finished executing.
+        virtual bool ready() const noexcept = 0;
+
         //! \brief Prepares the runtime for the next execution phase.
         //! \details The runtime will check and prepare the graph for execution if all necessary stages are available and everything was initialized.
         //!   In the case where some stages are still not available, the execute will be skipped.

source/code/iceshard/iceshard/private/iceshard_gfx_runner.cxx

@@ -132,7 +132,15 @@ namespace ice::gfx
             }
         }
 
-        _rendergraph = ice::move(rendergraph);
+        // If we are ready we can set the rendergraph immediately, if not we schedule it for later to be updated.
+        if (_rendergraph == nullptr || _rendergraph->ready())
+        {
+            _rendergraph = ice::move(rendergraph);
+        }
+        else
+        {
+            _scheduled_rendergraph = ice::move(rendergraph);
+        }
     }
 
     auto IceshardGfxRunner::update_data(
@@ -209,7 +217,13 @@ namespace ice::gfx
             ice::execute_tasks(tasks);
         }
 
-        if (_rendergraph->prepare(gpu_stages, *_stages, _gfx_tasks))
+        // Check if we have a scheduled render graph and if we can replace
+        if (_scheduled_rendergraph != nullptr && _rendergraph->ready())
+        {
+            _rendergraph = ice::move(_scheduled_rendergraph);
+        }
+
+        if (_scheduled_rendergraph == nullptr && _rendergraph->prepare(gpu_stages, *_stages, _gfx_tasks))
         {
             IPT_ZONE_SCOPED_NAMED("gfx_resume_prepare_tasks");
             // The tasks here might take more than a frame to finish. We should track them somewhere else.
@@ -255,7 +269,7 @@ namespace ice::gfx
         // Execute all stages (currently done simply going over the render graph)
         _present_fence->reset();
 
-        if (_rendergraph->execute(frame, *_present_fence))
+        if (_scheduled_rendergraph == nullptr && _rendergraph->execute(frame, *_present_fence))
         {
             _rendergraph->present();
         }

source/code/iceshard/iceshard/private/iceshard_gfx_runner.hxx

@@ -88,6 +88,7 @@ namespace ice::gfx
         ice::gfx::IceshardGfxRunnerState _state;
         ice::HashMap<ice::gfx::IceshardGfxWorldState> _world_states;
         ice::UniquePtr<ice::gfx::GfxGraphRuntime> _rendergraph;
+        ice::UniquePtr<ice::gfx::GfxGraphRuntime> _scheduled_rendergraph;
 
         ice::ScopedTaskContainer _gfx_tasks;