feedback

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 start of the application with the same configuration and same assets, we could use the snapshot.
+Instead of downloading all the assets and doing the runtime startup again.
+Such subsequent start is 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 se we calculate the hash at the runtime, just before taking snapshot. 
+- the snapshot is taken just after we initialize the Mono runtime
+    - cwraps 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 init
+    - before any JavaScript interop initialization
+    - before any Managed code initialization
+    - therefore we do not expect to store any application state in the snapshot.
+
+### How to opt out
+ - you can use new API `withMemoryCache(false)` to opt out from the feature.
+

src/mono/wasm/runtime/startup.ts

@@ -298,7 +298,6 @@ export function abort_startup(reason: any, should_exit: boolean): void {
     }
 }
 
-// runs in both blazor and non-blazor
 function mono_wasm_pre_init_essential(isWorker: boolean): void {
     if (!isWorker)
         Module.addRunDependency("mono_wasm_pre_init_essential");
@@ -321,22 +320,16 @@ function mono_wasm_pre_init_essential(isWorker: boolean): void {
         Module.removeRunDependency("mono_wasm_pre_init_essential");
 }
 
-// runs in both blazor and non-blazor
 async function mono_wasm_pre_init_essential_async(): Promise<void> {
     if (runtimeHelpers.diagnosticTracing) console.debug("MONO_WASM: mono_wasm_pre_init_essential_async");
     Module.addRunDependency("mono_wasm_pre_init_essential_async");
 
     await init_polyfills_async();
     await mono_wasm_load_config(Module.configSrc);
 
-    if (MonoWasmThreads) {
-        preAllocatePThreadWorkerPool(MONO_PTHREAD_POOL_SIZE, config);
-    }
-
     Module.removeRunDependency("mono_wasm_pre_init_essential_async");
 }
 
-// runs just in non-blazor
 async function mono_wasm_pre_init_full(): Promise<void> {
     if (runtimeHelpers.diagnosticTracing) console.debug("MONO_WASM: mono_wasm_pre_init_full");
     Module.addRunDependency("mono_wasm_pre_init_full");
@@ -347,7 +340,6 @@ async function mono_wasm_pre_init_full(): Promise<void> {
     Module.removeRunDependency("mono_wasm_pre_init_full");
 }
 
-// runs just in non-blazor
 async function mono_wasm_before_user_runtime_initialized(): Promise<void> {
     if (runtimeHelpers.diagnosticTracing) console.debug("MONO_WASM: mono_wasm_before_user_runtime_initialized");
 
@@ -359,6 +351,10 @@ async function mono_wasm_before_user_runtime_initialized(): Promise<void> {
         if (config.cacheMemory && !runtimeHelpers.memoryIsLoaded) {
             await storeMemory(Module.HEAP8.buffer);
         }
+        if (MonoWasmThreads) {
+            preAllocatePThreadWorkerPool(MONO_PTHREAD_POOL_SIZE, config);
+            await mono_wasm_init_diagnostics();
+        }
         bindings_init();
         if (!runtimeHelpers.mono_wasm_runtime_is_ready) mono_wasm_runtime_ready();
         if (!runtimeHelpers.mono_wasm_symbols_are_ready) readSymbolMapFile("dotnet.js.symbols");
@@ -373,7 +369,6 @@ async function mono_wasm_before_user_runtime_initialized(): Promise<void> {
     }
 }
 
-// runs in both blazor and non-blazor
 async function mono_wasm_after_user_runtime_initialized(): Promise<void> {
     if (runtimeHelpers.diagnosticTracing) console.debug("MONO_WASM: mono_wasm_after_user_runtime_initialized");
     try {
@@ -394,10 +389,6 @@ async function mono_wasm_after_user_runtime_initialized(): Promise<void> {
                 }
             }
         }
-        // for Blazor, init diagnostics after their "onRuntimeInitalized" sets env variables, but before their postRun callback (which calls mono_wasm_load_runtime)
-        if (MonoWasmThreads) {
-            await mono_wasm_init_diagnostics();
-        }
 
         if (runtimeHelpers.diagnosticTracing) console.debug("MONO_WASM: Initializing mono runtime");
 
@@ -509,7 +500,6 @@ async function instantiate_wasm_module(
     Module.removeRunDependency("instantiate_wasm_module");
 }
 
-// runs just in non-blazor
 async function _apply_configuration_from_args() {
     // create /usr/share folder which is SpecialFolder.CommonApplicationData
     Module["FS_createPath"]("/", "usr", true, true);
@@ -531,11 +521,6 @@ async function _apply_configuration_from_args() {
 
     if (config.browserProfilerOptions)
         mono_wasm_init_browser_profiler(config.browserProfilerOptions);
-
-    // for non-Blazor, init diagnostics after environment variables are set
-    if (MonoWasmThreads) {
-        await mono_wasm_init_diagnostics();
-    }
 }
 
 export function mono_wasm_load_runtime(unused?: string, debugLevel?: number): void {

src/mono/wasm/runtime/storage.ts

@@ -5,6 +5,8 @@ import ProductVersion from "consts:productVersion";
 import GitHash from "consts:gitHash";
 import { runtimeHelpers } from "./imports";
 
+const memoryPrefix = "https://dotnet.generated.invalid/wasm-memory";
+
 // adapted from Blazor's WebAssemblyResourceLoader.ts
 async function open(): Promise<Cache | null> {
     // caches will be undefined if we're running on an insecure origin (secure means https or localhost)
@@ -36,10 +38,11 @@ async function open(): Promise<Cache | null> {
     } catch {
         // There's no known scenario where we should get an exception here, but considering the
         // Chromium bug above, let's tolerate it and treat as "proceed without caching".
+        console.warn("MONO_WASM: Failed to open cache");
         return null;
     }
 }
-const memoryPrefix = "https://dotnet.generated.invalid/wasm-memory";
+
 export async function getMemory(): Promise<ArrayBuffer | undefined> {
     try {
         const inputsHash = await getInputsHash();
@@ -123,4 +126,4 @@ export async function getInputsHash(): Promise<string | null> {
     const uint8ViewOfHash = new Uint8Array(sha256Buffer);
     const hashAsString = Array.from(uint8ViewOfHash).map((b) => b.toString(16).padStart(2, "0")).join("");
     return hashAsString;
-}
+}

src/mono/wasm/runtime/strings.ts

@@ -275,4 +275,4 @@ export function js_string_to_mono_string_new(string: string): MonoString {
     } finally {
         temp.release();
     }
-}
+}