Skip to content

Commit

Permalink
hash: Add 128-bit murmurhash.
Browse files Browse the repository at this point in the history 
Add the 128-bit murmurhash by Austin Appleby, r150 from:
http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp

Signed-off-by: Joe Stringer <joestringer@nicira.com>
Acked-by: Ben Pfaff <blp@nicira.com>
  • Loading branch information
@joestringer
joestringer committed Nov 25, 2014
1 parent bc2df54 commit 468cdd9
Show file tree
Hide file tree
Showing 4 changed files with 368 additions and 6 deletions.
14 changes: 14 additions & 0 deletions include/openvswitch/types.h
View file
Expand Up @@ -81,6 +81,20 @@ typedef struct {
#endif
} ovs_32aligned_u64;

typedef union {
uint32_t u32[4];
struct {
uint64_t lo, hi;
} u64;
} ovs_u128;

/* Returns non-zero if the parameters have equal value. */
static inline int
ovs_u128_equal(const ovs_u128 *a, const ovs_u128 *b)
{
return (a->u64.hi == b->u64.hi) && (a->u64.lo == b->u64.lo);
}

/* A 64-bit value, in network byte order, that is only aligned on a 32-bit
* boundary. */
typedef struct {
Expand Down
266 changes: 265 additions & 1 deletion lib/hash.c
View file
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2008, 2009, 2010, 2012, 2013 Nicira, Inc.
* Copyright (c) 2008, 2009, 2010, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
Expand Down Expand Up @@ -71,3 +71,267 @@ hash_words64__(const uint64_t p[], size_t n_words, uint64_t basis)
{
return hash_words64_inline(p, n_words, basis);
}

#if !(defined(__x86_64__))
void
hash_bytes128(const void *p_, size_t len, uint32_t basis, ovs_u128 *out)
{
const uint32_t c1 = 0x239b961b;
const uint32_t c2 = 0xab0e9789;
const uint32_t c3 = 0x38b34ae5;
const uint32_t c4 = 0xa1e38b93;
const uint8_t *tail, *data = (const uint8_t *)p_;
const uint32_t *blocks = (const uint32_t *)p_;
const int nblocks = len / 16;
uint32_t h1 = basis;
uint32_t h2 = basis;
uint32_t h3 = basis;
uint32_t h4 = basis;
uint32_t k1, k2, k3, k4;

/* Body */
for (int i = 0; i < nblocks; i++) {
uint32_t k1 = get_unaligned_u32(&blocks[i * 4 + 0]);
uint32_t k2 = get_unaligned_u32(&blocks[i * 4 + 1]);
uint32_t k3 = get_unaligned_u32(&blocks[i * 4 + 2]);
uint32_t k4 = get_unaligned_u32(&blocks[i * 4 + 3]);

k1 *= c1;
k1 = hash_rot(k1, 15);
k1 *= c2;
h1 ^= k1;

h1 = hash_rot(h1, 19);
h1 += h2;
h1 = h1 * 5 + 0x561ccd1b;

k2 *= c2;
k2 = hash_rot(k2, 16);
k2 *= c3;
h2 ^= k2;

h2 = hash_rot(h2, 17);
h2 += h3;
h2 = h2 * 5 + 0x0bcaa747;

k3 *= c3;
k3 = hash_rot(k3, 17);
k3 *= c4;
h3 ^= k3;

h3 = hash_rot(h3, 15);
h3 += h4;
h3 = h3 * 5 + 0x96cd1c35;

k4 *= c4;
k4 = hash_rot(k4, 18);
k4 *= c1;
h4 ^= k4;

h4 = hash_rot(h4, 13);
h4 += h1;
h4 = h4 * 5 + 0x32ac3b17;
}

/* Tail */
k1 = k2 = k3 = k4 = 0;
tail = data + nblocks * 16;
switch (len & 15) {
case 15:
k4 ^= tail[14] << 16;
case 14:
k4 ^= tail[13] << 8;
case 13:
k4 ^= tail[12] << 0;
k4 *= c4;
k4 = hash_rot(k4, 18);
k4 *= c1;
h4 ^= k4;

case 12:
k3 ^= tail[11] << 24;
case 11:
k3 ^= tail[10] << 16;
case 10:
k3 ^= tail[9] << 8;
case 9:
k3 ^= tail[8] << 0;
k3 *= c3;
k3 = hash_rot(k3, 17);
k3 *= c4;
h3 ^= k3;

case 8:
k2 ^= tail[7] << 24;
case 7:
k2 ^= tail[6] << 16;
case 6:
k2 ^= tail[5] << 8;
case 5:
k2 ^= tail[4] << 0;
k2 *= c2;
k2 = hash_rot(k2, 16);
k2 *= c3;
h2 ^= k2;

case 4:
k1 ^= tail[3] << 24;
case 3:
k1 ^= tail[2] << 16;
case 2:
k1 ^= tail[1] << 8;
case 1:
k1 ^= tail[0] << 0;
k1 *= c1;
k1 = hash_rot(k1, 15);
k1 *= c2;
h1 ^= k1;
};

/* Finalization */
h1 ^= len;
h2 ^= len;
h3 ^= len;
h4 ^= len;

h1 += h2;
h1 += h3;
h1 += h4;
h2 += h1;
h3 += h1;
h4 += h1;

h1 = mhash_finish(h1);
h2 = mhash_finish(h2);
h3 = mhash_finish(h3);
h4 = mhash_finish(h4);

h1 += h2;
h1 += h3;
h1 += h4;
h2 += h1;
h3 += h1;
h4 += h1;

out->u32[0] = h1;
out->u32[1] = h2;
out->u32[2] = h3;
out->u32[3] = h4;
}

#else /* __x86_64__ */

static inline uint64_t
hash_rot64(uint64_t x, int8_t r)
{
return (x << r) | (x >> (64 - r));
}

static inline uint64_t
fmix64(uint64_t k)
{
k ^= k >> 33;
k *= 0xff51afd7ed558ccdULL;
k ^= k >> 33;
k *= 0xc4ceb9fe1a85ec53ULL;
k ^= k >> 33;

return k;
}

void
hash_bytes128(const void *p_, size_t len, uint32_t basis, ovs_u128 *out)
{
const uint64_t c1 = 0x87c37b91114253d5ULL;
const uint64_t c2 = 0x4cf5ad432745937fULL;
const uint8_t *tail, *data = (const uint8_t *)p_;
const uint64_t *blocks = (const uint64_t *)p_;
const int nblocks = len / 16;
uint64_t h1 = basis;
uint64_t h2 = basis;
uint64_t k1, k2;

/* Body */
for (int i = 0; i < nblocks; i++) {
k1 = get_unaligned_u64(&blocks[i * 2 + 0]);
k2 = get_unaligned_u64(&blocks[i * 2 + 1]);

k1 *= c1;
k1 = hash_rot64(k1, 31);
k1 *= c2;
h1 ^= k1;

h1 = hash_rot64(h1, 27);
h1 += h2;
h1 = h1 * 5 + 0x52dce729;

k2 *= c2;
k2 = hash_rot64(k2, 33);
k2 *= c1;
h2 ^= k2;

h2 = hash_rot64(h2, 31);
h2 += h1;
h2 = h2 * 5 + 0x38495ab5;
}

/* Tail */
k1 = 0;
k2 = 0;
tail = data + nblocks * 16;
switch (len & 15) {
case 15:
k2 ^= ((uint64_t) tail[14]) << 48;
case 14:
k2 ^= ((uint64_t) tail[13]) << 40;
case 13:
k2 ^= ((uint64_t) tail[12]) << 32;
case 12:
k2 ^= ((uint64_t) tail[11]) << 24;
case 11:
k2 ^= ((uint64_t) tail[10]) << 16;
case 10:
k2 ^= ((uint64_t) tail[9]) << 8;
case 9:
k2 ^= ((uint64_t) tail[8]) << 0;
k2 *= c2;
k2 = hash_rot64(k2, 33);
k2 *= c1;
h2 ^= k2;

case 8:
k1 ^= ((uint64_t) tail[7]) << 56;
case 7:
k1 ^= ((uint64_t) tail[6]) << 48;
case 6:
k1 ^= ((uint64_t) tail[5]) << 40;
case 5:
k1 ^= ((uint64_t) tail[4]) << 32;
case 4:
k1 ^= ((uint64_t) tail[3]) << 24;
case 3:
k1 ^= ((uint64_t) tail[2]) << 16;
case 2:
k1 ^= ((uint64_t) tail[1]) << 8;
case 1:
k1 ^= ((uint64_t) tail[0]) << 0;
k1 *= c1;
k1 = hash_rot64(k1, 31);
k1 *= c2;
h1 ^= k1;
};

/* Finalization */
h1 ^= len;
h2 ^= len;
h1 += h2;
h2 += h1;
h1 = fmix64(h1);
h2 = fmix64(h2);
h1 += h2;
h2 += h1;

out->u64.lo = h1;
out->u64.hi = h2;
}
#endif /* __x86_64__ */
11 changes: 6 additions & 5 deletions lib/hash.h
View file
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2008, 2009, 2010, 2012, 2013 Nicira, Inc.
* Copyright (c) 2008, 2009, 2010, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
Expand Down Expand Up @@ -33,6 +33,8 @@ hash_rot(uint32_t x, int k)
}

uint32_t hash_bytes(const void *, size_t n_bytes, uint32_t basis);
void hash_bytes128(const void *_, size_t n_bytes, uint32_t basis,
ovs_u128 *out);

static inline uint32_t hash_int(uint32_t x, uint32_t basis);
static inline uint32_t hash_2words(uint32_t, uint32_t);
Expand Down Expand Up @@ -72,9 +74,8 @@ static inline uint32_t mhash_add(uint32_t hash, uint32_t data)
return hash * 5 + 0xe6546b64;
}

static inline uint32_t mhash_finish(uint32_t hash, uint32_t n_bytes)
static inline uint32_t mhash_finish(uint32_t hash)
{
hash ^= n_bytes;
hash ^= hash >> 16;
hash *= 0x85ebca6b;
hash ^= hash >> 13;
Expand All @@ -84,7 +85,7 @@ static inline uint32_t mhash_finish(uint32_t hash, uint32_t n_bytes)
}

#if !(defined(__SSE4_2__) && defined(__x86_64__))
/* Mhash-based implemantation. */
/* Mhash-based implementation. */

static inline uint32_t hash_add(uint32_t hash, uint32_t data)
{
Expand All @@ -93,7 +94,7 @@ static inline uint32_t hash_add(uint32_t hash, uint32_t data)

static inline uint32_t hash_finish(uint32_t hash, uint32_t final)
{
return mhash_finish(hash, final);
return mhash_finish(hash ^ final);
}

/* Returns the hash of the 'n' 32-bit words at 'p', starting from 'basis'.
Expand Down

0 comments on commit 468cdd9

Please sign in to comment.