[benchmark] Replace hashValue implementations with hash(into:)

benchmark/CMakeLists.txt

@@ -63,6 +63,7 @@ set(SWIFT_BENCH_MODULES
     single-source/DictTest2
     single-source/DictTest3
     single-source/DictTest4
+    single-source/DictTest4Legacy
     single-source/DictionaryBridge
     single-source/DictionaryCopy
     single-source/DictionaryGroup

benchmark/multi-source/PrimsSplit/Prims.swift

@@ -176,10 +176,9 @@ func ==(lhs: Edge, rhs: Edge) -> Bool {
 }
 
 extension Edge : Hashable {
-  var hashValue: Int {
-    get {
-      return start.hashValue ^ end.hashValue
-    }
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(start)
+    hasher.combine(end)
   }
 }
 

benchmark/single-source/AnyHashableWithAClass.swift

@@ -33,9 +33,11 @@ class TestHashableBase : Hashable {
   init(_ value: Int) {
     self.value = value
   }
-  var hashValue: Int {
-    return value
+
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
+
   static func == (
     lhs: TestHashableBase,
     rhs: TestHashableBase

benchmark/single-source/BinaryFloatingPointConversionFromBinaryInteger.swift

@@ -59,8 +59,8 @@ extension MockBinaryInteger : Comparable {
 }
 
 extension MockBinaryInteger : Hashable {
-  var hashValue: Int {
-    return _value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(_value)
   }
 }
 

benchmark/single-source/DictTest.swift

@@ -157,8 +157,8 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/single-source/DictTest2.swift

@@ -49,8 +49,8 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/single-source/DictTest3.swift

@@ -56,10 +56,10 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
-  
+
   static func ==(lhs: Box, rhs: Box) -> Bool {
     return lhs.value == rhs.value
   }

benchmark/single-source/DictTest4.swift

@@ -16,8 +16,14 @@ import TestsUtils
 // exercising the default hash compression function.
 
 public let Dictionary4 = [
-  BenchmarkInfo(name: "Dictionary4", runFunction: run_Dictionary4, tags: [.validation, .api, .Dictionary]),
-  BenchmarkInfo(name: "Dictionary4OfObjects", runFunction: run_Dictionary4OfObjects, tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(
+    name: "Dictionary4",
+    runFunction: run_Dictionary4,
+    tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(
+    name: "Dictionary4OfObjects",
+    runFunction: run_Dictionary4OfObjects,
+    tags: [.validation, .api, .Dictionary]),
 ]
 
 struct LargeKey: Hashable {
@@ -85,10 +91,10 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
-  
+
   static func ==(lhs: Box, rhs: Box) -> Bool {
     return lhs.value == rhs.value
   }

benchmark/single-source/DictTest4Legacy.swift

@@ -0,0 +1,158 @@
+//===--- DictTest4.swift --------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 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
+
+// This benchmark mostly measures lookups in dictionaries with complex keys,
+// using the legacy hashValue API.
+
+public let Dictionary4Legacy = [
+  BenchmarkInfo(
+    name: "Dictionary4Legacy",
+    runFunction: run_Dictionary4Legacy,
+    tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(
+    name: "Dictionary4OfObjectsLegacy",
+    runFunction: run_Dictionary4OfObjectsLegacy,
+    tags: [.validation, .api, .Dictionary]),
+]
+
+extension Int {
+  mutating func combine(_ value: Int) {
+    self = 16777619 &* self ^ value
+  }
+}
+
+struct LargeKey: Hashable {
+  let i: Int
+  let j: Int
+  let k: Double
+  let l: UInt32
+  let m: Bool
+  let n: Bool
+  let o: Bool
+  let p: Bool
+  let q: Bool
+
+  var hashValue: Int {
+    var hash = i.hashValue
+    hash.combine(j.hashValue)
+    hash.combine(k.hashValue)
+    hash.combine(l.hashValue)
+    hash.combine(m.hashValue)
+    hash.combine(n.hashValue)
+    hash.combine(o.hashValue)
+    hash.combine(p.hashValue)
+    hash.combine(q.hashValue)
+    return hash
+  }
+
+  init(_ value: Int) {
+    self.i = value
+    self.j = 2 * value
+    self.k = Double(value) / 7
+    self.l = UInt32(truncatingIfNeeded: value)
+    self.m = value & 1 == 0
+    self.n = value & 2 == 0
+    self.o = value & 4 == 0
+    self.p = value & 8 == 0
+    self.q = value & 16 == 0
+  }
+}
+
+@inline(never)
+public func run_Dictionary4Legacy(_ N: Int) {
+  let size1 = 100
+  let reps = 20
+  let ref_result = "1 99 \(reps) \(reps * 99)"
+  var hash1 = [LargeKey: Int]()
+  var hash2 = [LargeKey: Int]()
+  var res = ""
+
+  for _ in 1...N {
+    // Test insertions
+    hash1 = [:]
+    for i in 0..<size1 {
+      hash1[LargeKey(i)] = i
+    }
+
+    hash2 = hash1
+
+    // Test lookups & value replacement
+    for _ in 1..<reps {
+      for (k, v) in hash1 {
+        hash2[k] = hash2[k]! + v
+      }
+    }
+
+    res = "\(hash1[LargeKey(1)]!) \(hash1[LargeKey(99)]!)" +
+      " \(hash2[LargeKey(1)]!) \(hash2[LargeKey(99)]!)"
+    if res != ref_result {
+      break
+    }
+  }
+  CheckResults(res == ref_result)
+}
+
+class Box<T : Hashable> : Hashable {
+  var value: T
+
+  init(_ v: T) {
+    value = v
+  }
+
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
+  }
+
+  var hashValue: Int {
+    return value.hashValue
+  }
+
+  static func ==(lhs: Box, rhs: Box) -> Bool {
+    return lhs.value == rhs.value
+  }
+}
+
+@inline(never)
+public func run_Dictionary4OfObjectsLegacy(_ N: Int) {
+  let size1 = 100
+  let reps = 20
+  let ref_result = "1 99 \(reps) \(reps * 99)"
+  var hash1 = [Box<LargeKey>: Int]()
+  var hash2 = [Box<LargeKey>: Int]()
+  var res = ""
+
+  for _ in 1...N {
+    // Test insertions
+    hash1 = [:]
+    for i in 0..<size1 {
+      hash1[Box(LargeKey(i))] = i
+    }
+
+    hash2 = hash1
+
+    // Test lookups & value replacement
+    for _ in 1..<reps {
+      for (k, v) in hash1 {
+        hash2[k] = hash2[k]! + v
+      }
+    }
+
+    res = "\(hash1[Box(LargeKey(1))]!) \(hash1[Box(LargeKey(99))]!)" +
+      " \(hash2[Box(LargeKey(1))]!) \(hash2[Box(LargeKey(99))]!)"
+    if res != ref_result {
+      break
+    }
+  }
+  CheckResults(res == ref_result)
+}

benchmark/single-source/DictionaryGroup.swift

@@ -36,8 +36,8 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/single-source/DictionaryRemove.swift

@@ -52,8 +52,8 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/single-source/DictionarySubscriptDefault.swift

@@ -84,8 +84,8 @@ class Box<T : Hashable> : Hashable, P {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/single-source/DictionarySwap.swift

@@ -83,8 +83,8 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/single-source/Prims.swift

@@ -181,10 +181,9 @@ func ==(lhs: Edge, rhs: Edge) -> Bool {
 }
 
 extension Edge : Hashable {
-  var hashValue: Int {
-    get {
-      return start.hashValue ^ end.hashValue
-    }
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(start)
+    hasher.combine(end)
   }
 }
 

benchmark/single-source/RGBHistogram.swift

@@ -124,8 +124,8 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/single-source/SetTests.swift

@@ -122,8 +122,8 @@ class Box<T : Hashable> : Hashable {
     value = v
   }
 
-  var hashValue: Int {
-    return value.hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
   }
 
   static func ==(lhs: Box, rhs: Box) -> Bool {

benchmark/utils/TestsUtils.swift

@@ -111,8 +111,8 @@ extension BenchmarkInfo : Comparable {
 }
 
 extension BenchmarkInfo : Hashable {
-  public var hashValue: Int {
-    return name.hashValue
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(name)
   }
 }
 

benchmark/utils/main.swift

@@ -50,6 +50,7 @@ import DictTest
 import DictTest2
 import DictTest3
 import DictTest4
+import DictTest4Legacy
 import DictionaryBridge
 import DictionaryCopy
 import DictionaryGroup
@@ -203,6 +204,7 @@ registerBenchmark(Dictionary)
 registerBenchmark(Dictionary2)
 registerBenchmark(Dictionary3)
 registerBenchmark(Dictionary4)
+registerBenchmark(Dictionary4Legacy)
 registerBenchmark(DictionaryBridge)
 registerBenchmark(DictionaryCopy)
 registerBenchmark(DictionaryGroup)