Add performance tests for Map/Set with String and Object keys

test/js-perf-test/Collections/map.js

 // Copyright 2014 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.
 
 
-var MapBenchmark = new BenchmarkSuite('Map', [1000], [
-  new Benchmark('Set', false, false, 0, MapSet),
-  new Benchmark('Has', false, false, 0, MapHas, MapSetup, MapTearDown),
-  new Benchmark('Get', false, false, 0, MapGet, MapSetup, MapTearDown),
-  new Benchmark('Delete', false, false, 0, MapDelete, MapSetup, MapTearDown),
-  new Benchmark('ForEach', false, false, 0, MapForEach, MapSetup, MapTearDown),
+var MapSmiBenchmark = new BenchmarkSuite('Map-Smi', [1000], [
+  new Benchmark('Set', false, false, 0, MapSet, MapSetupSmiBase, MapTearDown),

[Dmitry Lomov (no reviews), 2014/10/29 10:02:25]

In this perf test, you reuse MapSet/MapHas/MapGet/MapDelete between different
types of keys. This means that (in the future highly optimized world) if the
tests are run consequently, each of these functions might  be specialized to a
particular type of a key, and then deopted and re-compiled for a different type
of a key. This means that the test perf results will depend on the order of test
runs, which is not happy.

AFAIU, this is not the case today since we do not really optimize map accesses
well, but something to consider.

+  new Benchmark('Has', false, false, 0, MapHas, MapSetupSmi, MapTearDown),
+  new Benchmark('Get', false, false, 0, MapGet, MapSetupSmi, MapTearDown),
+  new Benchmark('Delete', false, false, 0, MapDelete, MapSetupSmi, MapTearDown),
+]);
+
+
+var MapStringBenchmark = new BenchmarkSuite('Map-String', [1000], [
+  new Benchmark('Set', false, false, 0, MapSet, MapSetupStringBase, MapTearDown),
+  new Benchmark('Has', false, false, 0, MapHas, MapSetupString, MapTearDown),
+  new Benchmark('Get', false, false, 0, MapGet, MapSetupString, MapTearDown),
+  new Benchmark('Delete', false, false, 0, MapDelete, MapSetupString, MapTearDown),
+]);
+
+
+var MapObjectBenchmark = new BenchmarkSuite('Map-Object', [1000], [
+  new Benchmark('Set', false, false, 0, MapSet, MapSetupObjectBase, MapTearDown),
+  new Benchmark('Has', false, false, 0, MapHas, MapSetupObject, MapTearDown),
+  new Benchmark('Get', false, false, 0, MapGet, MapSetupObject, MapTearDown),
+  new Benchmark('Delete', false, false, 0, MapDelete, MapSetupObject, MapTearDown),
+]);
+
+
+var MapIterationBenchmark = new BenchmarkSuite('Map-Iteration', [1000], [
+  new Benchmark('ForEach', false, false, 0, MapForEach, MapSetupSmi, MapTearDown),
 ]);
 
 
 var map;
-var N = 10;
 
 
-function MapSetup() {
+function MapSetupSmiBase() {
+  SetupSmiKeys();
   map = new Map;
-  for (var i = 0; i < N; i++) {
-    map.set(i, i);
-  }
 }
 
 
+function MapSetupSmi() {
+  MapSetupSmiBase();
+  MapSet();
+}
+
+
+function MapSetupStringBase() {
+  SetupStringKeys();
+  map = new Map;
+}
+
+
+function MapSetupString() {
+  MapSetupStringBase();
+  MapSet();
+}
+
+
+function MapSetupObjectBase() {
+  SetupObjectKeys();
+  map = new Map;
+}
+
+
+function MapSetupObject() {
+  MapSetupObjectBase();
+  MapSet();
+}
+
+
 function MapTearDown() {
   map = null;
 }
 
 
 function MapSet() {
-  MapSetup();
-  MapTearDown();
+  for (var i = 0; i < N; i++) {
+    map.set(keys[i], i);
+  }
 }
 
 
 function MapHas() {
   for (var i = 0; i < N; i++) {
-    if (!map.has(i)) {
+    if (!map.has(keys[i])) {
       throw new Error();
     }
   }
   for (var i = N; i < 2 * N; i++) {
-    if (map.has(i)) {
+    if (map.has(keys[i])) {
       throw new Error();
     }
   }
 }
 
 
 function MapGet() {
   for (var i = 0; i < N; i++) {
-    if (map.get(i) !== i) {
+    if (map.get(keys[i]) !== i) {
       throw new Error();
     }
   }
   for (var i = N; i < 2 * N; i++) {
-    if (map.get(i) !== undefined) {
+    if (map.get(keys[i]) !== undefined) {
       throw new Error();
     }
   }
 }
 
 
 function MapDelete() {
   // This is run more than once per setup so we will end up deleting items
   // more than once. Therefore, we do not the return value of delete.
   for (var i = 0; i < N; i++) {
-    map.delete(i);
+    map.delete(keys[i]);
   }
 }
 
 
 function MapForEach() {
   map.forEach(function(v, k) {
     if (v !== k) {
       throw new Error();
     }
   });
 }