Perf : filling the array is taking time

[akroshg]

(function() {
  print('Array fill with increment of 2')
  var start = new Date();
  let maxSize = 2**25;
  let arr = new Array(maxSize);
  for (i = 0; i < maxSize; i += 2) {
      arr[i] = i;
  }

  print('time spent : ' + ((new Date()) - start));
})();

(function() {
  print('Array fill with increment of 512')
  var start = new Date();
  let maxSize = 2**25;
  let arr = new Array(maxSize);
  for (i = 0; i < maxSize; i += 512) {
      arr[i] = i;
  }

  print('time spent : ' + ((new Date()) - start));
})();

Output:

Array fill with increment of 2
time spent : 369
Array fill with increment of 512
time spent : 4196

This is strange - with 512 increment we should be filling less items to the array and we should be spending less time.
I suspect this may be due to more number of sparse array segment. I haven't created trace to support my theory.

[akroshg]

Ha - I should have tried that earlier.
but with -nonnative flag we get the right number

> ch.exe test.js -nonative
Array fill with increment of 2
time spent : 1257
Array fill with increment of 512
time spent : 119

[akroshg]

@meg-gupta @rajatd probably due to jitloopbody?

[rajatd]

I think the root cause is that in the first case, the head segment has missing values while in the second it doesn't. For a store to an array whose head segment didn't have missing values before jitting, the jit emits a call to runtime helper Jit_OperationCreatedFirstMissingValue if it had to call a helper to do the set.

One of the conditions to call the set helper is that the index is greater than the head segment length. In both your cases, that happens a lot. In the second case, we will call Jit_OperationCreatedFirstMissingValue after every set and then have a branch on its return value in the jitted code.

I have not captured a trace to verify this but that's what I suspect.

cc @pleath

[sigatrev]

This is a result of heuristics. In the case of increments of < ~0x80 (MergeSegmentsLengthHeuristics), it will reallocate a larger head segment, growing exponentially and rarely have to allocate segments. If the increment is larger, it will allocate a new distinct segment for every single assignment.

[rajatd]

@sigatrev but does that not happen in -nonative runs?