Metal: call frame scheduled callback on driver thread (#7414)

filament/backend/src/metal/MetalDriver.h

@@ -28,6 +28,10 @@
 #include <utils/Log.h>
 #include <utils/debug.h>
 
+#include <functional>
+#include <mutex>
+#include <vector>
+
 namespace filament {
 namespace backend {
 
@@ -52,20 +56,27 @@ class MetalDriver final : public DriverBase {
 
 public:
     static Driver* create(MetalPlatform* platform, const Platform::DriverConfig& driverConfig);
+    void runAtNextTick(const std::function<void()>& fn) noexcept;
 
 private:
 
     friend class MetalSwapChain;
 
     MetalPlatform& mPlatform;
-
     MetalContext* mContext;
 
     ShaderModel getShaderModel() const noexcept final;
 
     // Overrides the default implementation by wrapping the call to fn in an @autoreleasepool block.
     void execute(std::function<void(void)> const& fn) noexcept final;
 
+    /*
+     * Tasks run regularly on the driver thread.
+     */
+    void executeTickOps() noexcept;
+    std::vector<std::function<void()>> mTickOps;
+    std::mutex mTickOpsLock;
+
     /*
      * Driver interface
      */

filament/backend/src/metal/MetalDriver.mm

@@ -166,6 +166,7 @@
 }
 
 void MetalDriver::tick(int) {
+    executeTickOps();
 }
 
 void MetalDriver::beginFrame(int64_t monotonic_clock_ns, uint32_t frameId) {
@@ -583,6 +584,8 @@
     // This must be done before calling bufferPool->reset() to ensure no buffers are in flight.
     finish();
 
+    executeTickOps();
+
     mContext->bufferPool->reset();
     mContext->commandQueue = nil;
 
@@ -1904,6 +1907,21 @@
 void MetalDriver::resetState(int) {
 }
 
+void MetalDriver::runAtNextTick(const std::function<void()>& fn) noexcept {
+    std::lock_guard<std::mutex> const lock(mTickOpsLock);
+    mTickOps.push_back(fn);
+}
+
+void MetalDriver::executeTickOps() noexcept {
+    std::vector<std::function<void()>> ops;
+    mTickOpsLock.lock();
+    std::swap(ops, mTickOps);
+    mTickOpsLock.unlock();
+    for (const auto& f : ops) {
+        f();
+    }
+}
+
 // explicit instantiation of the Dispatcher
 template class ConcreteDispatcher<MetalDriver>;
 

filament/backend/src/metal/MetalHandles.mm

@@ -245,13 +245,30 @@ static inline MTLTextureUsage getMetalTextureUsage(TextureUsage usage) {
     }
 }
 
+struct PresentDrawableData {
+    void* drawable = nullptr;
+    MetalDriver* driver = nullptr;
+};
+
 void presentDrawable(bool presentFrame, void* user) {
-    // CFBridgingRelease here is used to balance the CFBridgingRetain inside of acquireDrawable.
-    id<CAMetalDrawable> drawable = (id<CAMetalDrawable>) CFBridgingRelease(user);
+    auto* presentDrawableData = static_cast<PresentDrawableData*>(user);
+
+    // CFBridgingRelease here is used to balance the CFBridgingRetain inside acquireDrawable.
+    id<CAMetalDrawable> drawable =
+            (id<CAMetalDrawable>)CFBridgingRelease(presentDrawableData->drawable);
     if (presentFrame) {
         [drawable present];
     }
-    // The drawable will be released here when the "drawable" variable goes out of scope.
+
+    // Schedule the drawable destruction on the driver thread.
+    void* voidDrawable = (void*) CFBridgingRetain(drawable);
+    MetalDriver* driver = presentDrawableData->driver;
+    driver->runAtNextTick([voidDrawable]() {
+        // The drawable is released here.
+        CFBridgingRelease(voidDrawable);
+    });
+
+    delete presentDrawableData;
 }
 
 void MetalSwapChain::scheduleFrameScheduledCallback() {
@@ -266,13 +283,15 @@ void presentDrawable(bool presentFrame, void* user) {
     // capture the _this_ pointer (MetalSwapChain*) instead of the drawable.
     id<CAMetalDrawable> d = drawable;
     void* userData = frameScheduledUserData;
+    MetalDriver* driver = context.driver;
     [getPendingCommandBuffer(&context) addScheduledHandler:^(id<MTLCommandBuffer> cb) {
         // CFBridgingRetain is used here to give the drawable a +1 retain count before
         // casting it to a void*.
-        PresentCallable callable(presentDrawable, (void*) CFBridgingRetain(d));
-        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-            callback(callable, userData);
-        });
+        auto* presentDrawableData = new PresentDrawableData;
+        presentDrawableData->drawable = (void*) CFBridgingRetain(d);
+        presentDrawableData->driver = driver;
+        PresentCallable callable(presentDrawable, (void*) presentDrawableData);
+        callback(callable, userData);
     }];
 }
 

filament/include/filament/SwapChain.h

@@ -252,6 +252,12 @@ class UTILS_PUBLIC SwapChain : public FilamentAPI {
      * automatically schedule itself for presentation. Instead, the application must call the
      * PresentCallable passed to the FrameScheduledCallback.
      *
+     * If your application delays the call to the PresentCallable by, for example, calling it on a
+     * separate thread, you must ensure all PresentCallables have been called before shutting down
+     * the Filament Engine. You can do this by issuing an Engine::flushAndWait before calling
+     * Engine::shutdown. This is necessary to ensure the Filament Engine has had a chance to clean
+     * up all memory related to frame presentation.
+     *
      * @param callback    A callback, or nullptr to unset.
      * @param user        An optional pointer to user data passed to the callback function.
      *