Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Use a faster hash function

  • Loading branch information...
commit 9e65eb9ad37f87d4caec3541f0851e22f714b711 1 parent 721d8fd
@tstarling tstarling authored tricky committed
View
2  config.m4
@@ -49,6 +49,6 @@ if test "$PHP_IGBINARY" != "no"; then
PHP_ADD_MAKEFILE_FRAGMENT(Makefile.bench)
PHP_INSTALL_HEADERS([ext/igbinary], [igbinary.h])
- PHP_NEW_EXTENSION(igbinary, igbinary.c hash_si.c hash_function.c, $ext_shared,, $PHP_IGBINARY_CFLAGS)
+ PHP_NEW_EXTENSION(igbinary, igbinary.c hash_si.c, $ext_shared,, $PHP_IGBINARY_CFLAGS)
PHP_ADD_EXTENSION_DEP(igbinary, session, true)
fi
View
2  config.w32
@@ -8,7 +8,7 @@ if (PHP_IGBINARY == "yes") {
if (res) {
AC_DEFINE('HAVE_APC_SUPPORT', 1, 'Whether to enable apc support')
}
- EXTENSION("igbinary", "igbinary.c hash_si.c hash_function.c");
+ EXTENSION("igbinary", "igbinary.c hash_si.c");
AC_DEFINE('HAVE_IGBINARY', 1, 'Have igbinary support', false);
ADD_EXTENSION_DEP('igbinary', 'session');
}
View
185 hash_function.c
@@ -1,185 +0,0 @@
-/*
--------------------------------------------------------------------------------
-lookup3.c, by Bob Jenkins, May 2006, Public Domain.
-*/
-#ifdef PHP_WIN32
-# include "ig_win32.h"
-#else
-# include <sys/param.h> /* attempt to define endianness */
-# ifdef linux
-# include <endian.h> /* attempt to define endianness */
-# endif
-#endif
-#include "hash_function.h"
-
-#define hashsize(n) ((uint32_t)1<<(n))
-#define hashmask(n) (hashsize(n)-1)
-#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
-
-/*
--------------------------------------------------------------------------------
-mix -- mix 3 32-bit values reversibly.
-
-This is reversible, so any information in (a,b,c) before mix() is
-still in (a,b,c) after mix().
-
-If four pairs of (a,b,c) inputs are run through mix(), or through
-mix() in reverse, there are at least 32 bits of the output that
-are sometimes the same for one pair and different for another pair.
-This was tested for:
-* pairs that differed by one bit, by two bits, in any combination
- of top bits of (a,b,c), or in any combination of bottom bits of
- (a,b,c).
-* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
- the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
- is commonly produced by subtraction) look like a single 1-bit
- difference.
-* the base values were pseudorandom, all zero but one bit set, or
- all zero plus a counter that starts at zero.
-
-Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
-satisfy this are
- 4 6 8 16 19 4
- 9 15 3 18 27 15
- 14 9 3 7 17 3
-Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
-for "differ" defined as + with a one-bit base and a two-bit delta. I
-used http://burtleburtle.net/bob/hash/avalanche.html to choose
-the operations, constants, and arrangements of the variables.
-
-This does not achieve avalanche. There are input bits of (a,b,c)
-that fail to affect some output bits of (a,b,c), especially of a. The
-most thoroughly mixed value is c, but it doesn't really even achieve
-avalanche in c.
-
-This allows some parallelism. Read-after-writes are good at doubling
-the number of bits affected, so the goal of mixing pulls in the opposite
-direction as the goal of parallelism. I did what I could. Rotates
-seem to cost as much as shifts on every machine I could lay my hands
-on, and rotates are much kinder to the top and bottom bits, so I used
-rotates.
--------------------------------------------------------------------------------
-*/
-#define mix(a,b,c) \
-{ \
- a -= c; a ^= rot(c, 4); c += b; \
- b -= a; b ^= rot(a, 6); a += c; \
- c -= b; c ^= rot(b, 8); b += a; \
- a -= c; a ^= rot(c,16); c += b; \
- b -= a; b ^= rot(a,19); a += c; \
- c -= b; c ^= rot(b, 4); b += a; \
-}
-
-/*
--------------------------------------------------------------------------------
-final -- final mixing of 3 32-bit values (a,b,c) into c
-
-Pairs of (a,b,c) values differing in only a few bits will usually
-produce values of c that look totally different. This was tested for
-* pairs that differed by one bit, by two bits, in any combination
- of top bits of (a,b,c), or in any combination of bottom bits of
- (a,b,c).
-* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
- the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
- is commonly produced by subtraction) look like a single 1-bit
- difference.
-* the base values were pseudorandom, all zero but one bit set, or
- all zero plus a counter that starts at zero.
-
-These constants passed:
- 14 11 25 16 4 14 24
- 12 14 25 16 4 14 24
-and these came close:
- 4 8 15 26 3 22 24
- 10 8 15 26 3 22 24
- 11 8 15 26 3 22 24
--------------------------------------------------------------------------------
-*/
-#define final(a,b,c) \
-{ \
- c ^= b; c -= rot(b,14); \
- a ^= c; a -= rot(c,11); \
- b ^= a; b -= rot(a,25); \
- c ^= b; c -= rot(b,16); \
- a ^= c; a -= rot(c,4); \
- b ^= a; b -= rot(a,14); \
- c ^= b; c -= rot(b,24); \
-}
-
-/*
--------------------------------------------------------------------------------
-hashlittle() -- hash a variable-length key into a 32-bit value
- k : the key (the unaligned variable-length array of bytes)
- length : the length of the key, counting by bytes
- initval : can be any 4-byte value
-Returns a 32-bit value. Every bit of the key affects every bit of
-the return value. Two keys differing by one or two bits will have
-totally different hash values.
-
-The best hash table sizes are powers of 2. There is no need to do
-mod a prime (mod is sooo slow!). If you need less than 32 bits,
-use a bitmask. For example, if you need only 10 bits, do
- h = (h & hashmask(10));
-In which case, the hash table should have hashsize(10) elements.
-
-If you are hashing n strings (uint8_t **)k, do it like this:
- for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
-
-By Bob Jenkins, 2006. bob_jenkins@burtleburtle.net. You may use this
-code any way you wish, private, educational, or commercial. It's free.
-
-Use for hash table lookup, or anything where one collision in 2^^32 is
-acceptable. Do NOT use for cryptographic purposes.
--------------------------------------------------------------------------------
-*/
-
-uint32_t hash_function( const void *key, size_t length, uint32_t initval)
-{
- uint32_t a,b,c; /* internal state */
- const uint8_t *k = (const uint8_t *)key;
- /* Set up the internal state */
- a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
-
-
- /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
- while (length > 12)
- {
- a += k[0];
- a += ((uint32_t)k[1])<<8;
- a += ((uint32_t)k[2])<<16;
- a += ((uint32_t)k[3])<<24;
- b += k[4];
- b += ((uint32_t)k[5])<<8;
- b += ((uint32_t)k[6])<<16;
- b += ((uint32_t)k[7])<<24;
- c += k[8];
- c += ((uint32_t)k[9])<<8;
- c += ((uint32_t)k[10])<<16;
- c += ((uint32_t)k[11])<<24;
- mix(a,b,c);
- length -= 12;
- k += 12;
- }
-
- /*-------------------------------- last block: affect all 32 bits of (c) */
- switch(length) /* all the case statements fall through */
- {
- case 12: c+=((uint32_t)k[11])<<24;
- case 11: c+=((uint32_t)k[10])<<16;
- case 10: c+=((uint32_t)k[9])<<8;
- case 9 : c+=k[8];
- case 8 : b+=((uint32_t)k[7])<<24;
- case 7 : b+=((uint32_t)k[6])<<16;
- case 6 : b+=((uint32_t)k[5])<<8;
- case 5 : b+=k[4];
- case 4 : a+=((uint32_t)k[3])<<24;
- case 3 : a+=((uint32_t)k[2])<<16;
- case 2 : a+=((uint32_t)k[1])<<8;
- case 1 : a+=k[0];
- break;
- case 0 : return c;
- }
-
- final(a,b,c);
- return c;
-}
View
31 hash_function.h
@@ -1,31 +0,0 @@
-/*
- +----------------------------------------------------------------------+
- | See COPYING file for further copyright information |
- +----------------------------------------------------------------------+
- | Author: Oleg Grenrus <oleg.grenrus@dynamoid.com> |
- | See CREDITS for contributors |
- +----------------------------------------------------------------------+
-*/
-
-#ifndef HASH_FUNCTION_H
-#define HASH_FUNCTION_H
-#ifdef PHP_WIN32
-# include "ig_win32.h"
-#else
-# include <stdint.h> /* defines uint32_t etc */
-#endif
-/**
- * Hash function
- *
- * At this moment lookup3 by Bob Jerkins
- *
- * @param key key
- * @param length key length
- * @param initval hash init val
- * @return hash value of key
- * @see http://burtleburtle.net/bob/hash/index.html
- * @author Bob Jerkins <bob_jenkins@burtleburtle.net>
- */
-uint32_t hash_function(const void *key, size_t length, uint32_t initval);
-
-#endif /* HASH_FUNCTION_H */
View
6 hash_si.c
@@ -18,7 +18,7 @@
#include <assert.h>
#include "hash.h"
-#include "hash_function.h"
+#include "zend.h"
/* {{{ nextpow2 */
/** Next power of 2.
@@ -80,7 +80,7 @@ inline static size_t _hash_si_find(struct hash_si *h, const char *key, size_t ke
assert(h != NULL);
size = h->size;
- hv = hash_function(key, key_len, 0) & (h->size-1);
+ hv = zend_inline_hash_func(key, key_len) & (h->size-1);
while (size > 0 &&
h->data[hv].key != NULL &&
@@ -116,7 +116,7 @@ int hash_si_remove(struct hash_si *h, const char *key, size_t key_len, uint32_t
j = (hv + 1) & (h->size-1);
while (h->data[j].key != NULL) {
- k = hash_function(h->data[j].key, strlen(h->data[j].key), 0) & (h->size-1);
+ k = zend_inline_hash_func(h->data[j].key, strlen(h->data[j].key)) & (h->size-1);
if ((j > hv && (k <= hv || k > j)) || (j < hv && (k <= hv && k > j))) {
h->data[hv].key = h->data[j].key;
h->data[hv].key_len = h->data[j].key_len;
Please sign in to comment.
Something went wrong with that request. Please try again.