renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-15 08:44:14 +08:00
Code

Eliminate bad hash multipliers from hash_32() and hash_64()

Browse Source 
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 32-bit systems is changed to use a different
algorithm.  It makes two calls to hash_32() instead.

drivers/media/usb/dvb-usb-v2/af9015.c uses the old GOLDEN_RATIO_PRIME_32
for some horrible reason, so it inherits a copy of the old definition.

Signed-off-by: George Spelvin <linux@sciencehorizons.net>
Cc: Antti Palosaari <crope@iki.fi>
Cc: Mauro Carvalho Chehab <m.chehab@samsung.com>
This commit is contained in:
George Spelvin 2016-05-26 23:00:23 -04:00
parent 92d567740f
commit ef703f49a6
2 changed files with 36 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/media/usb/dvb-usb-v2/af9015.c
View File

@ -398,6 +398,8 @@ error:
} }
#define AF9015_EEPROM_SIZE 256 #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 */ /* hash (and dump) eeprom */
static int af9015_eeprom_hash(struct dvb_usb_device *d) static int af9015_eeprom_hash(struct dvb_usb_device *d)

87
include/linux/hash.h
View File

@ -3,85 +3,65 @@
/* Fast hashing routine for ints, longs and pointers. /* Fast hashing routine for ints, longs and pointers.
(C) 2002 Nadia Yvette Chambers, IBM */ (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/citi-tr-00-1.pdf
*
* These primes are chosen to be bit-sparse, that is operations on
* them can use shifts and additions instead of multiplications for
* machines where multiplications are slow.
*/
#include <asm/types.h> #include <asm/types.h>
#include <linux/compiler.h> #include <linux/compiler.h>
/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */ /*
#define GOLDEN_RATIO_PRIME_32 0x9e370001UL * The "GOLDEN_RATIO_PRIME" is used in ifs/btrfs/brtfs_inode.h and
/* 2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1 */ * fs/inode.c. It's not actually prime any more (the previous primes
#define GOLDEN_RATIO_PRIME_64 0x9e37fffffffc0001UL * were actively bad for hashing), but the name remains.
*/
#if BITS_PER_LONG == 32 #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) #define hash_long(val, bits) hash_32(val, bits)
#elif BITS_PER_LONG == 64 #elif BITS_PER_LONG == 64
#define hash_long(val, bits) hash_64(val, bits) #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 #else
#error Wordsize not 32 or 64 #error Wordsize not 32 or 64
#endif #endif
/* /*
* The above primes are actively bad for hashing, since they are * This hash multiplies the input by a large odd number and takes the
* too sparse. The 32-bit one is mostly ok, the 64-bit one causes * high bits. Since multiplication propagates changes to the most
* real problems. Besides, the "prime" part is pointless for the * significant end only, it is essential that the high bits of the
* multiplicative hash. * product be used for the hash value.
*
* Chuck Lever verified the effectiveness of this technique:
* http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf
* *
* Although a random odd number will do, it turns out that the golden * 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 * 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. * These are the negative, (1 - phi) = phi**2 = (3 - sqrt(5))/2,
* (See Knuth vol 3, section 6.4, exercise 9.) * which is very slightly easier to multiply by and makes no
* difference to the hash distribution.
*/ */
#define GOLDEN_RATIO_32 0x61C88647 #define GOLDEN_RATIO_32 0x61C88647
#define GOLDEN_RATIO_64 0x61C8864680B583EBull #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; return val * GOLDEN_RATIO_32;
#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));
} }
static inline u32 hash_32(u32 val, unsigned int bits) 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. */ /* 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
/* 64x64-bit multiply is efficient on all 64-bit processors */
return val * GOLDEN_RATIO_64 >> (64 - bits);
#else
/* Hash 64 bits using only 32x32-bit multiply. */
return hash_32((u32)val ^ __hash_32(val >> 32), bits);
#endif
} }
static inline u32 hash_ptr(const void *ptr, unsigned int bits) 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); 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) static inline u32 hash32_ptr(const void *ptr)
{ {
unsigned long val = (unsigned long)ptr; unsigned long val = (unsigned long)ptr;