Merge branch 'async-fixes' of https://github.com/bghgary/BabylonNative into async-fixes

bghgary · bghgary · commit 31248b65da7b · 2023-03-29T09:57:18.000-07:00
diff --git a/Core/AppRuntime/Source/AppRuntime.cpp b/Core/AppRuntime/Source/AppRuntime.cpp
@@ -12,7 +12,8 @@ namespace Babylon
         : m_workQueue{std::make_unique<WorkQueue>([this] { RunPlatformTier(); })}
         , m_unhandledExceptionHandler{unhandledExceptionHandler}
     {
-        Dispatch([this](Napi::Env env) {
+        Dispatch([this](Napi::Env env)
+        {
             JsRuntime::CreateForJavaScript(env, [this](auto func) { Dispatch(std::move(func)); });
         });
     }
@@ -45,8 +46,10 @@ namespace Babylon
 
     void AppRuntime::Dispatch(Dispatchable<void(Napi::Env)> func)
     {
-        m_workQueue->Append([this, func{std::move(func)}](Napi::Env env) mutable {
-            Execute([this, env, func{std::move(func)}]() mutable {
+        m_workQueue->Append([this, func{std::move(func)}](Napi::Env env) mutable
+        {
+            Execute([this, env, func{std::move(func)}]() mutable
+            {
                 try
                 {
                     func(env);
diff --git a/Core/AppRuntime/Source/WorkQueue.cpp b/Core/AppRuntime/Source/WorkQueue.cpp
@@ -48,8 +48,10 @@ namespace Babylon
             m_dispatcher.blocking_tick(m_cancellationSource);
         }
 
-        // There should not be any outstanding work during the shutdown sequence
-        // which should be the only way exit the while loop above.
+        // Drain the queue to complete work dispatched after cancellation.
+        m_dispatcher.tick(arcana::cancellation::none());
+
+        // There should no longer be any outstanding work once the queue is drained.
         assert(m_dispatcher.empty());
     }
 }
diff --git a/Core/AppRuntime/Source/WorkQueue.h b/Core/AppRuntime/Source/WorkQueue.h
@@ -22,7 +22,7 @@ namespace Babylon
             if (m_cancellationSource.cancelled())
             {
                 // There is likely a coding error if this exception is thrown.
-                throw std::runtime_error{"Cannot append to the work queue after it is canceled"};
+                throw std::runtime_error{"Cannot append to the work queue while shutting down"};
             }
 
             // Manual dispatcher queueing requires a copyable CallableT, we use a shared pointer trick to make a
@@ -55,6 +55,6 @@ namespace Babylon
         arcana::cancellation_source m_cancellationSource{};
         arcana::manual_dispatcher<128> m_dispatcher{};
 
-        std::thread m_thread;
+        std::thread m_thread{};
     };
 }
diff --git a/Core/JsRuntime/Include/Babylon/JsRuntime.h b/Core/JsRuntime/Include/Babylon/JsRuntime.h
@@ -42,12 +42,20 @@ namespace Babylon
         // Gets the JsRuntime from the given N-API environment.
         static JsRuntime& GetFromJavaScript(Napi::Env);
 
+        struct IDisposingCallback
+        {
+            virtual void Disposing() = 0;
+        };
+
         // Notifies the JsRuntime that the JavaScript environment will begin shutting down.
         // Calling this function will signal callbacks registered with RegisterDisposing.
         static void NotifyDisposing(JsRuntime&);
 
         // Registers a callback for when the JavaScript environment will begin shutting down.
-        static void RegisterDisposing(JsRuntime&, std::function<void()>);
+        static void RegisterDisposing(JsRuntime&, IDisposingCallback*);
+
+        // Unregisters a callback for when the JavaScript environment will begin shutting down.
+        static void UnregisterDisposing(JsRuntime&, IDisposingCallback*);
 
         // Dispatches work onto the JavaScript thread and provides access to the N-API
         // environment.
@@ -58,6 +66,6 @@ namespace Babylon
 
         std::mutex m_mutex{};
         DispatchFunctionT m_dispatchFunction{};
-        std::vector<std::function<void()>> m_disposingCallbacks{};
+        std::vector<IDisposingCallback*> m_disposingCallbacks{};
     };
 }
diff --git a/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h b/Core/JsRuntime/Include/Babylon/JsRuntimeScheduler.h
@@ -53,22 +53,26 @@ namespace Babylon
     //      the continuation, must capture a persistent reference to the N-API object itself to prevent the GC from
     //      collecting the N-API object during the asynchronous operation. Failing to do so will result in a hang
     //      when `Rundown()` is called in the N-API class destructor.
-    class JsRuntimeScheduler
+    class JsRuntimeScheduler : public JsRuntime::IDisposingCallback
     {
     public:
         explicit JsRuntimeScheduler(JsRuntime& runtime)
             : m_runtime{&runtime}
             , m_scheduler{*this}
         {
-            JsRuntime::RegisterDisposing(*m_runtime, [this]()
-            {
-                m_runtime = nullptr;
-            });
+            std::scoped_lock lock{m_mutex};
+            JsRuntime::RegisterDisposing(*m_runtime, this);
         }
 
         ~JsRuntimeScheduler()
         {
             assert(m_count == 0 && "Schedulers for the JavaScript thread are not yet invoked");
+
+            std::scoped_lock lock{m_mutex};
+            if (m_runtime != nullptr)
+            {
+                JsRuntime::UnregisterDisposing(*m_runtime, this);
+            }
         }
 
         // Wait until all of the schedulers are invoked.
@@ -88,6 +92,12 @@ namespace Babylon
         }
 
     private:
+        void Disposing() override
+        {
+            std::scoped_lock lock{m_mutex};
+            m_runtime = nullptr;
+        }
+
         class SchedulerImpl
         {
         public:
@@ -108,6 +118,8 @@ namespace Babylon
         template<typename CallableT>
         void Dispatch(CallableT&& callable)
         {
+            std::scoped_lock lock{m_mutex};
+
             if (m_runtime != nullptr)
             {
                 m_runtime->Dispatch([callable{std::forward<CallableT>(callable)}](Napi::Env)
@@ -123,7 +135,10 @@ namespace Babylon
             --m_count;
         }
 
-        JsRuntime* m_runtime;
+        mutable std::mutex m_mutex{};
+        JsRuntime* m_runtime{};
+        std::function<void()> m_disposingCallback{};
+
         SchedulerImpl m_scheduler;
         std::atomic<int> m_count{0};
         arcana::manual_dispatcher<128> m_disposingDispatcher{};
diff --git a/Core/JsRuntime/Source/JsRuntime.cpp b/Core/JsRuntime/Source/JsRuntime.cpp
@@ -1,4 +1,5 @@
 #include "JsRuntime.h"
+#include <cassert>
 
 namespace Babylon
 {
@@ -43,15 +44,27 @@ namespace Babylon
     void JsRuntime::NotifyDisposing(JsRuntime& runtime)
     {
         auto callbacks = std::move(runtime.m_disposingCallbacks);
-        for (const auto& callback : callbacks)
+        for (auto* callback : callbacks)
         {
-            callback();
+            callback->Disposing();
         }
     }
 
-    void JsRuntime::RegisterDisposing(JsRuntime& runtime, std::function<void()> callback)
+    void JsRuntime::RegisterDisposing(JsRuntime& runtime, IDisposingCallback* callback)
     {
-        runtime.m_disposingCallbacks.push_back(std::move(callback));
+        auto& callbacks = runtime.m_disposingCallbacks;
+        assert(std::find(callbacks.begin(), callbacks.end(), callback) == callbacks.end());
+        callbacks.push_back(callback);
+    }
+
+    void JsRuntime::UnregisterDisposing(JsRuntime& runtime, IDisposingCallback* callback)
+    {
+        auto& callbacks = runtime.m_disposingCallbacks;
+        auto it = std::find(callbacks.begin(), callbacks.end(), callback);
+        if (it != callbacks.end())
+        {
+            callbacks.erase(it);
+        }
     }
 
     void JsRuntime::Dispatch(std::function<void(Napi::Env)> function)
diff --git a/Plugins/NativeEngine/Source/NativeEngine.cpp b/Plugins/NativeEngine/Source/NativeEngine.cpp
@@ -1127,26 +1127,25 @@ namespace Babylon
                 });
     }
 
-    void NativeEngine::CopyTexture(const Napi::CallbackInfo& /*info*/)
-    {
-        //const auto textureDestination = info[0].As<Napi::Pointer<Graphics::Texture>>().Get();
-        //const auto textureSource = info[1].As<Napi::Pointer<Graphics::Texture>>().Get();
-
-        // TODO: this code makes no sense
-        //arcana::make_task(m_graphicsUpdate.Scheduler(), m_cancellationSource, [this, textureDestination, textureSource]()
-        //{
-        //    return arcana::make_task(m_runtimeScheduler.Get(), m_cancellationSource, [this, textureDestination, textureSource, updateToken = m_graphicsUpdate.GetUpdateToken()]() mutable
-        //    {
-        //        bgfx::Encoder* encoder = updateToken.GetEncoder();
-        //        GetBoundFrameBuffer(*encoder).Blit(*encoder, textureDestination->Handle(), 0, 0, textureSource->Handle());
-        //    }).then(arcana::inline_scheduler, m_cancellationSource, [this, thisRef = Napi::Persistent(info.Env())](const arcana::expected<void, std::exception_ptr>& result)
-        //    {
-        //        if (result.has_error())
-        //        {
-        //            Napi::Error::New(Env(), result.error()).ThrowAsJavaScriptException();
-        //        }
-        //    });
-        //});
+    void NativeEngine::CopyTexture(const Napi::CallbackInfo& info)
+    {
+        const auto textureDestination = info[0].As<Napi::Pointer<Graphics::Texture>>().Get();
+        const auto textureSource = info[1].As<Napi::Pointer<Graphics::Texture>>().Get();
+
+        arcana::make_task(m_update.Scheduler(), m_cancellationSource, [this, textureDestination, textureSource]() mutable
+        {
+            return arcana::make_task(m_runtimeScheduler.Get(), m_cancellationSource, [this, textureDestination, textureSource, updateToken = m_update.GetUpdateToken()]() mutable
+            {
+                bgfx::Encoder* encoder = updateToken.GetEncoder();
+                GetBoundFrameBuffer(*encoder).Blit(*encoder, textureDestination->Handle(), 0, 0, textureSource->Handle());
+            }).then(arcana::inline_scheduler, m_cancellationSource, [this](const arcana::expected<void, std::exception_ptr>& result)
+            {
+                if (result.has_error())
+                {
+                    Napi::Error::New(Env(), result.error()).ThrowAsJavaScriptException();
+                }
+            });
+        });
     }
 
     void NativeEngine::LoadRawTexture(const Napi::CallbackInfo& info)
diff --git a/Polyfills/Canvas/Source/Canvas.cpp b/Polyfills/Canvas/Source/Canvas.cpp
@@ -52,26 +52,27 @@ namespace Babylon::Polyfills::Internal
 
     Napi::Value NativeCanvas::LoadTTFAsync(const Napi::CallbackInfo& info)
     {
-        const auto fontName = info[0].As<Napi::String>().Utf8Value();
+        auto fontName = info[0].As<Napi::String>().Utf8Value();
         const auto buffer = info[1].As<Napi::ArrayBuffer>();
         std::vector<uint8_t> fontBuffer(buffer.ByteLength());
         memcpy(fontBuffer.data(), (uint8_t*)buffer.Data(), buffer.ByteLength());
 
         auto& runtime = JsRuntime::GetFromJavaScript(info.Env());
         auto deferred = Napi::Promise::Deferred::New(info.Env());
+        auto promise = deferred.Promise();
 
         auto& deviceContext = Graphics::DeviceContext::GetFromJavaScript(info.Env());
         auto update = deviceContext.GetUpdate("update");
-        arcana::make_task(update.Scheduler(), arcana::cancellation::none(), [fontName = std::move(fontName), fontData = std::move(fontBuffer), &runtime, deferred]()
+        arcana::make_task(update.Scheduler(), arcana::cancellation::none(), [fontName = std::move(fontName), fontData = std::move(fontBuffer), &runtime, deferred = std::move(deferred)]() mutable
         {
             fontsInfos[fontName] = fontData;
-            runtime.Dispatch([deferred](Napi::Env env)
+            runtime.Dispatch([deferred = std::move(deferred)](Napi::Env env)
             {
                 deferred.Resolve(env.Undefined());
             });
         });
 
-        return deferred.Promise();
+        return promise;
     }
 
     Napi::Value NativeCanvas::GetContext(const Napi::CallbackInfo& info)
diff --git a/Polyfills/Window/Source/TimeoutDispatcher.cpp b/Polyfills/Window/Source/TimeoutDispatcher.cpp
@@ -14,46 +14,29 @@ namespace Babylon::Polyfills::Internal
         }
     }
 
-    struct TimeoutDispatcher::Timeout
-    {
-        TimeoutId id;
-
-        // Make this non-shared when JsRuntime::Dispatch supports it.
-        std::shared_ptr<Napi::FunctionReference> function;
-
-        TimePoint time;
-
-        Timeout(TimeoutId id, std::shared_ptr<Napi::FunctionReference> function, TimePoint time)
-            : id{id}
-            , function{std::move(function)}
-            , time{time}
-        {
-        }
-
-        Timeout(const Timeout&) = delete;
-        Timeout(Timeout&&) = delete;
-    };
-
     TimeoutDispatcher::TimeoutDispatcher(Babylon::JsRuntime& runtime)
-        : m_runtime{runtime}
+        : m_runtimeScheduler{runtime}
         , m_thread{std::thread{&TimeoutDispatcher::ThreadFunction, this}}
     {
     }
 
     TimeoutDispatcher::~TimeoutDispatcher()
     {
         {
-            std::unique_lock<std::mutex> lk{m_mutex};
+            std::unique_lock<std::mutex> lock{m_mutex};
             m_idMap.clear();
             m_timeMap.clear();
         }
 
-        m_shutdown = true;
+        m_cancellationSource.cancel();
         m_condVariable.notify_one();
         m_thread.join();
+
+        // Wait for async operations to complete.
+        m_runtimeScheduler.Rundown();
     }
 
-    TimeoutDispatcher::TimeoutId TimeoutDispatcher::Dispatch(std::shared_ptr<Napi::FunctionReference> function, std::chrono::milliseconds delay)
+    TimeoutId TimeoutDispatcher::Dispatch(std::shared_ptr<Napi::FunctionReference> function, std::chrono::milliseconds delay)
     {
         if (delay.count() < 0)
         {
@@ -70,7 +53,8 @@ namespace Babylon::Polyfills::Internal
 
         if (time <= earliestTime)
         {
-            m_runtime.Dispatch([this](Napi::Env) {
+            m_runtimeScheduler.Get()([this]()
+            {
                 m_condVariable.notify_one();
             });
         }
@@ -102,7 +86,7 @@ namespace Babylon::Polyfills::Internal
         }
     }
 
-    TimeoutDispatcher::TimeoutId TimeoutDispatcher::NextTimeoutId()
+    TimeoutId TimeoutDispatcher::NextTimeoutId()
     {
         while (true)
         {
@@ -122,11 +106,11 @@ namespace Babylon::Polyfills::Internal
 
     void TimeoutDispatcher::ThreadFunction()
     {
-        while (!m_shutdown)
+        while (!m_cancellationSource.cancelled())
         {
-            std::unique_lock<std::mutex> lk{m_mutex};
-            TimePoint nextTimePoint{};
+            std::unique_lock<std::mutex> lock{m_mutex};
 
+            TimePoint nextTimePoint{};
             while (!m_timeMap.empty())
             {
                 nextTimePoint = m_timeMap.begin()->second->time;
@@ -135,7 +119,7 @@ namespace Babylon::Polyfills::Internal
                     break;
                 }
 
-                m_condVariable.wait_until(lk, nextTimePoint);
+                m_condVariable.wait_until(lock, nextTimePoint);
             }
 
             while (!m_timeMap.empty() && m_timeMap.begin()->second->time == nextTimePoint)
@@ -147,9 +131,9 @@ namespace Babylon::Polyfills::Internal
                 CallFunction(std::move(function));
             }
 
-            while (!m_shutdown && m_timeMap.empty())
+            while (!m_cancellationSource.cancelled() && m_timeMap.empty())
             {
-                m_condVariable.wait(lk);
+                m_condVariable.wait(lock);
             }
         }
     }
@@ -158,7 +142,10 @@ namespace Babylon::Polyfills::Internal
     {
         if (function)
         {
-            m_runtime.Dispatch([function = std::move(function)](Napi::Env) { function->Call({}); });
+            m_runtimeScheduler.Get()([function = std::move(function)]()
+            {
+                function->Call({});
+            });
         }
     }
 }
diff --git a/Polyfills/Window/Source/TimeoutDispatcher.h b/Polyfills/Window/Source/TimeoutDispatcher.h
diff --git a/Polyfills/Window/Source/Window.cpp b/Polyfills/Window/Source/Window.cpp
diff --git a/Polyfills/Window/Source/Window.h b/Polyfills/Window/Source/Window.h

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,8 @@ namespace Babylon`
`12`	`12`	`: m_workQueue{std::make_unique<WorkQueue>([this] { RunPlatformTier(); })}`
`13`	`13`	`, m_unhandledExceptionHandler{unhandledExceptionHandler}`
`14`	`14`	`{`
`15`		`- Dispatch([this](Napi::Env env) {`
	`15`	`+ Dispatch([this](Napi::Env env)`
	`16`	`+ {`
`16`	`17`	`JsRuntime::CreateForJavaScript(env, [this](auto func) { Dispatch(std::move(func)); });`
`17`	`18`	`});`
`18`	`19`	`}`
`@@ -45,8 +46,10 @@ namespace Babylon`
`45`	`46`
`46`	`47`	`void AppRuntime::Dispatch(Dispatchable<void(Napi::Env)> func)`
`47`	`48`	`{`
`48`		`- m_workQueue->Append([this, func{std::move(func)}](Napi::Env env) mutable {`
`49`		`- Execute([this, env, func{std::move(func)}]() mutable {`
	`49`	`+ m_workQueue->Append([this, func{std::move(func)}](Napi::Env env) mutable`
	`50`	`+ {`
	`51`	`+ Execute([this, env, func{std::move(func)}]() mutable`
	`52`	`+ {`
`50`	`53`	`try`
`51`	`54`	`{`
`52`	`55`	`func(env);`
Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,10 @@ namespace Babylon`
`48`	`48`	`m_dispatcher.blocking_tick(m_cancellationSource);`
`49`	`49`	`}`
`50`	`50`
`51`		`- // There should not be any outstanding work during the shutdown sequence`
`52`		`- // which should be the only way exit the while loop above.`
	`51`	`+ // Drain the queue to complete work dispatched after cancellation.`
	`52`	`+ m_dispatcher.tick(arcana::cancellation::none());`
	`53`	`+`
	`54`	`+ // There should no longer be any outstanding work once the queue is drained.`
`53`	`55`	`assert(m_dispatcher.empty());`
`54`	`56`	`}`
`55`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ namespace Babylon`
`22`	`22`	`if (m_cancellationSource.cancelled())`
`23`	`23`	`{`
`24`	`24`	`// There is likely a coding error if this exception is thrown.`
`25`		`- throw std::runtime_error{"Cannot append to the work queue after it is canceled"};`
	`25`	`+ throw std::runtime_error{"Cannot append to the work queue while shutting down"};`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`// Manual dispatcher queueing requires a copyable CallableT, we use a shared pointer trick to make a`
`@@ -55,6 +55,6 @@ namespace Babylon`
`55`	`55`	`arcana::cancellation_source m_cancellationSource{};`
`56`	`56`	`arcana::manual_dispatcher<128> m_dispatcher{};`
`57`	`57`
`58`		`- std::thread m_thread;`
	`58`	`+ std::thread m_thread{};`
`59`	`59`	`};`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#include "JsRuntime.h"`
	`2`	`+#include <cassert>`
`2`	`3`
`3`	`4`	`namespace Babylon`
`4`	`5`	`{`
`@@ -43,15 +44,27 @@ namespace Babylon`
`43`	`44`	`void JsRuntime::NotifyDisposing(JsRuntime& runtime)`
`44`	`45`	`{`
`45`	`46`	`auto callbacks = std::move(runtime.m_disposingCallbacks);`
`46`		`- for (const auto& callback : callbacks)`
	`47`	`+ for (auto* callback : callbacks)`
`47`	`48`	`{`
`48`		`- callback();`
	`49`	`+ callback->Disposing();`
`49`	`50`	`}`
`50`	`51`	`}`
`51`	`52`
`52`		`- void JsRuntime::RegisterDisposing(JsRuntime& runtime, std::function<void()> callback)`
	`53`	`+ void JsRuntime::RegisterDisposing(JsRuntime& runtime, IDisposingCallback* callback)`
`53`	`54`	`{`
`54`		`- runtime.m_disposingCallbacks.push_back(std::move(callback));`
	`55`	`+ auto& callbacks = runtime.m_disposingCallbacks;`
	`56`	`+ assert(std::find(callbacks.begin(), callbacks.end(), callback) == callbacks.end());`
	`57`	`+ callbacks.push_back(callback);`
	`58`	`+ }`
	`59`	`+`
	`60`	`+ void JsRuntime::UnregisterDisposing(JsRuntime& runtime, IDisposingCallback* callback)`
	`61`	`+ {`
	`62`	`+ auto& callbacks = runtime.m_disposingCallbacks;`
	`63`	`+ auto it = std::find(callbacks.begin(), callbacks.end(), callback);`
	`64`	`+ if (it != callbacks.end())`
	`65`	`+ {`
	`66`	`+ callbacks.erase(it);`
	`67`	`+ }`
`55`	`68`	`}`
`56`	`69`
`57`	`70`	`void JsRuntime::Dispatch(std::function<void(Napi::Env)> function)`
Original file line number	Diff line number	Diff line change
`@@ -14,46 +14,29 @@ namespace Babylon::Polyfills::Internal`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`17`		`- struct TimeoutDispatcher::Timeout`
`18`		`- {`
`19`		`- TimeoutId id;`
`20`		`-`
`21`		`- // Make this non-shared when JsRuntime::Dispatch supports it.`
`22`		`- std::shared_ptr<Napi::FunctionReference> function;`
`23`		`-`
`24`		`- TimePoint time;`
`25`		`-`
`26`		`- Timeout(TimeoutId id, std::shared_ptr<Napi::FunctionReference> function, TimePoint time)`
`27`		`- : id{id}`
`28`		`- , function{std::move(function)}`
`29`		`- , time{time}`
`30`		`- {`
`31`		`- }`
`32`		`-`
`33`		`- Timeout(const Timeout&) = delete;`
`34`		`- Timeout(Timeout&&) = delete;`
`35`		`- };`
`36`		`-`
`37`	`17`	`TimeoutDispatcher::TimeoutDispatcher(Babylon::JsRuntime& runtime)`
`38`		`- : m_runtime{runtime}`
	`18`	`+ : m_runtimeScheduler{runtime}`
`39`	`19`	`, m_thread{std::thread{&TimeoutDispatcher::ThreadFunction, this}}`
`40`	`20`	`{`
`41`	`21`	`}`
`42`	`22`
`43`	`23`	`TimeoutDispatcher::~TimeoutDispatcher()`
`44`	`24`	`{`
`45`	`25`	`{`
`46`		`- std::unique_lock<std::mutex> lk{m_mutex};`
	`26`	`+ std::unique_lock<std::mutex> lock{m_mutex};`
`47`	`27`	`m_idMap.clear();`
`48`	`28`	`m_timeMap.clear();`
`49`	`29`	`}`
`50`	`30`
`51`		`- m_shutdown = true;`
	`31`	`+ m_cancellationSource.cancel();`
`52`	`32`	`m_condVariable.notify_one();`
`53`	`33`	`m_thread.join();`
	`34`	`+`
	`35`	`+ // Wait for async operations to complete.`
	`36`	`+ m_runtimeScheduler.Rundown();`
`54`	`37`	`}`
`55`	`38`
`56`		`- TimeoutDispatcher::TimeoutId TimeoutDispatcher::Dispatch(std::shared_ptr<Napi::FunctionReference> function, std::chrono::milliseconds delay)`
	`39`	`+ TimeoutId TimeoutDispatcher::Dispatch(std::shared_ptr<Napi::FunctionReference> function, std::chrono::milliseconds delay)`
`57`	`40`	`{`
`58`	`41`	`if (delay.count() < 0)`
`59`	`42`	`{`
`@@ -70,7 +53,8 @@ namespace Babylon::Polyfills::Internal`
`70`	`53`
`71`	`54`	`if (time <= earliestTime)`
`72`	`55`	`{`
`73`		`- m_runtime.Dispatch([this](Napi::Env) {`
	`56`	`+ m_runtimeScheduler.Get()([this]()`
	`57`	`+ {`
`74`	`58`	`m_condVariable.notify_one();`
`75`	`59`	`});`
`76`	`60`	`}`
`@@ -102,7 +86,7 @@ namespace Babylon::Polyfills::Internal`
`102`	`86`	`}`
`103`	`87`	`}`
`104`	`88`
`105`		`- TimeoutDispatcher::TimeoutId TimeoutDispatcher::NextTimeoutId()`
	`89`	`+ TimeoutId TimeoutDispatcher::NextTimeoutId()`
`106`	`90`	`{`
`107`	`91`	`while (true)`
`108`	`92`	`{`
`@@ -122,11 +106,11 @@ namespace Babylon::Polyfills::Internal`
`122`	`106`
`123`	`107`	`void TimeoutDispatcher::ThreadFunction()`
`124`	`108`	`{`
`125`		`- while (!m_shutdown)`
	`109`	`+ while (!m_cancellationSource.cancelled())`
`126`	`110`	`{`
`127`		`- std::unique_lock<std::mutex> lk{m_mutex};`
`128`		`- TimePoint nextTimePoint{};`
	`111`	`+ std::unique_lock<std::mutex> lock{m_mutex};`
`129`	`112`
	`113`	`+ TimePoint nextTimePoint{};`
`130`	`114`	`while (!m_timeMap.empty())`
`131`	`115`	`{`
`132`	`116`	`nextTimePoint = m_timeMap.begin()->second->time;`
`@@ -135,7 +119,7 @@ namespace Babylon::Polyfills::Internal`
`135`	`119`	`break;`
`136`	`120`	`}`
`137`	`121`
`138`		`- m_condVariable.wait_until(lk, nextTimePoint);`
	`122`	`+ m_condVariable.wait_until(lock, nextTimePoint);`
`139`	`123`	`}`
`140`	`124`
`141`	`125`	`while (!m_timeMap.empty() && m_timeMap.begin()->second->time == nextTimePoint)`
`@@ -147,9 +131,9 @@ namespace Babylon::Polyfills::Internal`
`147`	`131`	`CallFunction(std::move(function));`
`148`	`132`	`}`
`149`	`133`
`150`		`- while (!m_shutdown && m_timeMap.empty())`
	`134`	`+ while (!m_cancellationSource.cancelled() && m_timeMap.empty())`
`151`	`135`	`{`
`152`		`- m_condVariable.wait(lk);`
	`136`	`+ m_condVariable.wait(lock);`
`153`	`137`	`}`
`154`	`138`	`}`
`155`	`139`	`}`
`@@ -158,7 +142,10 @@ namespace Babylon::Polyfills::Internal`
`158`	`142`	`{`
`159`	`143`	`if (function)`
`160`	`144`	`{`
`161`		`- m_runtime.Dispatch([function = std::move(function)](Napi::Env) { function->Call({}); });`
	`145`	`+ m_runtimeScheduler.Get()([function = std::move(function)]()`
	`146`	`+ {`
	`147`	`+ function->Call({});`
	`148`	`+ });`
`162`	`149`	`}`
`163`	`150`	`}`
`164`	`151`	`}`