[4.0] Move Dictionary(grouping:by) down a level (#10450)

* [benchmark] Add benchmark for Dictionary(group:by:)

* [benchmark] Fix the Dictionary(group:by:) test

When testing quadratic behavior, remember to repeat small amounts of the
behavior several times, not to increase the N, which is squared. :roll_eyes:

* [stdlib] Move Dictionary(grouping:by) down a level

Author: natecook1000

benchmark/CMakeLists.txt

@@ -40,6 +40,7 @@ set(SWIFT_BENCH_MODULES
     single-source/DictTest2
     single-source/DictTest3
     single-source/DictionaryBridge
+    single-source/DictionaryGroup
     single-source/DictionaryLiteral
     single-source/DictionaryRemove
     single-source/DictionarySwap

benchmark/single-source/DictionaryGroup.swift

@@ -0,0 +1,51 @@
+//===--- DictionaryGroup.swift --------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+let count = 10_000
+let result = count / 10
+
+@inline(never)
+public func run_DictionaryGroup(_ N: Int) {
+  for _ in 1...N {
+    let dict = Dictionary(grouping: 0..<count, by: { $0 % 10 })
+    CheckResults(dict.count == 10)
+    CheckResults(dict[0]!.count == result)
+  }
+}
+
+class Box<T : Hashable> : Hashable {
+  var value: T
+
+  init(_ v: T) {
+    value = v
+  }
+
+  var hashValue: Int {
+    return value.hashValue
+  }
+
+  static func ==(lhs: Box, rhs: Box) -> Bool {
+    return lhs.value == rhs.value
+  }
+}
+
+@inline(never)
+public func run_DictionaryGroupOfObjects(_ N: Int) {
+  let objects = (0..<count).map { Box($0) }
+  for _ in 1...N {
+    let dict = Dictionary(grouping: objects, by: { Box($0.value % 10) })
+    CheckResults(dict.count == 10)
+    CheckResults(dict[Box(0)]!.count == result)
+  }
+}

benchmark/utils/main.swift

@@ -45,6 +45,7 @@ import DictTest
 import DictTest2
 import DictTest3
 import DictionaryBridge
+import DictionaryGroup
 import DictionaryLiteral
 import DictionaryRemove
 import DictionarySwap
@@ -181,6 +182,8 @@ addTo(&precommitTests, "Dictionary2OfObjects", run_Dictionary2OfObjects)
 addTo(&precommitTests, "Dictionary3", run_Dictionary3)
 addTo(&precommitTests, "Dictionary3OfObjects", run_Dictionary3OfObjects)
 addTo(&precommitTests, "DictionaryBridge", run_DictionaryBridge)
+addTo(&precommitTests, "DictionaryGroup", run_DictionaryGroup)
+addTo(&precommitTests, "DictionaryGroupOfObjects", run_DictionaryGroupOfObjects)
 addTo(&precommitTests, "DictionaryLiteral", run_DictionaryLiteral)
 addTo(&precommitTests, "DictionaryOfObjects", run_DictionaryOfObjects)
 addTo(&precommitTests, "DictionaryRemove", run_DictionaryRemove)

stdlib/public/core/HashedCollections.swift.gyb

@@ -1810,9 +1810,7 @@ public struct Dictionary<Key : Hashable, Value> :
     by keyForValue: (S.Element) throws -> Key
   ) rethrows where Value == [S.Element] {
     self = [:]
-    for value in values {
-      self[try keyForValue(value), default: []].append(value)
-    }
+    try _variantBuffer.nativeGroup(values, by: keyForValue)
   }
 
   internal init(_nativeBuffer: _NativeDictionaryBuffer<Key, Value>) {
@@ -5053,6 +5051,32 @@ internal enum _Variant${Self}Buffer<${TypeParametersDecl}> : _HashBuffer {
 #endif
     }
   }
+
+  internal mutating func nativeGroup<S: Sequence>(
+    _ values: S,
+    by keyForValue: (S.Element) throws -> Key
+  ) rethrows where Value == [S.Element] {
+    defer { _fixLifetime(asNative) }
+    for value in values {
+      let key = try keyForValue(value)
+      var (i, found) = asNative._find(key, startBucket: asNative._bucket(key))
+      if found {
+        asNative.values[i.offset].append(value)
+      } else {
+        let minCapacity = NativeBuffer.minimumCapacity(
+          minimumCount: asNative.count + 1,
+          maxLoadFactorInverse: _hashContainerDefaultMaxLoadFactorInverse)
+
+        let (_, capacityChanged) = ensureUniqueNativeBuffer(minCapacity)
+        if capacityChanged {
+          i = asNative._find(key, startBucket: asNative._bucket(key)).pos
+        }
+
+        asNative.initializeKey(key, value: [value], at: i.offset)
+        asNative.count += 1
+      }
+    }
+  }
 %end
 
   /// - parameter idealBucket: The ideal bucket for the element being deleted.