Escribí un código muy rudimentario para calcular si un número es primo en Rust (compilado en WASM) y en JavaScript para comparar el rendimiento aritmético.

Esperaba que Rust/WASM acabara con JavaScript. En todos los demás puntos de referencia aritméticos que he hecho, Rust/WASM parece tener la ventaja sobre JavaScript o al menos igualarlo. Sin embargo, en esta prueba, JavaScript parece superar en gran medida a WASM y realmente no tengo una explicación de por qué.

Código de óxido:

 pub fn calculate_is_prime(number: u64) -> bool { if number == 1 { return false; } if number == 2 { return true; } for i in 2..number { if number % i == 0 { return false; } } return true; } #[wasm_bindgen] pub fn bench_rs(max: u64) -> u64 { (1..=max).map(|n| calculate_is_prime_rs(n) as u64).sum() }

Código JavaScript:

 function calculateIsPrime(number) { if (number === 1) { return false; } if (number === 2) { return true; } for (let i = 2; i < number; i++) { if (number % i === 0) { return false; } } return true; } function bench_js(max) { let tot = 0; for (let n = 1; n <= max; n++) { tot += calculateIsPrime(n); } return tot; } let max = 200000; console.log(`Amount of primes under ${max} is ${bench_js(max)}`);

Proyecto de muestra básico: https://github.com/Mcluky/Stack-Overflow-Rust-Wasm-Performance-Example

Cosas que ya he comprobado/hecho:

• Me aseguré de configurar siempre el indicador --release mientras construía el código de óxido.
• Ejecuté el código de Rust directamente en mi máquina, que es mucho más rápido que JS y WASM, por lo que sospecho que tiene algo que ver con el objetivo de WASM.
• Reemplacé el tipo entero (u64) con un punto flotante (f64) en Rust ya que JavaScript usa flotantes pero obtuve resultados similares.
• Probado en iteraciones para asegurarse de que sea consistente.
• Intenté while en lugar de for-in en la versión de Rust en caso de que no estuviera tan optimizado como pensaría.