O resultado aqui no M1 Max foi bem diferente.

rinha % bun execute.js
test x 3.80 ops/sec ±5.63% (14 runs sampled)

rinha % node execute.js      
test x 12.14 ops/sec ±3.39% (35 runs sampled)

Rodei multiplas vezes em todas o bun ficava em 3-4 ops/sec enquanto o Node ficava em 11-12 ops/sec, confirmando que no meu M1 Max rodando o mesmo teste que você o Node performou 3x-4x mais rapido que bun.

Seria interessante alguem com Apple Chip M1 fazer o mesmo testes, e talvez alguem com MacOs Intel Chip.

khtano passado

Eu tenho um MacBook antigo (2012), processador 2.6 GHz Quad-Core Intel Core i7, e refiz o teste nele com as mesmas versões (Node 18.17.1 e Bun 1.0.1).

Agora a diferença foi bem maior no código que calcula Fibonacci. Primeiro com time:

Node:

real    0m9.818s
user    0m9.412s
sys     0m0.443s

Bun:

real    0m33.275s
user    0m33.062s
sys     0m3.324s

E com o Benchmark.js:

Node:

test x 0.14 ops/sec ±1.67% (5 runs sampled)

Bun:

test x 0.03 ops/sec ±0.36% (5 runs sampled)

Já com o segundo código (console.log dentro do loop), a situação se inverte e o Bun se mostra mais rápido. Primeiro com time:

Node:

real    0m12.736s
user    0m10.322s
sys     0m1.732s

Bun:

real    0m5.140s
user    0m2.289s
sys     0m1.335s

E com o Benchmark.js:

Node:

test x 0.09 ops/sec ±0.15% (5 runs sampled)

Bun:

test x 0.21 ops/sec ±0.15% (5 runs sampled)

Provavelmente por causa do que já mencionei, de que a implementação do console.log no Node piora bastante a performance. No primeiro código não causa problema porque é só uma chamada no final e o grosso do trabalho é no cálculo, mas no segundo já faz diferença.

Curiosamente, se não usar BigInt, aí muda de novo:

// diminuí o n para não estourar o valor máximo de Number
let n = 1000;
let a = 0, b = 1;
for (let i = 0; i < n; i++) {
    [a, b] = [b, a + b];
}

Usando este código, o Bun foi muito mais rápido que o Node, tanto no Mac quanto no Linux (em média cerca de 10 vezes mais rápido).

lucasmontanoano passado
só que usando esse codigo tu nao chega em `n` de 100.000 imagina 1.000.000 haha BigInt parece ser uma limitação do bun atual, sobre o `console.log` se nao me engano ele vai direto pra API nativa no V8, provavelmente aqui temos uma diferença do Zig no bun?
khtano passado
Bom, a ideia era eliminar o uso de `BigInt` pra ver se mudava alguma coisa, então o jeito foi diminuir o valor. Mas se somente o `BigInt` fosse o problema, então daria diferença no Linux também, mas aqui deu "empate técnico". Talvez seja a combinação `BigInt` + Mac que cause essa perda de desempenho, fica aí a questão pra uma futura investigação :-) Também pensei se a desestruturação faz alguma diferença, fica aí outra sugestão de teste também (usar atribuições simples em vez de `[a, b] = [b, a + b]`).
khtano passado
Bom, fiz o teste comparando os algoritmos com e sem desestruturação, e também com e sem `BigInt`: ```javascript var Benchmark = require('benchmark'); var suite = new Benchmark.Suite; suite .add('desestruturação', function () { const n = 1000; let a = 0, b = 1; for (let i = 0; i < n; i++) { [a, b] = [b, a + b]; } }) .add('sem desestruturação', function () { const n = 1000; let a = 0, b = 1; for (let i = 0; i < n; i++) { let tmp = a; a = b; b += tmp; } }) .add('desestruturação BigInt', function () { const n = 1000000n; let a = 0n, b = 1n; for (let i = 0n; i < n; i++) { [a, b] = [b, a + b]; } }) .add('sem desestruturação BigInt', function () { const n = 1000000n; let a = 0n, b = 1n; for (let i = 0n; i < n; i++) { let tmp = a; a = b; b += tmp; } }) .on('complete', function () { console.log('Fastest is ' + this.filter('fastest').map('name')); }) .on('cycle', function (event) { console.log(String(event.target)); }) .run({ 'async': true }); ``` Testei só no Linux, porque no Mac já vimos que `BigInt` fica bem mais lento usando o Bun. Resultados (em operações por segundo, ou seja, **quanto mais, melhor**): | Teste | Node | Bun | |------------------------------|-----------|-----------| | desestruturação | 236.387 | 3.920.325 | | sem desestruturação | 1.085.075 | 3.897.458 | | desestruturação `BigInt` | 0,11 | 0,11 | | sem desestruturação `BigInt` | 0,12 | 0,11 | Ou seja, parece que a implementação da desestruturação no Bun é mais rápida que no Node. Basta ver que sem desestruturação e sem `BigInt`, o Node pulou de 236 mil para 1 milhão de operações por segundo (e mesmo assim não chegou perto do Bun). Mas quando `BigInt` é usado, a diferença já não foi tão grande. Imagino que neste caso o *overhead* dos cálculos parece ter um impacto maior que a desestruturação.
gabrielTapesano passado

Intrigante o resultado, o Bun é feito com o motor WebPack, que roda no Safari, ao invés do V8. Teoricamente o Bun deveria ir melhor no hardware da Apple, já que utiliza um recurso que a própria Apple utiliza e provavelmente otimiza por padrão.

Outro adendo importante é que o Bun recomenda que esses tipos de teste em apps cli sejam feitos com o hyperfine