Cache JS->.NET string decoding results within a single renderbatch

Author: SteveSandersonMS

src/Components/Web.JS/dist/Release/blazor.webassembly.js

@@ -29,7 +29,19 @@ async function boot(options?: Partial<WebAssemblyStartOptions>): Promise<void> {
   window['Blazor'].platform = platform;
   window['Blazor']._internal.renderBatch = (browserRendererId: number, batchAddress: Pointer) => {
     profileStart('renderBatch');
-    renderBatch(browserRendererId, new SharedMemoryRenderBatch(batchAddress));
+
+    // We're going to read directly from the .NET memory heap, so indicate to the platform
+    // that we don't want anything to modify the memory contents during this time. Currently this
+    // is only guaranteed by the fact that .NET code doesn't run during this time, but in the
+    // future (when multithreading is implemented) we might need the .NET runtime to understand
+    // that GC compaction isn't allowed during this critical section.
+    const heapLock = monoPlatform.beginHeapLock();
+    try {
+      renderBatch(browserRendererId, new SharedMemoryRenderBatch(batchAddress));
+    } finally {
+      heapLock.release();
+    }
+
     profileEnd('renderBatch');
   };
 

src/Components/Web.JS/src/Boot.WebAssembly.ts

@@ -2,17 +2,18 @@ import { DotNet } from '@microsoft/dotnet-js-interop';
 import { attachDebuggerHotkey, hasDebuggingEnabled } from './MonoDebugger';
 import { showErrorNotification } from '../../BootErrors';
 import { WebAssemblyResourceLoader, LoadingResource } from '../WebAssemblyResourceLoader';
-import { Platform, System_Array, Pointer, System_Object, System_String } from '../Platform';
+import { Platform, System_Array, Pointer, System_Object, System_String, HeapLock } from '../Platform';
 import { loadTimezoneData } from './TimezoneDataFile';
 import { WebAssemblyBootResourceType } from '../WebAssemblyStartOptions';
 import { initializeProfiling } from '../Profiling';
 
-let mono_string_get_utf8: (managedString: System_String) => Pointer;
 let mono_wasm_add_assembly: (name: string, heapAddress: number, length: number) => void;
 const appBinDirName = 'appBinDir';
 const uint64HighOrderShift = Math.pow(2, 32);
 const maxSafeNumberHighPart = Math.pow(2, 21) - 1; // The high-order int32 from Number.MAX_SAFE_INTEGER
 
+let currentHeapLock: MonoHeapLock | null = null;
+
 // Memory access helpers
 // The implementations are exactly equivalent to what the global getValue(addr, type) function does,
 // except without having to parse the 'type' parameter, and with less risk of mistakes at the call site
@@ -124,12 +125,29 @@ export const monoPlatform: Platform = {
       return unboxedValue;
     }
 
-    return BINDING.conv_string(fieldValue as any as System_String);
+    let decodedString: string | null | undefined;
+    if (currentHeapLock) {
+      decodedString = currentHeapLock.stringCache.get(fieldValue);
+      if (decodedString === undefined) {
+        decodedString = BINDING.conv_string(fieldValue as any as System_String);
+        currentHeapLock.stringCache.set(fieldValue, decodedString);
+      }
+    } else {
+      decodedString = BINDING.conv_string(fieldValue as any as System_String);
+    }
+
+    return decodedString;
   },
 
   readStructField: function readStructField<T extends Pointer>(baseAddress: Pointer, fieldOffset?: number): T {
     return ((baseAddress as any as number) + (fieldOffset || 0)) as any as T;
   },
+
+  beginHeapLock: function() {
+    assertHeapIsNotLocked();
+    currentHeapLock = new MonoHeapLock();
+    return currentHeapLock;
+  }
 };
 
 function addScriptTagsToDocument(resourceLoader: WebAssemblyResourceLoader) {
@@ -246,7 +264,6 @@ function createEmscriptenModuleInstance(resourceLoader: WebAssemblyResourceLoade
   module.preRun.push(() => {
     // By now, emscripten should be initialised enough that we can capture these methods for later use
     mono_wasm_add_assembly = cwrap('mono_wasm_add_assembly', null, ['string', 'number', 'number']);
-    mono_string_get_utf8 = cwrap('mono_wasm_string_get_utf8', 'number', ['number']);
     MONO.loaded_files = [];
 
     if (timeZoneResource) {
@@ -387,6 +404,7 @@ function attachInteropInvoker(): void {
 
   DotNet.attachDispatcher({
     beginInvokeDotNetFromJS: (callId: number, assemblyName: string | null, methodIdentifier: string, dotNetObjectId: any | null, argsJson: string): void => {
+      assertHeapIsNotLocked();
       if (!dotNetObjectId && !assemblyName) {
         throw new Error('Either assemblyName or dotNetObjectId must have a non null value.');
       }
@@ -409,6 +427,7 @@ function attachInteropInvoker(): void {
       );
     },
     invokeDotNetFromJS: (assemblyName, methodIdentifier, dotNetObjectId, argsJson) => {
+      assertHeapIsNotLocked();
       return dotNetDispatcherInvokeMethodHandle(
         assemblyName ? assemblyName : null,
         methodIdentifier,
@@ -460,3 +479,22 @@ function changeExtension(filename: string, newExtensionWithLeadingDot: string) {
 
   return filename.substr(0, lastDotIndex) + newExtensionWithLeadingDot;
 }
+
+function assertHeapIsNotLocked() {
+  if (currentHeapLock) {
+    throw new Error('Assertion failed - heap is currently locked');
+  }
+}
+
+class MonoHeapLock implements HeapLock {
+  // Within a given heap lock, it's safe to cache decoded strings since the memory can't change
+  stringCache = new Map<number, string | null>();
+
+  release() {
+    if (currentHeapLock !== this) {
+      throw new Error('Trying to release a lock which isn\'t current');
+    }
+
+    currentHeapLock = null;
+  }
+}

src/Components/Web.JS/src/Platform/Mono/MonoPlatform.ts

@@ -18,6 +18,12 @@ export interface Platform {
   readObjectField<T extends System_Object>(baseAddress: Pointer, fieldOffset?: number): T;
   readStringField(baseAddress: Pointer, fieldOffset?: number, readBoolValueAsString?: boolean): string | null;
   readStructField<T extends Pointer>(baseAddress: Pointer, fieldOffset?: number): T;
+
+  beginHeapLock(): HeapLock;
+}
+
+export interface HeapLock {
+  release();
 }
 
 // We don't actually instantiate any of these at runtime. For perf it's preferable to