Object constructor calls are slow

[kunalspathak]

There was a discussion going on in webpack/webpack#5600 that wraps all references into Object () which was slow. v8 recently fixed it and I piggy-backed the test case from here that was used to demonstrate v8's behavior and verified for chakracore and the results are similar. We are slow too and will be good to optimize to get boost in webpack module.

const identity = x => x;

function callDirect(o) {
  const foo = o.foo;
  return foo(1, 2, 3);
}

function callViaCall(o) {
  return o.foo.call(undefined, 1, 2, 3);
}

function callViaObject(o) {
  return Object(o.foo)(1, 2, 3);
}

function callViaIdentity(o) {
  return identity(o.foo)(1, 2, 3);
}

var TESTS = [
    callDirect,
    callViaObject,
    callViaCall,
    callViaIdentity
];

class A { foo(x, y, z) { return x + y + z; } };
var o = new A;
var n = 1e8;

function test(fn) {
  var result;
  for (var i = 0; i < n; ++i) result = fn(o);
  return result;
}

// Warmup.
for (var j = 0; j < TESTS.length; ++j) {
  test(TESTS[j]);
}

// Measure.
for (var j = 0; j < TESTS.length; ++j) {
  var startTime = Date.now();
  test(TESTS[j]);
  console.log(TESTS[j].name + ':', (Date.now() - startTime), 'ms.');
}

Results :

E:\git\Chakra\core>node f:\temp\object.js
callDirect: 664 ms.
callViaObject: 1906 ms.
callViaCall: 329 ms.
callViaIdentity: 454 ms.

E:\git\Chakra\core>node -pe "process.versions"
{ http_parser: '2.7.0',
  node: '8.4.0',
  chakracore: '1.7.1.0',
  uv: '1.13.1',
  zlib: '1.2.11',
  ares: '1.10.1-DEV',
  modules: '57',
  nghttp2: '1.22.0',
  openssl: '1.0.2l',
  icu: '59.1',
  unicode: '9.0',
  cldr: '31.0.1',
  tz: '2017b' }

[obastemur]

callViaObject looks seriously slow. However not sure its popularity. Do you have v8 numbers?

[kunalspathak]

Yes. Check the blog in the description of this issue.

[LouisLaf]

I tried playing with his code a bit:
Original:

Test	Edge	Chrome
callDirect	716	546
callViaObject	2156	1152
callViaCall	196	579
callViaIdentity	302	521

The reason for our poor callDirect score is that warmup wasn’t sufficient for us. Running the warmup twice, we get:

Test	Edge	Chrome
callDirect	198	545
callViaObject	2157	1154
callViaCall	190	582
callViaIdentity	304	519

I then used a switch to get rid of the polymorphic calls:

Test	Edge	Chrome
callDirect	159	43
callViaObject	1741	1309
callViaCall	168	718
callViaIdentity	281	667

Our numbers make sense here, but not sure what happened to Chrome…

We have some pretty easy optimizations (allowing non-fixed field inlining checks to be hoisted our of lops) that should speed up all of these significantly. Inlining Object() would certainly help the second case and we should look into it. It should be easy.

Firefox has pretty consistent results across all 3 runs:

Test	FireFox
callDirect	199ms.
callViaObject	1505ms.
callViaCall	194ms.
callViaIdentity	192ms.

[bmeurer]

Awesome.

Note however that the polymorphic call site inside test is there by design to make sure we measure the right thing, i.e. the cost of the actual functions under test and not our ability to inline everything into the driver and then hoist checks out of the loop.