[WASM] Why JS mono AOT is so slow?

[elringus]

I'm not sure if that's by design or a bug or I'm doing something wrong, but [JSExport/Import] interop in .NET 9 AOT is about 10 times slower than in Rust. Even considering the runtime overhead, 10x difference seems just too much.

Below are the samples I've used for the benchmark:

C#

.csproj

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>net9.0</TargetFramework>
        <Configuration>Release</Configuration>
        <RuntimeIdentifier>browser-wasm</RuntimeIdentifier>
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
        <RunAOTCompilation>true</RunAOTCompilation>
        <OptimizationPreference>Speed</OptimizationPreference>
    </PropertyGroup>

    <ItemGroup>
        <AssemblyAttribute Include="System.Runtime.Versioning.SupportedOSPlatform">
            <_Parameter1>browser</_Parameter1>
        </AssemblyAttribute>
    </ItemGroup>
</Project>

Program.cs

using System.Runtime.InteropServices.JavaScript;
using System.Text.Json;
using System.Text.Json.Serialization;

public struct Data
{
    public string Info;
    public bool Ok;
    public int Revision;
    public string[] Messages;
}

[JsonSerializable(typeof(Data))]
internal partial class SourceGenerationContext : JsonSerializerContext;

public static partial class Program
{
    public static void Main () { }

    [JSExport]
    public static int EchoNumber ()
    {
        return GetNumber();
    }

    [JSExport]
    public static string EchoStruct ()
    {
        var json = GetStruct();
        var data = JsonSerializer.Deserialize(json, SourceGenerationContext.Default.Data);
        return JsonSerializer.Serialize(data, SourceGenerationContext.Default.Data);
    }

    [JSImport("getNumber", "x")]
    private static partial int GetNumber ();

    [JSImport("getStruct", "x")]
    private static partial string GetStruct ();
}

main.mjs

import { dotnet } from "./bin/Release/net9.0/browser-wasm/AppBundle/_framework/dotnet.js";

const { setModuleImports, getAssemblyExports, getConfig } = await dotnet
    .withDiagnosticTracing(false)
    .create();

setModuleImports("x", {
    getNumber: () => 42,
    getStruct: () => JSON.stringify({
        Info: "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
        Ok: true,
        Revision: -112,
        Messages: ["foo", "bar", "baz", "nya", "far"]
    })
});

const exports = await getAssemblyExports(getConfig().mainAssemblyName);

await new Promise(res => setTimeout(res, 100));
let startTime = performance.now();
for (let i = 0; i < 100000; i++)
    exports.Program.EchoNumber();
console.log(`Echo number: ${(performance.now() - startTime).toFixed(2)} ms`);

await new Promise(res => setTimeout(res, 100));
startTime = performance.now();
for (let i = 0; i < 100000; i++)
    exports.Program.EchoStruct();
console.log(`Echo struct: ${(performance.now() - startTime).toFixed(2)} ms`);

Rust

Cargo.toml

[package]
name = "rust-wasm"
version = "0.1.0"
edition = "2024"

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

[profile.release]
codegen-units = 1
lto = true
opt-level = 3
panic = "abort"
strip = true

lib.rs

use serde::{Deserialize, Serialize};
use wasm_bindgen::prelude::*;

#[derive(Serialize, Deserialize)]
pub struct Data {
    pub info: String,
    pub ok: bool,
    pub revision: i32,
    pub messages: Vec<String>,
}

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(js_name = getNumber)]
    fn get_number() -> i32;
    #[wasm_bindgen(js_name = getStruct)]
    fn get_struct() -> String;
}

#[wasm_bindgen(js_name = echoNumber)]
pub fn echo_number() -> i32 {
    get_number()
}

#[wasm_bindgen(js_name = echoStruct)]
pub fn echo_struct() -> String {
    let json = get_struct();
    let data: Data = serde_json::from_str(&json).unwrap();
    serde_json::to_string(&data).unwrap()
}

main.mjs

import { echoNumber, echoStruct } from './pkg/rust_wasm.js';

global.getNumber = () => 42;
global.getStruct = () => JSON.stringify({
    info: "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
    ok: true,
    revision: -112,
    messages: ["foo", "bar", "baz", "nya", "far"]
});

await new Promise(res => setTimeout(res, 100));
let startTime = performance.now();
for (let i = 0; i < 100000; i++)
    echoNumber();
console.log(`Echo number: ${(performance.now() - startTime).toFixed(2)} ms`);

await new Promise(res => setTimeout(res, 100));
startTime = performance.now();
for (let i = 0; i < 100000; i++)
    echoStruct();
console.log(`Echo struct: ${(performance.now() - startTime).toFixed(2)} ms`);

dotnet publish -c Release
node main.mjs

Echo number: 65.49 ms
Echo struct: 1082.17 ms

wasm-pack build --target nodejs
node main.mjs

Echo number: 5.91 ms
Echo struct: 238.33 ms

Is this something to be expected and can't be improved or maybe I'm missing some configuration/optimization options?

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-text-json, @gregsdennis
See info in area-owners.md if you want to be subscribed.

[dotnet-policy-service]

Tagging subscribers to 'arch-wasm': @lewing
See info in area-owners.md if you want to be subscribed.

[hez2010]

Can you try NativeAOT-LLVM? By default .NET uses mono (even for aot) for wasm on browser which is known to be slow.

To try NativeAOT-LLVM, you can replace your csproj file with the following:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net9.0-browser</TargetFramework>
    <RuntimeIdentifier>browser-wasm</RuntimeIdentifier>
    <OutputType>Exe</OutputType>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <DotNetJsApi>true</DotNetJsApi>
    <PublishTrimmed>true</PublishTrimmed>
    <InvariantGlobalization>true</InvariantGlobalization>
    <NativeDebugSymbols>false</NativeDebugSymbols>
    <StackTraceSupport>false</StackTraceSupport>
    <DebugType>none</DebugType>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <IlcHostPackagePath Condition="'$([MSBuild]::IsOSPlatform(&quot;Windows&quot;))' == 'true'">$(Pkgruntime_win-x64_Microsoft_DotNet_ILCompiler_LLVM)</IlcHostPackagePath>
    <IlcHostPackagePath Condition="'$([MSBuild]::IsOSPlatform(&quot;Windows&quot;))' == 'false'">$(Pkgruntime_linux-x64_Microsoft_DotNet_ILCompiler_LLVM)</IlcHostPackagePath>
    <UseAppHost>false</UseAppHost>
    <UsingBrowserRuntimeWorkload>false</UsingBrowserRuntimeWorkload>
    <UsingWasiRuntimeWorkload>false</UsingWasiRuntimeWorkload>
    <UsingEmscriptenWorkload>true</UsingEmscriptenWorkload>
    <RestoreAdditionalProjectSources>
      https://api.nuget.org/v3/index.json;
      https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json;
    </RestoreAdditionalProjectSources>
  </PropertyGroup>

  <PropertyGroup>
    <EmccExtraArgs>$(EmccExtraArgs) -lcompiler_rt-wasm-sjlj</EmccExtraArgs>
    <EmccFlags>$(EmccFlags) -O3</EmccFlags>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.DotNet.ILCompiler.LLVM" Version="10.0.0-*" />
    <PackageReference Condition="'$([MSBuild]::IsOSPlatform(&quot;Windows&quot;))' == 'true'" Include="runtime.win-x64.Microsoft.DotNet.ILCompiler.LLVM" Version="10.0.0-*" />
    <PackageReference Condition="'$([MSBuild]::IsOSPlatform(&quot;Windows&quot;))' == 'false'" Include="runtime.linux-x64.Microsoft.DotNet.ILCompiler.LLVM" Version="10.0.0-*" />
  </ItemGroup>
  
  <PropertyGroup>
    <ExecutableExtensionName Condition="'$([MSBuild]::IsOSPlatform(&quot;Windows&quot;))' == 'true'">.exe</ExecutableExtensionName>
  </PropertyGroup>

  <ItemGroup>
    <EmscriptenEnvVars Include="DOTNET_EMSCRIPTEN_LLVM_ROOT=$(EmscriptenUpstreamBinPath)" />
    <EmscriptenEnvVars Include="DOTNET_EMSCRIPTEN_BINARYEN_ROOT=$(EmscriptenSdkToolsPath)" />
    <EmscriptenEnvVars Include="DOTNET_EMSCRIPTEN_NODE_JS=$(EmscriptenNodeBinPath)node$(ExecutableExtensionName)" />
    <EmscriptenEnvVars Include="EM_CACHE=$(EmscriptenCacheSdkCacheDir)" />
  </ItemGroup>

</Project>

and build your project with dotnet publish -c Release -r browser-wasm

And your mjs file need to be modified to

import { dotnet } from "./dotnet.js"; // update path here

const { setModuleImports, getAssemblyExports, getConfig } = await dotnet
    .withDiagnosticTracing(false)
    .withMainAssembly("MyWasmJsInteropTest") // set the main assembly name to match your project
    .create();

setModuleImports("x", {
    getNumber: () => 42,
    getStruct: () => JSON.stringify({
        Info: "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
        Ok: true,
        Revision: -112,
        Messages: ["foo", "bar", "baz", "nya", "far"]
    })
});

const exports = await getAssemblyExports(getConfig().mainAssemblyName);

await new Promise(res => setTimeout(res, 100));
let startTime = performance.now();
for (let i = 0; i < 100000; i++)
    exports.Program.EchoNumber();
console.log(`Echo number: ${(performance.now() - startTime).toFixed(2)} ms`);

await new Promise(res => setTimeout(res, 100));
startTime = performance.now();
for (let i = 0; i < 100000; i++)
    exports.Program.EchoStruct();
console.log(`Echo struct: ${(performance.now() - startTime).toFixed(2)} ms`);

On my machine this yielded

Echo number: 18.85 ms
Echo struct: 190.76 ms

which is quite competitive with Rust version.

[elringus]

@hez2010 Thank you so much for sharing this! I've tried NativeAOT-LLVM in the past, but wasn't aware of the correct project config/setup. It does indeed work much faster, especially when dealing with JSON serialization. I got following results on my machine:

Echo number: 45.08 ms
Echo struct: 374.72 ms

— this is now actually on the level I expected. Great stuff.

Do I understand correctly that the intention is to eventually use NativeAOT-LLVM as the default backend for the browser-wasm target?

[hez2010]

Do I understand correctly that the intention is to eventually use NativeAOT-LLVM as the default backend for the browser-wasm target?

Maybe? It's still an actively developed experimental backend driven by the community, and there're still many issues need to be resolved before it can be made as the default backend.

[pavelsavara]

this is "why is interpreter slow", not really about interop

We don't have JIT on WASM (RiuJIT backend).
For now we have interpreter accelerator https://github.com/dotnet/runtime/blob/main/docs/design/mono/jiterpreter.md

Few optimization hints

• for json https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-source-generator/
• you can try Mono AOT <RunAOTCompilation>true</RunAOTCompilation> in your csproj

Here are other advanced knobs you can try to tune https://github.com/dotnet/runtime/blob/main/src/mono/wasm/features.md