Buffer.length became significantelly slower in 3.x

[matklad]

May be it's a know issue, but I was surprised to discover this behavior in my benchmarks.

Consider this two snippets of code:

for (var i = 0; i < buffer.length; i++) {
    ...
}

and

var length = buffer.length;
for (var i = 0; i < length; i++) {
    ...
}

under v2.5.0 their performance is indistinguishable, but under v3.0.0 or v3.1.0 the first version causes 1.5x slowdown of my whole benchmark.

[Fishrock123]

Probably because .length is now a part of the underlying Uint8Array implementation, rather than just a lazy value.

[vkurchatkin]

It makes sense since in 3.0.0 it's a getter non-own property and previously it was just a simple own data property. Probably we can just attach it to an instance. /cc @trevnorris

[thefourtheye]

I am not sure if this benchmark is correct, but it shows the difference

'use strict';

const common = require('../common');

const bench = common.createBenchmark(main, {
  n: [10e3, 10e4, 10e5, 10e6, 10e7, 10e8]
});

function main(conf) {
  const buffer = new Buffer(conf.n | 0);

  bench.start();
  for (var i = 0; i < buffer.length; i++);
  bench.end(n);
}

And this is the result I got with the latest master,

➜  io.js git:(master) ✗ ./iojs --version
v4.0.0-pre
➜  io.js git:(master) ✗ ./iojs benchmark/buffers/buffer-length.js
buffers/buffer-length.js n=10000:       27445910.97095
buffers/buffer-length.js n=100000:      56917366.79771
buffers/buffer-length.js n=1000000:    128949281.28184
buffers/buffer-length.js n=10000000:   151316669.89778
buffers/buffer-length.js n=100000000:  146552505.52810
buffers/buffer-length.js n=1000000000: 133754893.46407

And the following with v2.5.0,

➜  io.js git:(master) ✗ node --version
v2.5.0
➜  io.js git:(master) ✗ node benchmark/buffers/buffer-length.js 
buffers/buffer-length.js n=10000:        76998891.21597
buffers/buffer-length.js n=100000:       57674750.16740
buffers/buffer-length.js n=1000000:     375004593.80627
buffers/buffer-length.js n=10000000:    800677373.05761
buffers/buffer-length.js n=100000000:  1046371009.02718
buffers/buffer-length.js n=1000000000: 1129972622.92159

[trevnorris]

@vkurchatkin What do you mean by "can just attach it to an instance"?

@matklad Yeah. Sorry about this. Thanks to everything W3C related, properties must be a getter.

[vkurchatkin]

I mean just stick this.length = length in constructor. It is also good for backward compatibility

[trevnorris]

@vkurchatkin we don't have a constructor anymore. It's now essentially var ua = new Uint8Array(n); ua.__proto__ = Buffer.prototype;

[trevnorris]

Can this be closed? It's not a won't fix, but a can't fix. Part of what we inherited by needing to use typed arrays.

[thefourtheye]

@trevnorris Can we maintain a length property and update it whenever the actual size of the buffer object is altered?

[trevnorris]

@thefourtheye It's not a property. It's a getter on the typed array. And since we can only "inherit" the typed array by setting its __proto__ there's no way, that I'm aware of, we can override the default getter with our own value.

And if the size of the Buffer could be altered, then v8 will have to provide a new API that alerts us when that happens. Otherwise we'll have no idea when the array size changed.

[thefourtheye]

we can override the default getter with our own value

Yup that's what I had in my mind.

[trevnorris]

@thefourtheye Eh? The only way to do that from JS is to use Object.defineProperty(). That brings construction time of a 64KB Buffer from 3150 ns/op to 5170 ns/op. And using v8::Object::ForceSet() would change instantiation from 3170 ns/op to 3700 ns/op.

Either way we're taking a performance hit. Not to mention the fact that we'll have no way of knowing when the user runs ArrayBuffer.transfer() unless v8 gives us a hook.

I'm far more concerned about construction time then loop iteration time.

/cc @domenic I'm sure you can rule in from the ECMA side what could potentially happen if we override the .length getter?

[thefourtheye]

I was thinking more like

if (arg < 0 || arg !== arg)
  arg = 0;
const buf = allocate(arg);
buf.length = arg;
return buf;

and maintaining there onwards.

[domenic]

@thefourtheye Doing buf.length = arg will throw in strict mode or be a no-op in sloppy mode, since buf.length is a property with a getter and no setter.

@trevnorris right, you could add a per-instance property that shadows the inherited property, using Object.defineProperty. Seems a bit silly.

The real fix here is just to get V8 to make this fast, like array.length is. Both are basically getters, although only one happens to be manifested as a JS getter.

[ChALkeR]

This is fixed by #2801, it seems.

[bnoordhuis]

Fixed by acb6779.