NetWasm 0.10 acelera C# no WebAssembly em benchmarks
Em 2.213 benchmarks, NetWasm 0.10.8 levou 0,41 vez o tempo do Mono AOT em média geométrica; cinco casos foram excluídos.
O NetWasm 0.10 reduziu tempos de execução de programas C# em WebAssembly e chegou a 0,41 vez o tempo do Mono AOT na média geométrica dos benchmarks do projeto. As otimizações, distribuídas das versões 0.10.1 a 0.10.8, abrangem exceções, limites de arrays, SIMD e divisão de inteiros.
NetWasm é um compilador e runtime que transforma programas C# em arquivos WebAssembly autônomos por compilação antecipada. A ferramenta recebe o IL produzido pelo Roslyn, gera Wasm e usa runtime próprio com uma versão do CoreLib portada do .NET. Como referência, os testes usam a compilação Mono AOT para WASI, que executa .NET no mesmo mecanismo.
Exceções e loops mais rápidos
Boa parte do ganho inicial veio do tratamento de exceções na versão 0.10.1. O Wasmtime acrescenta operações para salvar e restaurar registradores em funções que podem lançar ou capturar exceções, inclusive registradores de ponto flutuante. Métodos com verificações de nulidade, limites ou aritmética verificada pagavam esse custo a cada chamada.
O NetWasm passou a encaminhar lançamentos de exceção por uma função compartilhada, enquanto o manipulador libera os frames; a mudança reduziu o teste UI churn de 17,6 para 7,9 milissegundos. Na versão 0.10.2, o compilador também passou a inserir métodos simples em linha em loops, incluindo trocas de tuplas, e a eliminar verificações já feitas para o mesmo array e índice.
Embora um novo coletor de lixo já tivesse dado vantagem em cargas com muitas alocações, loops comuns ainda ficavam atrás: o quicksort de 100 mil inteiros levava 77,2 milissegundos, contra 58 milissegundos no Mono AOT. Com as otimizações, o teste caiu para 54 milissegundos. No DoomSharp, renderizador de software de Doom escrito em C# com build NetWasm, acessores de tipos por valor passaram a gerar leituras diretas de campos. No nível O3, pequenos auxiliares condicionais também foram inseridos em loops; o render de 120 quadros caiu de 3.595 para 1.934 milissegundos.
SIMD e operações aritméticas
A versão 0.10.7 introduziu suporte SIMD: Vector128, Vector<T> e PackedSimd são convertidos em instruções WebAssembly de 128 bits. Loops que processam arrays passam a tratar quatro ou mais elementos por iteração, com uma alternativa escalar para os elementos restantes.
Ao mover chamadas Math invariantes para fora dos loops, o compilador permitiu vetorizar um solver da equação de Burgers, equação diferencial parcial fundamental da mecânica dos fluidos. O primeiro teste caiu de 497 para 71 milissegundos; o Mono AOT levou 186 milissegundos e o .NET para desktop, 93.
Na versão 0.10.8, o foco passou para divisão e aritmética com verificações de intervalo. Quando uma operação de resto vem depois de uma divisão, o compilador reutiliza o quociente e evita repetir verificações de divisor zero e do caso int.MinValue dividido por -1.
Em um teste de divisão por tentativa, o tempo caiu de 1.376 para 765 milissegundos, contra 862 milissegundos no Mono AOT. Os resultados mostram ganhos também em operações aritméticas, embora o desempenho varie conforme a carga de trabalho.
Resultados e condições dos testes
Nos 2.213 casos de benchmark citados pelos autores, a versão 0.10.8 em O3 com NetWasmGC levou, em média geométrica, 0,41 vez o tempo do Mono AOT. O cálculo exclui cinco casos em que o LLVM do Mono remove o trabalho; por família, a proporção em relação ao Mono AOT varia de 0,34 para intrinsics a 0,81 para matemática.
Na comparação com o JIT do .NET 11 RC3 para desktop, a proporção foi 0,87, ante 2,15 na versão 0.10.6. No render de 120 quadros do DoomSharp, o NetWasmGC levou 1.623 milissegundos, contra 2.371 do Mono AOT e 1.053 do JIT do .NET para desktop.
Os testes usaram Wasmtime 49.0.3 em um Apple M1 Max e combinaram casos do dotnet/performance com cinco cargas de trabalho do NetWasm. Os autores também observaram que loops idênticos podiam variar até 15% conforme o endereço na memória e alinharam cada função a 4 KiB para reduzir essa diferença nos testes A/B.
Limitações e acesso
O .NET para desktop ainda foi cerca de 3,1 vezes mais rápido nos benchmarks vetoriais, pois usa SIMD nativo do processador, enquanto o WebAssembly trabalha com operações fixas de 128 bits. Math.Pow ficou 1,4 vez mais lento que no Mono AOT, e CopyBlock64, 3,3 vezes mais lento.
Um dos testes, NewtR, regrediu e ficou 1,9 vez mais lento que na versão 0.10.6. Os autores atribuem o resultado ao alocador de registradores do Wasmtime, que mantém um valor em uma posição da pilha durante o loop. Os números vêm de uma única máquina e runtime, e o NetWasm pode ser experimentado no playground online; o projeto também oferece um guia de compilação e publicação e documentação no GitHub oficial.
Informações deste conteúdo
Tecnologias: .NET, C#, NetWasm, SIMD, WebAssembly
Carreiras: Desenvolvedor de Software, Engenheiro de Software
Idiomas: Português
Tags: coding, compiladores, csharp, dotnet, software, webassembly