[stdlib] Switch to using SipHash-1-3 as the standard hash function

Beyond switching hashing algorithms, this also enables per-execution hash seeds, fulfilling a long-standing prophecy in Hashable’s documentation.

To reduce the possibility of random test failures, StdlibUnittest’s TestSuite overrides the random hash seed on initialization.

rdar://problem/24109692
rdar://problem/35052153

Author: lorentey

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -1089,6 +1089,15 @@ struct PersistentState {
   static var runNoTestsWasCalled: Bool = false
   static var ranSomething: Bool = false
   static var complaintInstalled = false
+  static var hashingKeyOverridden = false
+
+  static func overrideHashingKey() {
+    if !hashingKeyOverridden {
+      // FIXME(hasher): This has to run before creating the first Set/Dictionary
+      _Hasher._secretKey = (0, 0)
+      hashingKeyOverridden = true
+    }
+  }
 
   static func complainIfNothingRuns() {
     if !complaintInstalled {
@@ -1200,6 +1209,7 @@ func stopTrackingObjects(_: UnsafePointer<CChar>) -> Int
 
 public final class TestSuite {
   public init(_ name: String) {
+    PersistentState.overrideHashingKey()
     self.name = name
     _precondition(
       _testNameToIndex[name] == nil,

stdlib/public/core/Hashing.swift

@@ -216,7 +216,7 @@ internal struct _LegacyHasher {
 
 // NOT @_fixed_layout
 public struct _Hasher {
-  internal typealias Core = _LegacyHasher
+  internal typealias Core = _SipHash13
 
   // NOT @_versioned
   internal var _core: Core

stdlib/public/core/SipHash.swift.gyb

@@ -19,63 +19,20 @@
 /// * Daniel J. Bernstein <[email protected]>
 //===----------------------------------------------------------------------===//
 
+%{
+# Number of bits in the Builtin.Word type
+word_bits = int(CMAKE_SIZEOF_VOID_P) * 8
+}%
+
 @_fixed_layout // FIXME(sil-serialize-all)
 @_versioned
 internal enum _SipHashDetail {
-  @_inlineable // FIXME(sil-serialize-all)
-  @_versioned
-  @inline(__always)
-  internal static func _rotate(_ x: UInt64, leftBy amount: Int) -> UInt64 {
-    return (x &<< UInt64(amount)) | (x &>> UInt64(64 - amount))
-  }
-
-  @_inlineable // FIXME(sil-serialize-all)
-  @_versioned
-  @inline(__always)
-  internal static func _loadUnalignedUInt64LE(
-    from p: UnsafeRawPointer
-  ) -> UInt64 {
-    // FIXME(integers): split into multiple expressions to speed up the
-    // typechecking
-    var result =
-      UInt64(p.load(fromByteOffset: 0, as: UInt8.self))
-    result |=
-      (UInt64(p.load(fromByteOffset: 1, as: UInt8.self)) &<< (8 as UInt64))
-    result |=
-      (UInt64(p.load(fromByteOffset: 2, as: UInt8.self)) &<< (16 as UInt64))
-    result |=
-      (UInt64(p.load(fromByteOffset: 3, as: UInt8.self)) &<< (24 as UInt64))
-    result |=
-      (UInt64(p.load(fromByteOffset: 4, as: UInt8.self)) &<< (32 as UInt64))
-    result |=
-      (UInt64(p.load(fromByteOffset: 5, as: UInt8.self)) &<< (40 as UInt64))
-    result |=
-      (UInt64(p.load(fromByteOffset: 6, as: UInt8.self)) &<< (48 as UInt64))
-    result |=
-      (UInt64(p.load(fromByteOffset: 7, as: UInt8.self)) &<< (56 as UInt64))
-    return result
-  }
-
-  @_inlineable // FIXME(sil-serialize-all)
   @_versioned
   @inline(__always)
-  internal static func _loadPartialUnalignedUInt64LE(
-    from p: UnsafeRawPointer,
-    byteCount: Int
-  ) -> UInt64 {
-    _sanityCheck((0..<8).contains(byteCount))
-    var result: UInt64 = 0
-    if byteCount >= 1 { result |= UInt64(p.load(fromByteOffset: 0, as: UInt8.self)) }
-    if byteCount >= 2 { result |= UInt64(p.load(fromByteOffset: 1, as: UInt8.self)) &<< (8 as UInt64) }
-    if byteCount >= 3 { result |= UInt64(p.load(fromByteOffset: 2, as: UInt8.self)) &<< (16 as UInt64) }
-    if byteCount >= 4 { result |= UInt64(p.load(fromByteOffset: 3, as: UInt8.self)) &<< (24 as UInt64) }
-    if byteCount >= 5 { result |= UInt64(p.load(fromByteOffset: 4, as: UInt8.self)) &<< (32 as UInt64) }
-    if byteCount >= 6 { result |= UInt64(p.load(fromByteOffset: 5, as: UInt8.self)) &<< (40 as UInt64) }
-    if byteCount >= 7 { result |= UInt64(p.load(fromByteOffset: 6, as: UInt8.self)) &<< (48 as UInt64) }
-    return result
+  internal static func _rotate(_ x: UInt64, leftBy amount: UInt64) -> UInt64 {
+    return (x &<< amount) | (x &>> (64 - amount))
   }
 
-  @_inlineable // FIXME(sil-serialize-all)
   @_versioned
   @inline(__always)
   internal static func _sipRound(
@@ -102,7 +59,7 @@ internal enum _SipHashDetail {
 }
 
 % for (c_rounds, d_rounds) in [(2, 4), (1, 3)]:
-%   Self = '_SipHash{}{}Context'.format(c_rounds, d_rounds)
+%   Self = '_SipHash{}{}'.format(c_rounds, d_rounds)
 
 @_fixed_layout // FIXME(sil-serialize-all)
 public // @testable
@@ -120,181 +77,125 @@ struct ${Self} {
   @_versioned
   internal var v3: UInt64 = 0x7465646279746573
 
+  /// This value holds the byte count and the pending bytes that haven't been
+  /// compressed yet, in the format that the finalization step needs. (The least
+  /// significant 56 bits hold the trailing bytes, while the most significant 8
+  /// bits hold the count of bytes appended so far, mod 256.)
   @_versioned
-  internal var hashedByteCount: UInt64 = 0
-
-  @_versioned
-  internal var dataTail: UInt64 = 0
-
-  @_versioned
-  internal var dataTailByteCount: Int = 0
+  internal var tailAndByteCount: UInt64 = 0
 
-  @_versioned
-  internal var finalizedHash: UInt64?
-
-  @_inlineable // FIXME(sil-serialize-all)
+  @inline(__always)
   public init(key: (UInt64, UInt64)) {
     v3 ^= key.1
     v2 ^= key.0
     v1 ^= key.1
     v0 ^= key.0
   }
 
-  // FIXME(ABI)#62 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
-  @_inlineable // FIXME(sil-serialize-all)
-  public // @testable
-  mutating func append(_ data: UnsafeRawPointer, byteCount: Int) {
-    _append_alwaysInline(data, byteCount: byteCount)
-  }
-
-  // FIXME(ABI)#63 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
-  @_inlineable // FIXME(sil-serialize-all)
   @_versioned
-  @inline(__always)
-  internal mutating func _append_alwaysInline(
-    _ data: UnsafeRawPointer,
-    byteCount: Int
-  ) {
-    precondition(finalizedHash == nil)
-    _sanityCheck((0..<8).contains(dataTailByteCount))
-
-    let dataEnd = data + byteCount
-
-    var data = data
-    var byteCount = byteCount
-    if dataTailByteCount != 0 {
-      let restByteCount = min(
-        MemoryLayout<UInt64>.size - dataTailByteCount,
-        byteCount)
-      let rest = _SipHashDetail._loadPartialUnalignedUInt64LE(
-        from: data,
-        byteCount: restByteCount)
-      dataTail |= rest &<< UInt64(dataTailByteCount * 8)
-      dataTailByteCount += restByteCount
-      data += restByteCount
-      byteCount -= restByteCount
-    }
-
-    if dataTailByteCount == MemoryLayout<UInt64>.size {
-      _appendDirectly(dataTail)
-      dataTail = 0
-      dataTailByteCount = 0
-    } else if dataTailByteCount != 0 {
-      _sanityCheck(data == dataEnd)
-      return
-    }
-
-    let endOfWords =
-      data + byteCount - (byteCount % MemoryLayout<UInt64>.size)
-    while data != endOfWords {
-      _appendDirectly(_SipHashDetail._loadUnalignedUInt64LE(from: data))
-      data += 8
-      // No need to update `byteCount`, it is not used beyond this point.
+  internal var byteCount: UInt64 {
+    @inline(__always)
+    get {
+      return tailAndByteCount &>> 56
     }
+  }
 
-    if data != dataEnd {
-      dataTailByteCount = dataEnd - data
-      dataTail = _SipHashDetail._loadPartialUnalignedUInt64LE(
-        from: data,
-        byteCount: dataTailByteCount)
+  @_versioned
+  internal var tail: UInt64 {
+    @inline(__always)
+    get {
+      return tailAndByteCount & ~(0xFF &<< 56)
     }
   }
 
-  /// This function mixes in the given word directly into the state,
-  /// ignoring `dataTail`.
-  @_inlineable // FIXME(sil-serialize-all)
-  @_versioned
   @inline(__always)
-  internal mutating func _appendDirectly(_ m: UInt64) {
+  @_versioned
+  internal mutating func _compress(_ m: UInt64) {
     v3 ^= m
     for _ in 0..<${c_rounds} {
       _SipHashDetail._sipRound(v0: &v0, v1: &v1, v2: &v2, v3: &v3)
     }
     v0 ^= m
-    hashedByteCount += 8
   }
 
-% for data_type in ['UInt', 'Int', 'UInt64', 'Int64', 'UInt32', 'Int32']:
-  @_inlineable // FIXME(sil-serialize-all)
-  public // @testable
-  mutating func append(_ data: ${data_type}) {
-    var data = data
-    _append_alwaysInline(&data, byteCount: MemoryLayout.size(ofValue: data))
+  @inline(__always)
+  public mutating func append(_ value: Int) {
+    append(UInt(bitPattern: value))
   }
-% end
 
-  @_inlineable // FIXME(sil-serialize-all)
-  public // @testable
-  mutating func finalizeAndReturnHash() -> UInt64 {
-    return _finalizeAndReturnHash_alwaysInline()
+  @inline(__always)
+  public mutating func append(_ value: UInt) {
+    % if word_bits == 64:
+    append(UInt64(_truncatingBits: value._lowWord))
+    % elif word_bits == 32:
+    append(UInt32(_truncatingBits: value._lowWord))
+    % else:
+    fatalError("Unsupported word width")
+    % end
   }
 
-  @_inlineable // FIXME(sil-serialize-all)
-  @_versioned
   @inline(__always)
-  internal mutating func _finalizeAndReturnHash_alwaysInline() -> UInt64 {
-    if let finalizedHash = finalizedHash {
-      return finalizedHash
-    }
-
-    _sanityCheck((0..<8).contains(dataTailByteCount))
-
-    hashedByteCount += UInt64(dataTailByteCount)
-    let b: UInt64 = (hashedByteCount << 56) | dataTail
-
-    v3 ^= b
-    for _ in 0..<${c_rounds} {
-      _SipHashDetail._sipRound(v0: &v0, v1: &v1, v2: &v2, v3: &v3)
-    }
-    v0 ^= b
-
-    v2 ^= 0xff
+  public mutating func append(_ value: Int32) {
+    append(UInt32(bitPattern: value))
+  }
 
-    for _ in 0..<${d_rounds} {
-      _SipHashDetail._sipRound(v0: &v0, v1: &v1, v2: &v2, v3: &v3)
+  @inline(__always)
+  public mutating func append(_ value: UInt32) {
+    let m = UInt64(_truncatingBits: value._lowWord)
+    if byteCount & 4 == 0 {
+      _sanityCheck(byteCount & 7 == 0 && tail == 0)
+      tailAndByteCount = (tailAndByteCount | m) &+ (4 &<< 56)
+    } else {
+      _sanityCheck(byteCount & 3 == 0)
+      _compress((m &<< 32) | tail)
+      tailAndByteCount = (byteCount &+ 4) &<< 56
     }
+  }
 
-    finalizedHash = v0 ^ v1 ^ v2 ^ v3
-    return finalizedHash!
+  @inline(__always)
+  public mutating func append(_ value: Int64) {
+    append(UInt64(bitPattern: value))
   }
 
-  @_inlineable // FIXME(sil-serialize-all)
-  @_versioned // FIXME(sil-serialize-all)
-  internal mutating func _finalizeAndReturnIntHash() -> Int {
-    let hash: UInt64 = finalizeAndReturnHash()
-#if arch(i386) || arch(arm)
-    return Int(truncatingIfNeeded: hash)
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
-    return Int(Int64(bitPattern: hash))
-#endif
+  @inline(__always)
+  public mutating func append(_ m: UInt64) {
+    if byteCount & 4 == 0 {
+      _sanityCheck(byteCount & 7 == 0 && tail == 0)
+      _compress(m)
+      tailAndByteCount = tailAndByteCount &+ (8 &<< 56)
+    } else {
+      _sanityCheck(byteCount & 3 == 0)
+      _compress((m &<< 32) | tail)
+      tailAndByteCount = ((byteCount &+ 8) &<< 56) | (m &>> 32)
+    }
   }
 
-  // FIXME(ABI)#64 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
-  @_inlineable // FIXME(sil-serialize-all)
-  public // @testable
-  static func hash(
-    data: UnsafeRawPointer,
-    dataByteCount: Int,
-    key: (UInt64, UInt64)
+  @inline(__always)
+  public mutating func finalize(
+    tailBytes: UInt64,
+    tailByteCount: Int
   ) -> UInt64 {
-    return ${Self}._hash_alwaysInline(
-      data: data,
-      dataByteCount: dataByteCount,
-      key: key)
+    _sanityCheck(tailByteCount >= 0)
+    _sanityCheck(tailByteCount < 8 - (byteCount & 7))
+    _sanityCheck(tailBytes >> (tailByteCount << 3) == 0)
+    let count = UInt64(_truncatingBits: tailByteCount._lowWord)
+    let currentByteCount = byteCount & 7
+    tailAndByteCount |= (tailBytes &<< (currentByteCount &<< 3))
+    tailAndByteCount = tailAndByteCount &+ (count &<< 56)
+    return finalize()
   }
 
-  // FIXME(ABI)#65 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
-  @_inlineable // FIXME(sil-serialize-all)
   @inline(__always)
-  public // @testable
-  static func _hash_alwaysInline(
-    data: UnsafeRawPointer,
-    dataByteCount: Int,
-    key: (UInt64, UInt64)
-  ) -> UInt64 {
-    var context = ${Self}(key: key)
-    context._append_alwaysInline(data, byteCount: dataByteCount)
-    return context._finalizeAndReturnHash_alwaysInline()
+  public mutating func finalize() -> UInt64 {
+    _compress(tailAndByteCount)
+
+    v2 ^= 0xff
+
+    for _ in 0..<${d_rounds} {
+      _SipHashDetail._sipRound(v0: &v0, v1: &v1, v2: &v2, v3: &v3)
+    }
+
+    return (v0 ^ v1 ^ v2 ^ v3)
   }
 }
 % end