[vm] Don't allocate a backing store for maps until the first insert.

Empty maps are fairly common; delaying allocation of the backing store saves time and memory for empty maps. Non-empty maps probe an extra time for the first insert.

Most maps also have few associations, so reducing the initial backing store size also saves memory on balance. The best value for dart2js would be 2 associations, but this CL changes it to 4 as a compromise with other benchmarks on Golem.

Runtime as Score geomean              2.620%
MemoryUse geomean                    -5.233%
dart2js CompileSwarmLatest            0%
dart2js CompileSwarmLastedMemoryUse -10.51%

TEST=ci
Bug: #26081
Change-Id: I80a925f698f3df44fae5e97e1804c8dff2ce0c60
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/176583
Reviewed-by: Alexander Markov <[email protected]>
Reviewed-by: Stephen Adams <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

runtime/vm/object.h

@@ -10507,7 +10507,7 @@ class LinkedHashMap : public Instance {
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap, Instance);
 
   // Keep this in sync with Dart implementation (lib/compact_hash.dart).
-  static const intptr_t kInitialIndexBits = 3;
+  static const intptr_t kInitialIndexBits = 2;
   static const intptr_t kInitialIndexSize = 1 << (kInitialIndexBits + 1);
 
   // Allocate a map, but leave all fields set to null.

runtime/vm/object_test.cc

@@ -4667,73 +4667,6 @@ TEST_CASE(HashCode) {
   EXPECT(result.IsIdenticalTo(expected));
 }
 
-static void CheckIdenticalHashStructure(Thread* T,
-                                        const Instance& a,
-                                        const Instance& b) {
-  const char* kScript =
-      "(a, b) {\n"
-      "  if (a._usedData != b._usedData ||\n"
-      "      a._deletedKeys != b._deletedKeys ||\n"
-      "      a._hashMask != b._hashMask ||\n"
-      "      a._index.length != b._index.length ||\n"
-      "      a._data.length != b._data.length) {\n"
-      "    return false;\n"
-      "  }\n"
-      "  for (var i = 0; i < a._index.length; ++i) {\n"
-      "    if (a._index[i] != b._index[i]) {\n"
-      "      return false;\n"
-      "    }\n"
-      "  }\n"
-      "  for (var i = 0; i < a._data.length; ++i) {\n"
-      "    var ad = a._data[i];\n"
-      "    var bd = b._data[i];\n"
-      "    if (!identical(ad, bd) && !(ad == a && bd == b)) {\n"
-      "      return false;\n"
-      "    }\n"
-      "  }\n"
-      "  return true;\n"
-      "}(a, b)";
-  String& name = String::Handle();
-  Array& param_names = Array::Handle(Array::New(2));
-  name = String::New("a");
-  param_names.SetAt(0, name);
-  name = String::New("b");
-  param_names.SetAt(1, name);
-  Array& param_values = Array::Handle(Array::New(2));
-  param_values.SetAt(0, a);
-  param_values.SetAt(1, b);
-  name = String::New(kScript);
-  Library& lib = Library::Handle(Library::CollectionLibrary());
-  EXPECT(Api::UnwrapHandle(TestCase::EvaluateExpression(
-             lib, name, param_names, param_values)) == Bool::True().raw());
-}
-
-TEST_CASE(LinkedHashMap) {
-  // Check that initial index size and hash mask match in Dart vs. C++.
-  // 1. Create an empty custom linked hash map in Dart.
-  const char* kScript =
-      "import 'dart:collection';\n"
-      "makeMap() {\n"
-      "  bool Function(dynamic, dynamic) eq = (a, b) => true;\n"
-      "  int Function(dynamic) hc = (a) => 42;\n"
-      "  return new LinkedHashMap(equals: eq, hashCode: hc);\n"
-      "}";
-  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, NULL);
-  EXPECT_VALID(h_lib);
-  Dart_Handle h_result = Dart_Invoke(h_lib, NewString("makeMap"), 0, NULL);
-  EXPECT_VALID(h_result);
-
-  TransitionNativeToVM transition(thread);
-
-  // 2. Create an empty internalized LinkedHashMap in C++.
-  Instance& dart_map = Instance::Handle();
-  dart_map ^= Api::UnwrapHandle(h_result);
-  LinkedHashMap& cc_map = LinkedHashMap::Handle(LinkedHashMap::NewDefault());
-
-  // 3. Expect them to have identical structure.
-  CheckIdenticalHashStructure(thread, dart_map, cc_map);
-}
-
 TEST_CASE(LinkedHashMap_iteration) {
   const char* kScript =
       "makeMap() {\n"

sdk/lib/_internal/vm/lib/compact_hash.dart

@@ -24,13 +24,13 @@ abstract class _HashFieldBase {
   // least one unoccupied entry.
   // NOTE: When maps are deserialized, their _index and _hashMask is regenerated
   // eagerly by _regenerateIndex.
-  Uint32List _index = new Uint32List(_HashBase._INITIAL_INDEX_SIZE);
+  Uint32List _index = _initialIndex;
 
   // Cached in-place mask for the hash pattern component.
-  int _hashMask = _HashBase._indexSizeToHashMask(_HashBase._INITIAL_INDEX_SIZE);
+  int _hashMask = 0;
 
   // Fixed-length list of keys (set) or key/value at even/odd indices (map).
-  List _data;
+  List _data = _initialData;
 
   // Length of _data that is used (i.e., keys + values for a map).
   int _usedData = 0;
@@ -41,7 +41,7 @@ abstract class _HashFieldBase {
   // Note: All fields are initialized in a single constructor so that the VM
   // recognizes they cannot hold null values. This makes a big (20%) performance
   // difference on some operations.
-  _HashFieldBase(int dataSize) : this._data = new List.filled(dataSize, null);
+  _HashFieldBase(int dataSize);
 }
 
 // Base class for VM-internal classes; keep in sync with _HashFieldBase.
@@ -97,7 +97,7 @@ abstract class _HashBase implements _HashVMBase {
   // are doubled when _data is full. Thus, _index will have a max load factor
   // of 1/2, which enables one more bit to be used for the hash.
   // TODO(koda): Consider growing _data by factor sqrt(2), twice as often.
-  static const int _INITIAL_INDEX_BITS = 3;
+  static const int _INITIAL_INDEX_BITS = 2;
   static const int _INITIAL_INDEX_SIZE = 1 << (_INITIAL_INDEX_BITS + 1);
 
   // Unused and deleted entries are marked by 0 and 1, respectively.
@@ -155,6 +155,12 @@ class _IdenticalAndIdentityHashCode {
   bool _equals(e1, e2) => identical(e1, e2);
 }
 
+final _initialIndex = new Uint32List(1);
+// Note: not const. Const arrays are made immutable by having a different class
+// than regular arrays that throws on element assignment. We want the data field
+// in maps and sets to be monomorphic.
+final _initialData = new List.filled(0, null);
+
 // VM-internalized implementation of a default-constructed LinkedHashMap.
 @pragma("vm:entry-point")
 class _InternalLinkedHashMap<K, V> extends _HashVMBase
@@ -165,9 +171,9 @@ class _InternalLinkedHashMap<K, V> extends _HashVMBase
         _OperatorEqualsAndHashCode
     implements LinkedHashMap<K, V> {
   _InternalLinkedHashMap() {
-    _index = new Uint32List(_HashBase._INITIAL_INDEX_SIZE);
-    _hashMask = _HashBase._indexSizeToHashMask(_HashBase._INITIAL_INDEX_SIZE);
-    _data = new List.filled(_HashBase._INITIAL_INDEX_SIZE, null);
+    _index = _initialIndex;
+    _hashMask = 0;
+    _data = _initialData;
     _usedData = 0;
     _deletedKeys = 0;
   }
@@ -202,6 +208,10 @@ abstract class _LinkedHashMapMixin<K, V> implements _HashBase {
 
   // Allocate new _index and _data, and optionally copy existing contents.
   void _init(int size, int hashMask, List? oldData, int oldUsed) {
+    if (size < _HashBase._INITIAL_INDEX_SIZE) {
+      size = _HashBase._INITIAL_INDEX_SIZE;
+      hashMask = _HashBase._indexSizeToHashMask(size);
+    }
     assert(size & (size - 1) == 0);
     assert(_HashBase._UNUSED_PAIR == 0);
     _index = new Uint32List(size);
@@ -222,7 +232,7 @@ abstract class _LinkedHashMapMixin<K, V> implements _HashBase {
 
   // This method is called by [_rehashObjects] (see above).
   void _regenerateIndex() {
-    _index = new Uint32List(_data.length);
+    _index = _data.length == 0 ? _initialIndex : new Uint32List(_data.length);
     assert(_hashMask == 0);
     _hashMask = _HashBase._indexSizeToHashMask(_index.length);
     final int tmpUsed = _usedData;
@@ -526,6 +536,10 @@ class _CompactLinkedHashSet<E> extends _HashFieldBase
   }
 
   void _init(int size, int hashMask, List? oldData, int oldUsed) {
+    if (size < _HashBase._INITIAL_INDEX_SIZE) {
+      size = _HashBase._INITIAL_INDEX_SIZE;
+      hashMask = _HashBase._indexSizeToHashMask(size);
+    }
     _index = new Uint32List(size);
     _hashMask = hashMask;
     _data = new List.filled(size >> 1, null);