Putting the code within for (let j = 0; j < 100; j++) in its own function did not affect results in either benchmark.
Removing this.x = 0; this.y = 0; did not affect results for the JS Array benchmark.
Passing --trace-opt and --trace-deopt shows that the JIT optimizes all lines of code for both benchmarks in the first few iterations; it does not repeatedly try to re-optimize for either.
The results scale. When passing j < 300, the JS Array takes 15-17 seconds while the Int8Array takes 0.54 seconds. That's a 27x performance improvement for a pure read/write/multiply ALU test.
More complex loop benchmark (if/else branch) Surprisingly, the Int8Array (now turned into a Float64Array) isn't just faster at loads and stores. Here's a floating point arithmetic benchmark (the code that's identical to the previous benchmark have been omitted):
function bench() {
let buf = []
for (let i = 0; i < 100000; ++i) {
buf[i] = new obj();
buf[i].x = Math.random()*2;
buf[i].y = Math.random()*3;
}
for (let i = 0; i < 100000; ++i) {
buf[i].x += Math.random();
buf[i].y += Math.random();
}
for (let i = 0; i < 100000; ++i) {
buf[i].x *= Math.random();
buf[i].y *= Math.random();
}
}
node -e 6.19s user 0.58s system 194% cpu 3.475 total
function bench() {
buf = new Float64Array(100000)
for (let i = 0; i < 100000; ++i) {
(new obj(i)).x = Math.random()*2;
(new obj(i)).y = Math.random()*3;
}
for (let i = 0; i < 100000; ++i) {
(new obj(i)).x += Math.random();
(new obj(i)).y += Math.random();
}
for (let i = 0; i < 100000; ++i) {
(new obj(i)).x *= Math.random();
(new obj(i)).y *= Math.random();
}
}
node -e 1.24s user 0.06s system 98% cpu 1.247 total
We can even throw in an unpredictable branch prediction and the affect remains:
function bench() {
let buf = []
for (let i = 0; i < 100000; ++i) {
buf[i] = new obj();
buf[i].x = Math.random()*2;
buf[i].y = Math.random()*3;
}
for (let i = 0; i < 100000; ++i) {
if(Math.random() > 0.5) {
buf[i].x += Math.random();
} else if (i > 0) {
buf[i].x -= (buf[i-1].y)*Math.random();
}
buf[i].x += Math.random();
buf[i].y += Math.random();
}
for (let i = 0; i < 100000; ++i) {
buf[i].x *= Math.random();
buf[i].y *= Math.random();
}
}
node -e 6.64s user 0.56s system 173% cpu 4.149 total
function bench() {
buf = new Float64Array(100000)
for (let i = 0; i < 100000; ++i) {
(new obj(i)).x = Math.random()*2;
(new obj(i)).y = Math.random()*3;
}
for (let i = 0; i < 100000; ++i) {
if(Math.random() > 0.5) {
(new obj(i)).x += Math.random();
} else if (i > 0) {
(new obj(i)).x -= (new obj(i-1)).y*Math.random();
}
(new obj(i)).y += Math.random();
}
for (let i = 0; i < 100000; ++i) {
(new obj(i)).x *= Math.random();
(new obj(i)).y *= Math.random();
}
}
node -e 1.58s user 0.12s system 93% cpu 1.813 total
Combining the three loops into one made the JS Array version ~0.2 seconds faster and did not observably affect the speed of the Int8Array. Combining the loops always made it 0.2 seconds faster, even when j < 300 was used.
Adding a new z property (below) results in 0.8 additional seconds for 2.0 seconds. Still faster than the JS Array.
// class obj {
get x() { return buf[this.index*3] }
set x(v) { buf[this.index*3] = v }
get y() { return buf[this.index*3 + 1] }
set y(v) { buf[this.index*3 + 1] = v }
get z() { return buf[this.index*3 + 2] }
set z(v) { buf[this.index*3 + 2] = v }
// first loop
(new obj(i)).z = Math.random()*2.78243;
// second loop
(new obj(i)).z += Math.random();
// third loop
(new obj(i)).z *= Math.random();
Just for fun, let's throw in a string test in there.
~ time node -e "
let log
class obj {
constructor() {this.x=0; this.y=0}
hello() {
log += 'hi' + this.x + this.y
}
}
function bench() {
let buf = []; log = ''
for (let i = 0; i < 100000; ++i) {
buf[i] = new obj();
buf[i].x = Math.random()*2;
buf[i].y = Math.random()*3;
}
for (let i = 0; i < 100000; ++i) {
if(Math.random() > 0.5) {
buf[i].x += Math.random();
} else if (i > 0) {
buf[i].x -= (buf[i-1].y)*Math.random();
}
buf[i].x += Math.random();
buf[i].y += Math.random();
}
for (let i = 0; i < 100000; ++i) {
buf[i].x *= Math.random();
buf[i].y *= Math.random();
buf[i].hello()
}
}
for(let i = 0; i < 80; ++i) {
bench()
}"
node -e 19.19s user 1.21s system 152% cpu 13.408 total
~ time node -e "let buf
let log = ''
class obj {
constructor(index) {
this.index = index
}
get x() {
return buf[this.index * 2]
}
set x(v) {
buf[this.index * 2] = v
}
get y() {
return buf[this.index * 2 + 1]
}
set y(v) {
buf[this.index *2 + 1] = v
}
hello() {
log += 'hi' + this.x + this.y
}
}
function bench() {
buf = new Float64Array(100000)
log = ''
for (let i = 0; i < 100000; ++i) {
(new obj(i)).x = Math.random()*2;
(new obj(i)).y = Math.random()*3;
}
for (let i = 0; i < 100000; ++i) {
if(Math.random() > 0.5) {
(new obj(i)).x += Math.random();
} else if (i > 0) {
(new obj(i)).x -= (new obj(i-1)).y*Math.random();
}
(new obj(i)).y += Math.random();
}
for (let i = 0; i < 100000; ++i) {
(new obj(i)).x *= Math.random();
(new obj(i)).y *= Math.random();
(new obj(i)).hello();
}
}
for (let j = 0; j < 80; j++) {
bench()
};"
node -e 7.80s user 0.52s system 121% cpu 6.857 total
Simply put, using an ArrayBuffer is just faster.