Executando verificação de segurança...
5

Exato! Foi um typo porque eu reescrevi o Fibonacci enquanto postava aqui :)
b = BigInt(1)

PRIMEIRAMENTE: MUITO MASSA A TUA ANALISE!
Eu vou postar um video amanhã sobre e vou colocar o link do TabNews nele porque acredito que até amanhã conseguimos chegar na conclusão do porque o NodeJS performa muito mais rapido que o Bun (todas as vezes aqui) no meu ambiente com um MacOS M1 Max. Não usei nenhuma biblioteca, apenas usei de fato o console.log e um console.time.

Eu vou rodar o Benchmark.Suite; aqui e postar como que ficou no M1.

Carregando publicação patrocinada...
3

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.

3

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).

1

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?

2

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]).

2

Bom, fiz o teste comparando os algoritmos com e sem desestruturação, e também com e sem BigInt:

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):

TesteNodeBun
desestruturação236.3873.920.325
sem desestruturação1.085.0753.897.458
desestruturação BigInt0,110,11
sem desestruturação BigInt0,120,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.

2

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

3

Vou compartilhar o resultado do benchmark com o M1 Pro:

~/projects/bun-benchmark  node index.js
test x 0.17 ops/sec ±2.08% (5 runs sampled)
 ~/projects/bun-benchmark  bun index.js
test x 0.07 ops/sec ±1.74% (5 runs sampled)

Executei o teste algumas vezes, e em todas elas, o node foi em média 2x mais rápido.

De fato, parece que o node é mais rápido no M1/M1 Pro (e ainda melhor no M1 Max), porém mais lento (ou praticamente igual) no Intel.

1
2

Eu vou postar um video amanhã sobre e vou colocar o link do TabNews nele

Opa, que bom que avisou sobre o vídeo dessa vez! hahaha

Pra aguentar o volume de acessos vindos pelo seu vídeo, já vou trocar aqui o Node pelo Bun no TabNews... 😜

Não, péra! Vendo os comparativos, é melhor adicionar uns pentes de memória e trocar o HD por SSD pra dar um gás no servidor 🤣🚀

Falando sério agora... É muito massa que sempre vem um pico de acessos e de novos cadastros quando você fala do TabNews nos seus vídeos. 💪🚀