[temp] Per-instance hash seeds

Author: lorentey

stdlib/public/core/DictionaryStorage.swift

@@ -366,24 +366,30 @@ 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
-    )
+    let newStorage: _DictionaryStorage<Key, Value>
+    if rehash {
+      // Invalidate indices and generate a new seed.
+      newStorage = .allocate(scale: scale, age: nil, seed: nil)
+    } else {
+      newStorage = .allocate(
+        scale: scale,
+        age: original._age,
+        seed: original._seed)
+    }
     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)
   }
 
   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.
@@ -419,19 +425,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

@@ -83,6 +83,32 @@ extension _HashTable {
     _sanityCheck(self.capacity(forScale: scale) >= capacity)
     return scale
   }
+
+  internal static func hashSeed(
+    for object: AnyObject,
+    scale: Int8
+  ) -> Int {
+    // 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 Int(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)
+  }
 }
 
 extension _HashTable {

stdlib/public/core/NativeDictionary.swift

@@ -535,10 +535,10 @@ extension _NativeDictionary { // Deletion
   @usableFromInline
   internal mutating func removeAll(isUnique: Bool) {
     guard isUnique else {
-      let scale = self._storage._scale
       _storage = _DictionaryStorage<Key, Value>.allocate(
-        scale: scale,
-        age: nil)
+        scale: _storage._scale,
+        age: nil,
+        seed: nil)
       return
     }
     for bucket in hashTable {

stdlib/public/core/NativeSet.swift

@@ -431,8 +431,10 @@ extension _NativeSet { // Deletion
   @usableFromInline
   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: _storage._scale,
+        age: nil,
+        seed: nil)
       return
     }
     for bucket in hashTable {

stdlib/public/core/SetStorage.swift

@@ -292,24 +292,30 @@ 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
-    )
+    let newStorage: _SetStorage<Element>
+    if rehash {
+      // Invalidate indices and generate a new seed.
+      newStorage = .allocate(scale: scale, age: nil, seed: nil)
+    } else {
+      newStorage = .allocate(
+        scale: scale,
+        age: original._age,
+        seed: original._seed)
+    }
     return (newStorage, 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)
   }
 
   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.
@@ -341,18 +347,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