Merge pull request #15239 from lorentey/intentionally-linear

[stdlib] Set, Dictionary: Mix the hash table size into the hash seed

Author: lorentey

stdlib/public/core/HashedCollections.swift.gyb

@@ -3172,6 +3172,9 @@ internal class _RawNative${Self}Storage:
   internal final var values: UnsafeMutableRawPointer
 % end
 
+  @_versioned // FIXME(sil-serialize-all)
+  internal final var seed: (UInt64, UInt64)
+
   // This API is unsafe and needs a `_fixLifetime` in the caller.
   @_inlineable // FIXME(sil-serialize-all)
   @_versioned // FIXME(sil-serialize-all)
@@ -3626,6 +3629,19 @@ internal struct _Native${Self}Buffer<${TypeParameters}> {
         bucketCount._builtinWordValue, Key.self, Value.self)
     _storage.values = UnsafeMutableRawPointer(valuesAddr)
 %end
+    // We assign a unique hash seed to each distinct hash table size, so that we
+    // avoid certain copy operations becoming quadratic, without breaking value
+    // semantics. (See https://bugs.swift.org/browse/SR-3268)
+    //
+    // We don't need to generate a brand new seed for each table size: it's
+    // enough to change a single bit in the global seed by XORing the bucket
+    // count to it. (The bucket count is always a power of two.)
+    //
+    // FIXME: Use an approximation of true per-instance seeding. We can't just
+    // use the base address, because COW copies need to share the same seed.
+    let seed = _Hasher._seed
+    let perturbation = bucketCount
+    _storage.seed = (seed.0 ^ UInt64(truncatingIfNeeded: perturbation), seed.1)
   }
 
   // Forwarding the individual fields of the storage in various forms
@@ -3990,7 +4006,9 @@ extension _Native${Self}Buffer
   @_versioned
   @inline(__always) // For performance reasons.
   internal func _bucket(_ k: Key) -> Int {
-    return _hashValue(for: k) & _bucketMask
+    var hasher = _Hasher(seed: _storage.seed)
+    hasher.append(k)
+    return hasher.finalize() & _bucketMask
   }
 
   @_inlineable // FIXME(sil-serialize-all)

validation-test/stdlib/Dictionary.swift

@@ -4574,6 +4574,48 @@ DictionaryTestSuite.test("removeAt") {
   }
 }
 
+DictionaryTestSuite.test("localHashSeeds") {
+  // With global hashing, copying elements in hash order between hash tables
+  // can become quadratic. (See https://bugs.swift.org/browse/SR-3268)
+  //
+  // We defeat this by mixing the local storage capacity into the global hash
+  // seed, thereby breaking the correlation between bucket indices across
+  // hash tables with different sizes.
+  //
+  // Verify this works by copying a small sampling of elements near the
+  // beginning of a large Dictionary into a smaller one. If the elements end up
+  // in the same order in the smaller Dictionary, then that indicates we do not
+  // use size-dependent seeding.
+
+  let count = 100_000
+  // Set a large table size to reduce frequency/length of collision chains.
+  var large = [Int: Int](minimumCapacity: 4 * count)
+  for i in 1 ..< count {
+    large[i] = 2 * i
+  }
+
+  let bunch = count / 100 // 1 percent's worth of elements
+
+  // Copy two bunches of elements into another dictionary that's half the size
+  // of the first. We start after the initial bunch because the hash table may
+  // begin with collided elements wrapped over from the end, and these would be
+  // sorted into irregular slots in the smaller table.
+  let slice = large.prefix(3 * bunch).dropFirst(bunch)
+  var small = [Int: Int](minimumCapacity: large.capacity / 2)
+  expectLT(small.capacity, large.capacity)
+  for (key, value) in slice {
+    small[key] = value
+  }
+
+  // Compare the second halves of the new dictionary and the slice.  Ignore the
+  // first halves; the first few elements may not be in the correct order if we
+  // happened to start copying from the middle of a collision chain.
+  let smallKeys = small.dropFirst(bunch).map { $0.key }
+  let sliceKeys = slice.dropFirst(bunch).map { $0.key }
+  // If this test fails, there is a problem with local hash seeding.
+  expectFalse(smallKeys.elementsEqual(sliceKeys))
+}
+
 DictionaryTestSuite.setUp {
   resetLeaksOfDictionaryKeysValues()
 #if _runtime(_ObjC)

validation-test/stdlib/Set.swift

@@ -4258,4 +4258,46 @@ SetTestSuite.test("SetAlgebra.UpdateWith.EmptySet") {
   expectOptionalEqual(1010, member2)
 }
 
+SetTestSuite.test("localHashSeeds") {
+  // With global hashing, copying elements in hash order between hash tables
+  // can become quadratic. (See https://bugs.swift.org/browse/SR-3268)
+  //
+  // We defeat this by mixing the local storage capacity into the global hash
+  // seed, thereby breaking the correlation between bucket indices across
+  // hash tables with different sizes.
+  //
+  // Verify this works by copying a small sampling of elements near the
+  // beginning of a large Set into a smaller one. If the elements end up in the
+  // same order in the smaller Set, then that indicates we do not use
+  // size-dependent seeding.
+
+  let count = 100_000
+  // Set a large table size to reduce frequency/length of collision chains.
+  var large = Set<Int>(minimumCapacity: 4 * count)
+  for i in 1 ..< count {
+    large.insert(i)
+  }
+
+  let bunch = count / 100 // 1 percent's worth of elements
+
+  // Copy two bunches of elements into another set that's half the size of the
+  // first. We start after the initial bunch because the hash table may begin
+  // with collided elements wrapped over from the end, and these would be sorted
+  // into irregular slots in the smaller table.
+  let slice = large.prefix(3 * bunch).dropFirst(bunch)
+  var small = Set<Int>(minimumCapacity: large.capacity / 2)
+  expectLT(small.capacity, large.capacity)
+  for element in slice {
+    small.insert(element)
+  }
+
+  // Compare the second halves of the new set and the slice.  Ignore the first
+  // halves; the first few elements may not be in the correct order if we
+  // happened to start copying from the middle of a collision chain.
+  let smallElements = small.dropFirst(bunch)
+  let sliceElements = slice.dropFirst(bunch)
+  // If this test fails, there is a problem with local hash seeding.
+  expectFalse(smallElements.elementsEqual(sliceElements))
+}
+
 runAllTests()