tanjent@gmail.com | f3b7897 | 2012-03-01 03:38:55 +0000 | [diff] [blame] | 1 | // |
| 2 | // SpookyHash: a 128-bit noncryptographic hash function |
| 3 | // By Bob Jenkins, public domain |
| 4 | // Oct 31 2010: alpha, framework + SpookyHash::Mix appears right |
| 5 | // Oct 31 2011: alpha again, Mix only good to 2^^69 but rest appears right |
| 6 | // Dec 31 2011: beta, improved Mix, tested it for 2-bit deltas |
| 7 | // Feb 2 2012: production, same bits as beta |
| 8 | // Feb 5 2012: adjusted definitions of uint* to be more portable |
| 9 | // |
| 10 | // Up to 4 bytes/cycle for long messages. Reasonably fast for short messages. |
| 11 | // All 1 or 2 bit deltas achieve avalanche within 1% bias per output bit. |
| 12 | // |
| 13 | // This was developed for and tested on 64-bit x86-compatible processors. |
| 14 | // It assumes the processor is little-endian. There is a macro |
| 15 | // controlling whether unaligned reads are allowed (by default they are). |
| 16 | // This should be an equally good hash on big-endian machines, but it will |
| 17 | // compute different results on them than on little-endian machines. |
| 18 | // |
| 19 | // Google's CityHash has similar specs to SpookyHash, and CityHash is faster |
| 20 | // on some platforms. MD4 and MD5 also have similar specs, but they are orders |
| 21 | // of magnitude slower. CRCs are two or more times slower, but unlike |
| 22 | // SpookyHash, they have nice math for combining the CRCs of pieces to form |
| 23 | // the CRCs of wholes. There are also cryptographic hashes, but those are even |
| 24 | // slower than MD5. |
| 25 | // |
| 26 | |
tanjent@gmail.com | dd462f2 | 2012-03-01 06:06:01 +0000 | [diff] [blame] | 27 | #include "Platform.h" |
tanjent@gmail.com | f3b7897 | 2012-03-01 03:38:55 +0000 | [diff] [blame] | 28 | #include <stddef.h> |
| 29 | |
| 30 | #ifdef _MSC_VER |
| 31 | # define INLINE __forceinline |
| 32 | typedef unsigned __int64 uint64; |
| 33 | typedef unsigned __int32 uint32; |
| 34 | typedef unsigned __int16 uint16; |
| 35 | typedef unsigned __int8 uint8; |
| 36 | #else |
| 37 | # include <stdint.h> |
| 38 | # define INLINE inline |
| 39 | typedef uint64_t uint64; |
| 40 | typedef uint32_t uint32; |
| 41 | typedef uint16_t uint16; |
| 42 | typedef uint8_t uint8; |
| 43 | #endif |
| 44 | |
| 45 | |
| 46 | class SpookyHash |
| 47 | { |
| 48 | public: |
| 49 | // |
| 50 | // SpookyHash: hash a single message in one call, produce 128-bit output |
| 51 | // |
| 52 | static void Hash128( |
| 53 | const void *message, // message to hash |
| 54 | size_t length, // length of message in bytes |
| 55 | uint64 *hash1, // in/out: in seed 1, out hash value 1 |
| 56 | uint64 *hash2); // in/out: in seed 2, out hash value 2 |
| 57 | |
| 58 | // |
| 59 | // Hash64: hash a single message in one call, return 64-bit output |
| 60 | // |
| 61 | static uint64 Hash64( |
| 62 | const void *message, // message to hash |
| 63 | size_t length, // length of message in bytes |
| 64 | uint64 seed) // seed |
| 65 | { |
| 66 | uint64 hash1 = seed; |
| 67 | Hash128(message, length, &hash1, &seed); |
| 68 | return hash1; |
| 69 | } |
| 70 | |
| 71 | // |
| 72 | // Hash32: hash a single message in one call, produce 32-bit output |
| 73 | // |
| 74 | static uint32 Hash32( |
| 75 | const void *message, // message to hash |
| 76 | size_t length, // length of message in bytes |
| 77 | uint32 seed) // seed |
| 78 | { |
| 79 | uint64 hash1 = seed, hash2 = seed; |
| 80 | Hash128(message, length, &hash1, &hash2); |
| 81 | return (uint32)hash1; |
| 82 | } |
| 83 | |
| 84 | // |
| 85 | // Init: initialize the context of a SpookyHash |
| 86 | // |
| 87 | void Init( |
| 88 | uint64 seed1, // any 64-bit value will do, including 0 |
| 89 | uint64 seed2); // different seeds produce independent hashes |
| 90 | |
| 91 | // |
| 92 | // Update: add a piece of a message to a SpookyHash state |
| 93 | // |
| 94 | void Update( |
| 95 | const void *message, // message fragment |
| 96 | size_t length); // length of message fragment in bytes |
| 97 | |
| 98 | |
| 99 | // |
| 100 | // Final: compute the hash for the current SpookyHash state |
| 101 | // |
| 102 | // This does not modify the state; you can keep updating it afterward |
| 103 | // |
| 104 | // The result is the same as if SpookyHash() had been called with |
| 105 | // all the pieces concatenated into one message. |
| 106 | // |
| 107 | void Final( |
| 108 | uint64 *hash1, // out only: first 64 bits of hash value. |
| 109 | uint64 *hash2); // out only: second 64 bits of hash value. |
| 110 | |
| 111 | // |
| 112 | // left rotate a 64-bit value by k bytes |
| 113 | // |
| 114 | static INLINE uint64 Rot64(uint64 x, int k) |
| 115 | { |
| 116 | return (x << k) | (x >> (64 - k)); |
| 117 | } |
| 118 | |
| 119 | // |
| 120 | // This is used if the input is 96 bytes long or longer. |
| 121 | // |
| 122 | // The internal state is fully overwritten every 96 bytes. |
| 123 | // Every input bit appears to cause at least 128 bits of entropy |
| 124 | // before 96 other bytes are combined, when run forward or backward |
| 125 | // For every input bit, |
| 126 | // Two inputs differing in just that input bit |
| 127 | // Where "differ" means xor or subtraction |
| 128 | // And the base value is random |
| 129 | // When run forward or backwards one Mix |
| 130 | // I tried 3 pairs of each; they all differed by at least 212 bits. |
| 131 | // |
| 132 | static INLINE void Mix( |
| 133 | const uint64 *data, |
| 134 | uint64 &s0, uint64 &s1, uint64 &s2, uint64 &s3, |
| 135 | uint64 &s4, uint64 &s5, uint64 &s6, uint64 &s7, |
| 136 | uint64 &s8, uint64 &s9, uint64 &s10,uint64 &s11) |
| 137 | { |
| 138 | s0 += data[0]; s2 ^= s10; s11 ^= s0; s0 = Rot64(s0,11); s11 += s1; |
| 139 | s1 += data[1]; s3 ^= s11; s0 ^= s1; s1 = Rot64(s1,32); s0 += s2; |
| 140 | s2 += data[2]; s4 ^= s0; s1 ^= s2; s2 = Rot64(s2,43); s1 += s3; |
| 141 | s3 += data[3]; s5 ^= s1; s2 ^= s3; s3 = Rot64(s3,31); s2 += s4; |
| 142 | s4 += data[4]; s6 ^= s2; s3 ^= s4; s4 = Rot64(s4,17); s3 += s5; |
| 143 | s5 += data[5]; s7 ^= s3; s4 ^= s5; s5 = Rot64(s5,28); s4 += s6; |
| 144 | s6 += data[6]; s8 ^= s4; s5 ^= s6; s6 = Rot64(s6,39); s5 += s7; |
| 145 | s7 += data[7]; s9 ^= s5; s6 ^= s7; s7 = Rot64(s7,57); s6 += s8; |
| 146 | s8 += data[8]; s10 ^= s6; s7 ^= s8; s8 = Rot64(s8,55); s7 += s9; |
| 147 | s9 += data[9]; s11 ^= s7; s8 ^= s9; s9 = Rot64(s9,54); s8 += s10; |
| 148 | s10 += data[10]; s0 ^= s8; s9 ^= s10; s10 = Rot64(s10,22); s9 += s11; |
| 149 | s11 += data[11]; s1 ^= s9; s10 ^= s11; s11 = Rot64(s11,46); s10 += s0; |
| 150 | } |
| 151 | |
| 152 | // |
| 153 | // Mix all 12 inputs together so that h0, h1 are a hash of them all. |
| 154 | // |
| 155 | // For two inputs differing in just the input bits |
| 156 | // Where "differ" means xor or subtraction |
| 157 | // And the base value is random, or a counting value starting at that bit |
| 158 | // The final result will have each bit of h0, h1 flip |
| 159 | // For every input bit, |
| 160 | // with probability 50 +- .3% |
| 161 | // For every pair of input bits, |
| 162 | // with probability 50 +- 3% |
| 163 | // |
| 164 | // This does not rely on the last Mix() call having already mixed some. |
| 165 | // Two iterations was almost good enough for a 64-bit result, but a |
| 166 | // 128-bit result is reported, so End() does three iterations. |
| 167 | // |
| 168 | static INLINE void EndPartial( |
| 169 | uint64 &h0, uint64 &h1, uint64 &h2, uint64 &h3, |
| 170 | uint64 &h4, uint64 &h5, uint64 &h6, uint64 &h7, |
| 171 | uint64 &h8, uint64 &h9, uint64 &h10,uint64 &h11) |
| 172 | { |
| 173 | h11+= h1; h2 ^= h11; h1 = Rot64(h1,44); |
| 174 | h0 += h2; h3 ^= h0; h2 = Rot64(h2,15); |
| 175 | h1 += h3; h4 ^= h1; h3 = Rot64(h3,34); |
| 176 | h2 += h4; h5 ^= h2; h4 = Rot64(h4,21); |
| 177 | h3 += h5; h6 ^= h3; h5 = Rot64(h5,38); |
| 178 | h4 += h6; h7 ^= h4; h6 = Rot64(h6,33); |
| 179 | h5 += h7; h8 ^= h5; h7 = Rot64(h7,10); |
| 180 | h6 += h8; h9 ^= h6; h8 = Rot64(h8,13); |
| 181 | h7 += h9; h10^= h7; h9 = Rot64(h9,38); |
| 182 | h8 += h10; h11^= h8; h10= Rot64(h10,53); |
| 183 | h9 += h11; h0 ^= h9; h11= Rot64(h11,42); |
| 184 | h10+= h0; h1 ^= h10; h0 = Rot64(h0,54); |
| 185 | } |
| 186 | |
| 187 | static INLINE void End( |
| 188 | uint64 &h0, uint64 &h1, uint64 &h2, uint64 &h3, |
| 189 | uint64 &h4, uint64 &h5, uint64 &h6, uint64 &h7, |
| 190 | uint64 &h8, uint64 &h9, uint64 &h10,uint64 &h11) |
| 191 | { |
| 192 | EndPartial(h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11); |
| 193 | EndPartial(h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11); |
| 194 | EndPartial(h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11); |
| 195 | } |
| 196 | |
| 197 | // |
| 198 | // The goal is for each bit of the input to expand into 128 bits of |
| 199 | // apparent entropy before it is fully overwritten. |
| 200 | // n trials both set and cleared at least m bits of h0 h1 h2 h3 |
| 201 | // n: 2 m: 29 |
| 202 | // n: 3 m: 46 |
| 203 | // n: 4 m: 57 |
| 204 | // n: 5 m: 107 |
| 205 | // n: 6 m: 146 |
| 206 | // n: 7 m: 152 |
| 207 | // when run forwards or backwards |
| 208 | // for all 1-bit and 2-bit diffs |
| 209 | // with diffs defined by either xor or subtraction |
| 210 | // with a base of all zeros plus a counter, or plus another bit, or random |
| 211 | // |
| 212 | static INLINE void ShortMix(uint64 &h0, uint64 &h1, uint64 &h2, uint64 &h3) |
| 213 | { |
| 214 | h2 = Rot64(h2,50); h2 += h3; h0 ^= h2; |
| 215 | h3 = Rot64(h3,52); h3 += h0; h1 ^= h3; |
| 216 | h0 = Rot64(h0,30); h0 += h1; h2 ^= h0; |
| 217 | h1 = Rot64(h1,41); h1 += h2; h3 ^= h1; |
| 218 | h2 = Rot64(h2,54); h2 += h3; h0 ^= h2; |
| 219 | h3 = Rot64(h3,48); h3 += h0; h1 ^= h3; |
| 220 | h0 = Rot64(h0,38); h0 += h1; h2 ^= h0; |
| 221 | h1 = Rot64(h1,37); h1 += h2; h3 ^= h1; |
| 222 | h2 = Rot64(h2,62); h2 += h3; h0 ^= h2; |
| 223 | h3 = Rot64(h3,34); h3 += h0; h1 ^= h3; |
| 224 | h0 = Rot64(h0,5); h0 += h1; h2 ^= h0; |
| 225 | h1 = Rot64(h1,36); h1 += h2; h3 ^= h1; |
| 226 | } |
| 227 | |
| 228 | // |
| 229 | // Mix all 4 inputs together so that h0, h1 are a hash of them all. |
| 230 | // |
| 231 | // For two inputs differing in just the input bits |
| 232 | // Where "differ" means xor or subtraction |
| 233 | // And the base value is random, or a counting value starting at that bit |
| 234 | // The final result will have each bit of h0, h1 flip |
| 235 | // For every input bit, |
| 236 | // with probability 50 +- .3% (it is probably better than that) |
| 237 | // For every pair of input bits, |
| 238 | // with probability 50 +- .75% (the worst case is approximately that) |
| 239 | // |
| 240 | static INLINE void ShortEnd(uint64 &h0, uint64 &h1, uint64 &h2, uint64 &h3) |
| 241 | { |
| 242 | h3 ^= h2; h2 = Rot64(h2,15); h3 += h2; |
| 243 | h0 ^= h3; h3 = Rot64(h3,52); h0 += h3; |
| 244 | h1 ^= h0; h0 = Rot64(h0,26); h1 += h0; |
| 245 | h2 ^= h1; h1 = Rot64(h1,51); h2 += h1; |
| 246 | h3 ^= h2; h2 = Rot64(h2,28); h3 += h2; |
| 247 | h0 ^= h3; h3 = Rot64(h3,9); h0 += h3; |
| 248 | h1 ^= h0; h0 = Rot64(h0,47); h1 += h0; |
| 249 | h2 ^= h1; h1 = Rot64(h1,54); h2 += h1; |
| 250 | h3 ^= h2; h2 = Rot64(h2,32); h3 += h2; |
| 251 | h0 ^= h3; h3 = Rot64(h3,25); h0 += h3; |
| 252 | h1 ^= h0; h0 = Rot64(h0,63); h1 += h0; |
| 253 | } |
| 254 | |
| 255 | private: |
| 256 | |
| 257 | // |
| 258 | // Short is used for messages under 192 bytes in length |
| 259 | // Short has a low startup cost, the normal mode is good for long |
| 260 | // keys, the cost crossover is at about 192 bytes. The two modes were |
| 261 | // held to the same quality bar. |
| 262 | // |
| 263 | static void Short( |
| 264 | const void *message, |
| 265 | size_t length, |
| 266 | uint64 *hash1, |
| 267 | uint64 *hash2); |
| 268 | |
| 269 | // number of uint64's in internal state |
| 270 | static const size_t sc_numVars = 12; |
| 271 | |
| 272 | // size of the internal state |
| 273 | static const size_t sc_blockSize = sc_numVars*8; |
| 274 | |
| 275 | // size of buffer of unhashed data, in bytes |
| 276 | static const size_t sc_bufSize = 2*sc_blockSize; |
| 277 | |
| 278 | // |
| 279 | // sc_const: a constant which: |
| 280 | // * is not zero |
| 281 | // * is odd |
| 282 | // * is a not-very-regular mix of 1's and 0's |
| 283 | // * does not need any other special mathematical properties |
| 284 | // |
tanjent@gmail.com | dd462f2 | 2012-03-01 06:06:01 +0000 | [diff] [blame] | 285 | static const uint64 sc_const = 0xdeadbeefdeadbeefULL; |
tanjent@gmail.com | f3b7897 | 2012-03-01 03:38:55 +0000 | [diff] [blame] | 286 | |
| 287 | uint64 m_data[2*sc_numVars]; // unhashed data, for partial messages |
| 288 | uint64 m_state[sc_numVars]; // internal state of the hash |
| 289 | size_t m_length; // total length of the input so far |
| 290 | uint8 m_remainder; // length of unhashed data stashed in m_data |
| 291 | }; |
| 292 | |
| 293 | |
| 294 | |