[browser][coreCLR] finalizer on a browser event loop

src/coreclr/vm/ceemain.cpp

@@ -922,8 +922,8 @@ void EEStartupHelper()
         // right before doing HasStarted(). We will release it now.
         FinalizerThread::EnableFinalization();
 #elif defined(TARGET_WASM)
-        // on wasm we need to run finalizers on main thread as we are single threaded
-        // active issue: https://github.com/dotnet/runtime/issues/114096
+        // On wasm this schedules finalization onto the browser event loop.
+        FinalizerThread::EnableFinalization();
 #else
         // This isn't done as part of InitializeGarbageCollector() above because
         // debugger must be initialized before creating EE thread objects

src/coreclr/vm/finalizerthread.cpp

@@ -40,12 +40,54 @@ bool FinalizerThread::IsCurrentThreadFinalizer()
     return GetThreadNULLOk() == g_pFinalizerThread;
 }
 
+#ifdef TARGET_WASM
+
+extern "C" void SystemJS_ScheduleFinalization();
+extern "C"
+{
+    void SystemJS_ExecuteFinalizationCallback()
+    {
+        CONTRACTL
+        {
+            NOTHROW;
+            GC_TRIGGERS;
+            ENTRY_POINT;  // This is called by a host.
+        }
+        CONTRACTL_END;
+
+        HRESULT hr=S_OK;
+
+        BEGIN_EXTERNAL_ENTRYPOINT(&hr);
+
+        EX_TRY
+        {
+            GCX_COOP();
+            FinalizerThread::FinalizerThreadWorkerIteration();
+        }
+        EX_HOOK
+        {
+            Exception *ex = GET_EXCEPTION();
+            SString err;
+            ex->GetMessage(err);
+            LogErrorToHost("Error message: %s", err.GetUTF8());
+            abort();
+        }
+        EX_END_HOOK;
+
+        END_EXTERNAL_ENTRYPOINT;
+    }
+}
+
+#endif // !TARGET_WASM
+
 void FinalizerThread::EnableFinalization()
 {
     WRAPPER_NO_CONTRACT;
 
 #ifndef TARGET_WASM
     hEventFinalizer->Set();
+#else  // !TARGET_WASM
+    SystemJS_ScheduleFinalization();
 #endif // !TARGET_WASM
 }
 
@@ -379,123 +421,148 @@ void FinalizerThread::WaitForFinalizerEvent (CLREvent *event)
 
 static BOOL s_FinalizerThreadOK = FALSE;
 static BOOL s_InitializedFinalizerThreadForPlatform = FALSE;
+static BOOL s_PriorityBoosted = FALSE;
 
 VOID FinalizerThread::FinalizerThreadWorker(void *args)
 {
-    BOOL bPriorityBoosted = FALSE;
 
     while (!fQuitFinalizer)
     {
-        // Wait for work to do...
+        FinalizerThread::FinalizerThreadWorkerIteration();
+    }
+
+    if (s_InitializedFinalizerThreadForPlatform)
+        Thread::CleanUpForManagedThreadInNative(GetFinalizerThread());
+}
+
+VOID FinalizerThread::FinalizerThreadWorkerIteration()
+{
+#ifndef TARGET_WASM
+    // Wait for work to do...
 
-        _ASSERTE(GetFinalizerThread()->PreemptiveGCDisabled());
 #ifdef _DEBUG
-        if (g_pConfig->FastGCStressLevel())
-        {
-            GetFinalizerThread()->m_GCOnTransitionsOK = FALSE;
-        }
+    if (g_pConfig->FastGCStressLevel())
+    {
+        GetFinalizerThread()->m_GCOnTransitionsOK = FALSE;
+    }
 #endif
-        GetFinalizerThread()->EnablePreemptiveGC();
+    GetFinalizerThread()->EnablePreemptiveGC();
 #ifdef _DEBUG
-        if (g_pConfig->FastGCStressLevel())
-        {
-            GetFinalizerThread()->m_GCOnTransitionsOK = TRUE;
-        }
+    if (g_pConfig->FastGCStressLevel())
+    {
+        GetFinalizerThread()->m_GCOnTransitionsOK = TRUE;
+    }
 #endif
 #if 0
-        // Setting the event here, instead of at the bottom of the loop, could
-        // cause us to skip draining the Q, if the request is made as soon as
-        // the app starts running.
-        SignalFinalizationDone();
+    // Setting the event here, instead of at the bottom of the loop, could
+    // cause us to skip draining the Q, if the request is made as soon as
+    // the app starts running.
+    SignalFinalizationDone();
 #endif //0
 
-        WaitForFinalizerEvent (hEventFinalizer);
+    WaitForFinalizerEvent (hEventFinalizer);
 
-        // Process pending finalizer work items from the GC first.
-        FinalizerWorkItem* pWork = GCHeapUtilities::GetGCHeap()->GetExtraWorkForFinalization();
-        while (pWork != NULL)
-        {
-            FinalizerWorkItem* pNext = pWork->next;
-            pWork->callback(pWork);
-            pWork = pNext;
-        }
+    // Process pending finalizer work items from the GC first.
+    FinalizerWorkItem* pWork = GCHeapUtilities::GetGCHeap()->GetExtraWorkForFinalization();
+    while (pWork != NULL)
+    {
+        FinalizerWorkItem* pNext = pWork->next;
+        pWork->callback(pWork);
+        pWork = pNext;
+    }
 
 #if defined(__linux__) && defined(FEATURE_EVENT_TRACE)
-        if (g_TriggerHeapDump && (minipal_lowres_ticks() > (LastHeapDumpTime + LINUX_HEAP_DUMP_TIME_OUT)))
-        {
-            s_forcedGCInProgress = true;
-            GetFinalizerThread()->DisablePreemptiveGC();
-            GCHeapUtilities::GetGCHeap()->GarbageCollect(2, false, collection_blocking);
-            GetFinalizerThread()->EnablePreemptiveGC();
-            s_forcedGCInProgress = false;
+    if (g_TriggerHeapDump && (minipal_lowres_ticks() > (LastHeapDumpTime + LINUX_HEAP_DUMP_TIME_OUT)))
+    {
+        s_forcedGCInProgress = true;
+        GetFinalizerThread()->DisablePreemptiveGC();
+        GCHeapUtilities::GetGCHeap()->GarbageCollect(2, false, collection_blocking);
+        GetFinalizerThread()->EnablePreemptiveGC();
+        s_forcedGCInProgress = false;
 
-            LastHeapDumpTime = minipal_lowres_ticks();
-            g_TriggerHeapDump = FALSE;
-        }
+        LastHeapDumpTime = minipal_lowres_ticks();
+        g_TriggerHeapDump = FALSE;
+    }
 #endif
-        if (gcGenAnalysisState == GcGenAnalysisState::Done)
+    if (gcGenAnalysisState == GcGenAnalysisState::Done)
+    {
+        gcGenAnalysisState = GcGenAnalysisState::Disabled;
+        if (gcGenAnalysisTrace)
         {
-            gcGenAnalysisState = GcGenAnalysisState::Disabled;
-            if (gcGenAnalysisTrace)
-            {
 #ifdef FEATURE_PERFTRACING
-                EventPipeAdapter::Disable(gcGenAnalysisEventPipeSessionId);
+            EventPipeAdapter::Disable(gcGenAnalysisEventPipeSessionId);
 #ifdef GEN_ANALYSIS_STRESS
-                GenAnalysis::EnableGenerationalAwareSession();
+            GenAnalysis::EnableGenerationalAwareSession();
 #endif //GEN_ANALYSIS_STRESS
 #endif //FEATURE_PERFTRACING
-            }
-
-            // Writing an empty file to indicate completion
-            WCHAR outputPath[MAX_PATH];
-            ReplacePid(GENAWARE_COMPLETION_FILE_NAME, outputPath, MAX_PATH);
-            FILE* fp = NULL;
-            if (fopen_lp(&fp, outputPath, W("w+")) == 0)
-            {
-                fclose(fp);
-            }
         }
 
-        if (!bPriorityBoosted)
+        // Writing an empty file to indicate completion
+        WCHAR outputPath[MAX_PATH];
+        ReplacePid(GENAWARE_COMPLETION_FILE_NAME, outputPath, MAX_PATH);
+        FILE* fp = NULL;
+        if (fopen_lp(&fp, outputPath, W("w+")) == 0)
         {
-            if (GetFinalizerThread()->SetThreadPriority(THREAD_PRIORITY_HIGHEST))
-                bPriorityBoosted = TRUE;
+            fclose(fp);
         }
+    }
 
-        // The Finalizer thread is started very early in EE startup. We deferred
-        // some initialization until a point we are sure the EE is up and running. At
-        // this point we make a single attempt and if it fails won't try again.
-        if (!s_InitializedFinalizerThreadForPlatform)
-        {
-            s_InitializedFinalizerThreadForPlatform = TRUE;
-            Thread::InitializationForManagedThreadInNative(GetFinalizerThread());
-        }
+    if (!s_PriorityBoosted)
+    {
+        if (GetFinalizerThread()->SetThreadPriority(THREAD_PRIORITY_HIGHEST))
+            s_PriorityBoosted = TRUE;
+    }
 
-        JitHost::Reclaim();
+    // The Finalizer thread is started very early in EE startup. We deferred
+    // some initialization until a point we are sure the EE is up and running. At
+    // this point we make a single attempt and if it fails won't try again.
+    if (!s_InitializedFinalizerThreadForPlatform)
+    {
+        s_InitializedFinalizerThreadForPlatform = TRUE;
+        Thread::InitializationForManagedThreadInNative(GetFinalizerThread());
+    }
 
-        GetFinalizerThread()->DisablePreemptiveGC();
+    JitHost::Reclaim();
 
-        // we might want to do some extra work on the finalizer thread
-        // check and do it
-        if (HaveExtraWorkForFinalizer())
-        {
-            DoExtraWorkForFinalizer(GetFinalizerThread());
-        }
-        LOG((LF_GC, LL_INFO100, "***** Calling Finalizers\n"));
+    GetFinalizerThread()->DisablePreemptiveGC();
 
-        int observedFullGcCount =
-            GCHeapUtilities::GetGCHeap()->CollectionCount(GCHeapUtilities::GetGCHeap()->GetMaxGeneration());
-        FinalizeAllObjects();
+    // we might want to do some extra work on the finalizer thread
+    // check and do it
+    if (HaveExtraWorkForFinalizer())
+    {
+        DoExtraWorkForFinalizer(GetFinalizerThread());
+    }
+    LOG((LF_GC, LL_INFO100, "***** Calling Finalizers\n"));
+
+    int observedFullGcCount =
+        GCHeapUtilities::GetGCHeap()->CollectionCount(GCHeapUtilities::GetGCHeap()->GetMaxGeneration());
+    FinalizeAllObjects();
 
-        // Anyone waiting to drain the Q can now wake up.  Note that there is a
-        // race in that another thread starting a drain, as we leave a drain, may
-        // consider itself satisfied by the drain that just completed.
-        // Thus we include the Full GC count that we have certaily observed.
-        SignalFinalizationDone(observedFullGcCount);
+    // Anyone waiting to drain the Q can now wake up.  Note that there is a
+    // race in that another thread starting a drain, as we leave a drain, may
+    // consider itself satisfied by the drain that just completed.
+    // Thus we include the Full GC count that we have certaily observed.
+    SignalFinalizationDone(observedFullGcCount);
+
+#else // !TARGET_WASM
+
+    // Process pending finalizer work items from the GC first.
+    FinalizerWorkItem* pWork = GCHeapUtilities::GetGCHeap()->GetExtraWorkForFinalization();
+    while (pWork != NULL)
+    {
+        FinalizerWorkItem* pNext = pWork->next;
+        pWork->callback(pWork);
+        pWork = pNext;
     }
 
-    if (s_InitializedFinalizerThreadForPlatform)
-        Thread::CleanUpForManagedThreadInNative(GetFinalizerThread());
+    JitHost::Reclaim();
+
+    LOG((LF_GC, LL_INFO100, "***** Calling Finalizers\n"));
+
+    int observedFullGcCount =
+        GCHeapUtilities::GetGCHeap()->CollectionCount(GCHeapUtilities::GetGCHeap()->GetMaxGeneration());
+    FinalizeAllObjects();
+#endif // !TARGET_WASM
 }
 
 DWORD WINAPI FinalizerThread::FinalizerThreadStart(void *args)

src/coreclr/vm/finalizerthread.h

@@ -62,6 +62,9 @@ class FinalizerThread
     static void SignalFinalizationDone(int observedFullGcCount);
 
     static VOID FinalizerThreadWorker(void *args);
+
+    static VOID FinalizerThreadWorkerIteration();
+
     static DWORD WINAPI FinalizerThreadStart(void *args);
 
     static void FinalizerThreadCreate();

src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs

@@ -232,8 +232,7 @@ private static bool GetLinqExpressionsBuiltWithIsInterpretingOnly()
         // heavily on Reflection.Emit
         public static bool IsXmlDsigXsltTransformSupported => !PlatformDetection.IsInAppContainer && IsReflectionEmitSupported;
 
-        public static bool IsPreciseGcSupported => !IsMonoRuntime 
-                                                    && !IsBrowser; // TODO-WASM: https://github.com/dotnet/runtime/issues/114096
+        public static bool IsPreciseGcSupported => !IsMonoRuntime;
 
         public static bool IsRareEnumsSupported => !IsNativeAot;
 

src/native/libs/Common/JavaScript/types/ems-ambient.ts

@@ -27,6 +27,7 @@ export type EmsAmbientSymbolsType = EmscriptenModuleInternal & {
     _GetDotNetRuntimeContractDescriptor: () => void;
     _SystemJS_ExecuteTimerCallback: () => void;
     _SystemJS_ExecuteBackgroundJobCallback: () => void;
+    _SystemJS_ExecuteFinalizationCallback: () => void;
     _BrowserHost_CreateHostContract: () => VoidPtr;
     _BrowserHost_InitializeCoreCLR: (propertiesCount: number, propertyKeys: CharPtrPtr, propertyValues: CharPtrPtr) => number;
     _BrowserHost_ExecuteAssembly: (mainAssemblyNamePtr: number, argsLength: number, argsPtr: number) => number;

src/native/libs/System.Native.Browser/libSystem.Native.Browser.footer.js

@@ -21,7 +21,9 @@
 
         let commonDeps = [
             "$BROWSER_UTILS",
-            "SystemJS_ExecuteTimerCallback", "SystemJS_ExecuteBackgroundJobCallback"
+            "SystemJS_ExecuteTimerCallback",
+            "SystemJS_ExecuteBackgroundJobCallback",
+            "SystemJS_ExecuteFinalizationCallback",
         ];
         const lib = {
             $DOTNET: {

src/native/libs/System.Native.Browser/native/index.ts

@@ -10,7 +10,7 @@ import GitHash from "consts:gitHash";
 export { SystemJS_RandomBytes } from "./crypto";
 export { SystemJS_GetLocaleInfo } from "./globalization-locale";
 export { SystemJS_RejectMainPromise, SystemJS_ResolveMainPromise, SystemJS_ConsoleClear } from "./main";
-export { SystemJS_ScheduleTimer, SystemJS_ScheduleBackgroundJob } from "./scheduling";
+export { SystemJS_ScheduleTimer, SystemJS_ScheduleBackgroundJob, SystemJS_ScheduleFinalization } from "./scheduling";
 
 export const gitHash = GitHash;
 export function dotnetInitializeModule(internals: InternalExchange): void {

src/native/libs/System.Native.Browser/native/scheduling.ts

@@ -30,3 +30,17 @@ export function SystemJS_ScheduleBackgroundJob(): void {
         _ems_._SystemJS_ExecuteBackgroundJobCallback();
     }
 }
+
+export function SystemJS_ScheduleFinalization(): void {
+    if (_ems_.DOTNET.lastScheduledFinalizationId) {
+        globalThis.clearTimeout(_ems_.DOTNET.lastScheduledFinalizationId);
+        _ems_.runtimeKeepalivePop();
+        _ems_.DOTNET.lastScheduledFinalizationId = undefined;
+    }
+    _ems_.DOTNET.lastScheduledFinalizationId = _ems_.safeSetTimeout(SystemJS_ScheduleFinalizationTick, 0);
+
+    function SystemJS_ScheduleFinalizationTick(): void {
+        _ems_.DOTNET.lastScheduledFinalizationId = undefined;
+        _ems_._SystemJS_ExecuteFinalizationCallback();
+    }
+}

src/native/libs/System.Native.Browser/utils/host.ts

@@ -28,6 +28,11 @@ export function abortBackgroundTimers(): void {
         _ems_.runtimeKeepalivePop();
         _ems_.DOTNET.lastScheduledThreadPoolId = undefined;
     }
+    if (_ems_.DOTNET.lastScheduledFinalizationId) {
+        globalThis.clearTimeout(_ems_.DOTNET.lastScheduledFinalizationId);
+        _ems_.runtimeKeepalivePop();
+        _ems_.DOTNET.lastScheduledFinalizationId = undefined;
+    }
 }
 
 export function abortPosix(exitCode: number): void {