[PATCH v3 05/10] Eliminate bad hash multipliers from hash_32() and hash_64()
From: George Spelvin
Date: Sat May 28 2016  15:58:10 EST
The "simplified" prime multipliers made very bad hash functions, so get rid
of them. This completes the work of 689de1d6ca.
To avoid the inefficiency which was the motivation for the "simplified"
multipliers, hash_64() on 32bit systems is changed to use a different
algorithm. It makes two calls to hash_32() instead.
drivers/media/usb/dvbusbv2/af9015.c uses the old GOLDEN_RATIO_PRIME_32
for some horrible reason, so it inherits a copy of the old definition.
Signedoffby: George Spelvin <linux@xxxxxxxxxxxxxxxxxxx>
Cc: Antti Palosaari <crope@xxxxxx>
Cc: Mauro Carvalho Chehab <m.chehab@xxxxxxxxxxx>

drivers/media/usb/dvbusbv2/af9015.c  2 +
include/linux/hash.h  87 ++++++++++++++
2 files changed, 36 insertions(+), 53 deletions()
diff git a/drivers/media/usb/dvbusbv2/af9015.c b/drivers/media/usb/dvbusbv2/af9015.c
index 95a7388e..09e0f58f 100644
 a/drivers/media/usb/dvbusbv2/af9015.c
+++ b/drivers/media/usb/dvbusbv2/af9015.c
@@ 398,6 +398,8 @@ error:
}
#define AF9015_EEPROM_SIZE 256
+/* 2^31 + 2^29  2^25 + 2^22  2^19  2^16 + 1 */
+#define GOLDEN_RATIO_PRIME_32 0x9e370001UL
/* hash (and dump) eeprom */
static int af9015_eeprom_hash(struct dvb_usb_device *d)
diff git a/include/linux/hash.h b/include/linux/hash.h
index f967dedb..613cfde3 100644
 a/include/linux/hash.h
+++ b/include/linux/hash.h
@@ 3,85 +3,65 @@
/* Fast hashing routine for ints, longs and pointers.
(C) 2002 Nadia Yvette Chambers, IBM */
/*
 * Knuth recommends primes in approximately golden ratio to the maximum
 * integer representable by a machine word for multiplicative hashing.
 * Chuck Lever verified the effectiveness of this technique:
 * http://www.citi.umich.edu/techreports/reports/cititr001.pdf
 *
 * These primes are chosen to be bitsparse, that is operations on
 * them can use shifts and additions instead of multiplications for
 * machines where multiplications are slow.
 */

#include <asm/types.h>
#include <linux/compiler.h>
/* 2^31 + 2^29  2^25 + 2^22  2^19  2^16 + 1 */
#define GOLDEN_RATIO_PRIME_32 0x9e370001UL
/* 2^63 + 2^61  2^57 + 2^54  2^51  2^18 + 1 */
#define GOLDEN_RATIO_PRIME_64 0x9e37fffffffc0001UL

+/*
+ * The "GOLDEN_RATIO_PRIME" is used in ifs/btrfs/brtfs_inode.h and
+ * fs/inode.c. It's not actually prime any more (the previous primes
+ * were actively bad for hashing), but the name remains.
+ */
#if BITS_PER_LONG == 32
#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_PRIME_32
+#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_32
#define hash_long(val, bits) hash_32(val, bits)
#elif BITS_PER_LONG == 64
#define hash_long(val, bits) hash_64(val, bits)
#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_PRIME_64
+#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_64
#else
#error Wordsize not 32 or 64
#endif
/*
 * The above primes are actively bad for hashing, since they are
 * too sparse. The 32bit one is mostly ok, the 64bit one causes
 * real problems. Besides, the "prime" part is pointless for the
 * multiplicative hash.
+ * This hash multiplies the input by a large odd number and takes the
+ * high bits. Since multiplication propagates changes to the most
+ * significant end only, it is essential that the high bits of the
+ * product be used for the hash value.
+ *
+ * Chuck Lever verified the effectiveness of this technique:
+ * http://www.citi.umich.edu/techreports/reports/cititr001.pdf
*
* Although a random odd number will do, it turns out that the golden
* ratio phi = (sqrt(5)1)/2, or its negative, has particularly nice
 * properties.
+ * properties. (See Knuth vol 3, section 6.4, exercise 9.)
*
 * These are the negative, (1  phi) = (phi^2) = (3  sqrt(5))/2.
 * (See Knuth vol 3, section 6.4, exercise 9.)
+ * These are the negative, (1  phi) = phi**2 = (3  sqrt(5))/2,
+ * which is very slightly easier to multiply by and makes no
+ * difference to the hash distribution.
*/
#define GOLDEN_RATIO_32 0x61C88647
#define GOLDEN_RATIO_64 0x61C8864680B583EBull
static __always_inline u32 hash_64(u64 val, unsigned int bits)
+
+static inline u32 __hash_32(u32 val)
{
 u64 hash = val;

#if BITS_PER_LONG == 64
 hash = hash * GOLDEN_RATIO_64;
#else
 /* Sigh, gcc can't optimise this alone like it does for 32 bits. */
 u64 n = hash;
 n <<= 18;
 hash = n;
 n <<= 33;
 hash = n;
 n <<= 3;
 hash += n;
 n <<= 3;
 hash = n;
 n <<= 4;
 hash += n;
 n <<= 2;
 hash += n;
#endif

 /* High bits are more random, so use them. */
 return (u32)(hash >> (64  bits));
+ return val * GOLDEN_RATIO_32;
}
static inline u32 hash_32(u32 val, unsigned int bits)
{
 /* On some cpus multiply is faster, on others gcc will do shifts */
 u32 hash = val * GOLDEN_RATIO_PRIME_32;

/* High bits are more random, so use them. */
 return hash >> (32  bits);
+ return __hash_32(val) >> (32  bits);
+}
+
+static __always_inline u32 hash_64(u64 val, unsigned int bits)
+{
+#if BITS_PER_LONG == 64
+ /* 64x64bit multiply is efficient on all 64bit processors */
+ return val * GOLDEN_RATIO_64 >> (64  bits);
+#else
+ /* Hash 64 bits using only 32x32bit multiply. */
+ return hash_32((u32)val ^ __hash_32(val >> 32), bits);
+#endif
}
static inline u32 hash_ptr(const void *ptr, unsigned int bits)
@@ 89,6 +69,7 @@ static inline u32 hash_ptr(const void *ptr, unsigned int bits)
return hash_long((unsigned long)ptr, bits);
}
+/* This really should be called fold32_ptr; it does no hashing to speak of. */
static inline u32 hash32_ptr(const void *ptr)
{
unsigned long val = (unsigned long)ptr;

2.8.1