[browser] wasm memory snapshot into browser cache

src/mono/mono/mini/interp/jiterpreter.c

@@ -1075,6 +1075,9 @@ mono_jiterp_update_jit_call_dispatcher (WasmDoJitCall dispatcher)
 	//  blocked the use of Module.addFunction
 	if (!dispatcher)
 		dispatcher = (WasmDoJitCall)mono_llvm_cpp_catch_exception;
+	else if (((int)(void*)dispatcher)==-1)
+		dispatcher = mono_jiterp_do_jit_call_indirect;
+
 	jiterpreter_do_jit_call = dispatcher;
 }
 

src/mono/sample/wasm/browser-advanced/index.html

@@ -11,6 +11,7 @@
   <script type='module' src="./dotnet.js"></script>
   <link rel="preload" href="./mono-config.json" as="fetch" crossorigin="anonymous">
   <link rel="prefetch" href="./dotnet.wasm" as="fetch" crossorigin="anonymous">
+  <!-- users should consider if they optimize for the first load or subsequent load from memory snapshot -->
   <link rel="prefetch" href="./icudt.dat" as="fetch" crossorigin="anonymous">
   <link rel="prefetch" href="./managed/System.Private.CoreLib.webcil" as="fetch" crossorigin="anonymous">
 </head>

src/mono/sample/wasm/browser-bench/appstart-frame.html

@@ -11,6 +11,7 @@
   <script type='module' src="./dotnet.js"></script>
   <link rel="preload" href="./mono-config.json" as="fetch" crossorigin="anonymous">
   <link rel="prefetch" href="./dotnet.wasm" as="fetch" crossorigin="anonymous">
+  <!-- users should consider if they optimize for the first load or subsequent load from memory snapshot -->
   <link rel="prefetch" href="./icudt.dat" as="fetch" crossorigin="anonymous">
   <link rel="prefetch" href="./managed/System.Private.CoreLib.dll" as="fetch" crossorigin="anonymous">
 </head>

src/mono/wasm/build/WasmApp.targets

@@ -364,7 +364,7 @@
     <PropertyGroup>
       <_WasmAppIncludeThreadsWorker Condition="'$(WasmEnableThreads)' == 'true' or '$(WasmEnablePerfTracing)' == 'true'">true</_WasmAppIncludeThreadsWorker>
       <!-- TODO: set this from some user-facing property?  -1 means use the default baked into dotnet.js -->
-      <_WasmPThreadPoolSize Condition="'$(_WasmPThreadPoolSize)' == '' and ('$(WasmEnableThreads)' == 'true' or '$(WasmEnablePerfTracing)' == 'true')">-1</_WasmPThreadPoolSize>
+      <_WasmPThreadPoolSize Condition="'$(_WasmPThreadPoolSize)' == ''">-1</_WasmPThreadPoolSize>
     </PropertyGroup>
 
     <ItemGroup>

src/mono/wasm/memory-snapshot.md

@@ -0,0 +1,27 @@
+# Memory snapshot of the Mono runtime #
+
+We take snapshot of WASM memory after first cold start at run time​.
+We store it on the client side in the browser cache.
+For subsequent runs with the same configuration and same assets, we use the snapshot .
+instead of downloading everything again and doing the runtime startup again.
+These subsequent starts are significantly faster.
+
+### Implementation details
+
+- the consistency of inputs (configuration and assets) with the snapshot is done by calculating SHA256 of the inputs.
+    - the DLLs and other downloaded assets each have SHA256 which is used to validate 'integrity' by the browser.
+    - the mono-config has field `assetsHash` which is summary SHA256 of all the assets.
+    - the configuration could be changed programmatically and so we calculate the hash at the runtime, just before taking snapshot.
+- the snapshot is taken just after we initialize the Mono runtime.
+    - before cwraps are initialized (they would be initialized again on subsequent start).
+    - after loading all the DLLs into memory.
+    - after loading ICU and timezone data.
+    - after applying environment variables and other runtime options.
+    - before any worker threads initialization.
+    - before any JavaScript interop initialization.
+    - before any Managed code executes.
+    - therefore we do not expect to store any application state in the snapshot.
+
+### How to opt out
+You can turn this feature of by calling `withStartupMemoryCache (false)` on [dotnet API](https://github.com/dotnet/runtime/blob/main/src/mono/wasm/runtime/dotnet.d.ts).
+

src/mono/wasm/runtime/assets.ts

@@ -8,7 +8,7 @@ import { mono_wasm_load_bytes_into_heap } from "./memory";
 import { endMeasure, MeasuredBlock, startMeasure } from "./profiler";
 import { createPromiseController, PromiseAndController } from "./promise-controller";
 import { delay } from "./promise-utils";
-import { abort_startup, beforeOnRuntimeInitialized } from "./startup";
+import { abort_startup, beforeOnRuntimeInitialized, memorySnapshotSkippedOrDone } from "./startup";
 import { AssetBehaviours, AssetEntry, AssetEntryInternal, LoadingResource, mono_assert, ResourceRequest } from "./types";
 import { InstantiateWasmSuccessCallback, VoidPtr } from "./types/emscripten";
 
@@ -38,6 +38,19 @@ const skipBufferByAssetTypes: {
     "dotnetwasm": true,
 };
 
+const containedInSnapshotByAssetTypes: {
+    [k: string]: boolean
+} = {
+    "resource": true,
+    "assembly": true,
+    "pdb": true,
+    "heap": true,
+    "icu": true,
+    "js-module-threads": true,
+    "dotnetwasm": true,
+};
+
+
 // these assets are instantiated differently than the main flow
 const skipInstantiateByAssetTypes: {
     [k: string]: boolean
@@ -63,8 +76,10 @@ export async function mono_download_assets(): Promise<void> {
     runtimeHelpers.maxParallelDownloads = runtimeHelpers.config.maxParallelDownloads || runtimeHelpers.maxParallelDownloads;
     runtimeHelpers.enableDownloadRetry = runtimeHelpers.config.enableDownloadRetry || runtimeHelpers.enableDownloadRetry;
     try {
+        const alwaysLoadedAssets: AssetEntryInternal[] = [];
+        const containedInSnapshotAssets: AssetEntryInternal[] = [];
         const promises_of_assets: Promise<AssetEntryInternal>[] = [];
-        // start fetching and instantiating all assets in parallel
+
         for (const a of runtimeHelpers.config.assets!) {
             const asset: AssetEntryInternal = a;
             mono_assert(typeof asset === "object", "asset must be object");
@@ -73,14 +88,51 @@ export async function mono_download_assets(): Promise<void> {
             mono_assert(!asset.resolvedUrl || typeof asset.resolvedUrl === "string", "asset resolvedUrl could be string");
             mono_assert(!asset.hash || typeof asset.hash === "string", "asset resolvedUrl could be string");
             mono_assert(!asset.pendingDownload || typeof asset.pendingDownload === "object", "asset pendingDownload could be object");
+            if (containedInSnapshotByAssetTypes[asset.behavior]) {
+                containedInSnapshotAssets.push(asset);
+            } else {
+                alwaysLoadedAssets.push(asset);
+            }
+        }
+
+        const countAndStartDownload = (asset: AssetEntryInternal) => {
             if (!skipInstantiateByAssetTypes[asset.behavior] && shouldLoadIcuAsset(asset)) {
                 expected_instantiated_assets_count++;
             }
             if (!skipDownloadsByAssetTypes[asset.behavior] && shouldLoadIcuAsset(asset)) {
                 expected_downloaded_assets_count++;
                 promises_of_assets.push(start_asset_download(asset));
             }
+        };
+
+        // start fetching and assets in parallel, only assets which are not part of memory snapshot
+        for (const asset of alwaysLoadedAssets) {
+            countAndStartDownload(asset);
+        }
+
+        // continue after we know if memory snapshot is available or not
+        await memorySnapshotSkippedOrDone.promise;
+
+        // start fetching and assets in parallel, only if memory snapshot is not available.
+        for (const asset of containedInSnapshotAssets) {
+            if (!runtimeHelpers.loadedMemorySnapshot) {
+                countAndStartDownload(asset);
+            } else {
+                // Otherwise cleanup in case we were given pending download. It would be even better if we could abort the download.
+                asset.pendingDownloadInternal = null as any; // GC
+                asset.pendingDownload = null as any; // GC
+                asset.buffer = null as any; // GC
+                // tell the debugger it is loaded
+                if (asset.behavior == "resource" || asset.behavior == "assembly" || asset.behavior == "pdb") {
+                    const url = resolve_path(asset, "");
+                    const virtualName: string = typeof (asset.virtualPath) === "string"
+                        ? asset.virtualPath
+                        : asset.name;
+                    loaded_files.push({ url: url, file: virtualName });
+                }
+            }
         }
+
         allDownloadsQueued.promise_control.resolve();
 
         const promises_of_asset_instantiation: Promise<void>[] = [];
@@ -96,8 +148,9 @@ export async function mono_download_assets(): Promise<void> {
                         asset.pendingDownload = null as any; // GC
                         asset.buffer = null as any; // GC
 
+                        // wait till after onRuntimeInitialized and after memory snapshot is loaded or skipped
+                        await memorySnapshotSkippedOrDone.promise;
                         await beforeOnRuntimeInitialized.promise;
-                        // this is after onRuntimeInitialized
                         _instantiate_asset(asset, url, data);
                     }
                 } else {

src/mono/wasm/runtime/diagnostics/server_pthread/index.ts

@@ -230,7 +230,7 @@ class DiagnosticServerImpl implements DiagnosticServer {
     }
 
     async stopEventPipe(ws: WebSocket | MockRemoteSocket, sessionID: EventPipeSessionIDImpl): Promise<void> {
-        console.info("MONO_WASM: stopEventPipe", sessionID);
+        console.debug("MONO_WASM: stopEventPipe", sessionID);
         cwraps.mono_wasm_event_pipe_session_disable(sessionID);
         // we might send OK before the session is actually stopped since the websocket is async
         // but the client end should be robust to that.
@@ -266,7 +266,7 @@ class DiagnosticServerImpl implements DiagnosticServer {
 
     resumeRuntime(): void {
         if (!this.runtimeResumed) {
-            console.info("MONO_WASM: resuming runtime startup");
+            console.debug("MONO_WASM: resuming runtime startup");
             cwraps.mono_wasm_diagnostic_server_post_resume_runtime();
             this.runtimeResumed = true;
         }

src/mono/wasm/runtime/dotnet.d.ts

@@ -18,6 +18,7 @@ interface DotnetHostBuilder {
     withDebugging(level: number): DotnetHostBuilder;
     withMainAssembly(mainAssemblyName: string): DotnetHostBuilder;
     withApplicationArgumentsFromQuery(): DotnetHostBuilder;
+    withStartupMemoryCache(value: boolean): DotnetHostBuilder;
     create(): Promise<RuntimeAPI>;
     run(): Promise<number>;
 }
@@ -38,6 +39,7 @@ declare interface EmscriptenModule {
     HEAP8: Int8Array;
     HEAP16: Int16Array;
     HEAP32: Int32Array;
+    HEAP64: BigInt64Array;
     HEAPU8: Uint8Array;
     HEAPU16: Uint16Array;
     HEAPU32: Uint32Array;
@@ -128,6 +130,10 @@ type MonoConfig = {
      * initial number of workers to add to the emscripten pthread pool
      */
     pthreadPoolSize?: number;
+    /**
+     * If true, the snapshot of runtime's memory will be stored in the browser and used for faster startup next time. Default is true.
+     */
+    startupMemoryCache?: boolean;
     /**
      * hash of assets
      */

src/mono/wasm/runtime/icu.ts

@@ -5,53 +5,50 @@ import cwraps from "./cwraps";
 import { Module, runtimeHelpers } from "./imports";
 import { VoidPtr } from "./types/emscripten";
 
-let num_icu_assets_loaded_successfully = 0;
-
 // @offset must be the address of an ICU data archive in the native heap.
 // returns true on success.
 export function mono_wasm_load_icu_data(offset: VoidPtr): boolean {
-    const ok = (cwraps.mono_wasm_load_icu_data(offset)) === 1;
-    if (ok)
-        num_icu_assets_loaded_successfully++;
-    return ok;
+    return (cwraps.mono_wasm_load_icu_data(offset)) === 1;
 }
 
-// Performs setup for globalization.
-// @globalizationMode is one of "icu", "invariant", or "auto".
-// "auto" will use "icu" if any ICU data archives have been loaded,
-//  otherwise "invariant".
-export function mono_wasm_globalization_init(): void {
-    const config = runtimeHelpers.config;
-    let invariantMode = false;
-    if (!config.globalizationMode)
-        config.globalizationMode = "auto";
-    if (config.globalizationMode === "invariant")
-        invariantMode = true;
+export function init_globalization() {
+    runtimeHelpers.invariantMode = runtimeHelpers.config.globalizationMode === "invariant";
+    runtimeHelpers.preferredIcuAsset = get_preferred_icu_asset();
 
-    if (!invariantMode) {
-        if (num_icu_assets_loaded_successfully > 0) {
-            if (runtimeHelpers.diagnosticTracing) {
-                console.debug("MONO_WASM: ICU data archive(s) loaded, disabling invariant mode");
-            }
-        } else if (config.globalizationMode !== "icu") {
-            if (runtimeHelpers.diagnosticTracing) {
-                console.debug("MONO_WASM: ICU data archive(s) not loaded, using invariant globalization mode");
-            }
-            invariantMode = true;
+    if (!runtimeHelpers.invariantMode) {
+        if (runtimeHelpers.preferredIcuAsset) {
+            if (runtimeHelpers.diagnosticTracing) console.debug("MONO_WASM: ICU data archive(s) available, disabling invariant mode");
+        } else if (runtimeHelpers.config.globalizationMode !== "icu") {
+            if (runtimeHelpers.diagnosticTracing) console.debug("MONO_WASM: ICU data archive(s) not available, using invariant globalization mode");
+            runtimeHelpers.invariantMode = true;
+            runtimeHelpers.preferredIcuAsset = null;
         } else {
-            const msg = "invariant globalization mode is inactive and no ICU data archives were loaded";
+            const msg = "invariant globalization mode is inactive and no ICU data archives are available";
             Module.err(`MONO_WASM: ERROR: ${msg}`);
             throw new Error(msg);
         }
     }
 
-    if (invariantMode) {
-        cwraps.mono_wasm_setenv("DOTNET_SYSTEM_GLOBALIZATION_INVARIANT", "1");
+    const invariantEnv = "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT";
+    const env_variables = runtimeHelpers.config.environmentVariables!;
+    if (env_variables[invariantEnv] === undefined && runtimeHelpers.invariantMode) {
+        env_variables[invariantEnv] = "1";
+    }
+    if (env_variables["TZ"] === undefined) {
+        try {
+            // this call is relatively expensive, so we call it during download of other assets
+            const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || null;
+            if (timezone) {
+                env_variables!["TZ"] = timezone;
+            }
+        } catch {
+            console.info("MONO_WASM: failed to detect timezone, will fallback to UTC");
+        }
     }
 }
 
 export function get_preferred_icu_asset(): string | null {
-    if (!runtimeHelpers.config.assets)
+    if (!runtimeHelpers.config.assets || runtimeHelpers.invariantMode)
         return null;
 
     // By setting <WasmIcuDataFileName> user can define what ICU source file they want to load.

src/mono/wasm/runtime/jiterpreter-jit-call.ts

@@ -3,7 +3,7 @@
 
 import { mono_assert, MonoType, MonoMethod } from "./types";
 import { NativePointer, Int32Ptr, VoidPtr } from "./types/emscripten";
-import { Module } from "./imports";
+import { Module, runtimeHelpers } from "./imports";
 import {
     getU8, getI32_unaligned, getU32_unaligned, setU32_unchecked
 } from "./memory";
@@ -256,6 +256,7 @@ function getIsWasmEhSupported () : boolean {
 export function mono_jiterp_do_jit_call_indirect (
     jit_call_cb: number, cb_data: VoidPtr, thrown: Int32Ptr
 ) : void {
+    mono_assert(!runtimeHelpers.storeMemorySnapshotPending, "Attempting to set function into table during creation of memory snapshot");
     const table = getWasmFunctionTable();
     const jitCallCb = table.get(jit_call_cb);
 

src/mono/wasm/runtime/jiterpreter-support.ts

@@ -3,7 +3,7 @@
 
 import { mono_assert } from "./types";
 import { NativePointer, ManagedPointer, VoidPtr } from "./types/emscripten";
-import { Module } from "./imports";
+import { Module, runtimeHelpers } from "./imports";
 import { WasmOpcode } from "./jiterpreter-opcodes";
 import cwraps from "./cwraps";
 
@@ -1201,8 +1201,9 @@ export function getWasmFunctionTable () {
 }
 
 export function addWasmFunctionPointer (f: Function) {
-    if (!f)
-        throw new Error("Attempting to set null function into table");
+    mono_assert(f,"Attempting to set null function into table");
+    mono_assert(!runtimeHelpers.storeMemorySnapshotPending, "Attempting to set function into table during creation of memory snapshot");
+
     const table = getWasmFunctionTable();
     if (wasmFunctionIndicesFree <= 0) {
         wasmNextFunctionIndex = table.length;

src/mono/wasm/runtime/jiterpreter.ts

@@ -3,7 +3,7 @@
 
 import { mono_assert, MonoMethod } from "./types";
 import { NativePointer } from "./types/emscripten";
-import { Module } from "./imports";
+import { Module, runtimeHelpers } from "./imports";
 import {
     getU16, getU32_unaligned
 } from "./memory";
@@ -762,6 +762,8 @@ function generate_wasm (
         //  independently jitting traces will not stomp on each other and all threads
         //  have a globally consistent view of which function pointer maps to each trace.
         rejected = false;
+        mono_assert(!runtimeHelpers.storeMemorySnapshotPending, "Attempting to set function into table during creation of memory snapshot");
+
         const idx =
             trapTraceErrors
                 ? Module.addFunction(

src/mono/wasm/runtime/polyfills.ts

@@ -215,6 +215,7 @@ export async function init_polyfills_async(): Promise<void> {
             }
         }
     }
+    runtimeHelpers.subtle = globalThis.crypto?.subtle;
 }
 
 const dummyPerformance = {

src/mono/wasm/runtime/profiler.ts

@@ -41,6 +41,7 @@ export const enum MeasuredBlock {
     preRunWorker = "mono.preRunWorker",
     onRuntimeInitialized = "mono.onRuntimeInitialized",
     postRun = "mono.postRun",
+    memorySnapshot = "mono.memorySnapshot",
     loadRuntime = "mono.loadRuntime",
     bindingsInit = "mono.bindingsInit",
     bindJsFunction = "mono.bindJsFunction:",

src/mono/wasm/runtime/run-outer.ts

@@ -18,6 +18,7 @@ export interface DotnetHostBuilder {
     withDebugging(level: number): DotnetHostBuilder
     withMainAssembly(mainAssemblyName: string): DotnetHostBuilder
     withApplicationArgumentsFromQuery(): DotnetHostBuilder
+    withStartupMemoryCache(value: boolean): DotnetHostBuilder
     create(): Promise<RuntimeAPI>
     run(): Promise<number>
 }
@@ -137,6 +138,19 @@ class HostBuilder implements DotnetHostBuilder {
         }
     }
 
+    withStartupMemoryCache(value: boolean): DotnetHostBuilder {
+        try {
+            const configInternal: MonoConfigInternal = {
+                startupMemoryCache: value
+            };
+            Object.assign(this.moduleConfig.config!, configInternal);
+            return this;
+        } catch (err) {
+            mono_exit(1, err);
+            throw err;
+        }
+    }
+
     withConfig(config: MonoConfig): DotnetHostBuilder {
         try {
             const providedConfig = { ...config };