Bug 1477626 - Move ScrambleHashCode() from js/src/Utility.h to mfbt/HashFunctions.h. r=Waldo

And use it in PLDHashTable.cpp.

MozReview-Commit-ID: BqwEkE0p5AG

--HG--
extra : rebase_source : bd9118e24b82add6ad1fdcb067a5f25b25e90201

Author: nnethercote

js/public/HashTable.h

@@ -1282,7 +1282,7 @@ class HashTable : private AllocPolicy
 
     static HashNumber prepareHash(const Lookup& l)
     {
-        HashNumber keyHash = ScrambleHashCode(HashPolicy::hash(l));
+        HashNumber keyHash = mozilla::ScrambleHashCode(HashPolicy::hash(l));
 
         // Avoid reserved hash codes.
         if (!isLiveHash(keyHash))

js/public/Utility.h

@@ -14,7 +14,6 @@
 #include "mozilla/Move.h"
 #include "mozilla/TemplateLib.h"
 #include "mozilla/UniquePtr.h"
-#include "mozilla/WrappingOperations.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -664,51 +663,6 @@ typedef mozilla::UniquePtr<char16_t[], JS::FreePolicy> UniqueTwoByteChars;
 
 } // namespace JS
 
-namespace js {
-
-namespace detail {
-
-/*
- * Given a raw hash code, h, return a number that can be used to select a hash
- * bucket.
- *
- * This function aims to produce as uniform an output distribution as possible,
- * especially in the most significant (leftmost) bits, even though the input
- * distribution may be highly nonrandom, given the constraints that this must
- * be deterministic and quick to compute.
- *
- * Since the leftmost bits of the result are best, the hash bucket index is
- * computed by doing ScrambleHashCode(h) / (2^32/N) or the equivalent
- * right-shift, not ScrambleHashCode(h) % N or the equivalent bit-mask.
- *
- * FIXME: OrderedHashTable uses a bit-mask; see bug 775896.
- */
-inline uint32_t
-ScrambleHashCode(uint32_t h)
-{
-    /*
-     * Simply returning h would not cause any hash tables to produce wrong
-     * answers. But it can produce pathologically bad performance: The caller
-     * right-shifts the result, keeping only the highest bits. The high bits of
-     * hash codes are very often completely entropy-free. (So are the lowest
-     * bits.)
-     *
-     * So we use Fibonacci hashing, as described in Knuth, The Art of Computer
-     * Programming, 6.4. This mixes all the bits of the input hash code h.
-     *
-     * The value of goldenRatio is taken from the hex
-     * expansion of the golden ratio, which starts 1.9E3779B9....
-     * This value is especially good if values with consecutive hash codes
-     * are stored in a hash table; see Knuth for details.
-     */
-    static const uint32_t goldenRatio = 0x9E3779B9U;
-    return mozilla::WrappingMultiply(h, goldenRatio);
-}
-
-} /* namespace detail */
-
-} /* namespace js */
-
 /* sixgill annotation defines */
 #ifndef HAVE_STATIC_ANNOTATIONS
 # define HAVE_STATIC_ANNOTATIONS

js/src/ds/OrderedHashTable.h

@@ -618,7 +618,7 @@ class OrderedHashTable
 
   public:
     HashNumber prepareHash(const Lookup& l) const {
-        return ScrambleHashCode(Ops::hash(l, hcs));
+        return mozilla::ScrambleHashCode(Ops::hash(l, hcs));
     }
 
   private:

mfbt/HashFunctions.h

@@ -66,6 +66,42 @@ static const uint32_t kHashNumberBits = 32;
  */
 static const HashNumber kGoldenRatioU32 = 0x9E3779B9U;
 
+/*
+ * Given a raw hash code, h, return a number that can be used to select a hash
+ * bucket.
+ *
+ * This function aims to produce as uniform an output distribution as possible,
+ * especially in the most significant (leftmost) bits, even though the input
+ * distribution may be highly nonrandom, given the constraints that this must
+ * be deterministic and quick to compute.
+ *
+ * Since the leftmost bits of the result are best, the hash bucket index is
+ * computed by doing ScrambleHashCode(h) / (2^32/N) or the equivalent
+ * right-shift, not ScrambleHashCode(h) % N or the equivalent bit-mask.
+ *
+ * FIXME: OrderedHashTable uses a bit-mask; see bug 775896.
+ */
+constexpr HashNumber
+ScrambleHashCode(HashNumber h)
+{
+  /*
+   * Simply returning h would not cause any hash tables to produce wrong
+   * answers. But it can produce pathologically bad performance: The caller
+   * right-shifts the result, keeping only the highest bits. The high bits of
+   * hash codes are very often completely entropy-free. (So are the lowest
+   * bits.)
+   *
+   * So we use Fibonacci hashing, as described in Knuth, The Art of Computer
+   * Programming, 6.4. This mixes all the bits of the input hash code h.
+   *
+   * The value of goldenRatio is taken from the hex expansion of the golden
+   * ratio, which starts 1.9E3779B9.... This value is especially good if
+   * values with consecutive hash codes are stored in a hash table; see Knuth
+   * for details.
+   */
+  return mozilla::WrappingMultiply(h, kGoldenRatioU32);
+}
+
 namespace detail {
 
 MOZ_NO_SANITIZE_UNSIGNED_OVERFLOW

xpcom/ds/PLDHashTable.cpp

@@ -528,8 +528,7 @@ PLDHashTable::ComputeKeyHash(const void* aKey) const
 {
   MOZ_ASSERT(mEntryStore.Get());
 
-  PLDHashNumber keyHash = mOps->hashKey(aKey);
-  keyHash *= kGoldenRatio;
+  PLDHashNumber keyHash = mozilla::ScrambleHashCode(mOps->hashKey(aKey));
 
   // Avoid 0 and 1 hash codes, they indicate free and removed entries.
   if (keyHash < 2) {

xpcom/ds/PLDHashTable.h

@@ -33,8 +33,8 @@ struct PLDHashTableOps;
 // structure, for single static initialization per hash table sub-type.
 //
 // Each hash table sub-type should make its entry type a subclass of
-// PLDHashEntryHdr. The mKeyHash member contains the result of multiplying the
-// hash code returned from the hashKey callback (see below) by kGoldenRatio,
+// PLDHashEntryHdr. The mKeyHash member contains the result of suitably
+// scrambling the hash code returned from the hashKey callback (see below),
 // then constraining the result to avoid the magic 0 and 1 values. The stored
 // mKeyHash value is table size invariant, and it is maintained automatically
 // -- users need never access it.
@@ -503,10 +503,6 @@ class PLDHashTable
   }
 
 private:
-  // Multiplicative hash uses an unsigned 32 bit integer and the golden ratio,
-  // expressed as a fixed-point 32-bit fraction.
-  static const uint32_t kGoldenRatio = 0x9E3779B9U;
-
   static uint32_t HashShift(uint32_t aEntrySize, uint32_t aLength);
 
   static const PLDHashNumber kCollisionFlag = 1;