Move the thread-safety release mechanism from Resource to the OpenGL backend only. (#952)

Author: domchen

include/tgfx/gpu/Context.h

@@ -49,7 +49,7 @@ class Context {
    */
   Context(Device* device, GPU* gpu);
 
-  virtual ~Context();
+  ~Context();
 
   /**
    * Returns the associated device.
@@ -203,11 +203,6 @@ class Context {
   SlidingWindowTracker* _maxValueTracker = nullptr;
   AtlasManager* _atlasManager = nullptr;
   std::shared_ptr<CommandBuffer> commandBuffer = nullptr;
-
-  void releaseAll(bool releaseGPU);
-
-  friend class Device;
-  friend class Resource;
 };
 
 }  // namespace tgfx

include/tgfx/gpu/Device.h

@@ -55,17 +55,16 @@ class Device {
 
  protected:
   std::mutex locker = {};
+  GPU* _gpu = nullptr;
   Context* context = nullptr;
   std::weak_ptr<Device> weakThis;
 
   explicit Device(std::unique_ptr<GPU> gpu);
-  void releaseAll();
   virtual bool onLockContext();
   virtual void onUnlockContext();
 
  private:
   uint32_t _uniqueID = 0;
-  GPU* _gpu = nullptr;
   bool contextLocked = false;
 
   friend class ResourceCache;

include/tgfx/gpu/RuntimeProgram.h

@@ -50,6 +50,6 @@ class RuntimeProgram {
  private:
   Context* context = nullptr;
 
-  friend class RuntimeProgramWrapper;
+  friend class GLRuntimeProgram;
 };
 }  // namespace tgfx

include/tgfx/gpu/opengl/GLDevice.h

@@ -67,6 +67,8 @@ class GLDevice : public Device {
 
   GLDevice(std::unique_ptr<GPU> gpu, void* nativeHandle);
 
+  void releaseAll();
+
   friend class GLContext;
 };
 }  // namespace tgfx

include/tgfx/gpu/opengl/eagl/EAGLWindow.h

@@ -32,8 +32,6 @@ class EAGLWindow : public Window {
   static std::shared_ptr<EAGLWindow> MakeFrom(CAEAGLLayer* layer,
                                               std::shared_ptr<GLDevice> device = nullptr);
 
-  ~EAGLWindow() override;
-
  protected:
   std::shared_ptr<Surface> onCreateSurface(Context* context) override;
   void onPresent(Context* context, int64_t presentationTime) override;

src/core/AtlasManager.cpp

@@ -96,11 +96,6 @@ void AtlasManager::postFlush() {
   }
 }
 
-void AtlasManager::releaseAll() {
-  for (auto& atlas : atlases) {
-    atlas = nullptr;
-  }
-}
 AtlasToken AtlasManager::nextFlushToken() const {
   return atlasTokenTracker.nextToken();
 }

src/core/AtlasManager.h

@@ -39,8 +39,6 @@ class AtlasManager : public AtlasGenerationCounter {
 
   void postFlush();
 
-  void releaseAll();
-
   AtlasToken nextFlushToken() const;
 
  private:

src/gpu/resources/UnreferencedResourceQueue.cpp renamed to src/core/utils/ReturnQueue.cpp

@@ -15,16 +15,34 @@
 //  and limitations under the license.
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////
-#include "UnreferencedResourceQueue.h"
-#include "gpu/resources/Resource.h"
+
+#include "ReturnQueue.h"
+#include "core/utils/Log.h"
 
 namespace tgfx {
+std::shared_ptr<ReturnQueue> ReturnQueue::Make() {
+  auto queue = std::shared_ptr<ReturnQueue>(new ReturnQueue());
+  queue->weakThis = queue;
+  return queue;
+}
+
+void ReturnQueue::NotifyReferenceReachedZero(ReturnNode* node) {
+  DEBUG_ASSERT(node->unreferencedQueue != nullptr);
+  node->unreferencedQueue->queue.enqueue(node);
+  node->unreferencedQueue = nullptr;
+}
 
-UnreferencedResourceQueue::~UnreferencedResourceQueue() {
-  Resource* resource = nullptr;
-  while (queue.try_dequeue(resource)) {
-    delete resource;
+ReturnQueue::~ReturnQueue() {
+  ReturnNode* node = nullptr;
+  while (queue.try_dequeue(node)) {
+    delete node;
   }
 }
 
+std::shared_ptr<ReturnNode> ReturnQueue::makeShared(ReturnNode* node) {
+  auto reference = std::shared_ptr<ReturnNode>(node, NotifyReferenceReachedZero);
+  reference->unreferencedQueue = weakThis.lock();
+  return reference;
+}
+
 }  // namespace tgfx

src/core/utils/ReturnQueue.h

@@ -0,0 +1,77 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2025 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <concurrentqueue.h>
+#include <memory>
+
+namespace tgfx {
+class ReturnNode;
+
+/**
+ * A thread-safe queue for storing ReturnNode objects that are no longer referenced. When a
+ * ReturnNode's reference count drops to zero, it is added to this queue for later processing.
+ * Any returned nodes that are not processed will be deleted when the ReturnQueue is destroyed.
+ */
+class ReturnQueue {
+ public:
+  /**
+   * Creates a new ReturnQueue instance.
+   */
+  static std::shared_ptr<ReturnQueue> Make();
+
+  ~ReturnQueue();
+
+  /**
+   * Wraps a ReturnNode in a shared_ptr that will add the node to this queue when its reference
+   * count reaches zero.
+   */
+  std::shared_ptr<ReturnNode> makeShared(ReturnNode* node);
+
+  /**
+   * Attempts to dequeue a ReturnNode from the queue. Returns nullptr if the queue is empty.
+   */
+  ReturnNode* dequeue() {
+    ReturnNode* node = nullptr;
+    return queue.try_dequeue(node) ? node : nullptr;
+  }
+
+ private:
+  std::weak_ptr<ReturnQueue> weakThis;
+  moodycamel::ConcurrentQueue<ReturnNode*> queue;
+
+  static void NotifyReferenceReachedZero(ReturnNode* node);
+
+  ReturnQueue() = default;
+};
+
+/**
+ * A base class for objects that can be managed by a ReturnQueue. When the reference count of a
+ * ReturnNode reaches zero, it is added to its associated ReturnQueue.
+ */
+class ReturnNode {
+ public:
+  virtual ~ReturnNode() = default;
+
+ private:
+  std::shared_ptr<ReturnQueue> unreferencedQueue = nullptr;
+
+  friend class ReturnQueue;
+};
+}  // namespace tgfx

src/gpu/CommandEncoder.h

@@ -49,28 +49,29 @@ class CommandEncoder {
    * @param dstTexture The destination texture to copy to.
    * @param dstOffset The offset in the destination texture where the copied region will be placed.
    */
-  virtual void copyTextureToTexture(GPUTexture* srcTexture, const Rect& srcRect,
-                                    GPUTexture* dstTexture, const Point& dstOffset) = 0;
+  virtual void copyTextureToTexture(std::shared_ptr<GPUTexture> srcTexture, const Rect& srcRect,
+                                    std::shared_ptr<GPUTexture> dstTexture,
+                                    const Point& dstOffset) = 0;
 
   /**
    * Encodes a command that generates mipmaps for the specified GPUTexture from the base level to
    * the highest level. This method only has an effect if the texture was created with mipmap
    * enabled.
    */
-  virtual void generateMipmapsForTexture(GPUTexture* texture) = 0;
+  virtual void generateMipmapsForTexture(std::shared_ptr<GPUTexture> texture) = 0;
 
   /**
    * Inserts a signal GPUFence into the command encoder. This is used to notify other
    * synchronization points once the preceding GPU commands have finished executing. Returns nullptr
    * if the GPUFence cannot be created or inserted.
    */
-  virtual std::unique_ptr<GPUFence> insertFence() = 0;
+  virtual std::shared_ptr<GPUFence> insertFence() = 0;
 
   /**
    * Makes subsequent commands added to the command encoder to wait until the specified GPUFence is
    * signaled.
    */
-  virtual void waitForFence(GPUFence* fence) = 0;
+  virtual void waitForFence(std::shared_ptr<GPUFence> fence) = 0;
 
   /**
    * Finalizes command encoding and returns a CommandBuffer with all recorded commands. You can then