[js-perf-test] Add Array#{indexOf,includes} micro-benchmark

This patch adds a micro-benchmark comparing Array#indexOf,
Array#includes, and a roughly equivalent `for` loop.

The benchmark can be used to measure any Array#{indexOf,includes}
optimizations we implement in the future.

Test:

    tools/run_perf.py --binary-override-path=out/x64.release/d8 \
      --filter=JSTests/ArrayIndexOfIncludesPolymorphic \
      --extra-flags=--trace-turbo test/js-perf-test/JSTests.json

Bug: v8:8388
Change-Id: I9150d3e56e9d4cb2ffe6baa50ee8cddf8df0ac74
Reviewed-on: https://chromium-review.googlesource.com/c/1307430Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Commit-Queue: Mathias Bynens <mathias@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57156}

test/js-perf-test/Array/reduce.js

@@ -6,7 +6,7 @@
 // Make sure we inline the callback, pick up all possible TurboFan
 // optimizations.
 function RunOptFastReduce(multiple) {
-  // Use of variable multiple in the callback function forces
+  // Use of multiple variables in the callback function forces
   // context creation without escape analysis.
   //
   // Also, the arrow function requires inlining based on

test/js-perf-test/ArrayIndexOfIncludesPolymorphic/indexof-includes-polymorphic.js

+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+function benchy(fn, name) {
+  new BenchmarkSuite(name, [1], [
+    new Benchmark(name, true, false, 0, fn),
+  ]);
+}
+
+function forLoop(array, searchValue) {
+  for (let i = 0; i < array.length; ++i) {
+    if (array[i] === searchValue) return true;
+  }
+  return farraylse;
+}
+
+function indexOf(array, searchValue) {
+  return array.indexOf(searchValue) !== -1;
+}
+
+function includes(array, searchValue) {
+  return array.includes(searchValue);
+}
+
+const PACKED = [
+  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
+];
+const HOLEY = new Array(PACKED.length);
+for (let i = 0; i < PACKED.length; ++i)
+  HOLEY[i] = PACKED[i];
+
+function helper(fn) {
+  const SEARCH_VALUE = 15;
+  const result = fn(PACKED, SEARCH_VALUE) && fn(HOLEY, SEARCH_VALUE);
+  return result;
+}
+
+benchy(() => helper(forLoop), 'for loop');
+benchy(() => helper(indexOf), 'Array#indexOf');
+benchy(() => helper(includes), 'Array#includes');

test/js-perf-test/ArrayIndexOfIncludesPolymorphic/run.js

+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+load('../base.js');
+load(arguments[0] + '.js')
+
+function PrintResult(name, result) {
+  print(name + '-ArrayIndexOfIncludesPolymorphic(Score): ' + result);
+}
+
+function PrintStep(name) {}
+
+function PrintError(name, error) {
+  PrintResult(name, error);
+}
+
+BenchmarkSuite.config.doWarmup = undefined;
+BenchmarkSuite.config.doDeterministic = undefined;
+
+BenchmarkSuite.RunSuites({ NotifyResult: PrintResult,
+                           NotifyError: PrintError,
+                           NotifyStep: PrintStep });

test/js-perf-test/JSTests.json

@@ -912,6 +912,22 @@
         {"name": "SparseStringCopyWithin"}
       ]
     },
+    {
+      "name": "ArrayIndexOfIncludesPolymorphic",
+      "path": ["ArrayIndexOfIncludesPolymorphic"],
+      "main": "run.js",
+      "resources": ["indexof-includes-polymorphic.js"],
+      "test_flags": ["indexof-includes-polymorphic"],
+      "results_regexp": "^%s\\-ArrayIndexOfIncludesPolymorphic\\(Score\\): (.+)$",
+      "flags": [
+        "--allow-natives-syntax"
+      ],
+      "tests": [
+        {"name": "for loop"},
+        {"name": "Array#indexOf"},
+        {"name": "Array#includes"}
+      ]
+    },
     {
       "name": "ArraySort",
       "path": ["ArraySort"],

test/js-perf-test/base.js

@@ -105,7 +105,7 @@ BenchmarkSuite.ResetRNG = function() {
   Math.random = (function() {
     var seed = 49734321;
     return function() {
-      // Robert Jenkins' 32 bit integer hash function.
+      // Robert Jenkins' 32-bit integer hash function.
       seed = ((seed + 0x7ed55d16) + (seed << 12))  & 0xffffffff;
       seed = ((seed ^ 0xc761c23c) ^ (seed >>> 19)) & 0xffffffff;
       seed = ((seed + 0x165667b1) + (seed << 5))   & 0xffffffff;