[Tizen] Clear pipelie cache if geometry destroyed

We also cache pipeline cache the Render::Geometry by the raw pointer.
If someone use duplicated pointer, it might return invalid pipeline
with unmatched vertexInputState.

To avoid this issue, let we erase cache if Render::Geometry destroyed,
same as Render::Program

Change-Id: Ia1dec43dbed3fdccc5ebd3279dc0b4466a9ce43f
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>

diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp
index a1dffa267a3d0be0eefe90c4a4e037f28edcab70..2109d3b8aff9288cd930493b68a1f54a2ce0d150 100644 (file)
--- a/dali/internal/render/common/render-manager.cpp
+++ b/dali/internal/render/common/render-manager.cpp
@@ -133,7 +133,9 @@ struct RenderManager::Impl
   ~Impl()
   {
     threadPool.reset(nullptr); // reset now to maintain correct destruction order
-    rendererContainer.Clear(); // clear now before the pipeline cache is deleted
+    geometryContainer.Clear(); // clear now before the pipeline cache is deleted
+    rendererContainer.Clear(); // clear now before the program contoller and the pipeline cache are deleted
+    pipelineCache.reset();     // clear now before the program contoller is deleted
   }
 
   void AddRenderTracker(Render::RenderTracker* renderTracker)

diff --git a/dali/internal/render/renderers/pipeline-cache.cpp b/dali/internal/render/renderers/pipeline-cache.cpp
index 4f71b9169b22a9a82155e5f317e16320bd83097b..d89244f1cecb833d69828207a0d07aacba9bb3eb 100644 (file)
--- a/dali/internal/render/renderers/pipeline-cache.cpp
+++ b/dali/internal/render/renderers/pipeline-cache.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -243,6 +243,9 @@ PipelineCacheL0Ptr PipelineCache::GetPipelineCacheL0(Program* program, Render::G
     level0.geometry   = geometry;
     level0.inputState = vertexInputState;
 
+    // Observer geometry lifecycle
+    geometry->AddLifecycleObserver(*this);
+
     it = level0nodes.insert(level0nodes.end(), std::move(level0));
   }
 
@@ -445,6 +448,15 @@ PipelineCache::PipelineCache(Graphics::Controller& controller)
 {
 }
 
+PipelineCache::~PipelineCache()
+{
+  // Stop observer lifecycle
+  for(auto&& level0node : level0nodes)
+  {
+    level0node.geometry->RemoveLifecycleObserver(*this);
+  }
+}
+
 PipelineResult PipelineCache::GetPipeline(const PipelineCacheQueryInfo& queryInfo, bool createNewIfNotFound)
 {
   auto level0 = GetPipelineCacheL0(queryInfo.program, queryInfo.geometry);
@@ -499,6 +511,8 @@ void PipelineCache::ClearUnusedCache()
 
     if(iter->level1nodes.empty())
     {
+      // Stop observer lifecycle
+      iter->geometry->RemoveLifecycleObserver(*this);
       iter = level0nodes.erase(iter);
     }
     else
@@ -514,4 +528,20 @@ void PipelineCache::ResetPipeline(PipelineCachePtr pipelineCache)
   pipelineCache->referenceCount--;
 }
 
+void PipelineCache::GeometryDestroyed(const Geometry* geometry)
+{
+  // Remove cached items what cache hold now.
+  for(auto iter = level0nodes.begin(); iter != level0nodes.end();)
+  {
+    if(iter->geometry == geometry)
+    {
+      iter = level0nodes.erase(iter);
+    }
+    else
+    {
+      iter++;
+    }
+  }
+}
+
 } // namespace Dali::Internal::Render

diff --git a/dali/internal/render/renderers/pipeline-cache.h b/dali/internal/render/renderers/pipeline-cache.h
index 34a3a51a5b8e47fba2e3191f7e8ed44f6bf3ba2c..859dac90c80044318d8969b72138e19582f0dae7 100644 (file)
--- a/dali/internal/render/renderers/pipeline-cache.h
+++ b/dali/internal/render/renderers/pipeline-cache.h
@@ -2,7 +2,7 @@
 #define DALI_INTERNAL_RENDER_PIPELINE_CACHE_H
 
 /*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@
 #include <dali/graphics-api/graphics-types.h>
 #include <dali/internal/common/blending-options.h>
 #include <dali/public-api/common/list-wrapper.h>
+#include <dali/internal/render/renderers/render-geometry.h> ///< For Geometry::LifecycleObserver
 
 namespace Dali::Internal
 {
@@ -30,7 +31,6 @@ class Program;
 namespace Render
 {
 class Renderer;
-class Geometry;
 
 struct PipelineCacheL2;
 struct PipelineCacheL1;
@@ -121,7 +121,7 @@ struct PipelineResult
 /**
  * Pipeline cache
  */
-class PipelineCache
+class PipelineCache : public Geometry::LifecycleObserver
 {
 public:
   /**
@@ -130,6 +130,11 @@ public:
    */
   explicit PipelineCache(Graphics::Controller& controller);
 
+  /**
+   * Destructor
+   */
+  ~PipelineCache();
+
   /**
    * Retrieves next cache level
    */
@@ -153,6 +158,12 @@ public:
    */
   void ResetPipeline(PipelineCachePtr pipelineCache);
 
+public: // From Geometry::LifecycleObserver
+  /**
+   * @copydoc Dali::Internal::Geometry::LifecycleObserver::GeometryDestroyed()
+   */
+  void GeometryDestroyed(const Geometry* geometry);
+
 private:
   /**
    * @brief Clear unused caches.

diff --git a/dali/internal/render/renderers/render-geometry.cpp b/dali/internal/render/renderers/render-geometry.cpp
index 4ada7ce5f53cfda93953cb1b14e4e7eeb100845f..3f58bc482ab8f2cc5d4181976f75bf0fb14bc770 100644 (file)
--- a/dali/internal/render/renderers/render-geometry.cpp
+++ b/dali/internal/render/renderers/render-geometry.cpp
@@ -51,17 +51,31 @@ inline constexpr size_t GetSizeOfIndexFromIndexType(Dali::Graphics::Format graph
 }
 } // unnamed namespace
 Geometry::Geometry()
-: mIndices(),
+: mLifecycleObservers(),
+  mIndices(),
   mIndexBuffer(nullptr),
   mIndexType(Dali::Graphics::Format::R16_UINT),
   mGeometryType(Dali::Geometry::TRIANGLES),
   mIndicesChanged(false),
   mHasBeenUploaded(false),
-  mUpdated(true)
+  mUpdated(true),
+  mObserverNotifying(false)
 {
 }
 
-Geometry::~Geometry() = default;
+Geometry::~Geometry()
+{
+  mObserverNotifying = true;
+  for(auto&& iter : mLifecycleObservers)
+  {
+    auto* observer = iter.first;
+    observer->GeometryDestroyed(this);
+  }
+  mLifecycleObservers.clear();
+
+  // Note : We don't need to restore mObserverNotifying to false as we are in delete the object.
+  // If someone call AddObserver / RemoveObserver after this, assert.
+}
 
 void Geometry::AddVertexBuffer(Render::VertexBuffer* vertexBuffer)
 {

diff --git a/dali/internal/render/renderers/render-geometry.h b/dali/internal/render/renderers/render-geometry.h
index 3c99076732237d7ce1eebc851ca63725e09f3f97..eedfb380a5b3c6f1e7acb89df418a3633f95524d 100644 (file)
--- a/dali/internal/render/renderers/render-geometry.h
+++ b/dali/internal/render/renderers/render-geometry.h
@@ -17,6 +17,9 @@
  * limitations under the License.
  */
 
+// EXTERNAL INCLUDES
+#include <unordered_map>
+
 // INTERNAL INCLUDES
 #include <dali/devel-api/common/owner-container.h>
 #include <dali/graphics-api/graphics-controller.h>
@@ -51,6 +54,24 @@ public:
   using Uint16ContainerType = Dali::Vector<uint16_t>;
   using Uint32ContainerType = Dali::Vector<uint32_t>;
 
+  /**
+   * Observer to determine when the geometry is no longer present
+   */
+  class LifecycleObserver
+  {
+  public:
+    /**
+     * Called shortly before the program is destroyed.
+     */
+    virtual void GeometryDestroyed(const Geometry* program) = 0;
+
+  protected:
+    /**
+     * Virtual destructor, no deletion through this interface
+     */
+    virtual ~LifecycleObserver() = default;
+  };
+
   Geometry();
 
   /**
@@ -137,7 +158,50 @@ public:
             uint32_t                 elementBufferOffset,
             uint32_t                 elementBufferCount);
 
+  /**
+   * Allows Geometry to track the life-cycle of this object.
+   * Note that we allow to observe lifecycle multiple times.
+   * But GeometryDestroyed callback will be called only one time.
+   * @param[in] observer The observer to add.
+   */
+  void AddLifecycleObserver(LifecycleObserver& observer)
+  {
+    DALI_ASSERT_ALWAYS(!mObserverNotifying && "Cannot add observer while notifying Geometry::LifecycleObservers");
+
+    auto iter = mLifecycleObservers.find(&observer);
+    if(iter != mLifecycleObservers.end())
+    {
+      // Increase the number of observer count
+      ++(iter->second);
+    }
+    else
+    {
+      mLifecycleObservers.insert({&observer, 1u});
+    }
+  }
+
+  /**
+   * The Geometry no longer needs to track the life-cycle of this object.
+   * @param[in] observer The observer that to remove.
+   */
+  void RemoveLifecycleObserver(LifecycleObserver& observer)
+  {
+    DALI_ASSERT_ALWAYS(!mObserverNotifying && "Cannot remove observer while notifying Geometry::LifecycleObservers");
+
+    auto iter = mLifecycleObservers.find(&observer);
+    DALI_ASSERT_ALWAYS(iter != mLifecycleObservers.end());
+
+    if(--(iter->second) == 0u)
+    {
+      mLifecycleObservers.erase(iter);
+    }
+  }
+
 private:
+  using LifecycleObserverContainer = std::unordered_map<LifecycleObserver*, uint32_t>; ///< Lifecycle observers container. We allow to add same observer multiple times.
+                                                                                       ///< Key is a pointer to observer, value is the number of observer added.
+  LifecycleObserverContainer mLifecycleObservers;
+
   // VertexBuffers
   Vector<Render::VertexBuffer*> mVertexBuffers;
 
@@ -150,6 +214,8 @@ private:
   bool mIndicesChanged : 1;
   bool mHasBeenUploaded : 1;
   bool mUpdated : 1; ///< Flag to know if data has changed in a frame. Value fixed after Upload() call, and reset as false after OnRenderFinished
+
+  bool mObserverNotifying : 1; ///< Safety guard flag to ensure that the LifecycleObserver not be added or deleted while observing.
 };
 
 } // namespace Render

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index c46b27bcf392d2d0a309bd411baeaf846611b2e3..bfbbe2f0f4c210b1a3035e77927c4733937a05d8 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -221,6 +221,13 @@ void Renderer::SetGeometry(Render::Geometry* geometry)
 {
   mGeometry = geometry;
   mUpdated  = true;
+
+  // Reset old pipeline
+  if(DALI_LIKELY(mPipelineCached))
+  {
+    mPipelineCache->ResetPipeline(mPipeline);
+    mPipelineCached = false;
+  }
 }
 void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size)
 {