new to bun: why this simple javascript code is 2 times faster in nodejs than Bun?

[ironydips]

New to Bun. Looking fore faster alternate to nodejs for cpu intensive tasks.

When running below code in nodejs, it is 2 times faster than Bun. Please help me understand why? as Bun is expected to perform better.

function multiplyMatrices(m1, m2) {
    const result = new Array(m1.length).fill().map(() => new Array(m2[0].length).fill(0));
    for (let i = 0; i < m1.length; i++) {
        for (let k = 0; k < m1[0].length; k++) {
            for (let j = 0; j < m2[0].length; j++) {
                result[i][j] += m1[i][k] * m2[k][j];
            }
        }
    }
    return result;
}

// Create larger matrices to test performance
const C = Array.from({length: 300}, () => Array.from({length: 300}, () => Math.floor(Math.random() * 100)));
const D = Array.from({length: 300}, () => Array.from({length: 300}, () => Math.floor(Math.random() * 100)));

console.time('Matrix Multiplication');
multiplyMatrices(C, D);
console.timeEnd('Matrix Multiplication');

Node Perfomace: 120ms
Bun Performance: 225ms

[zC4sTr0]

Hi @ironydips

Please provide us the code sample of the console command you're using to run with bun and node

[ironydips]

Hi, I am using online Playground (https://codedamn.com/) to test code there by writing above mentioned code in an index.js file and simply running: bun index.js & node index.js

bun version: 1.1.4
node version: v18.20.2

[zC4sTr0]

Could you please provide the OS information of the machine you run the code?

[ironydips]

Sure. MacBook Pro: Apple M1, memory 8 GB, HD 250 GB, (MacOS Big Sur)

[ironydips]

@zC4sTr0 @Jarred-Sumner please do take a look at this as and when you get time.

[ironydips]

@Jarred-Sumner I understand you are busy with new releases, but pls help me understand performance difference as i have already moved my entire backend to bun and literally see no difference in performance when comparing side by side to node, rather cpu utilisation has went up a little on bun. My site www.stockmock.in is used by more than 50k users on daily basis and our business involves cpu intensive and high memory tasks. I am very very serious on using this on production but the query like above is stopping me to go deeper on this.

Simple Example like: sort() is 5x slower on bun than nodejs. Am i missing something here? pls guide.

If you can just help me understand these 2 queries: one mentioned at top of this thread, and other this .sort() --> this will bre great starting point for me to dig deeper.

const lengthToUse = 10000000;
const largeArray = Array.from({ length: lengthToUse }, (_, index) => index);

console.time('sort');
const sortedArray = largeArray.sort((a, b) => a - b)
console.timeEnd('sort');

Node Sort: 123ms
Bun Sort: 650ms

I am using bun version: 1.0.0
node version: v14.18.1

System Config: MacBook Pro: Apple M1, memory 8 GB, HD 250 GB, (MacOS Big Sur)

[liudonghua123]

I tested too, the result is the same, bun is slower than node.

[zC4sTr0]

Same result here. Node is faster than bun when executing this code.

[001123]

May be you should install latest version bun and check again.
I run your script, bun still faster ( image above)

My PC specs:
Hackintosh Sonoma 14.4.1
CPU: intel i5 12400

[ironydips]

thank you for trying it out, but somehow it's still same for me, using latest version of node and bun.

[alexeyten]

As this is CPU-intensive task you're just comparing V8 engine (nodejs) vs JavaScriptCore engine (bun).

I've installed v8 and javascriptcore from jsvu and run slightly modified script and get following results (on my machine):

$ time v8 a.js 
real	0m4,287s
user	0m4,281s
sys	0m0,021s

$ time javascriptcore a.js 
real	0m5,121s
user	0m5,128s
sys	0m0,040s

script

function multiplyMatrices(m1, m2) {
    const result = new Array(m1.length).fill().map(() => new Array(m2[0].length).fill(0));
    for (let i = 0; i < m1.length; i++) {
        for (let k = 0; k < m1[0].length; k++) {
            for (let j = 0; j < m2[0].length; j++) {
                result[i][j] += m1[i][k] * m2[k][j];
            }
        }
    }
    return result;
}

// Create larger matrices to test performance
const C = Array.from({length: 300}, () => Array.from({length: 300}, () => Math.floor(Math.random() * 100)));
const D = Array.from({length: 300}, () => Array.from({length: 300}, () => Math.floor(Math.random() * 100)));

// repeat 50 times
for (let i = 0; i < 50; i++) {
    let _ = multiplyMatrices(C, D);
}

So, essentially V8 is more optimized for this CPU-intensive task.