motiejus/turbonss
1
Fork 0
Code Releases Activity

Improved c++0x test.

Browse Source
This commit is contained in:
Davi Reis 2011-11-05 10:27:24 -02:00
parent 96862d3113
commit 2a67236e29
4 changed files with 142 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
acinclude.m4
View File

@ -12,6 +12,82 @@ AC_DEFUN([AC_CHECK_SPOON], [
AC_MSG_RESULT(no) AC_MSG_RESULT(no)
]) ])
dnl Check for baseline language coverage in the compiler for the C++0x standard.
# AC_COMPILE_STDCXX_OX
AC_DEFUN([AC_COMPILE_STDCXX_0X], [
AC_CACHE_CHECK(if compiler supports C++0x features without additional flags,
ac_cv_cxx_compile_cxx0x_native,
[AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_TRY_COMPILE([
#include <unorderd_map>
#include <unorderd_set>
template <typename T>
struct check
{
static_assert(sizeof(int) <= sizeof(T), "not big enough");
};
typedef check<check<bool>> right_angle_brackets;
int a;
decltype(a) b;
],,
ac_cv_cxx_compile_cxx0x_native=yes, ac_cv_cxx_compile_cxx0x_native=no)
AC_LANG_RESTORE
])
AC_CACHE_CHECK(if compiler supports C++0x features with -std=c++0x,
ac_cv_cxx_compile_cxx0x_cxx,
[AC_LANG_SAVE
AC_LANG_CPLUSPLUS
ac_save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS -std=c++0x"
AC_TRY_COMPILE([
template <typename T>
struct check
{
static_assert(sizeof(int) <= sizeof(T), "not big enough");
};
typedef check<check<bool>> right_angle_brackets;
int a;
decltype(a) b;],,
ac_cv_cxx_compile_cxx0x_cxx=yes, ac_cv_cxx_compile_cxx0x_cxx=no)
CXXFLAGS="$ac_save_CXXFLAGS"
AC_LANG_RESTORE
])
AC_CACHE_CHECK(if compiler supports C++0x features with -std=gnu++0x,
ac_cv_cxx_compile_cxx0x_gxx,
[AC_LANG_SAVE
AC_LANG_CPLUSPLUS
ac_save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS -std=gnu++0x"
AC_TRY_COMPILE([
template <typename T>
struct check
{
static_assert(sizeof(int) <= sizeof(T), "not big enough");
};
typedef check<check<bool>> right_angle_brackets;
int a;
decltype(a) b;],,
ac_cv_cxx_compile_cxx0x_gxx=yes, ac_cv_cxx_compile_cxx0x_gxx=no)
CXXFLAGS="$ac_save_CXXFLAGS"
AC_LANG_RESTORE
])
if test "$ac_cv_cxx_compile_cxx0x_native" = yes ||
test "$ac_cv_cxx_compile_cxx0x_cxx" = yes ||
test "$ac_cv_cxx_compile_cxx0x_gxx" = yes; then
AC_DEFINE(HAVE_STDCXX_0X,,[Define if g++ supports C++0x features. ])
fi
])
dnl By default, many hosts won't let programs access large files; dnl By default, many hosts won't let programs access large files;
dnl one must use special compiler options to get large-file access to work. dnl one must use special compiler options to get large-file access to work.
dnl For more details about this brain damage please see: dnl For more details about this brain damage please see:

10
configure.ac
View File

@ -36,6 +36,16 @@ CFLAGS="-Wall -Werror"
AC_PROG_CXX AC_PROG_CXX
AC_ENABLE_CXXMPH AC_ENABLE_CXXMPH
if test x$cxxmph = xtrue; then if test x$cxxmph = xtrue; then
AC_COMPILE_STDCXX_0X
if test x$ac_cv_cxx_compile_cxx0x_native = "xno"; then
if test x$ac_cv_cxx_compile_cxx0x_cxx = "xyes"; then
CXXFLAGS="$CXXFLAGS -std=c++0x"
elif test x$ac_cv_cxx_compile_cxx0x_gxx = "xyes"; then
CXXFLAGS="$CXXFLAGS -std=gnu++0x"
else
AC_MSG_ERROR("cxxmph demands a working c++0x compiler.")
fi
fi
AC_SUBST([CXXMPH], "cxxmph") AC_SUBST([CXXMPH], "cxxmph")
fi fi

1
cxxmph/Makefile.am
View File

@ -1,4 +1,3 @@
AM_CXXFLAGS='-std=c++0x'
TESTS = $(check_PROGRAMS) TESTS = $(check_PROGRAMS)
check_PROGRAMS = mph_map_test mph_index_test # trigraph_test check_PROGRAMS = mph_map_test mph_index_test # trigraph_test
noinst_PROGRAMS = bm_index bm_map noinst_PROGRAMS = bm_index bm_map

112
src/jenkins_hash.c
View File

@ -9,7 +9,6 @@
//#define DEBUG //#define DEBUG
#include "debug.h" #include "debug.h"
#include "MurmurHash2.h"
#define hashsize(n) ((cmph_uint32)1<<(n)) #define hashsize(n) ((cmph_uint32)1<<(n))
#define hashmask(n) (hashsize(n)-1) #define hashmask(n) (hashsize(n)-1)
@ -88,8 +87,8 @@ acceptable. Do NOT use for cryptographic purposes.
jenkins_state_t *jenkins_state_new(cmph_uint32 size) //size of hash table jenkins_state_t *jenkins_state_new(cmph_uint32 size) //size of hash table
{ {
jenkins_state_t *state = (jenkins_state_t *)malloc(sizeof(jenkins_state_t)); jenkins_state_t *state = (jenkins_state_t *)malloc(sizeof(jenkins_state_t));
DEBUGP("Initializing jenkins hash\n");
state->seed = ((cmph_uint32)rand() % size); state->seed = ((cmph_uint32)rand() % size);
DEBUGP("Initializied jenkins hash with seed %d\n", state->seed);
return state; return state;
} }
void jenkins_state_destroy(jenkins_state_t *state) void jenkins_state_destroy(jenkins_state_t *state)
@ -100,67 +99,63 @@ void jenkins_state_destroy(jenkins_state_t *state)
static inline void __jenkins_hash_vector(cmph_uint32 seed, const char *k, cmph_uint32 keylen, cmph_uint32 * hashes) static inline void __jenkins_hash_vector(cmph_uint32 seed, const char *k, cmph_uint32 keylen, cmph_uint32 * hashes)
{ {
int i; register cmph_uint32 len, length;
for (i = 0; i < 3; ++i) {
hashes[i] = MurmurHash2(k, keylen, seed + i); /* Set up the internal state */
length = keylen;
len = length;
hashes[0] = hashes[1] = 0x9e3779b9; /* the golden ratio; an arbitrary value */
hashes[2] = seed; /* the previous hash value - seed in our case */
/*---------------------------------------- handle most of the key */
while (len >= 12)
{
hashes[0] += ((cmph_uint32)k[0] +((cmph_uint32)k[1]<<8) +((cmph_uint32)k[2]<<16) +((cmph_uint32)k[3]<<24));
hashes[1] += ((cmph_uint32)k[4] +((cmph_uint32)k[5]<<8) +((cmph_uint32)k[6]<<16) +((cmph_uint32)k[7]<<24));
hashes[2] += ((cmph_uint32)k[8] +((cmph_uint32)k[9]<<8) +((cmph_uint32)k[10]<<16)+((cmph_uint32)k[11]<<24));
mix(hashes[0],hashes[1],hashes[2]);
k += 12; len -= 12;
} }
// register cmph_uint32 len, length;
// /*------------------------------------- handle the last 11 bytes */
// /* Set up the internal state */ hashes[2] += length;
// length = keylen; switch(len) /* all the case statements fall through */
// len = length; {
// hashes[0] = hashes[1] = 0x9e3779b9; /* the golden ratio; an arbitrary value */ case 11:
// hashes[2] = seed; /* the previous hash value - seed in our case */ hashes[2] +=((cmph_uint32)k[10]<<24);
// case 10:
// /*---------------------------------------- handle most of the key */ hashes[2] +=((cmph_uint32)k[9]<<16);
// while (len >= 12) case 9 :
// { hashes[2] +=((cmph_uint32)k[8]<<8);
// hashes[0] += ((cmph_uint32)k[0] +((cmph_uint32)k[1]<<8) +((cmph_uint32)k[2]<<16) +((cmph_uint32)k[3]<<24)); /* the first byte of hashes[2] is reserved for the length */
// hashes[1] += ((cmph_uint32)k[4] +((cmph_uint32)k[5]<<8) +((cmph_uint32)k[6]<<16) +((cmph_uint32)k[7]<<24)); case 8 :
// hashes[2] += ((cmph_uint32)k[8] +((cmph_uint32)k[9]<<8) +((cmph_uint32)k[10]<<16)+((cmph_uint32)k[11]<<24)); hashes[1] +=((cmph_uint32)k[7]<<24);
// mix(hashes[0],hashes[1],hashes[2]); case 7 :
// k += 12; len -= 12; hashes[1] +=((cmph_uint32)k[6]<<16);
// } case 6 :
// hashes[1] +=((cmph_uint32)k[5]<<8);
// /*------------------------------------- handle the last 11 bytes */ case 5 :
// hashes[2] += length; hashes[1] +=(cmph_uint8) k[4];
// switch(len) /* all the case statements fall through */ case 4 :
// { hashes[0] +=((cmph_uint32)k[3]<<24);
// case 11: case 3 :
// hashes[2] +=((cmph_uint32)k[10]<<24); hashes[0] +=((cmph_uint32)k[2]<<16);
// case 10: case 2 :
// hashes[2] +=((cmph_uint32)k[9]<<16); hashes[0] +=((cmph_uint32)k[1]<<8);
// case 9 : case 1 :
// hashes[2] +=((cmph_uint32)k[8]<<8); hashes[0] +=(cmph_uint8)k[0];
// /* the first byte of hashes[2] is reserved for the length */ /* case 0: nothing left to add */
// case 8 : }
// hashes[1] +=((cmph_uint32)k[7]<<24);
// case 7 : mix(hashes[0],hashes[1],hashes[2]);
// hashes[1] +=((cmph_uint32)k[6]<<16);
// case 6 :
// hashes[1] +=((cmph_uint32)k[5]<<8);
// case 5 :
// hashes[1] +=(cmph_uint8) k[4];
// case 4 :
// hashes[0] +=((cmph_uint32)k[3]<<24);
// case 3 :
// hashes[0] +=((cmph_uint32)k[2]<<16);
// case 2 :
// hashes[0] +=((cmph_uint32)k[1]<<8);
// case 1 :
// hashes[0] +=(cmph_uint8)k[0];
// /* case 0: nothing left to add */
// }
//
// mix(hashes[0],hashes[1],hashes[2]);
} }
cmph_uint32 jenkins_hash(jenkins_state_t *state, const char *k, cmph_uint32 keylen) cmph_uint32 jenkins_hash(jenkins_state_t *state, const char *k, cmph_uint32 keylen)
{ {
// cmph_uint32 hashes[3]; cmph_uint32 hashes[3];
// __jenkins_hash_vector(state->seed, k, keylen, hashes); __jenkins_hash_vector(state->seed, k, keylen, hashes);
// return hashes[2]; return hashes[2];
cmph_uint32 a, b, c; /* cmph_uint32 a, b, c;
cmph_uint32 len, length; cmph_uint32 len, length;
// Set up the internal state // Set up the internal state
@ -214,6 +209,7 @@ cmph_uint32 jenkins_hash(jenkins_state_t *state, const char *k, cmph_uint32 keyl
/// report the result /// report the result
return c; return c;
*/
} }
void jenkins_hash_vector_(jenkins_state_t *state, const char *k, cmph_uint32 keylen, cmph_uint32 * hashes) void jenkins_hash_vector_(jenkins_state_t *state, const char *k, cmph_uint32 keylen, cmph_uint32 * hashes)