[stdlib] Set, Dictionary: Prepare for per-instance hash seeds

Implement the per-instance seeding infrastructure without actually enabling per-instance seeding.

Author: lorentey

stdlib/public/core/DictionaryStorage.swift

@@ -366,19 +366,21 @@ extension _DictionaryStorage {
     _sanityCheck(capacity >= original._count)
     let scale = _HashTable.scale(forCapacity: capacity)
     let rehash = (scale != original._scale)
-    let newStorage = _DictionaryStorage<Key, Value>.allocate(
-      scale: scale,
-      // Invalidate indices if we're rehashing.
-      age: rehash ? nil : original._age
-    )
+    if rehash {
+      return (.allocate(scale: scale, age: nil, seed: nil), rehash)
+    }
+    return (
+      .allocate(scale: scale, age: original._age, seed: original._seed),
+      rehash)
+    }
     return (newStorage, rehash)
   }
 
   @usableFromInline
   @_effects(releasenone)
   static internal func allocate(capacity: Int) -> _DictionaryStorage {
     let scale = _HashTable.scale(forCapacity: capacity)
-    return allocate(scale: scale, age: nil)
+    return allocate(scale: scale, age: nil, seed: nil)
   }
 
 #if _runtime(_ObjC)
@@ -396,7 +398,8 @@ extension _DictionaryStorage {
 
   static internal func allocate(
     scale: Int8,
-    age: Int32?
+    age: Int32?,
+    seed: Int?
   ) -> _DictionaryStorage {
     // The entry count must be representable by an Int value; hence the scale's
     // peculiar upper bound.
@@ -432,19 +435,10 @@ extension _DictionaryStorage {
         truncatingIfNeeded: ObjectIdentifier(storage).hashValue)
     }
 
+    storage._seed = seed ?? _HashTable.hashSeed(for: storage, scale: scale)
     storage._rawKeys = UnsafeMutableRawPointer(keysAddr)
     storage._rawValues = UnsafeMutableRawPointer(valuesAddr)
 
-    // We use a slightly different hash seed whenever we change the size of the
-    // hash table, so that we avoid certain copy operations becoming quadratic,
-    // without breaking value semantics. (For background details, see
-    // https://bugs.swift.org/browse/SR-3268)
-
-    // FIXME: Use true per-instance seeding instead. Per-capacity seeding still
-    // leaves hash values the same in same-sized tables, which may affect
-    // operations on two tables at once. (E.g., union.)
-    storage._seed = Int(scale)
-
     // Initialize hash table metadata.
     storage._hashTable.clear()
     return storage

stdlib/public/core/HashTable.swift

@@ -89,6 +89,37 @@ extension _HashTable {
     let hash = ObjectIdentifier(cocoa).hashValue
     return Int32(truncatingIfNeeded: hash)
   }
+
+  internal static func hashSeed(
+    for object: AnyObject,
+    scale: Int
+  ) -> Int {
+#if false // FIXME: Enable per-instance seeding
+    // We generate a new hash seed whenever a new hash table is allocated and
+    // whenever an existing table is resized, so that we avoid certain copy
+    // operations becoming quadratic.  (For background details, see
+    // https://bugs.swift.org/browse/SR-3268)
+    //
+    // Note that we do reuse the existing seed when making copy-on-write copies
+    // so that we avoid breaking value semantics.
+    if Hasher._isDeterministic {
+      // When we're using deterministic hashing, the scale value as the seed is
+      // still allowed, and it covers most cases. (Unfortunately some operations
+      // that merge two similar-sized hash tables will still be quadratic.)
+      return scale
+    }
+    // Use the object address as the hash seed. This is cheaper than
+    // SystemRandomNumberGenerator, while it has the same practical effect.
+    // Addresses aren't entirely random, but that's not the goal here -- the
+    // 128-bit execution seed takes care of randomization. We only need to
+    // guarantee that no two tables with the same seed can coexist at the same
+    // time (apart from copy-on-write derivatives of the same table).
+    return unsafeBitCast(object, to: Int.self)
+#else
+    // Use per-capacity seeding for now.
+    return scale
+#endif
+  }
 }
 
 extension _HashTable {

stdlib/public/core/NativeDictionary.swift

@@ -552,7 +552,8 @@ extension _NativeDictionary { // Deletion
       let scale = self._storage._scale
       _storage = _DictionaryStorage<Key, Value>.allocate(
         scale: scale,
-        age: nil)
+        age: nil,
+        seed: nil)
       return
     }
     for bucket in hashTable {

stdlib/public/core/NativeSet.swift

@@ -451,7 +451,10 @@ extension _NativeSet { // Deletion
   internal mutating func removeAll(isUnique: Bool) {
     guard isUnique else {
       let scale = self._storage._scale
-      _storage = _SetStorage<Element>.allocate(scale: scale, age: nil)
+      _storage = _SetStorage<Element>.allocate(
+        scale: scale,
+        age: nil,
+        seed: nil)
       return
     }
     for bucket in hashTable {

stdlib/public/core/SetStorage.swift

@@ -292,19 +292,19 @@ extension _SetStorage {
     _sanityCheck(capacity >= original._count)
     let scale = _HashTable.scale(forCapacity: capacity)
     let rehash = (scale != original._scale)
-    let newStorage = _SetStorage<Element>.allocate(
-      scale: scale,
-      // Invalidate indices if we're rehashing.
-      age: rehash ? nil : original._age
-    )
-    return (newStorage, rehash)
+    if rehash {
+      return .allocate(scale: scale, age: nil, seed: nil)
+    }
+    return (
+      .allocate(scale: scale, age: original._age, seed: original._seed),
+      rehash)
   }
 
   @usableFromInline
   @_effects(releasenone)
   static internal func allocate(capacity: Int) -> _SetStorage {
     let scale = _HashTable.scale(forCapacity: capacity)
-    return allocate(scale: scale, age: nil)
+    return allocate(scale: scale, age: nil, seed: nil)
   }
 
 #if _runtime(_ObjC)
@@ -316,13 +316,14 @@ extension _SetStorage {
   ) -> _SetStorage {
     let scale = _HashTable.scale(forCapacity: capacity)
     let age = _HashTable.age(for: cocoa.object)
-    return allocate(scale: scale, age: age)
+    return allocate(scale: scale, age: age, seed: nil)
   }
 #endif
 
   static internal func allocate(
     scale: Int8,
-    age: Int32?
+    age: Int32?,
+    seed: Int?
   ) -> _SetStorage {
     // The entry count must be representable by an Int value; hence the scale's
     // peculiar upper bound.
@@ -354,18 +355,9 @@ extension _SetStorage {
         truncatingIfNeeded: ObjectIdentifier(storage).hashValue)
     }
 
+    storage._seed = seed ?? _HashTable.hashSeed(for: storage, scale: scale)
     storage._rawElements = UnsafeMutableRawPointer(elementsAddr)
 
-    // We use a slightly different hash seed whenever we change the size of the
-    // hash table, so that we avoid certain copy operations becoming quadratic,
-    // without breaking value semantics. (For background details, see
-    // https://bugs.swift.org/browse/SR-3268)
-
-    // FIXME: Use true per-instance seeding instead. Per-capacity seeding still
-    // leaves hash values the same in same-sized tables, which may affect
-    // operations on two tables at once. (E.g., union.)
-    storage._seed = Int(scale)
-
     // Initialize hash table metadata.
     storage._hashTable.clear()
     return storage