[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 44594ecbf7ed92843f54675a473a47e06dee8753..9fa49c72047cf9880a539d78ccc247dfaa20d8be 100644 (file)
--- a/dali/internal/render/common/render-manager.cpp
+++ b/dali/internal/render/common/render-manager.cpp
@@ -154,7 +154,9 @@ struct RenderManager::Impl
 
   ~Impl()
   {
-    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 e78b7f7dcb7be0da7848cec623aa378fd6e602f7..78aca471962e5576d1e117eabeceba0e7331fb7f 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.
@@ -255,6 +255,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));
 
     if(attrNotFound)
@@ -502,6 +505,15 @@ PipelineCache::PipelineCache(Graphics::Controller& controller)
   CleanLatestUsedCache();
 }
 
+PipelineCache::~PipelineCache()
+{
+  // Stop observer lifecycle
+  for(auto&& level0node : level0nodes)
+  {
+    level0node.geometry->RemoveLifecycleObserver(*this);
+  }
+}
+
 PipelineResult PipelineCache::GetPipeline(const PipelineCacheQueryInfo& queryInfo, bool createNewIfNotFound)
 {
   // Seperate branch whether query use blending or not.
@@ -577,6 +589,8 @@ void PipelineCache::ClearUnusedCache()
 
     if(iter->level1nodes.empty())
     {
+      // Stop observer lifecycle
+      iter->geometry->RemoveLifecycleObserver(*this);
       iter = level0nodes.erase(iter);
     }
     else
@@ -592,4 +606,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 6d5caf45f292aca4ec73ea386a6f8a7f9af75b72..4db65e31ee989eaae06a9852462f2f9b67a15257 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;
@@ -130,7 +130,7 @@ struct PipelineResult
 /**
  * Pipeline cache
  */
-class PipelineCache
+class PipelineCache : public Geometry::LifecycleObserver
 {
 public:
   /**
@@ -139,6 +139,11 @@ public:
    */
   explicit PipelineCache(Graphics::Controller& controller);
 
+  /**
+   * Destructor
+   */
+  ~PipelineCache();
+
   /**
    * Retrieves next cache level
    */
@@ -173,6 +178,12 @@ public:
    */
   void ResetPipeline(PipelineCachePtr pipelineCache);
 
+public: // From Geometry::LifecycleObserver
+  /**
+   * @copydoc Dali::Internal::Geometry::LifecycleObserver::GeometryDestroyed()
+   */
+  void GeometryDestroyed(const Geometry* geometry);
+
 private:
   /**
    * @brief Clear latest bound result.

diff --git a/dali/internal/render/renderers/render-geometry.cpp b/dali/internal/render/renderers/render-geometry.cpp
index a8b711552028c58c96a23ff2406fdfbb23070ed8..09dcf8933324f910c53f748eff430d8a8ac03002 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 1443d59f5f2b6627e00dae81d8a6a6708c4c0b41..be7744b0543d1fdb82071f70ac0e2f583acea2f7 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();
 
   /**
@@ -147,7 +168,50 @@ public:
    */
   bool BindVertexAttributes(Graphics::CommandBuffer& commandBuffer);
 
+  /**
+   * 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;
 
@@ -160,6 +224,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 46bffe4a38f845d29623c97af58f872a758ef5c3..4903b935d62352fdf9fee2f04e51946f210e9356 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -178,6 +178,13 @@ Renderer* Renderer::Get(RendererKey::KeyType rendererKey)
 void Renderer::SetGeometry(Render::Geometry* geometry)
 {
   mGeometry = geometry;
+
+  // Reset old pipeline
+  if(DALI_LIKELY(mPipelineCached))
+  {
+    mPipelineCache->ResetPipeline(mPipeline);
+    mPipelineCached = false;
+  }
 }
 
 void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size)