Add hashWangYi1

changelog.md

@@ -4,6 +4,9 @@
 
 ## Standard library additions and changes
 
+- The default hash for `Ordinal` has changed to something more bit-scrambling.
+  `import hashes; proc hash(x: myInt): Hash = hashIdentity(x)` recovers the old
+  one in an instantiation context while `-d:nimV1hash` recovers it globally.
 
 ## Language changes
 

lib/pure/collections/sets.nim

@@ -334,8 +334,7 @@ proc pop*[A](s: var HashSet[A]): A =
   ## * `clear proc <#clear,HashSet[A]>`_
   runnableExamples:
     var s = toHashSet([2, 1])
-    assert s.pop == 1
-    assert s.pop == 2
+    assert [s.pop, s.pop] in [[1, 2], [2,1]] # order unspecified
     doAssertRaises(KeyError, echo s.pop)
 
   for h in 0 .. high(s.data):
@@ -1008,7 +1007,7 @@ when isMainModule and not defined(release):
 
     block toSeqAndString:
       var a = toHashSet([2, 7, 5])
-      var b = initHashSet[int]()
+      var b = initHashSet[int](rightSize(a.len))
       for x in [2, 7, 5]: b.incl(x)
       assert($a == $b)
       #echo a

lib/pure/hashes.nim

@@ -70,6 +70,60 @@ proc `!$`*(h: Hash): Hash {.inline.} =
   res = res + res shl 15
   result = cast[Hash](res)
 
+proc hiXorLoFallback64(a, b: uint64): uint64 {.inline.} =
+  let # Fall back in 64-bit arithmetic
+    aH = a shr 32
+    aL = a and 0xFFFFFFFF'u64
+    bH = b shr 32
+    bL = b and 0xFFFFFFFF'u64
+    rHH = aH * bH
+    rHL = aH * bL
+    rLH = aL * bH
+    rLL = aL * bL
+    t = rLL + (rHL shl 32)
+  var c = if t < rLL: 1'u64 else: 0'u64
+  let lo = t + (rLH shl 32)
+  c += (if lo < t: 1'u64 else: 0'u64)
+  let hi = rHH + (rHL shr 32) + (rLH shr 32) + c
+  return hi xor lo
+
+proc hiXorLo(a, b: uint64): uint64 {.inline.} =
+  # Xor of high & low 8B of full 16B product
+  when nimvm:
+    result = hiXorLoFallback64(a, b) # `result =` is necessary here.
+  else:
+    when Hash.sizeof < 8:
+      result = hiXorLoFallback64(a, b)
+    elif defined(gcc) or defined(llvm_gcc) or defined(clang):
+      {.emit: """__uint128_t r = a; r *= b; return (r >> 64) ^ r;""".}
+    elif defined(windows) and not defined(tcc):
+      {.emit: """a = _umul128(a, b, &b); return a ^ b;""".}
+    else:
+      result = hiXorLoFallback64(a, b)
+
+proc hashWangYi1*(x: int64|uint64|Hash): Hash {.inline.} =
+  ## Wang Yi's hash_v1 for 8B int.  https://github.com/rurban/smhasher has more
+  ## details.  This passed all scrambling tests in Spring 2019 and is simple.
+  ## NOTE: It's ok to define ``proc(x: int16): Hash = hashWangYi1(Hash(x))``.
+  when defined(js) and not nimvm:
+    asm """
+      function hi_xor_lo_js(a, b) {
+        var prod = BigInt(a) * BigInt(b);
+        var mask = (BigInt(1) << BigInt(64)) - BigInt(1);
+        return (prod >> BigInt(64)) ^ (prod & mask);
+      }
+      const P0  = BigInt(0xa0761d64)<<BigInt(32)|BigInt(0x78bd642f);
+      const P1  = BigInt(0xe7037ed1)<<BigInt(32)|BigInt(0xa0b428db);
+      const P58 = BigInt(0xeb44acca)<<BigInt(32)|BigInt(0xb455d165) ^ BigInt(8);
+      var res   = hi_xor_lo_js(hi_xor_lo_js(P0, BigInt(`x`) ^ P1), P58);
+      `result`  = Number(res & ((BigInt(1) << BigInt(53)) - BigInt(1)));
+    """
+  else:
+    const P0  = 0xa0761d6478bd642f'u64
+    const P1  = 0xe7037ed1a0b428db'u64
+    const P58 = 0xeb44accab455d165'u64 xor 8'u64
+    cast[Hash](hiXorLo(hiXorLo(P0, uint64(x) xor P1), P58))
+
 proc hashData*(data: pointer, size: int): Hash =
   ## Hashes an array of bytes of size `size`.
   var h: Hash = 0
@@ -112,10 +166,19 @@ proc hash*[T: proc](x: T): Hash {.inline.} =
   else:
     result = hash(pointer(x))
 
-proc hash*[T: Ordinal](x: T): Hash {.inline.} =
-  ## Efficient hashing of integers.
+proc hashIdentity*[T: Ordinal](x: T): Hash {.inline.} =
+  ## The identity hash.  I.e. ``hashIdentity(x) = x``.
   cast[Hash](ord(x))
 
+when defined(nimV1hash):
+  proc hash*[T: Ordinal](x: T): Hash {.inline.} =
+    ## Efficient hashing of integers.
+    hashIdentity(x)
+else:
+  proc hash*[T: Ordinal](x: T): Hash {.inline.} =
+    ## Efficient hashing of integers.
+    hashWangYi1(uint64(ord(x)))
+
 proc hash*(x: float): Hash {.inline.} =
   ## Efficient hashing of floats.
   var y = x + 0.0 # for denormalization

tests/collections/tcollections.nim

@@ -76,8 +76,12 @@ doAssert $(toOrderedSet(["1", "2", "3"])) == """{"1", "2", "3"}"""
 doAssert $(toOrderedSet(['1', '2', '3'])) == """{'1', '2', '3'}"""
 
 # Tests for tables
-doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
-doAssert $({"1": 1, "2": 2}.toTable) == """{"1": 1, "2": 2}"""
+when defined(nimV1hash):
+  doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
+else:
+  doAssert $({1: "1", 2: "2"}.toTable) == """{2: "2", 1: "1"}"""
+let tabStr = $({"1": 1, "2": 2}.toTable)
+doAssert (tabStr == """{"2": 2, "1": 1}""" or tabStr == """{"1": 1, "2": 2}""")
 
 # Tests for deques
 block:

tests/collections/tcollections_to_string.nim

@@ -27,7 +27,10 @@ doAssert $(toOrderedSet(["1", "2", "3"])) == """{"1", "2", "3"}"""
 doAssert $(toOrderedSet(['1', '2', '3'])) == """{'1', '2', '3'}"""
 
 # Tests for tables
-doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
+when defined(nimV1hash):
+  doAssert $({1: "1", 2: "2"}.toTable) == """{1: "1", 2: "2"}"""
+else:
+  doAssert $({1: "1", 2: "2"}.toTable) == """{2: "2", 1: "1"}"""
 doAssert $({"1": 1, "2": 2}.toTable) == """{"1": 1, "2": 2}"""
 
 # Tests for deques

tests/stdlib/thashes.nim

@@ -15,3 +15,20 @@ suite "hashes":
     test "0.0 and -0.0 should have the same hash value":
       var dummy = 0.0
       check hash(dummy) == hash(-dummy)
+
+    test "VM and runtime should make the same hash value (hashIdentity)":
+      const hi123 = hashIdentity(123)
+      check hashIdentity(123) == hi123
+
+    test "VM and runtime should make the same hash value (hashWangYi1)":
+      const wy123 = hashWangYi1(123)
+      check hashWangYi1(123) == wy123
+
+    test "hashIdentity value incorrect at 456":
+      check hashIdentity(456) == 456
+
+    test "hashWangYi1 value incorrect at 456":
+      when Hash.sizeof < 8:
+        check hashWangYi1(456) == 1293320666
+      else:
+        check hashWangYi1(456) == -6421749900419628582