Potential Performance Issue with Large Numbers in Bun Compared to Node.js and Deno

[Matprogamerheus]

Title: Potential Performance Issue with Large Numbers in Bun Compared to Node.js and Deno

Body:

Hello everyone,

I recently encountered an issue while testing Bun's performance, particularly when handling large numbers. I noticed that Node.js and Deno are able to handle the same script without any issues, but Bun throws an error. Here’s the context:

I was running a Fibonacci sequence script, and while using Bun, I encountered the following error:

1 | const yourself = {
2 |   multiply: function(F, M) {
3 |     const x =  F[0][0]*M[0][0] + F[0][1]*M[1][0];
                   ^
RangeError: Out of memory: BigInt generated from this operation is too big
      at multiply (D:\work\study\fibonacci_go\fibonacci.js:3:16)
      at power (D:\work\study\fibonacci_go\fibonacci.js:20:10)
      at power (D:\work\study\fibonacci_go\fibonacci.js:19:10)
      at power (D:\work\study\fibonacci_go\fibonacci.js:19:10)
      at power (D:\work\study\fibonacci_go\fibonacci.js:19:10)
      at power (D:\work\study\fibonacci_go\fibonacci.js:19:10)
      at power (D:\work\study\fibonacci_go\fibonacci.js:19:10)
      at power (D:\work\study\fibonacci_go\fibonacci.js:19:10)
      at fibonacci (D:\work\study\fibonacci_go\fibonacci.js:30:10)
      at D:\work\study\fibonacci_go\fibonacci.js:36:25

• Bun Version: v1.1.33 (Windows x64)

Here is the Fibonacci script I used:

const yourself = {
  multiply: function(F, M) {
    const x =  F[0][0]*M[0][0] + F[0][1]*M[1][0];
    const y =  F[0][0]*M[0][1] + F[0][1]*M[1][1];
    const z =  F[1][0]*M[0][0] + F[1][1]*M[1][0];
    const w =  F[1][0]*M[0][1] + F[1][1]*M[1][1];
  
    F[0][0] = x;
    F[0][1] = y;
    F[1][0] = z;
    F[1][1] = w;
  },
  
  power: function(F, n) {
    if( n === 0 || n === 1)
      return;
    const M = [[BigInt(1), BigInt(1)], [BigInt(1), BigInt(0)]];
  
    this.power(F, Math.floor(n / 2));
    this.multiply(F, F);
  
    if (n % 2 !== 0)
      this.multiply(F, M);
  },
  
  fibonacci: function(n) {
    const F = [[BigInt(1), BigInt(1)], [BigInt(1), BigInt(0)]];
    if (n === 0)
      return BigInt(0);
    this.power(F, n - 1);
    return F[0][0];
  }
};

console.time('fibonacci');
const result = yourself.fibonacci(100_000_000);
console.timeEnd('fibonacci');

With this code, Bun quickly hits a RangeError: Out of memory, while Node.js and Deno can handle it just fine. Could this be an issue with Bun's BigInt implementation, or is there a known limitation I should be aware of? Any insights would be greatly appreciated!

[hubdidub]

I was wondering about that too the other day while playing around with bigints.
Got a smaller repro:

bun --print "999n**12345n" # works
bun --print "999n**123456n" # RangeError (immediately)

node --print "999n**12345678n" # works
node --print "999n**123456789n" # RangeError (after a while)
node --print "999n**1234567890n" # RangeError (immediately)

Not sure if it's dependent on the available system resources or if it's a fixed limit. But there's definitely a difference.