Merge lp:~jake-moilanen/libmemcached/ubuntu32-build into lp:~tangent-org/libmemcached/trunk

[Jake Moilanen]

[Jake Moilanen (jake-moilanen)]

Here's the code to hopefully fix the ubuntu 32-bit build issue.

=== modified file '.bzrignore'
--- .bzrignore	2009-10-01 13:45:12 +0000
+++ .bzrignore	2009-12-11 17:27:14 +0000
@@ -65,3 +65,4 @@
 libmemcached-0.31-1.src.rpm
 libmemcached-0.31-1.x86_64.rpm
 libmemcached-?.??/
+tests/testhashkit

=== modified file 'Makefile.am'
--- Makefile.am	2009-10-05 18:37:05 +0000
+++ Makefile.am	2009-12-11 17:27:14 +0000
@@ -1,6 +1,6 @@
 ACLOCAL_AMFLAGS = -I m4
 
-SUBDIRS = docs libmemcached support clients tests example
+SUBDIRS = docs ${PANDORA_BUNDLED_SUBDIRS} libmemcached support clients tests example
 EXTRA_dist = README.FIRST
 
 check-local: test-no-outputdiff

=== modified file 'clients/ms_atomic.h'
--- clients/ms_atomic.h	2009-12-03 19:26:03 +0000
+++ clients/ms_atomic.h	2009-12-11 17:27:14 +0000
@@ -23,6 +23,10 @@
 # define atomic_dec_16_nv(X) __sync_fetch_and_sub((X), 1)
 # define atomic_dec_32_nv(X) __sync_fetch_and_sub((X), 1)
 # define atomic_dec_64_nv(X) __sync_fetch_and_sub((X), 1)
+
+# define spin_lock(l) while (__sync_lock_test_and_set(l, (void *) 1) == 1) {}
+# define spin_unlock(l) { asm volatile ("sfence":::"memory"); *(l) = 0;}
+
 #endif /* defined(__SUNPRO_C) */
 
 #endif /* CLIENTS_MS_ATOMIC_H */

=== modified file 'clients/ms_conn.c'
--- clients/ms_conn.c	2009-12-06 09:02:23 +0000
+++ clients/ms_conn.c	2009-12-11 17:27:14 +0000
@@ -371,7 +371,7 @@
 
   if (! (ms_setting.facebook_test && is_udp))
   {
-    atomic_add_32(&ms_stats.active_conns, 1);
+    ms_update_conns(&ms_stats, &ms_stats.active_conns, 1);
   }
 
   return 0;
@@ -691,7 +691,7 @@
     close(c->udpsfd);
   }
 
-  atomic_dec_32(&ms_stats.active_conns);
+  ms_update_conns(&ms_stats, &ms_stats.active_conns, -1);
 
   ms_conn_free(c);
 
@@ -1589,7 +1589,7 @@
 
     if (res > 0)
     {
-      atomic_add_64(&ms_stats.bytes_read, res);
+      ms_update_stats(&ms_stats, &ms_stats.bytes_read, res);
       c->rudpbytes+= res;
       rbytes+= res;
       if (res == avail)
@@ -1623,7 +1623,7 @@
 
   if (copybytes == -1)
   {
-    atomic_add_64(&ms_stats.pkt_disorder, 1);
+    ms_update_stats(&ms_stats, (uint64_t *)&ms_stats.pkt_disorder, 1);    
   }
 
   return copybytes;
@@ -1701,7 +1701,7 @@
     {
       if (! c->udp)
       {
-        atomic_add_64(&ms_stats.bytes_read, res);
+        ms_update_stats(&ms_stats, &ms_stats.bytes_read, res);
       }
       gotdata= 1;
       c->rbytes+= res;
@@ -1765,7 +1765,7 @@
       if (curr_time.tv_sec - c->curr_task.item->client_time
           > c->curr_task.item->exp_time + EXPIRE_TIME_ERROR)
       {
-        atomic_add_64(&ms_stats.exp_get, 1);
+        ms_update_stats(&ms_stats, &ms_stats.exp_get, 1);
 
         if (ms_setting.verbose)
         {
@@ -1806,7 +1806,7 @@
       if ((c->curr_task.item->value_size != vlen)
           || (memcmp(orignval, value, (size_t)vlen) != 0))
       {
-        atomic_add_64(&ms_stats.vef_failed, 1);
+        ms_update_stats(&ms_stats, &ms_stats.vef_failed, 1);
 
         if (ms_setting.verbose)
         {
@@ -2254,7 +2254,7 @@
     res= sendmsg(c->sfd, m, 0);
     if (res > 0)
     {
-      atomic_add_64(&ms_stats.bytes_written, res);
+      ms_update_stats(&ms_stats, &ms_stats.bytes_written, (int)res);
 
       /* We've written some of the data. Remove the completed
        *  iovec entries from the list of pending writes. */
@@ -2997,9 +2997,9 @@
     }
   }
 
-  atomic_add_64(&ms_stats.obj_bytes,
-                item->key_size + item->value_size);
-  atomic_add_64(&ms_stats.cmd_set, 1);
+  ms_update_stats(&ms_stats, &ms_stats.obj_bytes,
+                  item->key_size + item->value_size);
+  ms_update_stats(&ms_stats, &ms_stats.cmd_set, 1);
 
   return 0;
 } /* ms_mcd_set */
@@ -3083,7 +3083,7 @@
     }
   }
 
-  atomic_add_64(&ms_stats.cmd_get, 1);
+  ms_update_stats(&ms_stats, &ms_stats.cmd_get, 1);
 
   return 0;
 } /* ms_mcd_get */
@@ -3182,7 +3182,7 @@
   for (int i= 0; i < c->mlget_task.mlget_num; i++)
   {
     item= c->mlget_task.mlget_item[i].item;
-    atomic_add_64(&ms_stats.cmd_get, 1);
+    ms_update_stats(&ms_stats, &ms_stats.cmd_get, 1);
   }
 
   return 0;

=== modified file 'clients/ms_memslap.h'
--- clients/ms_memslap.h	2009-12-03 19:26:03 +0000
+++ clients/ms_memslap.h	2009-12-11 17:27:14 +0000
@@ -28,6 +28,8 @@
 extern "C" {
 #endif
 
+typedef int32_t spin_lock_t;
+
 /* command line option  */
 typedef enum
 {
@@ -85,6 +87,7 @@
   volatile uint64_t pkt_disorder;            /* disorder packages of UDP */
   uint64_t pkt_drop;                /* packages dropped of UDP */
   uint64_t udp_timeout;             /* how many times timeout of UDP happens */
+  spin_lock_t stats_lock;           /* lock to update stats structure */        
 } ms_stats_t;
 
 /* lock adapter */

=== modified file 'clients/ms_stats.c'
--- clients/ms_stats.c	2009-12-03 20:16:27 +0000
+++ clients/ms_stats.c	2009-12-11 17:27:14 +0000
@@ -12,7 +12,9 @@
 #include "config.h"
 
 #include <inttypes.h>
+#include "ms_memslap.h"
 #include "ms_stats.h"
+#include "ms_atomic.h"
 
 #define array_size(x)    (sizeof(x) / sizeof((x)[0]))
 
@@ -305,3 +307,22 @@
   stat->period_max_time= 0;
   stat->pre_get_miss= stat->get_miss;
 } /* ms_dump_format_stats */
+
+void ms_update_stats(struct stats * stats,
+                     uint64_t * stat,
+                     int amount)
+{
+    spin_lock(&stats->stats_lock);
+    *stat += (uint64_t)amount;
+    spin_unlock(&stats->stats_lock);
+}
+                     
+void ms_update_conns(struct stats * stats,
+                     volatile uint32_t * num_conns,
+                     int amount)
+{
+    spin_lock(&stats->stats_lock);
+    *(int32_t *)num_conns += (int32_t)amount;
+    spin_unlock(&stats->stats_lock);
+}
+

=== modified file 'clients/ms_stats.h'
--- clients/ms_stats.h	2009-11-30 16:43:20 +0000
+++ clients/ms_stats.h	2009-12-11 17:27:14 +0000
@@ -62,6 +62,19 @@
                           int obj_size);
 
 
+struct stats;
+
+/* update a stats counter */
+void ms_update_stats(struct stats * stats,
+                     uint64_t * stat,
+                     int amount);
+
+/* update the number of connections */
+void ms_update_conns(struct stats * stats,
+                     volatile uint32_t * num_conns,
+                     int amount);
+
+
 #ifdef __cplusplus
 }
 #endif

=== modified file 'clients/ms_task.c'
--- clients/ms_task.c	2009-12-03 20:16:27 +0000
+++ clients/ms_task.c	2009-12-11 17:27:14 +0000
@@ -725,7 +725,7 @@
     /* update get miss counter */
     if (mlget_item->get_miss)
     {
-      atomic_add_64(&ms_stats.get_misses, 1);
+      ms_update_stats(&ms_stats, &ms_stats.get_misses, 1);
     }
 
     /* get nothing from server for this task item */
@@ -741,7 +741,7 @@
         if (curr_time.tv_sec - item->client_time
             < item->exp_time - EXPIRE_TIME_ERROR)
         {
-          atomic_add_64(&ms_stats.unexp_unget, 1);
+          ms_update_stats(&ms_stats, &ms_stats.unexp_unget, 1);
 
           if (ms_setting.verbose)
           {
@@ -779,7 +779,7 @@
       }
       else
       {
-        atomic_add_64(&ms_stats.vef_miss, 1);
+        ms_update_stats(&ms_stats, &ms_stats.vef_miss, 1);
 
         if (ms_setting.verbose)
         {
@@ -829,7 +829,7 @@
   /* update get miss counter */
   if ((c->precmd.cmd == CMD_GET) && c->curr_task.get_miss)
   {
-    atomic_add_64(&ms_stats.get_misses, 1);
+    ms_update_stats(&ms_stats, &ms_stats.get_misses, 1);
   }
 
   /* get nothing from server for this task item */
@@ -846,7 +846,7 @@
       if (curr_time.tv_sec - item->client_time
           < item->exp_time - EXPIRE_TIME_ERROR)
       {
-        atomic_add_64(&ms_stats.unexp_unget, 1);
+        ms_update_stats(&ms_stats, &ms_stats.unexp_unget, 1);
 
         if (ms_setting.verbose)
         {
@@ -884,7 +884,7 @@
     }
     else
     {
-      atomic_add_64(&ms_stats.vef_miss, 1);
+      ms_update_stats(&ms_stats, &ms_stats.vef_miss, 1);
 
       if (ms_setting.verbose)
       {

=== modified file 'clients/ms_thread.c'
--- clients/ms_thread.c	2009-12-06 09:02:23 +0000
+++ clients/ms_thread.c	2009-12-11 17:27:14 +0000
@@ -69,10 +69,10 @@
         /* calculate dropped packets count */
         if (c->recvpkt > 0)
         {
-          atomic_add_64(&ms_stats.pkt_drop, c->packets - c->recvpkt);
+          ms_update_stats(&ms_stats, &ms_stats.pkt_drop, c->packets - c->recvpkt);
         }
 
-        atomic_add_64(&ms_stats.udp_timeout, 1);
+        ms_update_stats(&ms_stats, &ms_stats.udp_timeout, 1);
         ms_reset_conn(c, true);
       }
     }

=== modified file 'configure.ac'
--- configure.ac	2009-12-05 13:11:26 +0000
+++ configure.ac	2009-12-11 17:27:14 +0000
@@ -14,6 +14,49 @@
 
 PANDORA_CANONICAL_TARGET
 
+#shared library versioning
+MEMCACHED_LIBRARY_VERSION=3:0:0
+#                         | | |
+#                  +------+ | +---+
+#                  |        |     |
+#                 current:revision:age
+#                  |        |     |
+#                  |        |     +- increment if interfaces have been added
+#                  |        |        set to zero if interfaces have been removed or changed
+#                  |        +- increment if source code has changed
+#                  |           set to zero if current is incremented
+#                  +- increment if interfaces have been added, removed or changed
+AC_SUBST(MEMCACHED_LIBRARY_VERSION)
+MEMCACHEDUTIL_LIBRARY_VERSION=0:0:0
+AC_SUBST(MEMCACHEDUTIL_LIBRARY_VERSION)
+MEMCACHEDPROTOCOL_LIBRARY_VERSION=0:0:0
+AC_SUBST(MEMCACHEDPROTOCOL_LIBRARY_VERSION)
+HASHKIT_LIBRARY_VERSION=0:0:0
+AC_SUBST(HASHKIT_LIBRARY_VERSION)
+
+
+# libmemcached versioning when linked with GNU ld.
+if test "$lt_cv_prog_gnu_ld" = "yes"
+then
+    LD_VERSION_SCRIPT="-Wl,--version-script=\$(top_srcdir)/libmemcached/libmemcached.ver"
+    LD_UTIL_VERSION_SCRIPT="-Wl,--version-script=\$(top_srcdir)/libmemcached/util/libmemcachedutil.ver"
+    LD_PROTOCOL_VERSION_SCRIPT="-Wl,--version-script=\$(top_srcdir)/libmemcached/protocol/libmemcachedprotocol.ver"
+fi
+AC_SUBST(LD_VERSION_SCRIPT)
+AC_SUBST(LD_UTIL_VERSION_SCRIPT)
+AC_SUBST(LD_PROTOCOL_VERSION_SCRIPT)
+
+
+#--------------------------------------------------------------------
+# Check for libpthread
+#--------------------------------------------------------------------
+
+ACX_PTHREAD(,AC_MSG_ERROR(could not find libpthread))
+LIBS="${PTHREAD_LIBS} ${LIBS}"
+CFLAGS="${PTHREAD_CFLAGS} ${CFLAGS}"
+CC="$PTHREAD_CC"
+
+
 AC_SEARCH_LIBS(getopt_long, gnugetopt)
 AC_SEARCH_LIBS(gethostbyname, nsl)
 
@@ -35,6 +78,7 @@
 ENABLE_DEPRECATED
 PANDORA_HAVE_LIBINNODB
 PANDORA_PRINT_CALLSTACK
+PANDORA_BUNDLE_LIBHASHKIT
 
 AC_CONFIG_FILES([
   Makefile
@@ -48,6 +92,7 @@
   support/libmemcached.pc
   support/libmemcached.spec
   support/libmemcached-fc.spec
+  libhashkit/Makefile
   ])
 AC_OUTPUT
 

=== added directory 'libhashkit'
=== added file 'libhashkit/Makefile.am'
--- libhashkit/Makefile.am	1970-01-01 00:00:00 +0000
+++ libhashkit/Makefile.am	2009-12-11 17:27:14 +0000
@@ -0,0 +1,43 @@
+# HashKit
+# Copyright (C) 2009 Brian Aker
+# All rights reserved.
+#
+# Use and distribution licensed under the BSD license.  See
+# the COPYING file in the parent directory for full text.
+
+lib_LTLIBRARIES= libhashkit.la
+
+libhashkitincludedir= ${includedir}/libhashkit
+
+dist_libhashkitinclude_HEADERS= \
+	algorithm.h \
+	behavior.h \
+        hashkit.h \
+        types.h \
+        visibility.h
+
+noinst_HEADERS= \
+        common.h
+
+libhashkit_la_SOURCES= \
+        crc32.c \
+        behavior.c \
+        default.c \
+        fnv.c \
+        hashkit.c \
+        jenkins.c \
+        ketama.c \
+        md5.c \
+        murmur.c
+
+if INCLUDE_HSIEH_SRC
+libhashkit_la_SOURCES+= hsieh.c
+endif
+
+libhashkit_la_CFLAGS= \
+        ${AM_CFLAGS} \
+        -DBUILDING_HASHKIT
+
+libhashkit_la_LDFLAGS= \
+        -version-info \
+        $(HASHKIT_LIBRARY_VERSION)

=== added file 'libhashkit/algorithm.h'
--- libhashkit/algorithm.h	1970-01-01 00:00:00 +0000
+++ libhashkit/algorithm.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,49 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/**
+ * @file
+ * @brief HashKit Header
+ */
+
+#ifndef HASHKIT_ALGORITHM_H
+#define HASHKIT_ALGORITHM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+HASHKIT_API
+uint32_t hashkit_default(const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_crc32(const char *key, size_t key_length);
+HASHKIT_API
+#ifdef HAVE_HSIEH_HASH
+HASHKIT_API
+uint32_t hashkit_hsieh(const char *key, size_t key_length);
+#endif
+HASHKIT_API
+uint32_t hashkit_murmur(const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_jenkins(const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_md5(const char *key, size_t key_length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HASHKIT_ALGORITHM_H */

=== added file 'libhashkit/behavior.c'
--- libhashkit/behavior.c	1970-01-01 00:00:00 +0000
+++ libhashkit/behavior.c	2009-12-11 17:27:14 +0000
@@ -0,0 +1,89 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+#include "common.h"
+
+void hashkit_set_distribution(hashkit_st *hashkit, hashkit_distribution_t distribution)
+{
+  hashkit->distribution= distribution;
+}
+
+hashkit_distribution_t hashkit_get_distribution(hashkit_st *hashkit)
+{
+  return hashkit->distribution;
+}
+
+
+void hashkit_set_hash_fn(hashkit_st *hashkit, hashkit_fn *function)
+{
+  hashkit->hash_fn= function;
+}
+
+hashkit_fn * hashkit_get_hash_fn(hashkit_st *hashkit)
+{
+  return hashkit->hash_fn;
+}
+
+
+void hashkit_set_active_fn(hashkit_st *hashkit, hashkit_active_fn *function)
+{
+  hashkit->active_fn= function;
+}
+
+
+hashkit_active_fn * hashkit_get_active_fn(hashkit_st *hashkit)
+{
+  return hashkit->active_fn;
+}
+
+
+void hashkit_set_continuum_hash_fn(hashkit_st *hashkit, hashkit_fn *function)
+{
+  hashkit->continuum_hash_fn= function;
+}
+
+
+hashkit_fn * hashkit_get_continuum_hash_fn(hashkit_st *hashkit)
+{
+  return hashkit->continuum_hash_fn;
+}
+
+
+void hashkit_set_continuum_key_fn(hashkit_st *hashkit, hashkit_key_fn *function)
+{
+  hashkit->continuum_key_fn= function;
+}
+
+hashkit_key_fn * hashkit_get_continuum_key_fn(hashkit_st *hashkit)
+{
+  return hashkit->continuum_key_fn;
+}
+
+
+void hashkit_set_sort_fn(hashkit_st *hashkit, hashkit_sort_fn *function)
+{
+  hashkit->sort_fn= function;
+}
+
+
+hashkit_sort_fn * hashkit_get_sort_fn(hashkit_st *hashkit)
+{
+  return hashkit->sort_fn;
+}
+
+
+void hashkit_set_weight_fn(hashkit_st *hashkit, hashkit_weight_fn *function)
+{
+  hashkit->weight_fn= function;
+}
+
+
+hashkit_weight_fn * hashkit_get_weight_fn(hashkit_st *hashkit)
+{
+  return hashkit->weight_fn;
+}

=== added file 'libhashkit/behavior.h'
--- libhashkit/behavior.h	1970-01-01 00:00:00 +0000
+++ libhashkit/behavior.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,68 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/**
+ * @file
+ * @brief HashKit Header
+ */
+
+#ifndef HASHKIT_BEHAVIOR_H
+#define HASHKIT_BEHAVIORH
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+HASHKIT_API
+void hashkit_set_distribution(hashkit_st *hash, hashkit_distribution_t distribution);
+
+HASHKIT_API
+hashkit_distribution_t hashkit_get_distribution(hashkit_st *hash);
+
+HASHKIT_API
+void hashkit_set_hash_fn(hashkit_st *hash, hashkit_fn *function);
+
+HASHKIT_API
+hashkit_fn * hashkit_get_hash_fn(hashkit_st *hash);
+
+HASHKIT_API
+void hashkit_set_active_fn(hashkit_st *hash, hashkit_active_fn *function);
+
+HASHKIT_API
+hashkit_active_fn * hashkit_get_active_fn(hashkit_st *hash);
+
+HASHKIT_API
+void hashkit_set_continuum_hash_fn(hashkit_st *hash, hashkit_fn *function);
+
+HASHKIT_API
+hashkit_fn * hashkit_get_continuum_hash_fn(hashkit_st *hash);
+
+HASHKIT_API
+void hashkit_set_continuum_key_fn(hashkit_st *hash, hashkit_key_fn *function);
+
+HASHKIT_API
+hashkit_key_fn * hashkit_get_continuum_key_fn(hashkit_st *hash);
+
+HASHKIT_API
+void hashkit_set_sort_fn(hashkit_st *hash, hashkit_sort_fn *function);
+
+HASHKIT_API
+hashkit_sort_fn * hashkit_get_sort_fn(hashkit_st *hash);
+
+HASHKIT_API
+void hashkit_set_weight_fn(hashkit_st *hash, hashkit_weight_fn *function);
+
+HASHKIT_API
+hashkit_weight_fn * hashkit_get_weight_fn(hashkit_st *hash);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HASHKIT_BEHAVIOR_H */

=== added file 'libhashkit/common.h'
--- libhashkit/common.h	1970-01-01 00:00:00 +0000
+++ libhashkit/common.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,32 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/**
+ * @file
+ * @brief System Include Files
+ */
+
+#ifndef HASHKIT_COMMON_H
+#define HASHKIT_COMMON_H
+
+#include "config.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "hashkit.h"
+
+HASHKIT_LOCAL
+void md5_signature(const unsigned char *key, unsigned int length, unsigned char *result);
+
+HASHKIT_LOCAL
+int update_continuum(hashkit_st *hashkit);
+
+#endif /* HASHKIT_COMMON_H */

=== renamed file 'libmemcached/crc.c' => 'libhashkit/crc32.c'
--- libmemcached/crc.c	2009-09-30 03:51:54 +0000
+++ libhashkit/crc32.c	2009-12-11 17:27:14 +0000
@@ -73,8 +73,7 @@
   0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
 
-
-uint32_t hash_crc32(const char *key, size_t key_length)
+uint32_t hashkit_crc32(const char *key, size_t key_length)
 {
   uint64_t x;
   uint32_t crc= UINT32_MAX;
@@ -82,5 +81,5 @@
   for (x= 0; x < key_length; x++)
      crc= (crc >> 8) ^ crc32tab[(crc ^ (uint64_t)key[x]) & 0xff];
 
-  return ~crc;
+  return ((~crc) >> 16) & 0x7fff;
 }

=== added file 'libhashkit/default.c'
--- libhashkit/default.c	1970-01-01 00:00:00 +0000
+++ libhashkit/default.c	2009-12-11 17:27:14 +0000
@@ -0,0 +1,28 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+#include "common.h"
+
+uint32_t hashkit_default(const char *key, size_t key_length)
+{
+  const char *ptr= key;
+  uint32_t value= 0;
+
+  while (key_length--)
+  {
+    uint32_t val= (uint32_t) *ptr++;
+    value += val;
+    value += (value << 10);
+    value ^= (value >> 6);
+  }
+  value += (value << 3);
+  value ^= (value >> 11);
+  value += (value << 15);
+
+  return value;
+}

=== added file 'libhashkit/fnv.c'
--- libhashkit/fnv.c	1970-01-01 00:00:00 +0000
+++ libhashkit/fnv.c	2009-12-11 17:27:14 +0000
@@ -0,0 +1,75 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+#include "common.h"
+
+/* FNV hash'es lifted from Dustin Sallings work */
+static uint64_t FNV_64_INIT= UINT64_C(0xcbf29ce484222325);
+static uint64_t FNV_64_PRIME= UINT64_C(0x100000001b3);
+static uint32_t FNV_32_INIT= 2166136261UL;
+static uint32_t FNV_32_PRIME= 16777619;
+
+uint32_t hashkit_fnv1_64(const char *key, size_t key_length)
+{
+  /* Thanks to [e-mail] for the pointer */
+  uint64_t hash= FNV_64_INIT;
+  size_t x= 0;
+
+  for (x= 0; x < key_length; x++)
+  {
+    hash *= FNV_64_PRIME;
+    hash ^= (uint64_t)key[x];
+  }
+
+  return (uint32_t)hash;
+}
+
+uint32_t hashkit_fnv1a_64(const char *key, size_t key_length)
+{
+  uint32_t hash= (uint32_t) FNV_64_INIT;
+  size_t x= 0;
+
+  for (x= 0; x < key_length; x++)
+  {
+    uint32_t val= (uint32_t)key[x];
+    hash ^= val;
+    hash *= (uint32_t) FNV_64_PRIME;
+  }
+
+  return hash;
+}
+
+uint32_t hashkit_fnv1_32(const char *key, size_t key_length)
+{
+  uint32_t hash= FNV_32_INIT;
+  size_t x= 0;
+
+  for (x= 0; x < key_length; x++)
+  {
+    uint32_t val= (uint32_t)key[x];
+    hash *= FNV_32_PRIME;
+    hash ^= val;
+  }
+
+  return hash;
+}
+
+uint32_t hashkit_fnv1a_32(const char *key, size_t key_length)
+{
+  uint32_t hash= FNV_32_INIT;
+  size_t x= 0;
+
+  for (x= 0; x < key_length; x++)
+  {
+    uint32_t val= (uint32_t)key[x];
+    hash ^= val;
+    hash *= FNV_32_PRIME;
+  }
+
+  return hash;
+}

=== renamed file 'libmemcached/memcached_hash.c' => 'libhashkit/hashkit.c'
--- libmemcached/memcached_hash.c	2009-11-03 13:09:13 +0000
+++ libhashkit/hashkit.c	2009-12-11 17:27:14 +0000
@@ -1,234 +1,263 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
 #include "common.h"
 
-
-/* Defines */
-static uint64_t FNV_64_INIT= UINT64_C(0xcbf29ce484222325);
-static uint64_t FNV_64_PRIME= UINT64_C(0x100000001b3);
-
-static uint32_t FNV_32_INIT= 2166136261UL;
-static uint32_t FNV_32_PRIME= 16777619;
-
-/* Prototypes */
-static uint32_t internal_generate_hash(const char *key, size_t key_length);
-static uint32_t internal_generate_md5(const char *key, size_t key_length);
-
-uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm)
-{
-  uint32_t hash= 1; /* Just here to remove compile warning */
-  uint32_t x= 0;
-
+inline static bool _is_allocated(const hashkit_st *hashk)
+{
+  return hashk->options.is_allocated == true;
+}
+
+inline static bool _is_initialized(const hashkit_st *hashk)
+{
+  return hashk->options.is_initialized == true;
+}
+
+/**
+  @note We make no assumptions that "hashk" has been, or not been allocated from heap/stack. We just know we didn't do it.
+*/
+hashkit_st *hashkit_create(hashkit_st *hashk)
+{
+  if (hashk == NULL)
+  {
+    hashk= (hashkit_st *)malloc(sizeof(hashkit_st));
+    if (hashk == NULL)
+    {
+      hashk->options.is_initialized= false;
+
+      return NULL;
+    }
+
+    hashk->options.is_allocated= true;
+  }
+  else
+  {
+    hashk->options.is_allocated= false;
+  }
+
+  hashk->options.is_initialized= true;
+
+  hashk->distribution= HASHKIT_DISTRIBUTION_MODULA;
+  hashk->continuum_count= 0;
+  hashk->continuum_points_count= 0;
+  hashk->list_size= 0;
+  hashk->context_size= 0;
+  hashk->continuum= NULL;
+  hashk->hash_fn= NULL;
+  hashk->active_fn= NULL;
+  hashk->continuum_hash_fn= NULL;
+  hashk->continuum_key_fn= NULL;
+  hashk->sort_fn= NULL;
+  hashk->weight_fn= NULL;
+  hashk->list= NULL;
+
+  return hashk;
+}
+
+
+void hashkit_free(hashkit_st *hashk)
+{
+  assert(_is_initialized(hashk) == true);
+
+  if (hashk->continuum != NULL)
+  {
+    free(hashk->continuum);
+  }
+
+  /**
+    We don't know if hashk is pointing to something else,
+    so we go on and set is_initialized.
+  */
+  hashk->options.is_initialized= false;
+
+  if (_is_allocated(hashk))
+  {
+    free(hashk);
+  }
+}
+
+bool hashkit_is_allocated(const hashkit_st *hashk)
+{
+  return _is_allocated(hashk);
+}
+
+bool hashkit_is_initialized(const hashkit_st *hashk)
+{
+  return _is_initialized(hashk);
+}
+
+
+/**
+  @note We do assume source is valid. If source does not exist, we allocate.
+*/
+hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *source)
+{
+  hashkit_st *new_clone;
+
+  if (source == NULL)
+  {
+    return hashkit_create(destination);
+  }
+  else
+  {
+    assert(_is_initialized(source) == true);
+  }
+
+  /* new_clone will be a pointer to destination */ 
+  new_clone= hashkit_create(destination);
+  assert((destination ?  ((_is_allocated(new_clone) == false)) : (_is_allocated(new_clone) == true)));
+
+  // Should only happen on allocation failure.
+  if (new_clone == NULL)
+  {
+    return NULL;
+  }
+
+  // For the moment we will not clone this.
+  new_clone->continuum= NULL;
+
+  new_clone->distribution= source->distribution;
+  new_clone->continuum_count= source->continuum_count;
+  new_clone->continuum_points_count= source->continuum_points_count;
+  new_clone->list_size= source->list_size;
+  new_clone->context_size= source->context_size;
+
+
+  new_clone->hash_fn= source->hash_fn;
+  new_clone->active_fn= source->active_fn;
+  new_clone->continuum_hash_fn= source->continuum_hash_fn;
+  new_clone->continuum_key_fn= source->continuum_key_fn;
+  new_clone->sort_fn= source->sort_fn;
+  new_clone->weight_fn= source->weight_fn;
+  new_clone->list= source->list;
+
+  return new_clone;
+}
+
+
+void hashkit_set_list(hashkit_st *hashkit, void *list, size_t list_size, size_t context_size)
+{
+  hashkit->list= list;
+  hashkit->list_size= list_size;
+  hashkit->context_size= context_size;
+}
+
+
+uint32_t hashkit_value(hashkit_st *hashkit, const char *key, size_t key_length)
+{
+  if (hashkit->hash_fn == NULL)
+    return hashkit_default(key, key_length);
+
+  return hashkit->hash_fn(key, key_length);
+}
+
+
+uint32_t hashkit_index(hashkit_st *hashkit, uint32_t hash_value)
+{
+  if (hashkit->list_size == 1)
+    return 0;
+
+  switch (hashkit->distribution)
+  {
+  case HASHKIT_DISTRIBUTION_MODULA:
+    return hash_value % (uint32_t)hashkit->list_size;
+
+  case HASHKIT_DISTRIBUTION_RANDOM:
+    return (uint32_t)random() % (uint32_t)hashkit->list_size;
+
+  case HASHKIT_DISTRIBUTION_KETAMA:
+  {
+    hashkit_continuum_point_st *begin, *end, *left, *right, *middle;
+    begin= left= hashkit->continuum;
+    end= right= hashkit->continuum + hashkit->continuum_points_count;
+
+    while (left < right)
+    {
+      middle= left + (right - left) / 2;
+      if (middle->value < hash_value)
+        left= middle + 1;
+      else
+        right= middle;
+    }
+    if (right == end)
+      right= begin;
+    return right->index;
+  }
+
+  case HASHKIT_DISTRIBUTION_MAX:
+  default:
+    /* We have added a distribution without extending the logic */
+    return hash_value % (uint32_t)hashkit->list_size;
+  }
+
+  /* NOTREACHED */
+}
+
+
+int hashkit_run_distribution(hashkit_st *hashkit)
+{
+  switch (hashkit->distribution)
+  {
+  case HASHKIT_DISTRIBUTION_MODULA:
+    if (hashkit->sort_fn != NULL && hashkit->list_size > 1)
+      hashkit->sort_fn(hashkit->list, hashkit->list_size);
+    break;
+  case HASHKIT_DISTRIBUTION_RANDOM:
+    break;
+  case HASHKIT_DISTRIBUTION_KETAMA:
+    return update_continuum(hashkit);
+  case HASHKIT_DISTRIBUTION_MAX:
+  default:
+    /* We have added a distribution without extending the logic */
+    break;
+  }
+
+  return 0;
+}
+
+
+uint32_t hashkit_generate_value(const char *key, size_t key_length, hashkit_hash_t hash_algorithm)
+{
   switch (hash_algorithm)
   {
-  case MEMCACHED_HASH_DEFAULT:
-    hash= internal_generate_hash(key, key_length);
-    break;
-  case MEMCACHED_HASH_MD5:
-    hash= internal_generate_md5(key, key_length);
-    break;
-  case MEMCACHED_HASH_CRC:
-    hash= ((hash_crc32(key, key_length) >> 16) & 0x7fff);
-    if (hash == 0)
-      hash= 1;
-    break;
-    /* FNV hash'es lifted from Dustin Sallings work */
-  case MEMCACHED_HASH_FNV1_64:
-    {
-      /* Thanks to [e-mail] for the pointer */
-      uint64_t temp_hash;
-
-      temp_hash= FNV_64_INIT;
-      for (x= 0; x < key_length; x++)
-      {
-        temp_hash *= FNV_64_PRIME;
-        temp_hash ^= (uint64_t)key[x];
-      }
-      hash= (uint32_t)temp_hash;
-    }
-    break;
-  case MEMCACHED_HASH_FNV1A_64:
-    {
-      hash= (uint32_t) FNV_64_INIT;
-      for (x= 0; x < key_length; x++)
-      {
-        uint32_t val= (uint32_t)key[x];
-        hash ^= val;
-        hash *= (uint32_t) FNV_64_PRIME;
-      }
-    }
-    break;
-  case MEMCACHED_HASH_FNV1_32:
-    {
-      hash= FNV_32_INIT;
-      for (x= 0; x < key_length; x++)
-      {
-        uint32_t val= (uint32_t)key[x];
-        hash *= FNV_32_PRIME;
-        hash ^= val;
-      }
-    }
-    break;
-  case MEMCACHED_HASH_FNV1A_32:
-    {
-      hash= FNV_32_INIT;
-      for (x= 0; x < key_length; x++)
-      {
-        uint32_t val= (uint32_t)key[x];
-        hash ^= val;
-        hash *= FNV_32_PRIME;
-      }
-    }
-    break;
-    case MEMCACHED_HASH_HSIEH:
-    {
+  case HASHKIT_HASH_DEFAULT:
+    return hashkit_default(key, key_length);
+  case HASHKIT_HASH_MD5:
+    return hashkit_md5(key, key_length);
+  case HASHKIT_HASH_CRC:
+    return hashkit_crc32(key, key_length);
+  case HASHKIT_HASH_FNV1_64:
+    return hashkit_fnv1_64(key, key_length);
+  case HASHKIT_HASH_FNV1A_64:
+    return hashkit_fnv1a_64(key, key_length);
+  case HASHKIT_HASH_FNV1_32:
+    return hashkit_fnv1_32(key, key_length);
+  case HASHKIT_HASH_FNV1A_32:
+    return hashkit_fnv1a_32(key, key_length);
+  case HASHKIT_HASH_HSIEH:
 #ifdef HAVE_HSIEH_HASH
-      hash= hsieh_hash(key, key_length);
+    return hashkit_hsieh(key, key_length);
+#else
+    return 1;
 #endif
-      break;
-    }
-    case MEMCACHED_HASH_MURMUR:
-    {
-      hash= murmur_hash(key, key_length);
-      break;
-    }
-    case MEMCACHED_HASH_JENKINS:
-    {
-      hash=jenkins_hash(key, key_length, 13);
-      break;
-    }
-    default:
-    {
-      WATCHPOINT_ASSERT(hash_algorithm);
-      break;
-    }
-  }
-  return hash;
-}
-
-uint32_t generate_hash(memcached_st *ptr, const char *key, size_t key_length)
-{
-  uint32_t hash= 1; /* Just here to remove compile warning */
-
-
-  WATCHPOINT_ASSERT(ptr->number_of_hosts);
-
-  if (ptr->number_of_hosts == 1)
-    return 0;
-
-  hash= memcached_generate_hash_value(key, key_length, ptr->hash);
-  WATCHPOINT_ASSERT(hash);
-  return hash;
-}
-
-static uint32_t dispatch_host(memcached_st *ptr, uint32_t hash)
-{
-  switch (ptr->distribution)
-  {
-  case MEMCACHED_DISTRIBUTION_CONSISTENT:
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY:
-    {
-      uint32_t num= ptr->continuum_points_counter;
-      WATCHPOINT_ASSERT(ptr->continuum);
-
-      hash= hash;
-      memcached_continuum_item_st *begin, *end, *left, *right, *middle;
-      begin= left= ptr->continuum;
-      end= right= ptr->continuum + num;
-
-      while (left < right)
-      {
-        middle= left + (right - left) / 2;
-        if (middle->value < hash)
-          left= middle + 1;
-        else
-          right= middle;
-      }
-      if (right == end)
-        right= begin;
-      return right->index;
-    }
-  case MEMCACHED_DISTRIBUTION_MODULA:
-    return hash % ptr->number_of_hosts;
-  case MEMCACHED_DISTRIBUTION_RANDOM:
-    return (uint32_t) random() % ptr->number_of_hosts;
+  case HASHKIT_HASH_MURMUR:
+    return hashkit_murmur(key, key_length);
+  case HASHKIT_HASH_JENKINS:
+    return hashkit_jenkins(key, key_length);
+  case HASHKIT_HASH_MAX:
   default:
-    WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
-    return hash % ptr->number_of_hosts;
-  }
-
-  /* NOTREACHED */
-}
-
-/*
-  One day make this public, and have it return the actual memcached_server_st
-  to the calling application.
-*/
-uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_length)
-{
-  uint32_t hash= 1; /* Just here to remove compile warning */
-
-  WATCHPOINT_ASSERT(ptr->number_of_hosts);
-
-  if (ptr->number_of_hosts == 1)
-    return 0;
-
-  if (ptr->flags & MEM_HASH_WITH_PREFIX_KEY)
-  {
-    size_t temp_length= ptr->prefix_key_length + key_length;
-    char temp[temp_length];
-
-    if (temp_length > MEMCACHED_MAX_KEY -1)
-      return 0;
-
-    strncpy(temp, ptr->prefix_key, ptr->prefix_key_length);
-    strncpy(temp + ptr->prefix_key_length, key, key_length);
-    hash= generate_hash(ptr, temp, temp_length);
-  }
-  else
-  {
-    hash= generate_hash(ptr, key, key_length);
-  }
-
-  WATCHPOINT_ASSERT(hash);
-
-  if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS) && ptr->next_distribution_rebuild) {
-    struct timeval now;
-
-    if (gettimeofday(&now, NULL) == 0 &&
-        now.tv_sec > ptr->next_distribution_rebuild)
-      run_distribution(ptr);
-  }
-
-  return dispatch_host(ptr, hash);
-}
-
-static uint32_t internal_generate_hash(const char *key, size_t key_length)
-{
-  const char *ptr= key;
-  uint32_t value= 0;
-
-  while (key_length--)
-  {
-    uint32_t val= (uint32_t) *ptr++;
-    value += val;
-    value += (value << 10);
-    value ^= (value >> 6);
-  }
-  value += (value << 3);
-  value ^= (value >> 11);
-  value += (value << 15);
-
-  return value == 0 ? 1 : (uint32_t) value;
-}
-
-static uint32_t internal_generate_md5(const char *key, size_t key_length)
-{
-  unsigned char results[16];
-
-  md5_signature((unsigned char*)key, (unsigned int)key_length, results);
-
-  return ((uint32_t) (results[3] & 0xFF) << 24)
-    | ((uint32_t) (results[2] & 0xFF) << 16)
-    | ((uint32_t) (results[1] & 0xFF) << 8)
-    | (results[0] & 0xFF);
+#ifdef HAVE_DEBUG
+    fprintf(stderr, "hashkit_hash_t was extended but hashkit_generate_value was not updated\n");
+    fflush(stderr);
+    assert(0);
+#endif
+    break;
+  }
+
+  return 1;
 }

=== added file 'libhashkit/hashkit.h'
--- libhashkit/hashkit.h	1970-01-01 00:00:00 +0000
+++ libhashkit/hashkit.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,117 @@
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/**
+ * @file
+ * @brief HashKit Header
+ */
+
+#ifndef HASHKIT_H
+#define HASHKIT_H
+
+#if !defined(__cplusplus)
+# include <stdbool.h>
+#endif
+#include <inttypes.h>
+#include <sys/types.h>
+#include <libhashkit/visibility.h>
+#include <libhashkit/types.h>
+#include <libhashkit/algorithm.h>
+#include <libhashkit/behavior.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup hashkit_constants Constants
+ * @ingroup hashkit
+ * @{
+ */
+
+/* Defines. */
+#define HASHKIT_MAX_KEY 251
+#define HASHKIT_POINTS_PER_NODE 100
+#define HASHKIT_POINTS_PER_NODE_WEIGHTED 160
+#define HASHKIT_CONTINUUM_ADDITION 10
+#define HASHKIT_CONTINUUM_KEY_SIZE 86
+
+/** @} */
+
+/**
+ * @ingroup hashkit
+ */
+struct hashkit_st
+{
+  hashkit_options_st options;
+  hashkit_distribution_t distribution;
+  uint32_t continuum_count;
+  uint32_t continuum_points_count;
+  size_t list_size;
+  size_t context_size;
+  hashkit_continuum_point_st *continuum;
+  hashkit_fn *hash_fn;
+  hashkit_active_fn *active_fn;
+  hashkit_fn *continuum_hash_fn;
+  hashkit_key_fn *continuum_key_fn;
+  hashkit_sort_fn *sort_fn;
+  hashkit_weight_fn *weight_fn;
+  void *list;
+};
+
+/**
+ * @ingroup hashkit
+ */
+struct hashkit_continuum_point_st
+{
+  uint32_t index;
+  uint32_t value;
+};
+
+/**
+ * @addtogroup hashkit Pandora Hash Declarations
+ * @{
+ */
+
+HASHKIT_API
+hashkit_st *hashkit_create(hashkit_st *hash);
+
+HASHKIT_API
+hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+
+HASHKIT_API
+void hashkit_free(hashkit_st *hash);
+
+HASHKIT_API
+bool hashkit_is_allocated(const hashkit_st *hash);
+
+HASHKIT_API
+bool hashkit_is_initialized(const hashkit_st *hash);
+
+HASHKIT_API
+void hashkit_set_list(hashkit_st *hash, void *list, size_t list_size,
+                           size_t context_size);
+
+HASHKIT_API
+uint32_t hashkit_value(hashkit_st *hash, const char *key, size_t key_length);
+HASHKIT_API
+uint32_t hashkit_index(hashkit_st *hash, uint32_t value);
+HASHKIT_API
+int hashkit_run_distribution(hashkit_st *hash);
+
+
+HASHKIT_API
+uint32_t hashkit_generate_value(const char *key, size_t key_length, hashkit_hash_t hash_algorithm);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HASHKIT_H */

=== renamed file 'libmemcached/hsieh_hash.c' => 'libhashkit/hsieh.c'
--- libmemcached/hsieh_hash.c	2009-03-11 20:06:43 +0000
+++ libhashkit/hsieh.c	2009-12-11 17:27:14 +0000
@@ -5,7 +5,7 @@
  * http://www.azillionmonkeys.com/qed/hash.html
 */
 
-#include "common.h"
+#include "hash_common.h"
 
 #undef get16bits
 #if (defined(__GNUC__) && defined(__i386__))
@@ -17,7 +17,7 @@
                       +(uint32_t)(((const uint8_t *)(d))[0]) )
 #endif
 
-uint32_t hsieh_hash(const char *key, size_t key_length)
+uint32_t hashkit_hsieh(const char *key, size_t key_length)
 {
   uint32_t hash = 0, tmp;
   int rem;

=== renamed file 'libmemcached/jenkins_hash.c' => 'libhashkit/jenkins.c'
--- libmemcached/jenkins_hash.c	2009-12-02 03:09:57 +0000
+++ libhashkit/jenkins.c	2009-12-11 17:27:14 +0000
@@ -38,6 +38,8 @@
   c ^= b; c -= rot(b,24); \
 }
 
+#define JENKINS_INITVAL 13
+
 /*
 jenkins_hash() -- hash a variable-length key into a 32-bit value
   k       : the key (the unaligned variable-length array of bytes)
@@ -54,13 +56,13 @@
 In which case, the hash table should have hashsize(10) elements.
 */
 
-uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval)
+uint32_t hashkit_jenkins(const char *key, size_t length)
 {
   uint32_t a,b,c;                                          /* internal state */
   union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
 
   /* Set up the internal state */
-  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + JENKINS_INITVAL;
 
   u.ptr = key;
 #ifndef WORDS_BIGENDIAN
@@ -209,5 +211,3 @@
   final(a,b,c);
   return c;
 }
-
-

=== renamed file 'libmemcached/memcached_hosts.c' => 'libhashkit/ketama.c'
--- libmemcached/memcached_hosts.c	2009-11-03 13:09:13 +0000
+++ libhashkit/ketama.c	2009-12-11 17:27:14 +0000
@@ -1,82 +1,6 @@
 #include "common.h"
 #include <math.h>
 
-/* Protoypes (static) */
-static memcached_return server_add(memcached_st *ptr, const char *hostname,
-                                   unsigned int port,
-                                   uint32_t weight,
-                                   memcached_connection type);
-memcached_return update_continuum(memcached_st *ptr);
-
-static int compare_servers(const void *p1, const void *p2)
-{
-  int return_value;
-  memcached_server_st *a= (memcached_server_st *)p1;
-  memcached_server_st *b= (memcached_server_st *)p2;
-
-  return_value= strcmp(a->hostname, b->hostname);
-
-  if (return_value == 0)
-  {
-    return_value= (int) (a->port - b->port);
-  }
-
-  return return_value;
-}
-
-static void sort_hosts(memcached_st *ptr)
-{
-  if (ptr->number_of_hosts)
-  {
-    qsort(ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st), compare_servers);
-    ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts;
-  }
-}
-
-
-memcached_return run_distribution(memcached_st *ptr)
-{
-  switch (ptr->distribution)
-  {
-  case MEMCACHED_DISTRIBUTION_CONSISTENT:
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
-  case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY:
-    return update_continuum(ptr);
-  case MEMCACHED_DISTRIBUTION_MODULA:
-    if (ptr->flags & MEM_USE_SORT_HOSTS)
-      sort_hosts(ptr);
-    break;
-  case MEMCACHED_DISTRIBUTION_RANDOM:
-    break;
-  default:
-    WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
-  }
-
-  ptr->last_disconnected_server = NULL;
-
-  return MEMCACHED_SUCCESS;
-}
-
-void server_list_free(memcached_st *ptr, memcached_server_st *servers)
-{
-  unsigned int x;
-
-  if (servers == NULL)
-    return;
-
-  for (x= 0; x < servers->count; x++)
-    if (servers[x].address_info)
-    {
-      freeaddrinfo(servers[x].address_info);
-      servers[x].address_info= NULL;
-    }
-
-  if (ptr)
-    ptr->call_free(ptr, servers);
-  else
-    free(servers);
-}
-
 static uint32_t ketama_server_hash(const char *key, unsigned int key_length, int alignment)
 {
   unsigned char results[16];
@@ -88,13 +12,11 @@
     | (results[0 + alignment * 4] & 0xFF);
 }
 
-static int continuum_item_cmp(const void *t1, const void *t2)
+static int continuum_points_cmp(const void *t1, const void *t2)
 {
-  memcached_continuum_item_st *ct1= (memcached_continuum_item_st *)t1;
-  memcached_continuum_item_st *ct2= (memcached_continuum_item_st *)t2;
+  hashkit_continuum_point_st *ct1= (hashkit_continuum_point_st *)t1;
+  hashkit_continuum_point_st *ct2= (hashkit_continuum_point_st *)t2;
 
-  /* Why 153? Hmmm... */
-  WATCHPOINT_ASSERT(ct1->value != 153);
   if (ct1->value == ct2->value)
     return 0;
   else if (ct1->value > ct2->value)
@@ -103,412 +25,130 @@
     return -1;
 }
 
-memcached_return update_continuum(memcached_st *ptr)
+int update_continuum(hashkit_st *hashkit)
 {
-  uint32_t host_index;
+  uint32_t count;
   uint32_t continuum_index= 0;
   uint32_t value;
-  memcached_server_st *list;
-  uint32_t pointer_index;
-  uint32_t pointer_counter= 0;
-  uint32_t pointer_per_server= MEMCACHED_POINTS_PER_SERVER;
-  uint32_t pointer_per_hash= 1;
+  uint32_t points_index;
+  uint32_t points_count= 0;
+  uint32_t points_per_server;
+  uint32_t points_per_hash;
   uint64_t total_weight= 0;
-  uint64_t is_ketama_weighted= 0;
-  uint64_t is_auto_ejecting= 0;
-  uint32_t points_per_server= 0;
-  uint32_t live_servers= 0;
-  struct timeval now;
-
-  if (gettimeofday(&now, NULL) != 0)
-  {
-    ptr->cached_errno = errno;
-    return MEMCACHED_ERRNO;
-  }
-
-  list = ptr->hosts;
-
-  /* count live servers (those without a retry delay set) */
-  is_auto_ejecting= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
-  if (is_auto_ejecting)
+  uint32_t live_servers;
+  uint8_t *context;
+
+  if (hashkit->active_fn != NULL || hashkit->weight_fn != NULL)
   {
     live_servers= 0;
-    ptr->next_distribution_rebuild= 0;
-    for (host_index= 0; host_index < ptr->number_of_hosts; ++host_index)
+
+    for (count= 0, context= hashkit->list; count < hashkit->list_size;
+         count++, context+= hashkit->context_size)
     {
-      if (list[host_index].next_retry <= now.tv_sec)
-        live_servers++;
-      else
+      if (hashkit->active_fn != NULL)
       {
-        if (ptr->next_distribution_rebuild == 0 || list[host_index].next_retry < ptr->next_distribution_rebuild)
-          ptr->next_distribution_rebuild= list[host_index].next_retry;
+        if (hashkit->active_fn(context))
+          live_servers++;
+        else
+          continue;
       }
+
+      if (hashkit->weight_fn != NULL)
+        total_weight+= hashkit->weight_fn(context);
     }
   }
-  else
-    live_servers= ptr->number_of_hosts;
 
-  is_ketama_weighted= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
-  points_per_server= (uint32_t) (is_ketama_weighted ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER);
+  if (hashkit->active_fn == NULL)
+    live_servers= (uint32_t)hashkit->list_size;
 
   if (live_servers == 0)
-    return MEMCACHED_SUCCESS;
-
-  if (live_servers > ptr->continuum_count)
-  {
-    memcached_continuum_item_st *new_ptr;
-
-    new_ptr= ptr->call_realloc(ptr, ptr->continuum,
-                               sizeof(memcached_continuum_item_st) * (live_servers + MEMCACHED_CONTINUUM_ADDITION) * points_per_server);
-
-    if (new_ptr == 0)
-      return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
-
-    ptr->continuum= new_ptr;
-    ptr->continuum_count= live_servers + MEMCACHED_CONTINUUM_ADDITION;
-  }
-
-  if (is_ketama_weighted)
-  {
-    for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index)
-    {
-      if (list[host_index].weight == 0)
-      {
-        list[host_index].weight = 1;
-      }
-      if (!is_auto_ejecting || list[host_index].next_retry <= now.tv_sec)
-        total_weight += list[host_index].weight;
-    }
-  }
-
-  for (host_index = 0; host_index < ptr->number_of_hosts; ++host_index)
-  {
-    if (is_auto_ejecting && list[host_index].next_retry > now.tv_sec)
+    return 0;
+
+  if (hashkit->weight_fn == NULL)
+  {
+    points_per_server= HASHKIT_POINTS_PER_NODE;
+    points_per_hash= 1;
+  }
+  else
+  {
+    points_per_server= HASHKIT_POINTS_PER_NODE_WEIGHTED;
+    points_per_hash= 4;
+  }
+
+  if (live_servers > hashkit->continuum_count)
+  {
+    hashkit_continuum_point_st *new_continuum;
+
+    new_continuum= realloc(hashkit->continuum,
+                           sizeof(hashkit_continuum_point_st) *
+                           (live_servers + HASHKIT_CONTINUUM_ADDITION) *
+                           points_per_server);
+
+    if (new_continuum == NULL)
+      return ENOMEM;
+
+    hashkit->continuum= new_continuum;
+    hashkit->continuum_count= live_servers + HASHKIT_CONTINUUM_ADDITION;
+  }
+
+  for (count= 0, context= hashkit->list; count < hashkit->list_size;
+       count++, context+= hashkit->context_size)
+  {
+    if (hashkit->active_fn != NULL && hashkit->active_fn(context) == false)
       continue;
 
-    if (is_ketama_weighted)
-    {
-        float pct = (float)list[host_index].weight / (float)total_weight;
-        pointer_per_server= (uint32_t) ((floorf((float) (pct * MEMCACHED_POINTS_PER_SERVER_KETAMA / 4 * (float)live_servers + 0.0000000001))) * 4);
-        pointer_per_hash= 4;
-#ifdef DEBUG
-        printf("ketama_weighted:%s|%d|%llu|%u\n",
-               list[host_index].hostname,
-               list[host_index].port,
-               (unsigned long long)list[host_index].weight,
-               pointer_per_server);
-#endif
-    }
-
-
-    if (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY)
-    {
-      for (pointer_index= 0;
-           pointer_index < pointer_per_server / pointer_per_hash;
-           pointer_index++)
-      {
-        char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
-        size_t sort_host_length;
-
-        // Spymemcached ketema key format is: hostname/ip:port-index
-        // If hostname is not available then: /ip:port-index
-        sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
-                                            "/%s:%d-%d",
-                                            list[host_index].hostname,
-                                            list[host_index].port,
-                                            pointer_index);
-#ifdef DEBUG
-        printf("update_continuum: key is %s\n", sort_host);
-#endif
-
-        WATCHPOINT_ASSERT(sort_host_length);
-
-        if (is_ketama_weighted)
-        {
-          unsigned int i;
-          for (i = 0; i < pointer_per_hash; i++)
-          {
-             value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i);
-             ptr->continuum[continuum_index].index= host_index;
-             ptr->continuum[continuum_index++].value= value;
-          }
-        }
-        else
-        {
-          value= memcached_generate_hash_value(sort_host, sort_host_length, ptr->hash_continuum);
-          ptr->continuum[continuum_index].index= host_index;
-          ptr->continuum[continuum_index++].value= value;
-        }
-      }
-    }
-    else
-    {
-      for (pointer_index= 1;
-           pointer_index <= pointer_per_server / pointer_per_hash;
-           pointer_index++)
-      {
-        char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
-        size_t sort_host_length;
-
-        if (list[host_index].port == MEMCACHED_DEFAULT_PORT)
-        {
-          sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
-                                              "%s-%d",
-                                              list[host_index].hostname,
-                                              pointer_index - 1);
-        }
-        else
-        {
-          sort_host_length= (size_t) snprintf(sort_host, MEMCACHED_MAX_HOST_SORT_LENGTH,
-                                              "%s:%d-%d",
-                                              list[host_index].hostname,
-                                              list[host_index].port, pointer_index - 1);
-        }
-
-        WATCHPOINT_ASSERT(sort_host_length);
-
-        if (is_ketama_weighted)
-        {
-          unsigned int i;
-          for (i = 0; i < pointer_per_hash; i++)
-          {
-             value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i);
-             ptr->continuum[continuum_index].index= host_index;
-             ptr->continuum[continuum_index++].value= value;
-          }
-        }
-        else
-        {
-          value= memcached_generate_hash_value(sort_host, sort_host_length, ptr->hash_continuum);
-          ptr->continuum[continuum_index].index= host_index;
-          ptr->continuum[continuum_index++].value= value;
-        }
-      }
-    }
-
-    pointer_counter+= pointer_per_server;
-  }
-
-  WATCHPOINT_ASSERT(ptr);
-  WATCHPOINT_ASSERT(ptr->continuum);
-  WATCHPOINT_ASSERT(ptr->number_of_hosts * MEMCACHED_POINTS_PER_SERVER <= MEMCACHED_CONTINUUM_SIZE);
-  ptr->continuum_points_counter= pointer_counter;
-  qsort(ptr->continuum, ptr->continuum_points_counter, sizeof(memcached_continuum_item_st), continuum_item_cmp);
-
-#ifdef DEBUG
-  for (pointer_index= 0; ptr->number_of_hosts && pointer_index < ((live_servers * MEMCACHED_POINTS_PER_SERVER) - 1); pointer_index++)
-  {
-    WATCHPOINT_ASSERT(ptr->continuum[pointer_index].value <= ptr->continuum[pointer_index + 1].value);
-  }
-#endif
-
-  return MEMCACHED_SUCCESS;
-}
-
-
-memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list)
-{
-  unsigned int x;
-  uint16_t count;
-  memcached_server_st *new_host_list;
-
-  if (!list)
-    return MEMCACHED_SUCCESS;
-
-  count= list[0].count;
-  new_host_list= ptr->call_realloc(ptr, ptr->hosts,
-                                   sizeof(memcached_server_st) * (count + ptr->number_of_hosts));
-
-  if (!new_host_list)
-    return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
-
-  ptr->hosts= new_host_list;
-
-  for (x= 0; x < count; x++)
-  {
-    if ((ptr->flags & MEM_USE_UDP && list[x].type != MEMCACHED_CONNECTION_UDP)
-            || ((list[x].type == MEMCACHED_CONNECTION_UDP)
-            && ! (ptr->flags & MEM_USE_UDP)) )
-      return MEMCACHED_INVALID_HOST_PROTOCOL;
-
-    WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
-    memcached_server_create(ptr, &ptr->hosts[ptr->number_of_hosts]);
-    /* TODO check return type */
-    (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], list[x].hostname,
-                                       list[x].port, list[x].weight, list[x].type);
-    ptr->number_of_hosts++;
-  }
-  ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts;
-
-  return run_distribution(ptr);
-}
-
-memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
-                                                  const char *filename)
-{
-  return memcached_server_add_unix_socket_with_weight(ptr, filename, 0);
-}
-
-memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
-                                                              const char *filename,
-                                                              uint32_t weight)
-{
-  if (!filename)
-    return MEMCACHED_FAILURE;
-
-  return server_add(ptr, filename, 0, weight, MEMCACHED_CONNECTION_UNIX_SOCKET);
-}
-
-memcached_return memcached_server_add_udp(memcached_st *ptr,
-                                          const char *hostname,
-                                          unsigned int port)
-{
-  return memcached_server_add_udp_with_weight(ptr, hostname, port, 0);
-}
-
-memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
-                                                      const char *hostname,
-                                                      unsigned int port,
-                                                      uint32_t weight)
-{
-  if (!port)
-    port= MEMCACHED_DEFAULT_PORT;
-
-  if (!hostname)
-    hostname= "localhost";
-
-  return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_UDP);
-}
-
-memcached_return memcached_server_add(memcached_st *ptr,
-                                      const char *hostname,
-                                      unsigned int port)
-{
-  return memcached_server_add_with_weight(ptr, hostname, port, 0);
-}
-
-memcached_return memcached_server_add_with_weight(memcached_st *ptr,
-                                                  const char *hostname,
-                                                  unsigned int port,
-                                                  uint32_t weight)
-{
-  if (!port)
-    port= MEMCACHED_DEFAULT_PORT;
-
-  if (!hostname)
-    hostname= "localhost";
-
-  return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_TCP);
-}
-
-static memcached_return server_add(memcached_st *ptr, const char *hostname,
-                                   unsigned int port,
-                                   uint32_t weight,
-                                   memcached_connection type)
-{
-  memcached_server_st *new_host_list;
-
-  if ( (ptr->flags & MEM_USE_UDP && type != MEMCACHED_CONNECTION_UDP)
-      || ( (type == MEMCACHED_CONNECTION_UDP) && !(ptr->flags & MEM_USE_UDP) ) )
-    return MEMCACHED_INVALID_HOST_PROTOCOL;
-
-  new_host_list= ptr->call_realloc(ptr, ptr->hosts,
-                                   sizeof(memcached_server_st) * (ptr->number_of_hosts+1));
-
-  if (new_host_list == NULL)
-    return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
-
-  ptr->hosts= new_host_list;
-
-  /* TODO: Check return type */
-  (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], hostname, port, weight, type);
-  ptr->number_of_hosts++;
-  ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts;
-
-  return run_distribution(ptr);
-}
-
-memcached_return memcached_server_remove(memcached_server_st *st_ptr)
-{
-  uint32_t x, host_index;
-  memcached_st *ptr= st_ptr->root;
-  memcached_server_st *list= ptr->hosts;
-
-  for (x= 0, host_index= 0; x < ptr->number_of_hosts; x++)
-  {
-    if (strncmp(list[x].hostname, st_ptr->hostname, MEMCACHED_MAX_HOST_LENGTH) != 0 || list[x].port != st_ptr->port)
-    {
-      if (host_index != x)
-        memcpy(list+host_index, list+x, sizeof(memcached_server_st));
-      host_index++;
-    }
-  }
-  ptr->number_of_hosts= host_index;
-
-  if (st_ptr->address_info)
-  {
-    freeaddrinfo(st_ptr->address_info);
-    st_ptr->address_info= NULL;
-  }
-  run_distribution(ptr);
-
-  return MEMCACHED_SUCCESS;
-}
-
-memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
-                                                  const char *hostname, unsigned int port,
-                                                  memcached_return *error)
-{
-  return memcached_server_list_append_with_weight(ptr, hostname, port, 0, error);
-}
-
-memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
-                                                              const char *hostname, unsigned int port,
-                                                              uint32_t weight,
-                                                              memcached_return *error)
-{
-  unsigned int count;
-  memcached_server_st *new_host_list;
-
-  if (hostname == NULL || error == NULL)
-    return NULL;
-
-  if (!port)
-    port= MEMCACHED_DEFAULT_PORT;
-
-  /* Increment count for hosts */
-  count= 1;
-  if (ptr != NULL)
-  {
-    count+= ptr[0].count;
-  }
-
-  new_host_list= (memcached_server_st *)realloc(ptr, sizeof(memcached_server_st) * count);
-  if (!new_host_list)
-  {
-    *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
-    return NULL;
-  }
-
-  /* TODO: Check return type */
-  memcached_server_create_with(NULL, &new_host_list[count-1], hostname, port, weight, MEMCACHED_CONNECTION_TCP);
-
-  /* Backwards compatibility hack */
-  new_host_list[0].count= (uint16_t) count;
-
-  *error= MEMCACHED_SUCCESS;
-  return new_host_list;
-}
-
-unsigned int memcached_server_list_count(memcached_server_st *ptr)
-{
-  if (ptr == NULL)
-    return 0;
-
-  return ptr[0].count;
-}
-
-void memcached_server_list_free(memcached_server_st *ptr)
-{
-  server_list_free(NULL, ptr);
+    if (hashkit->weight_fn != NULL)
+    {
+        float pct = (float)hashkit->weight_fn(context) / (float)total_weight;
+        points_per_server= (uint32_t) ((floorf((float) (pct * HASHKIT_POINTS_PER_NODE_WEIGHTED / 4 * (float)live_servers + 0.0000000001))) * 4);
+    }
+
+    for (points_index= 0;
+         points_index < points_per_server / points_per_hash;
+         points_index++)
+    {
+      char sort_host[HASHKIT_CONTINUUM_KEY_SIZE]= "";
+      size_t sort_host_length;
+
+      if (hashkit->continuum_key_fn == NULL)
+      {
+        sort_host_length= (size_t) snprintf(sort_host, HASHKIT_CONTINUUM_KEY_SIZE, "%d",
+                                            points_index);
+      }
+      else
+      {
+        sort_host_length= hashkit->continuum_key_fn(sort_host, HASHKIT_CONTINUUM_KEY_SIZE,
+                                                 points_index, context);
+      }
+
+      if (hashkit->weight_fn == NULL)
+      {
+        if (hashkit->continuum_hash_fn == NULL)
+          value= hashkit_default(sort_host, sort_host_length);
+        else
+          value= hashkit->continuum_hash_fn(sort_host, sort_host_length);
+
+        hashkit->continuum[continuum_index].index= count;
+        hashkit->continuum[continuum_index++].value= value;
+      }
+      else
+      {
+        unsigned int i;
+        for (i = 0; i < points_per_hash; i++)
+        {
+           value= ketama_server_hash(sort_host, (uint32_t) sort_host_length, (int) i);
+           hashkit->continuum[continuum_index].index= count;
+           hashkit->continuum[continuum_index++].value= value;
+        }
+      }
+    }
+
+    points_count+= points_per_server;
+  }
+
+  hashkit->continuum_points_count= points_count;
+  qsort(hashkit->continuum, hashkit->continuum_points_count, sizeof(hashkit_continuum_point_st),
+        continuum_points_cmp);
+
+  return 0;
 }

=== renamed file 'libmemcached/md5.c' => 'libhashkit/md5.c'
--- libmemcached/md5.c	2009-05-13 09:53:59 +0000
+++ libhashkit/md5.c	2009-12-11 17:27:14 +0000
@@ -29,7 +29,6 @@
 documentation and/or software.
 */
 
-
 #include "common.h"
 
 #include <string.h>
@@ -352,3 +351,15 @@
  output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
    (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
 }
+
+uint32_t hashkit_md5(const char *key, size_t key_length)
+{
+  unsigned char results[16];
+
+  md5_signature((unsigned char*)key, (unsigned int)key_length, results);
+
+  return ((uint32_t) (results[3] & 0xFF) << 24)
+    | ((uint32_t) (results[2] & 0xFF) << 16)
+    | ((uint32_t) (results[1] & 0xFF) << 8)
+    | (results[0] & 0xFF);
+}

=== renamed file 'libmemcached/murmur_hash.c' => 'libhashkit/murmur.c'
--- libmemcached/murmur_hash.c	2009-08-11 18:56:12 +0000
+++ libhashkit/murmur.c	2009-12-11 17:27:14 +0000
@@ -17,7 +17,7 @@
 
 #include "common.h"
 
-uint32_t murmur_hash(const char *key, size_t length)
+uint32_t hashkit_murmur(const char *key, size_t length)
 {
   /* 
     'm' and 'r' are mixing constants generated offline.  They're not
@@ -72,5 +72,5 @@
   h *= m;
   h ^= h >> 15;
 
-  return (uint32_t) h;
+  return h;
 }

=== added file 'libhashkit/types.h'
--- libhashkit/types.h	1970-01-01 00:00:00 +0000
+++ libhashkit/types.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,85 @@
+
+/* HashKit
+ * Copyright (C) 2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/**
+ * @file
+ * @brief HashKit Header
+ */
+
+#ifndef HASHKIT_TYPES_H
+#define HASHKIT_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup hashkit_types Types
+ * @ingroup hashkit
+ * @{
+ */
+
+/**
+  @todo hashkit_options_t is for future use, currently we do not define any user options.
+ */
+
+typedef enum
+{
+  HASHKIT_OPTION_MAX
+} hashkit_options_t;
+
+typedef struct
+{
+  /* We use the following for internal book keeping. */
+  bool is_initialized:1;
+  bool is_allocated:1;
+} hashkit_options_st;
+
+typedef enum {
+  HASHKIT_HASH_DEFAULT= 0,
+  HASHKIT_HASH_MD5,
+  HASHKIT_HASH_CRC,
+  HASHKIT_HASH_FNV1_64,
+  HASHKIT_HASH_FNV1A_64,
+  HASHKIT_HASH_FNV1_32,
+  HASHKIT_HASH_FNV1A_32,
+  HASHKIT_HASH_HSIEH,
+  HASHKIT_HASH_MURMUR,
+  HASHKIT_HASH_JENKINS,
+  HASHKIT_HASH_MAX
+} hashkit_hash_t;
+
+/**
+ * Hash distributions that are available to use.
+ */
+typedef enum
+{
+  HASHKIT_DISTRIBUTION_MODULA,
+  HASHKIT_DISTRIBUTION_RANDOM,
+  HASHKIT_DISTRIBUTION_KETAMA,
+  HASHKIT_DISTRIBUTION_MAX /* Always add new values before this. */
+} hashkit_distribution_t;
+
+
+typedef struct hashkit_st hashkit_st;
+typedef struct hashkit_continuum_point_st hashkit_continuum_point_st;
+typedef bool (hashkit_active_fn)(void *context);
+typedef uint32_t (hashkit_fn)(const char *key, size_t key_length);
+typedef size_t (hashkit_key_fn)(char *key, size_t key_length, uint32_t point_index, void *context);
+typedef void (hashkit_sort_fn)(void *context, size_t count);
+typedef uint32_t (hashkit_weight_fn)(void *context);
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HASHKIT_TYPES_H */

=== added file 'libhashkit/visibility.h'
--- libhashkit/visibility.h	1970-01-01 00:00:00 +0000
+++ libhashkit/visibility.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,51 @@
+/*
+ * Summary: interface for HashKit functions
+ * Description: visibitliy macros for HashKit library
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in this directory for full text.
+ * 
+ * Author: Monty Taylor
+ */
+
+/**
+ * @file
+ * @brief Visibility control macros
+ */
+
+#ifndef HASHKIT_VISIBILITY_H
+#define HASHKIT_VISIBILITY_H
+
+/**
+ *
+ * HASHKIT_API is used for the public API symbols. It either DLL imports or
+ * DLL exports (or does nothing for static build).
+ *
+ * HASHKIT_LOCAL is used for non-api symbols.
+ */
+
+#if defined(BUILDING_HASHKIT)
+# if defined(HAVE_VISIBILITY) && HAVE_VISIBILITY
+#  define HASHKIT_API __attribute__ ((visibility("default")))
+#  define HASHKIT_LOCAL  __attribute__ ((visibility("hidden")))
+# elif defined (__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#  define HASHKIT_API __global
+#  define HASHKIT_LOCAL __hidden
+# elif defined(_MSC_VER)
+#  define HASHKIT_API extern __declspec(dllexport) 
+#  define HASHKIT_LOCAL
+# else
+#  define HASHKIT_API
+#  define HASHKIT_LOCAL
+# endif /* defined(HAVE_VISIBILITY) */
+#else  /* defined(BUILDING_HASHKIT) */
+# if defined(_MSC_VER)
+#  define HASHKIT_API extern __declspec(dllimport) 
+#  define HASHKIT_LOCAL
+# else
+#  define HASHKIT_API
+#  define HASHKIT_LOCAL
+# endif /* defined(_MSC_VER) */
+#endif /* defined(BUILDING_HASHKIT) */
+
+#endif /* HASHKIT_VISIBILITY_H */

=== modified file 'libmemcached/Makefile.am'
--- libmemcached/Makefile.am	2009-12-02 04:43:41 +0000
+++ libmemcached/Makefile.am	2009-12-11 17:27:14 +0000
@@ -24,6 +24,7 @@
                     memcached_configure.h \
 		    memcached_constants.h \
 		    memcached_get.h \
+		    memcached_hash.h \
 		    memcached_result.h \
 		    memcached_server.h \
 		    memcached_storage.h \
@@ -51,8 +52,7 @@
 libmemcachedcallbacks_la_SOURCES = memcached_callback.c
 
 libmemcached_la_CFLAGS= ${AM_CFLAGS} ${NO_CONVERSION}
-libmemcached_la_SOURCES = crc.c \
-			  memcached.c \
+libmemcached_la_SOURCES = memcached.c \
 			  memcached_auto.c \
 			  memcached_analyze.c \
 			  memcached_behavior.c \
@@ -64,11 +64,9 @@
 			  memcached_flush.c \
 			  memcached_get.c \
 			  memcached_hash.c \
-			  memcached_hosts.c \
 			  memcached_io.c \
 			  memcached_purge.c \
                           memcached_flush_buffers.c \
-			  md5.c \
 			  memcached_key.c \
 			  memcached_quit.c \
 			  memcached_parse.c \
@@ -81,18 +79,11 @@
 			  memcached_strerror.c \
 			  memcached_verbosity.c \
 			  memcached_version.c \
-			  murmur_hash.c \
-			  jenkins_hash.c \
                           memcached_allocators.c
 
-
-if INCLUDE_HSIEH_SRC
-libmemcached_la_SOURCES += hsieh_hash.c
-endif
-
 libmemcached_la_DEPENDENCIES= libmemcachedcallbacks.la
-libmemcached_la_LIBADD= $(LIBM) libmemcachedcallbacks.la
-libmemcached_la_LDFLAGS= ${AM_LDFLAGS} -version-info 3:0:0
+libmemcached_la_LIBADD= $(LIBM) libmemcachedcallbacks.la $(LIBHASHKIT_LINK)
+libmemcached_la_LDFLAGS = -version-info $(MEMCACHED_LIBRARY_VERSION) $(LD_VERSION_SCRIPT) $(LIBM)
 
 if BUILD_LIBMEMCACHEDUTIL
 pkginclude_HEADERS+= memcached_util.h memcached_pool.h

=== modified file 'libmemcached/common.h'
--- libmemcached/common.h	2009-11-27 10:40:32 +0000
+++ libmemcached/common.h	2009-12-11 17:27:14 +0000
@@ -39,7 +39,6 @@
  */
 #define BUILDING_LIBMEMCACHED 1
 
-
 #include "libmemcached/memcached.h"
 #include "libmemcached/memcached_watchpoint.h"
 
@@ -50,13 +49,6 @@
 #include "libmemcached/memcached/protocol_binary.h"
 #include "libmemcached/byteorder.h"
 
-/* string value */
-struct memcached_continuum_item_st {
-  uint32_t index;
-  uint32_t value;
-};
-
-
 #if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
 
 #define likely(x)       if((x))
@@ -97,21 +89,10 @@
   MEM_RANDOMIZE_REPLICA_READ= (1 << 17)
 } memcached_flags;
 
-/* Hashing algo */
-
-LIBMEMCACHED_LOCAL
-void md5_signature(const unsigned char *key, unsigned int length, unsigned char *result);
-LIBMEMCACHED_LOCAL
-uint32_t hash_crc32(const char *data,
-                    size_t data_len);
-#ifdef HAVE_HSIEH_HASH
-LIBMEMCACHED_LOCAL
-uint32_t hsieh_hash(const char *key, size_t key_length);
-#endif
-LIBMEMCACHED_LOCAL
-uint32_t murmur_hash(const char *key, size_t key_length);
-LIBMEMCACHED_LOCAL
-uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval);
+LIBMEMCACHED_LOCAL
+extern hashkit_fn *memcached_hash_fn_map[MEMCACHED_HASH_MAX];
+LIBMEMCACHED_LOCAL
+extern hashkit_distribution_t memcached_distribution_map[MEMCACHED_DISTRIBUTION_MAX];
 
 LIBMEMCACHED_LOCAL
 memcached_return memcached_connect(memcached_server_st *ptr);
@@ -143,9 +124,6 @@
 
 
 LIBMEMCACHED_LOCAL
-uint32_t generate_hash(memcached_st *ptr, const char *key, size_t key_length);
-
-LIBMEMCACHED_LOCAL
 memcached_return memcached_purge(memcached_server_st *ptr);
 
 static inline memcached_return memcached_validate_key_length(size_t key_length,
@@ -167,4 +145,13 @@
   return MEMCACHED_SUCCESS;
 }
 
+LIBMEMCACHED_LOCAL
+bool memcached_server_active(void *context);
+LIBMEMCACHED_LOCAL
+uint32_t memcached_server_weight(void *context);
+LIBMEMCACHED_LOCAL
+void memcached_server_sort(void *context, size_t count);
+LIBMEMCACHED_LOCAL
+size_t memcached_server_key(char *key, size_t key_length, uint32_t point_index, void *context);
+
 #endif /* LIBMEMCACHED_COMMON_H */

=== modified file 'libmemcached/memcached.c'
--- libmemcached/memcached.c	2009-06-14 18:52:39 +0000
+++ libmemcached/memcached.c	2009-12-11 17:27:14 +0000
@@ -3,6 +3,33 @@
 */
 #include "common.h"
 
+hashkit_fn *memcached_hash_fn_map[MEMCACHED_HASH_MAX]=
+{
+  hashkit_default,
+  hashkit_md5,
+  hashkit_crc32,
+  hashkit_fnv1_64,
+  hashkit_fnv1a_64,
+  hashkit_fnv1_32,
+  hashkit_fnv1a_32,
+#ifdef HAVE_HSIEH_HASH
+  hashkit_hsieh,
+#else
+  NULL,
+#endif
+  hashkit_murmur,
+  hashkit_jenkins
+};
+
+hashkit_distribution_t memcached_distribution_map[MEMCACHED_DISTRIBUTION_MAX]=
+{
+  HASHKIT_DISTRIBUTION_MODULA,
+  HASHKIT_DISTRIBUTION_KETAMA,
+  HASHKIT_DISTRIBUTION_KETAMA,
+  HASHKIT_DISTRIBUTION_RANDOM,
+  HASHKIT_DISTRIBUTION_KETAMA
+};
+
 memcached_st *memcached_create(memcached_st *ptr)
 {
   memcached_result_st *result_ptr;
@@ -29,6 +56,8 @@
   ptr->connect_timeout= MEMCACHED_DEFAULT_TIMEOUT;
   ptr->retry_timeout= 0;
   ptr->distribution= MEMCACHED_DISTRIBUTION_MODULA;
+  hashkit_create(&ptr->hashkit);
+  hashkit_set_continuum_key_fn(&ptr->hashkit, memcached_server_key);
 
   /* TODO, Document why we picked these defaults */
   ptr->io_msg_watermark= 500;
@@ -47,8 +76,7 @@
   if (ptr->on_cleanup)
     ptr->on_cleanup(ptr);
 
-  if (ptr->continuum)
-    ptr->call_free(ptr, ptr->continuum);
+  hashkit_free(&ptr->hashkit);
 
   if (ptr->is_allocated)
     ptr->call_free(ptr, ptr);
@@ -67,7 +95,9 @@
   memcached_st *new_clone;
 
   if (source == NULL)
+  {
     return memcached_create(clone);
+  }
 
   if (clone && clone->is_allocated)
   {
@@ -86,8 +116,13 @@
   new_clone->connect_timeout= source->connect_timeout;
   new_clone->retry_timeout= source->retry_timeout;
   new_clone->distribution= source->distribution;
-  new_clone->hash= source->hash;
-  new_clone->hash_continuum= source->hash_continuum;
+  hashkit_set_distribution(&new_clone->hashkit,
+                           memcached_distribution_map[new_clone->distribution]);
+  new_clone->hash_type= source->hash_type;
+  hashkit_set_hash_fn(&new_clone->hashkit, memcached_hash_fn_map[new_clone->hash_type]);
+  new_clone->continuum_hash_type= source->continuum_hash_type;
+  hashkit_set_continuum_hash_fn(&new_clone->hashkit,
+                                memcached_hash_fn_map[new_clone->continuum_hash_type]);
   new_clone->user_data= source->user_data;
 
   new_clone->snd_timeout= source->snd_timeout;
@@ -148,3 +183,19 @@
   ptr->user_data= data;
   return ret;
 }
+
+memcached_return run_distribution(memcached_st *ptr)
+{
+  if (gettimeofday(&ptr->now, NULL) == 0 && ptr->now.tv_sec > ptr->next_distribution_rebuild)
+    ptr->next_distribution_rebuild= 0;
+
+  if (hashkit_run_distribution(&ptr->hashkit) != 0)
+  {
+    ptr->cached_errno= errno;
+    return MEMCACHED_ERRNO;
+  }
+
+  ptr->last_disconnected_server = NULL;
+
+  return MEMCACHED_SUCCESS;
+}

=== modified file 'libmemcached/memcached.h'
--- libmemcached/memcached.h	2009-12-02 22:04:02 +0000
+++ libmemcached/memcached.h	2009-12-11 17:27:14 +0000
@@ -18,11 +18,13 @@
 #include <sys/types.h>
 #include <netinet/in.h>
 
+#include <libhashkit/hashkit.h>
 #include <libmemcached/visibility.h>
 #include <libmemcached/memcached_configure.h>
 #include <libmemcached/memcached_constants.h>
 #include <libmemcached/memcached_types.h>
 #include <libmemcached/memcached_get.h>
+#include <libmemcached/memcached_hash.h>
 #include <libmemcached/memcached_server.h>
 #include <libmemcached/memcached_string.h>
 #include <libmemcached/memcached_result.h>
@@ -76,8 +78,6 @@
   uint8_t purging;
   bool is_allocated;
   uint8_t distribution;
-  uint8_t hash;
-  uint32_t continuum_points_counter;
   memcached_server_st *hosts;
   memcached_server_st *last_disconnected_server;
   int32_t snd_timeout;
@@ -93,15 +93,14 @@
   int32_t poll_timeout;
   int32_t connect_timeout;
   int32_t retry_timeout;
-  uint32_t continuum_count;
   int send_size;
   int recv_size;
   void *user_data;
   time_t next_distribution_rebuild;
   size_t prefix_key_length;
-  memcached_hash hash_continuum;
+  memcached_hash hash_type;
+  memcached_hash continuum_hash_type;
   memcached_result_st result;
-  memcached_continuum_item_st *continuum;
   memcached_clone_func on_clone;
   memcached_cleanup_func on_cleanup;
   memcached_free_function call_free;
@@ -110,9 +109,11 @@
   memcached_calloc_function call_calloc;
   memcached_trigger_key get_key_failure;
   memcached_trigger_delete_key delete_trigger;
+  hashkit_st hashkit;
   char prefix_key[MEMCACHED_PREFIX_KEY_MAX_SIZE];
   uint32_t number_of_replicas;
   memcached_callback_st *callbacks;
+  struct timeval now;
 };
 
 LIBMEMCACHED_API
@@ -214,12 +215,6 @@
 LIBMEMCACHED_API
 uint64_t memcached_behavior_get(memcached_st *ptr, memcached_behavior flag);
 
-/* The two public hash bits */
-LIBMEMCACHED_API
-uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm);
-LIBMEMCACHED_API
-uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_length);
-
 LIBMEMCACHED_API
 memcached_return memcached_flush_buffers(memcached_st *mem);
 

=== modified file 'libmemcached/memcached_behavior.c'
--- libmemcached/memcached_behavior.c	2009-11-27 19:46:16 +0000
+++ libmemcached/memcached_behavior.c	2009-12-11 17:27:14 +0000
@@ -75,6 +75,7 @@
   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
     {
       ptr->distribution= (memcached_server_distribution)(data);
+      hashkit_set_distribution(&ptr->hashkit, memcached_distribution_map[data]);
       if (ptr->distribution == MEMCACHED_DISTRIBUTION_RANDOM)
       {
         srandom((uint32_t) time(NULL));
@@ -86,21 +87,31 @@
     {
       if (data)
       {
-        ptr->hash= MEMCACHED_HASH_MD5;
+        ptr->hash_type= MEMCACHED_HASH_MD5;
+        hashkit_set_hash_fn(&ptr->hashkit, hashkit_md5);
         ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
+        hashkit_set_distribution(&ptr->hashkit, HASHKIT_DISTRIBUTION_KETAMA);
       }
       else
       {
-        ptr->hash= 0;
+        ptr->hash_type= 0;
+        hashkit_set_hash_fn(&ptr->hashkit, NULL);
         ptr->distribution= 0;
+        hashkit_set_distribution(&ptr->hashkit, HASHKIT_DISTRIBUTION_MODULA);
       }
       run_distribution(ptr);
       break;
     }
   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
     {
-      ptr->hash= MEMCACHED_HASH_MD5;
+      ptr->hash_type= MEMCACHED_HASH_MD5;
+      hashkit_set_hash_fn(&ptr->hashkit, hashkit_md5);
       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
+      hashkit_set_distribution(&ptr->hashkit, HASHKIT_DISTRIBUTION_KETAMA);
+      if (data)
+        hashkit_set_weight_fn(&ptr->hashkit, memcached_server_weight);
+      else
+        hashkit_set_weight_fn(&ptr->hashkit, NULL);
       set_behavior_flag(ptr, MEM_KETAMA_WEIGHTED, data);
       run_distribution(ptr);
       break;
@@ -109,12 +120,16 @@
     switch (data)
     {
     case MEMCACHED_KETAMA_COMPAT_LIBMEMCACHED:
-      ptr->hash= MEMCACHED_HASH_MD5;
+      ptr->hash_type= MEMCACHED_HASH_MD5;
+      hashkit_set_hash_fn(&ptr->hashkit, hashkit_md5);
       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
+      hashkit_set_distribution(&ptr->hashkit, HASHKIT_DISTRIBUTION_KETAMA);
       break;
     case MEMCACHED_KETAMA_COMPAT_SPY:
-      ptr->hash= MEMCACHED_HASH_MD5;
+      ptr->hash_type= MEMCACHED_HASH_MD5;
+      hashkit_set_hash_fn(&ptr->hashkit, hashkit_md5);
       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY;
+      hashkit_set_distribution(&ptr->hashkit, HASHKIT_DISTRIBUTION_KETAMA);
       break;
     default:
        return MEMCACHED_FAILURE;
@@ -122,14 +137,24 @@
     run_distribution(ptr);
     break;
   case MEMCACHED_BEHAVIOR_HASH:
+    if ((memcached_hash)data >= MEMCACHED_HASH_MAX)
+      return MEMCACHED_FAILURE;
 #ifndef HAVE_HSIEH_HASH
-    if ((memcached_hash)(data) == MEMCACHED_HASH_HSIEH)
+    else if ((memcached_hash)data == MEMCACHED_HASH_HSIEH)
       return MEMCACHED_FAILURE;
 #endif
-    ptr->hash= (memcached_hash)(data);
+    ptr->hash_type= (memcached_hash)data;
+    hashkit_set_hash_fn(&ptr->hashkit, memcached_hash_fn_map[(memcached_hash)data]);
     break;
   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
-    ptr->hash_continuum= (memcached_hash)(data);
+    if ((memcached_hash)data >= MEMCACHED_HASH_MAX)
+      return MEMCACHED_FAILURE;
+#ifndef HAVE_HSIEH_HASH
+    else if ((memcached_hash)data == MEMCACHED_HASH_HSIEH)
+      return MEMCACHED_FAILURE;
+#endif
+    ptr->continuum_hash_type= (memcached_hash)(data);
+    hashkit_set_continuum_hash_fn(&ptr->hashkit, memcached_hash_fn_map[(memcached_hash)data]);
     run_distribution(ptr);
     break;
   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
@@ -143,6 +168,10 @@
     break;
   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
     {
+      if (data)
+        hashkit_set_sort_fn(&ptr->hashkit, memcached_server_sort);
+      else
+        hashkit_set_sort_fn(&ptr->hashkit, NULL);
       set_behavior_flag(ptr, MEM_USE_SORT_HOSTS, data);
       run_distribution(ptr);
 
@@ -174,6 +203,10 @@
     set_behavior_flag(ptr, MEM_NOREPLY, data);
     break;
   case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
+    if (data)
+      hashkit_set_active_fn(&ptr->hashkit, memcached_server_active);
+    else
+      hashkit_set_active_fn(&ptr->hashkit, NULL);
     set_behavior_flag(ptr, MEM_AUTO_EJECT_HOSTS, data);
     break;
     case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
@@ -247,9 +280,9 @@
     }
     /* NOTREACHED */
   case MEMCACHED_BEHAVIOR_HASH:
-    return ptr->hash;
+    return ptr->hash_type;
   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
-    return ptr->hash_continuum;
+    return ptr->continuum_hash_type;
   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
     return ptr->server_failure_limit;
   case MEMCACHED_BEHAVIOR_SORT_HOSTS:

=== modified file 'libmemcached/memcached_constants.h'
--- libmemcached/memcached_constants.h	2009-11-27 10:40:32 +0000
+++ libmemcached/memcached_constants.h	2009-12-11 17:27:14 +0000
@@ -14,13 +14,8 @@
 #define MEMCACHED_MAX_KEY 251 /* We add one to have it null terminated */
 #define MEMCACHED_MAX_BUFFER 8196
 #define MEMCACHED_MAX_HOST_LENGTH 64
-#define MEMCACHED_MAX_HOST_SORT_LENGTH 86 /* Used for Ketama */
-#define MEMCACHED_POINTS_PER_SERVER 100
-#define MEMCACHED_POINTS_PER_SERVER_KETAMA 160
-#define MEMCACHED_CONTINUUM_SIZE MEMCACHED_POINTS_PER_SERVER*100 /* This would then set max hosts to 100 */
 #define MEMCACHED_STRIDE 4
 #define MEMCACHED_DEFAULT_TIMEOUT 1000
-#define MEMCACHED_CONTINUUM_ADDITION 10 /* How many extra slots we should build for in the continuum */
 #define MEMCACHED_PREFIX_KEY_MAX_SIZE 128
 #define MEMCACHED_EXPIRATION_NOT_ADD 0xffffffffU
 
@@ -72,7 +67,8 @@
   MEMCACHED_DISTRIBUTION_CONSISTENT,
   MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA,
   MEMCACHED_DISTRIBUTION_RANDOM,
-  MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY
+  MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY,
+  MEMCACHED_DISTRIBUTION_MAX
 } memcached_server_distribution;
 
 typedef enum {
@@ -137,7 +133,8 @@
   MEMCACHED_HASH_FNV1A_32,
   MEMCACHED_HASH_HSIEH,
   MEMCACHED_HASH_MURMUR,
-  MEMCACHED_HASH_JENKINS
+  MEMCACHED_HASH_JENKINS,
+  MEMCACHED_HASH_MAX
 } memcached_hash;
 
 typedef enum {

=== added file 'libmemcached/memcached_hash.c'
--- libmemcached/memcached_hash.c	1970-01-01 00:00:00 +0000
+++ libmemcached/memcached_hash.c	2009-12-11 17:27:14 +0000
@@ -0,0 +1,46 @@
+/*
+  Memcached library
+*/
+#include "common.h"
+
+uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm)
+{
+  return hashkit_generate_value(key, key_length, (hashkit_hash_t)hash_algorithm);
+
+}
+
+uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_length)
+{
+  uint32_t hash_value= 1; /* Just here to remove compile warning */
+
+  WATCHPOINT_ASSERT(ptr->number_of_hosts);
+
+  if (ptr->number_of_hosts == 1)
+    return 0;
+
+  if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS) &&
+      ptr->next_distribution_rebuild)
+  {
+    if (gettimeofday(&ptr->now, NULL) == 0 && ptr->now.tv_sec > ptr->next_distribution_rebuild)
+      run_distribution(ptr);
+  }
+
+  if (ptr->flags & MEM_HASH_WITH_PREFIX_KEY)
+  {
+    size_t temp_length= ptr->prefix_key_length + key_length;
+    char temp[temp_length];
+
+    if (temp_length > MEMCACHED_MAX_KEY -1)
+      return 0;
+
+    strncpy(temp, ptr->prefix_key, ptr->prefix_key_length);
+    strncpy(temp + ptr->prefix_key_length, key, key_length);
+    hash_value= hashkit_value(&ptr->hashkit, temp, temp_length);
+  }
+  else
+    hash_value= hashkit_value(&ptr->hashkit, key, key_length);
+
+  WATCHPOINT_ASSERT(hash_value);
+
+  return hashkit_index(&ptr->hashkit, hash_value);
+}

=== added file 'libmemcached/memcached_hash.h'
--- libmemcached/memcached_hash.h	1970-01-01 00:00:00 +0000
+++ libmemcached/memcached_hash.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,9 @@
+/*
+  Memcached library
+*/
+
+/* The two public hash bits */
+LIBMEMCACHED_API
+uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm);
+LIBMEMCACHED_API
+uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_length);

=== modified file 'libmemcached/memcached_server.c'
--- libmemcached/memcached_server.c	2009-10-10 11:57:03 +0000
+++ libmemcached/memcached_server.c	2009-12-11 17:27:14 +0000
@@ -3,6 +3,12 @@
 */
 #include "common.h"
 
+/* Protoypes (static) */
+static memcached_return server_add(memcached_st *ptr, const char *hostname,
+                                   unsigned int port,
+                                   uint32_t weight,
+                                   memcached_connection type);
+
 memcached_server_st *memcached_server_create(memcached_st *memc, memcached_server_st *ptr)
 {
   if (ptr == NULL)
@@ -159,3 +165,295 @@
 {
   return ptr->last_disconnected_server;
 }
+
+void server_list_free(memcached_st *ptr, memcached_server_st *servers)
+{
+  unsigned int x;
+
+  if (servers == NULL)
+    return;
+
+  for (x= 0; x < servers->count; x++)
+    if (servers[x].address_info)
+    {
+      freeaddrinfo(servers[x].address_info);
+      servers[x].address_info= NULL;
+    }
+
+  if (ptr)
+    ptr->call_free(ptr, servers);
+  else
+    free(servers);
+}
+
+memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list)
+{
+  unsigned int x;
+  uint16_t count;
+  memcached_server_st *new_host_list;
+
+  if (!list)
+    return MEMCACHED_SUCCESS;
+
+  count= list[0].count;
+  new_host_list= ptr->call_realloc(ptr, ptr->hosts,
+                                   sizeof(memcached_server_st) * (count + ptr->number_of_hosts));
+
+  if (!new_host_list)
+    return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+
+  ptr->hosts= new_host_list;
+  hashkit_set_list(&ptr->hashkit, ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st));
+
+  for (x= 0; x < count; x++)
+  {
+    if ((ptr->flags & MEM_USE_UDP && list[x].type != MEMCACHED_CONNECTION_UDP)
+            || ((list[x].type == MEMCACHED_CONNECTION_UDP)
+            && ! (ptr->flags & MEM_USE_UDP)) )
+      return MEMCACHED_INVALID_HOST_PROTOCOL;
+
+    WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
+    memcached_server_create(ptr, &ptr->hosts[ptr->number_of_hosts]);
+    /* TODO check return type */
+    (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], list[x].hostname,
+                                       list[x].port, list[x].weight, list[x].type);
+    ptr->number_of_hosts++;
+    hashkit_set_list(&ptr->hashkit, ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st));
+  }
+  ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts;
+
+  return run_distribution(ptr);
+}
+
+memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
+                                                  const char *filename)
+{
+  return memcached_server_add_unix_socket_with_weight(ptr, filename, 0);
+}
+
+memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
+                                                              const char *filename,
+                                                              uint32_t weight)
+{
+  if (!filename)
+    return MEMCACHED_FAILURE;
+
+  return server_add(ptr, filename, 0, weight, MEMCACHED_CONNECTION_UNIX_SOCKET);
+}
+
+memcached_return memcached_server_add_udp(memcached_st *ptr,
+                                          const char *hostname,
+                                          unsigned int port)
+{
+  return memcached_server_add_udp_with_weight(ptr, hostname, port, 0);
+}
+
+memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
+                                                      const char *hostname,
+                                                      unsigned int port,
+                                                      uint32_t weight)
+{
+  if (!port)
+    port= MEMCACHED_DEFAULT_PORT;
+
+  if (!hostname)
+    hostname= "localhost";
+
+  return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_UDP);
+}
+
+memcached_return memcached_server_add(memcached_st *ptr,
+                                      const char *hostname,
+                                      unsigned int port)
+{
+  return memcached_server_add_with_weight(ptr, hostname, port, 0);
+}
+
+memcached_return memcached_server_add_with_weight(memcached_st *ptr,
+                                                  const char *hostname,
+                                                  unsigned int port,
+                                                  uint32_t weight)
+{
+  if (!port)
+    port= MEMCACHED_DEFAULT_PORT;
+
+  if (!hostname)
+    hostname= "localhost";
+
+  return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_TCP);
+}
+
+static memcached_return server_add(memcached_st *ptr, const char *hostname,
+                                   unsigned int port,
+                                   uint32_t weight,
+                                   memcached_connection type)
+{
+  memcached_server_st *new_host_list;
+
+  if ( (ptr->flags & MEM_USE_UDP && type != MEMCACHED_CONNECTION_UDP)
+      || ( (type == MEMCACHED_CONNECTION_UDP) && !(ptr->flags & MEM_USE_UDP) ) )
+    return MEMCACHED_INVALID_HOST_PROTOCOL;
+
+  new_host_list= ptr->call_realloc(ptr, ptr->hosts,
+                                   sizeof(memcached_server_st) * (ptr->number_of_hosts+1));
+
+  if (new_host_list == NULL)
+    return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+
+  ptr->hosts= new_host_list;
+
+  /* TODO: Check return type */
+  (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], hostname, port, weight, type);
+  ptr->number_of_hosts++;
+  ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts;
+
+  hashkit_set_list(&ptr->hashkit, ptr->hosts, ptr->number_of_hosts, sizeof(memcached_server_st));
+
+  return run_distribution(ptr);
+}
+
+memcached_return memcached_server_remove(memcached_server_st *st_ptr)
+{
+  uint32_t x, host_index;
+  memcached_st *ptr= st_ptr->root;
+  memcached_server_st *list= ptr->hosts;
+
+  for (x= 0, host_index= 0; x < ptr->number_of_hosts; x++)
+  {
+    if (strncmp(list[x].hostname, st_ptr->hostname, MEMCACHED_MAX_HOST_LENGTH) != 0 || list[x].port != st_ptr->port)
+    {
+      if (host_index != x)
+        memcpy(list+host_index, list+x, sizeof(memcached_server_st));
+      host_index++;
+    }
+  }
+  ptr->number_of_hosts= host_index;
+
+  if (st_ptr->address_info)
+  {
+    freeaddrinfo(st_ptr->address_info);
+    st_ptr->address_info= NULL;
+  }
+  run_distribution(ptr);
+
+  return MEMCACHED_SUCCESS;
+}
+
+memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
+                                                  const char *hostname, unsigned int port,
+                                                  memcached_return *error)
+{
+  return memcached_server_list_append_with_weight(ptr, hostname, port, 0, error);
+}
+
+memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
+                                                              const char *hostname, unsigned int port,
+                                                              uint32_t weight,
+                                                              memcached_return *error)
+{
+  unsigned int count;
+  memcached_server_st *new_host_list;
+
+  if (hostname == NULL || error == NULL)
+    return NULL;
+
+  if (!port)
+    port= MEMCACHED_DEFAULT_PORT;
+
+  /* Increment count for hosts */
+  count= 1;
+  if (ptr != NULL)
+  {
+    count+= ptr[0].count;
+  }
+
+  new_host_list= (memcached_server_st *)realloc(ptr, sizeof(memcached_server_st) * count);
+  if (!new_host_list)
+  {
+    *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+    return NULL;
+  }
+
+  /* TODO: Check return type */
+  memcached_server_create_with(NULL, &new_host_list[count-1], hostname, port, weight, MEMCACHED_CONNECTION_TCP);
+
+  /* Backwards compatibility hack */
+  new_host_list[0].count= (uint16_t) count;
+
+  *error= MEMCACHED_SUCCESS;
+  return new_host_list;
+}
+
+unsigned int memcached_server_list_count(memcached_server_st *ptr)
+{
+  if (ptr == NULL)
+    return 0;
+
+  return ptr[0].count;
+}
+
+void memcached_server_list_free(memcached_server_st *ptr)
+{
+  server_list_free(NULL, ptr);
+}
+
+bool memcached_server_active(void *context)
+{
+  memcached_server_st *ptr= (memcached_server_st *)context;
+
+  if (ptr->next_retry <= ptr->root->now.tv_sec)
+    return true;
+  else if (ptr->root->next_distribution_rebuild == 0 ||
+           ptr->next_retry < ptr->root->next_distribution_rebuild)
+  {
+    ptr->root->next_distribution_rebuild= ptr->next_retry;
+  }
+
+  return false;
+}
+
+uint32_t memcached_server_weight(void *context)
+{
+  memcached_server_st *ptr= (memcached_server_st *)context;
+
+  if (ptr->weight == 0)
+    ptr->weight= 1;
+
+  return ptr->weight;
+}
+
+static int compare_servers(const void *p1, const void *p2)
+{
+  int return_value;
+  memcached_server_st *a= (memcached_server_st *)p1;
+  memcached_server_st *b= (memcached_server_st *)p2;
+
+  return_value= strcmp(a->hostname, b->hostname);
+
+  if (return_value == 0)
+  {
+    return_value= (int) (a->port - b->port);
+  }
+
+  return return_value;
+}
+
+void memcached_server_sort(void *context, size_t count)
+{
+  memcached_server_st *ptr= (memcached_server_st *)context;
+
+  qsort(context, count, sizeof(memcached_server_st), compare_servers);
+  ptr[0].count= (uint16_t) count;
+}
+
+size_t memcached_server_key(char *key, size_t key_length, uint32_t point_index, void *context)
+{
+  memcached_server_st *ptr= (memcached_server_st *)context;
+
+  if (ptr->root->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY)
+    return (size_t)snprintf(key, key_length, "/%s:%d-%d", ptr->hostname, ptr->port, point_index);
+  else if (ptr->port == MEMCACHED_DEFAULT_PORT)
+    return (size_t)snprintf(key, key_length, "%s-%d", ptr->hostname, point_index);
+
+  return (size_t)snprintf(key, key_length, "%s:%d-%d", ptr->hostname, ptr->port, point_index);
+}

=== modified file 'libmemcached/memcached_types.h'
--- libmemcached/memcached_types.h	2009-10-13 10:05:51 +0000
+++ libmemcached/memcached_types.h	2009-12-11 17:27:14 +0000
@@ -19,7 +19,6 @@
 typedef struct memcached_result_st memcached_result_st;
 typedef struct memcached_string_st memcached_string_st;
 typedef struct memcached_server_st memcached_server_st;
-typedef struct memcached_continuum_item_st memcached_continuum_item_st;
 typedef memcached_return (*memcached_clone_func)(memcached_st *parent, memcached_st *clone);
 typedef memcached_return (*memcached_cleanup_func)(memcached_st *ptr);
 typedef void (*memcached_free_function)(memcached_st *ptr, void *mem);
@@ -28,13 +27,13 @@
 typedef void *(*memcached_calloc_function)(memcached_st *ptr, size_t nelem, const size_t elsize);
 typedef memcached_return (*memcached_execute_function)(memcached_st *ptr, memcached_result_st *result, void *context);
 typedef memcached_return (*memcached_server_function)(memcached_st *ptr, memcached_server_st *server, void *context);
-typedef memcached_return (*memcached_trigger_key)(memcached_st *ptr,  
-                                                  const char *key, size_t key_length, 
+typedef memcached_return (*memcached_trigger_key)(memcached_st *ptr,
+                                                  const char *key, size_t key_length,
                                                   memcached_result_st *result);
-typedef memcached_return (*memcached_trigger_delete_key)(memcached_st *ptr,  
+typedef memcached_return (*memcached_trigger_delete_key)(memcached_st *ptr,
                                                          const char *key, size_t key_length);
 
-typedef memcached_return (*memcached_dump_func)(memcached_st *ptr,  
+typedef memcached_return (*memcached_dump_func)(memcached_st *ptr,
                                                 const char *key, size_t key_length, void *context);
 
 typedef struct {

=== added file 'm4/pandora_have_libhashkit.m4'
--- m4/pandora_have_libhashkit.m4	1970-01-01 00:00:00 +0000
+++ m4/pandora_have_libhashkit.m4	2009-12-11 17:27:14 +0000
@@ -0,0 +1,51 @@
+dnl  Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([_PANDORA_SEARCH_LIBHASHKIT],[
+  AC_REQUIRE([AC_LIB_PREFIX])
+
+  dnl --------------------------------------------------------------------
+  dnl  Check for libhashkit
+  dnl --------------------------------------------------------------------
+
+  AC_ARG_ENABLE([libhashkit],
+    [AS_HELP_STRING([--disable-libhashkit],
+      [Build with libhashkit support @<:@default=on@:>@])],
+    [ac_enable_libhashkit="$enableval"],
+    [ac_enable_libhashkit="yes"])
+
+  AS_IF([test "x$ac_enable_libhashkit" = "xyes"],[
+    AC_LIB_HAVE_LINKFLAGS(hashkit,,[
+      #include <libhashkit/hashkit.h>
+    ],[
+      hashkit_st hashkit;
+      hashkit_create(&hashkit);
+    ])
+  ],[
+    ac_cv_libhashkit="no"
+  ])
+  
+  AM_CONDITIONAL(HAVE_LIBHASHKIT, [test "x${ac_cv_libhashkit}" = "xyes"])
+])
+
+AC_DEFUN([PANDORA_HAVE_LIBHASHKIT],[
+  AC_REQUIRE([_PANDORA_SEARCH_LIBHASHKIT])
+])
+
+AC_DEFUN([PANDORA_REQUIRE_LIBHASHKIT],[
+  AC_REQUIRE([PANDORA_HAVE_LIBHASHKIT])
+  AS_IF([test "x${ac_cv_libhashkit}" = "xno"],
+      AC_MSG_ERROR([libhashkit is required for ${PACKAGE}]))
+])
+
+AC_DEFUN([PANDORA_BUNDLE_LIBHASHKIT],[
+  AC_REQUIRE([PANDORA_HAVE_LIBHASHKIT])
+  AS_IF([test "x${ac_cv_libhashkit}" = "xno"],
+    PANDORA_BUNDLED_SUBDIRS="${PANDORA_BUNDLED_SUBDIRS} libhashkit"
+    LIBHASHKIT_LINK="\$(top_builddir)/libhashkit/libhashkit.la",
+    LIBHASHKIT_LINK="${LTLIBHASHKIT}")
+  AC_SUBST(PANDORA_BUNDLED_SUBDIRS)
+  AC_SUBST(LIBHASHKIT_LINK)
+])

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2009-11-10 03:57:08 +0000
+++ tests/Makefile.am	2009-12-11 17:27:14 +0000
@@ -18,8 +18,11 @@
 
 LIBS =
 
+clean-local:
+	-rm -r ketama_keys.txt
+
 noinst_HEADERS = test.h server.h ketama_test_cases.h ketama_test_cases_spy.h
-noinst_PROGRAMS = testapp testplus udptest atomsmasher startservers
+noinst_PROGRAMS = testapp testplus udptest atomsmasher startservers testhashkit
 noinst_LTLIBRARIES= libserver.la libtest.la
 
 libserver_la_SOURCES= server.c
@@ -27,7 +30,11 @@
 
 testapp_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING)
 testapp_SOURCES = function.c
-testapp_LDADD = $(top_builddir)/clients/libgenexec.la libtest.la libserver.la $(LDADDS)
+testapp_LDADD = $(top_builddir)/clients/libgenexec.la libtest.la libserver.la $(LDADDS) $(LIBHASHKIT_LINK)
+
+testhashkit_CFLAGS=$(AM_CFLAGS)
+testhashkit_SOURCES= hashkit_functions.c
+testhashkit_LDADD = libtest.la $(LDADDS) $(LIBHASHKIT_LINK)
 
 testplus_SOURCES = plus.cpp
 testplus_LDADD = libtest.la libserver.la $(LDADDS)
@@ -41,10 +48,6 @@
 startservers_SOURCES = start.c
 startservers_LDADD = libserver.la $(LDADDS)
 
-record:
-	./testapp > output.res
-	./testplus > output_plus.res
-
 client-record:
 	sh t/memcat.test > r/memcat.res
 	sh t/memcp.test > r/memcp.res
@@ -52,17 +55,15 @@
 	sh t/memslap.test > r/memslap.res
 	sh t/memstat.test > r/memstat.res
 
-record-extended:
-	./testapp extended > output2.res
-
-test: testapp testplus library_test memcapable
+test: testapp testhashkit testplus libmemcached_test libmhashkit_test memcapable 
 	echo "Tests completed"
 
-library_test:
-	./testapp > output.cmp
-	diff output.res output.cmp
-#	./testplus > output_plus.cmp
-#	diff output_plus.res output_plus.cmp
+libmhashkit_test:
+	./testhashkit
+
+libmemcached_test:
+	./testapp
+#	./testplus
 
 memcapable:
 	@MEMC_BINARY@ -d -P /tmp/Xumemc.pid -p 12555
@@ -86,6 +87,12 @@
 	cat /tmp/Xumemc.pid | xargs kill
 	rm /tmp/Xumemc.pid
 
+gdb-hash:
+	$(LIBTOOL) --mode=execute gdb testhashkit
+
+valgrind-hash:
+	$(LIBTOOL) --mode=execute valgrind testhashkit
+
 valgrind:
 	libtool --mode=execute valgrind --leak-check=yes --show-reachable=yes  testapp
 

=== modified file 'tests/atomsmasher.c'
--- tests/atomsmasher.c	2009-11-25 08:21:57 +0000
+++ tests/atomsmasher.c	2009-12-11 17:27:14 +0000
@@ -199,10 +199,10 @@
 }
 
 test_st smash_tests[] ={
-  {"generate_pairs", 1, generate_pairs },
-  {"drizzle", 1, drizzle },
-  {"cleanup", 1, cleanup_pairs },
-  {"many_adds", 1, many_adds },
+  {"generate_pairs", 1, (test_execution_fn *)generate_pairs },
+  {"drizzle", 1, (test_execution_fn *)drizzle },
+  {"cleanup", 1, (test_execution_fn *)cleanup_pairs },
+  {"many_adds", 1, (test_execution_fn *)many_adds },
   {0, 0, 0}
 };
 

=== modified file 'tests/function.c'
--- tests/function.c	2009-12-02 23:07:20 +0000
+++ tests/function.c	2009-12-11 17:27:14 +0000
@@ -1,3 +1,11 @@
+/* libMemcached Functions Test
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
 /*
   Sample test application.
 */
@@ -33,6 +41,8 @@
 #include "libmemcached/memcached_util.h"
 #endif
 
+#include "hash_results.h"
+
 #define GLOBAL_COUNT 10000
 #define GLOBAL2_COUNT 100
 #define SERVERS_TO_CREATE 5
@@ -223,8 +233,8 @@
     test_truth(memc_clone->distribution == memc->distribution);
     test_truth(memc_clone->flags == memc->flags);
     test_truth(memc_clone->get_key_failure == memc->get_key_failure);
-    test_truth(memc_clone->hash == memc->hash);
-    test_truth(memc_clone->hash_continuum == memc->hash_continuum);
+    test_truth(memc_clone->hash_type == memc->hash_type);
+    test_truth(memc_clone->continuum_hash_type == memc->continuum_hash_type);
     test_truth(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
     test_truth(memc_clone->io_msg_watermark == memc->io_msg_watermark);
     test_truth(memc_clone->io_key_prefetch == memc->io_key_prefetch);
@@ -1625,18 +1635,18 @@
 
 static test_return_t  get_stats_keys(memcached_st *memc)
 {
- char **list;
+ char **stat_list;
  char **ptr;
  memcached_stat_st memc_stat;
  memcached_return rc;
 
- list= memcached_stat_get_keys(memc, &memc_stat, &rc);
+ stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);
  test_truth(rc == MEMCACHED_SUCCESS);
- for (ptr= list; *ptr; ptr++)
+ for (ptr= stat_list; *ptr; ptr++)
    test_truth(*ptr);
  fflush(stdout);
 
- free(list);
+ free(stat_list);
 
  return TEST_SUCCESS;
 }
@@ -1655,7 +1665,7 @@
 static test_return_t  get_stats(memcached_st *memc)
 {
  unsigned int x;
- char **list;
+ char **stat_list;
  char **ptr;
  memcached_return rc;
  memcached_stat_st *memc_stat;
@@ -1668,11 +1678,11 @@
 
  for (x= 0; x < memcached_server_count(memc); x++)
  {
-   list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
+   stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
    test_truth(rc == MEMCACHED_SUCCESS);
-   for (ptr= list; *ptr; ptr++);
+   for (ptr= stat_list; *ptr; ptr++);
 
-   free(list);
+   free(stat_list);
  }
 
  memcached_stat_free(NULL, memc_stat);
@@ -2699,7 +2709,7 @@
   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
    * us test the boundary wraparound.
    */
-  test_truth(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+  test_truth(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->hashkit.continuum[0].index);
 
   /* verify the standard ketama set. */
   for (x= 0; x < 99; x++)
@@ -3368,7 +3378,7 @@
 
 static memcached_return  pre_hash_fnv1_64(memcached_st *memc)
 {
-  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);
+  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)HASHKIT_HASH_MURMUR);
 
   return MEMCACHED_SUCCESS;
 }
@@ -3759,19 +3769,19 @@
       switch (count)
       {
       case 0:
-        ret=memcached_add(memc, key, len, key, len, 0, 0);
+        ret= memcached_add(memc, key, len, key, len, 0, 0);
         break;
       case 1:
-        ret=memcached_replace(memc, key, len, key, len, 0, 0);
+        ret= memcached_replace(memc, key, len, key, len, 0, 0);
         break;
       case 2:
-        ret=memcached_set(memc, key, len, key, len, 0, 0);
+        ret= memcached_set(memc, key, len, key, len, 0, 0);
         break;
       case 3:
-        ret=memcached_append(memc, key, len, key, len, 0, 0);
+        ret= memcached_append(memc, key, len, key, len, 0, 0);
         break;
       case 4:
-        ret=memcached_prepend(memc, key, len, key, len, 0, 0);
+        ret= memcached_prepend(memc, key, len, key, len, 0, 0);
         break;
       default:
         test_truth(count);
@@ -3923,7 +3933,7 @@
 }
 
 #ifdef HAVE_LIBMEMCACHEDUTIL
-static void* connection_release(void *arg) 
+static void* connection_release(void *arg)
 {
   struct {
     memcached_pool_st* pool;
@@ -4170,7 +4180,7 @@
     rc= memcached_set(memc, keys[x], len[x], "1", 1, 0, 0);
     test_truth(rc == MEMCACHED_SUCCESS);
   }
-  
+ 
   memcached_quit(memc);
 
   for (int x=0; x< 7; ++x) {
@@ -4567,25 +4577,55 @@
 {
   test_st current_op;
   test_st mixed_io_ops [] ={
-    {"udp_set_test", 0, udp_set_test},
-    {"udp_set_too_big_test", 0, udp_set_too_big_test},
-    {"udp_delete_test", 0, udp_delete_test},
-    {"udp_verbosity_test", 0, udp_verbosity_test},
-    {"udp_quit_test", 0, udp_quit_test},
-    {"udp_flush_test", 0, udp_flush_test},
-    {"udp_incr_test", 0, udp_incr_test},
-    {"udp_decr_test", 0, udp_decr_test},
-    {"udp_version_test", 0, udp_version_test}
+    {"udp_set_test", 0,
+      (test_execution_fn *)udp_set_test},
+    {"udp_set_too_big_test", 0,
+      (test_execution_fn *)udp_set_too_big_test},
+    {"udp_delete_test", 0,
+      (test_execution_fn *)udp_delete_test},
+    {"udp_verbosity_test", 0,
+      (test_execution_fn *)udp_verbosity_test},
+    {"udp_quit_test", 0,
+      (test_execution_fn *)udp_quit_test},
+    {"udp_flush_test", 0,
+      (test_execution_fn *)udp_flush_test},
+    {"udp_incr_test", 0,
+      (test_execution_fn *)udp_incr_test},
+    {"udp_decr_test", 0,
+      (test_execution_fn *)udp_decr_test},
+    {"udp_version_test", 0,
+      (test_execution_fn *)udp_version_test}
   };
   unsigned int x= 0;
   for (x= 0; x < 500; x++)
   {
     current_op= mixed_io_ops[random() % 9];
-    test_truth(current_op.function(memc) == TEST_SUCCESS);
+    test_truth(current_op.test_fn(memc) == TEST_SUCCESS);
   }
   return TEST_SUCCESS;
 }
 
+static test_return_t hash_sanity_test (memcached_st *memc)
+{
+  (void)memc;
+
+  assert(HASHKIT_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
+  assert(HASHKIT_HASH_MD5 == MEMCACHED_HASH_MD5);
+  assert(HASHKIT_HASH_CRC == MEMCACHED_HASH_CRC);
+  assert(HASHKIT_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
+  assert(HASHKIT_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
+  assert(HASHKIT_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
+  assert(HASHKIT_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
+#ifdef HAVE_HSIEH_HASH
+  assert(HASHKIT_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
+#endif
+  assert(HASHKIT_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
+  assert(HASHKIT_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
+  assert(HASHKIT_HASH_MAX == MEMCACHED_HASH_MAX);
+
+  return TEST_SUCCESS;
+}
+
 static test_return_t hsieh_avaibility_test (memcached_st *memc)
 {
   memcached_return expected_rc= MEMCACHED_FAILURE;
@@ -4598,55 +4638,17 @@
   return TEST_SUCCESS;
 }
 
-static const char *list[]=
-{
-  "apple",
-  "beat",
-  "carrot",
-  "daikon",
-  "eggplant",
-  "flower",
-  "green",
-  "hide",
-  "ick",
-  "jack",
-  "kick",
-  "lime",
-  "mushrooms",
-  "nectarine",
-  "orange",
-  "peach",
-  "quant",
-  "ripen",
-  "strawberry",
-  "tang",
-  "up",
-  "volumne",
-  "when",
-  "yellow",
-  "zip",
-  NULL
-};
-
 static test_return_t md5_run (memcached_st *memc __attribute__((unused)))
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  3195025439U, 2556848621U, 3724893440U, 3332385401U,
-                        245758794U, 2550894432U, 121710495U, 3053817768U,
-                        1250994555U, 1862072655U, 2631955953U, 2951528551U,
-                        1451250070U, 2820856945U, 2060845566U, 3646985608U,
-                        2138080750U, 217675895U, 2230934345U, 1234361223U,
-                        3968582726U, 2455685270U, 1293568479U, 199067604U,
-                        2042482093U };
-
-
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
-    test_truth(values[x] == hash_val);
+    test_truth(md5_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4656,17 +4658,13 @@
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
-                        9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
-                        7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
-                        17300U, 28156U, 9192U, 20484U, 16925U };
 
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
-    assert(values[x] == hash_val);
+    assert(crc_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4676,20 +4674,13 @@
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  473199127U, 4148981457U, 3971873300U, 3257986707U,
-                        1722477987U, 2991193800U, 4147007314U, 3633179701U,
-                        1805162104U, 3503289120U, 3395702895U, 3325073042U,
-                        2345265314U, 3340346032U, 2722964135U, 1173398992U,
-                        2815549194U, 2562818319U, 224996066U, 2680194749U,
-                        3035305390U, 246890365U, 2395624193U, 4145193337U,
-                        1801941682U };
 
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
-    assert(values[x] == hash_val);
+    assert(fnv1_64_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4699,20 +4690,13 @@
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  1488911807U, 2500855813U, 1510099634U, 1390325195U,
-                        3647689787U, 3241528582U, 1669328060U, 2604311949U,
-                        734810122U, 1516407546U, 560948863U, 1767346780U,
-                        561034892U, 4156330026U, 3716417003U, 3475297030U,
-                        1518272172U, 227211583U, 3938128828U, 126112909U,
-                        3043416448U, 3131561933U, 1328739897U, 2455664041U,
-                        2272238452U };
 
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
-    assert(values[x] == hash_val);
+    assert(fnv1a_64_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4722,21 +4706,14 @@
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  67176023U, 1190179409U, 2043204404U, 3221866419U,
-                        2567703427U, 3787535528U, 4147287986U, 3500475733U,
-                        344481048U, 3865235296U, 2181839183U, 119581266U,
-                        510234242U, 4248244304U, 1362796839U, 103389328U,
-                        1449620010U, 182962511U, 3554262370U, 3206747549U,
-                        1551306158U, 4127558461U, 1889140833U, 2774173721U,
-                        1180552018U };
-
-
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
-    assert(values[x] == hash_val);
+    assert(fnv1_32_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4746,20 +4723,13 @@
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  280767167U, 2421315013U, 3072375666U, 855001899U,
-                        459261019U, 3521085446U, 18738364U, 1625305005U,
-                        2162232970U, 777243802U, 3323728671U, 132336572U,
-                        3654473228U, 260679466U, 1169454059U, 2698319462U,
-                        1062177260U, 235516991U, 2218399068U, 405302637U,
-                        1128467232U, 3579622413U, 2138539289U, 96429129U,
-                        2877453236U };
 
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
-    assert(values[x] == hash_val);
+    assert(fnv1a_32_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4769,22 +4739,13 @@
 {
   uint32_t x;
   const char **ptr;
-#ifdef HAVE_HSIEH_HASH
-  uint32_t values[]= {  3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
-                        1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
-                        2265380744, 707972988, 353823508, 1549198350, 1327930172, 9304163,
-                        4220749037, 2493964934, 2777873870, 2057831732, 1510213931, 2027828987,
-                        3395453351 };
-#else
-  uint32_t values[]= {  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-#endif
 
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
-    assert(values[x] == hash_val);
+    assert(hsieh_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4794,20 +4755,13 @@
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
-                       1722477987U, 2991193800U, 4147007314U, 3633179701U,
-                       1805162104U, 3503289120U, 3395702895U, 3325073042U,
-                       2345265314U, 3340346032U, 2722964135U, 1173398992U,
-                       2815549194U, 2562818319U, 224996066U, 2680194749U,
-                       3035305390U, 246890365U, 2395624193U, 4145193337U,
-                       1801941682U };
 
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
-    hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
-    assert(values[x] == hash_val);
+    hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
+    assert(murmur_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4817,21 +4771,14 @@
 {
   uint32_t x;
   const char **ptr;
-  uint32_t values[]= {  1442444624U, 4253821186U, 1885058256U, 2120131735U,
-                        3261968576U, 3515188778U, 4232909173U, 4288625128U,
-                        1812047395U, 3689182164U, 2502979932U, 1214050606U,
-                        2415988847U, 1494268927U, 1025545760U, 3920481083U,
-                        4153263658U, 3824871822U, 3072759809U, 798622255U,
-                        3065432577U, 1453328165U, 2691550971U, 3408888387U,
-                        2629893356U };
-
-
-  for (ptr= list, x= 0; *ptr; ptr++, x++)
+
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
   {
     uint32_t hash_val;
 
     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
-    assert(values[x] == hash_val);
+    assert(jenkins_values[x] == hash_val);
   }
 
   return TEST_SUCCESS;
@@ -4881,7 +4828,7 @@
   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
    * us test the boundary wraparound.
    */
-  assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+  assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->hashkit.continuum[0].index);
 
   /* verify the standard ketama set. */
   for (x= 0; x < 99; x++)
@@ -4940,7 +4887,7 @@
   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
    * us test the boundary wraparound.
    */
-  assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
+  assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->hashkit.continuum[0].index);
 
   /* verify the standard ketama set. */
   for (x= 0; x < 99; x++)
@@ -5393,140 +5340,157 @@
 }
 
 test_st udp_setup_server_tests[] ={
-  {"set_udp_behavior_test", 0, set_udp_behavior_test},
-  {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
-  {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test},
+  {"set_udp_behavior_test", 0,
+    (test_execution_fn *)set_udp_behavior_test},
+  {"add_tcp_server_udp_client_test", 0,
+    (test_execution_fn *)add_tcp_server_udp_client_test},
+  {"add_udp_server_tcp_client_test", 0,
+    (test_execution_fn *)add_udp_server_tcp_client_test},
   {0, 0, 0}
 };
 
 test_st upd_io_tests[] ={
-  {"udp_set_test", 0, udp_set_test},
-  {"udp_buffered_set_test", 0, udp_buffered_set_test},
-  {"udp_set_too_big_test", 0, udp_set_too_big_test},
-  {"udp_delete_test", 0, udp_delete_test},
-  {"udp_buffered_delete_test", 0, udp_buffered_delete_test},
-  {"udp_verbosity_test", 0, udp_verbosity_test},
-  {"udp_quit_test", 0, udp_quit_test},
-  {"udp_flush_test", 0, udp_flush_test},
-  {"udp_incr_test", 0, udp_incr_test},
-  {"udp_decr_test", 0, udp_decr_test},
-  {"udp_stat_test", 0, udp_stat_test},
-  {"udp_version_test", 0, udp_version_test},
-  {"udp_get_test", 0, udp_get_test},
-  {"udp_mixed_io_test", 0, udp_mixed_io_test},
+  {"udp_set_test", 0,
+    (test_execution_fn *)udp_set_test},
+  {"udp_buffered_set_test", 0,
+    (test_execution_fn *)udp_buffered_set_test},
+  {"udp_set_too_big_test", 0,
+    (test_execution_fn *)udp_set_too_big_test},
+  {"udp_delete_test", 0,
+    (test_execution_fn *)udp_delete_test},
+  {"udp_buffered_delete_test", 0,
+    (test_execution_fn *)udp_buffered_delete_test},
+  {"udp_verbosity_test", 0,
+    (test_execution_fn *)udp_verbosity_test},
+  {"udp_quit_test", 0,
+    (test_execution_fn *)udp_quit_test},
+  {"udp_flush_test", 0,
+    (test_execution_fn *)udp_flush_test},
+  {"udp_incr_test", 0,
+    (test_execution_fn *)udp_incr_test},
+  {"udp_decr_test", 0,
+    (test_execution_fn *)udp_decr_test},
+  {"udp_stat_test", 0,
+    (test_execution_fn *)udp_stat_test},
+  {"udp_version_test", 0,
+    (test_execution_fn *)udp_version_test},
+  {"udp_get_test", 0,
+    (test_execution_fn *)udp_get_test},
+  {"udp_mixed_io_test", 0,
+    (test_execution_fn *)udp_mixed_io_test},
   {0, 0, 0}
 };
 
 /* Clean the server before beginning testing */
 test_st tests[] ={
-  {"flush", 0, flush_test },
-  {"init", 0, init_test },
-  {"allocation", 0, allocation_test },
-  {"server_list_null_test", 0, server_list_null_test},
-  {"server_unsort", 0, server_unsort_test},
-  {"server_sort", 0, server_sort_test},
-  {"server_sort2", 0, server_sort2_test},
-  {"clone_test", 0, clone_test },
-  {"connection_test", 0, connection_test},
-  {"callback_test", 0, callback_test},
-  {"behavior_test", 0, behavior_test},
-  {"userdata_test", 0, userdata_test},
-  {"error", 0, error_test },
-  {"set", 0, set_test },
-  {"set2", 0, set_test2 },
-  {"set3", 0, set_test3 },
-  {"dump", 1, dump_test},
-  {"add", 1, add_test },
-  {"replace", 1, replace_test },
-  {"delete", 1, delete_test },
-  {"get", 1, get_test },
-  {"get2", 0, get_test2 },
-  {"get3", 0, get_test3 },
-  {"get4", 0, get_test4 },
-  {"partial mget", 0, get_test5 },
-  {"stats_servername", 0, stats_servername_test },
-  {"increment", 0, increment_test },
-  {"increment_with_initial", 1, increment_with_initial_test },
-  {"decrement", 0, decrement_test },
-  {"decrement_with_initial", 1, decrement_with_initial_test },
-  {"increment_by_key", 0, increment_by_key_test },
-  {"increment_with_initial_by_key", 1, increment_with_initial_by_key_test },
-  {"decrement_by_key", 0, decrement_by_key_test },
-  {"decrement_with_initial_by_key", 1, decrement_with_initial_by_key_test },
-  {"quit", 0, quit_test },
-  {"mget", 1, mget_test },
-  {"mget_result", 1, mget_result_test },
-  {"mget_result_alloc", 1, mget_result_alloc_test },
-  {"mget_result_function", 1, mget_result_function },
-  {"mget_execute", 1, mget_execute },
-  {"mget_end", 0, mget_end },
-  {"get_stats", 0, get_stats },
-  {"add_host_test", 0, add_host_test },
-  {"add_host_test_1", 0, add_host_test1 },
-  {"get_stats_keys", 0, get_stats_keys },
-  {"behavior_test", 0, get_stats_keys },
-  {"callback_test", 0, get_stats_keys },
-  {"version_string_test", 0, version_string_test},
-  {"bad_key", 1, bad_key_test },
-  {"memcached_server_cursor", 1, memcached_server_cursor_test },
-  {"read_through", 1, read_through },
-  {"delete_through", 1, delete_through },
-  {"noreply", 1, noreply_test},
-  {"analyzer", 1, analyzer_test},
+  {"flush", 0, (test_execution_fn *)flush_test },
+  {"init", 0, (test_execution_fn *)init_test },
+  {"allocation", 0, (test_execution_fn *)allocation_test },
+  {"server_list_null_test", 0, (test_execution_fn *)server_list_null_test},
+  {"server_unsort", 0, (test_execution_fn *)server_unsort_test},
+  {"server_sort", 0, (test_execution_fn *)server_sort_test},
+  {"server_sort2", 0, (test_execution_fn *)server_sort2_test},
+  {"clone_test", 0, (test_execution_fn *)clone_test },
+  {"connection_test", 0, (test_execution_fn *)connection_test},
+  {"callback_test", 0, (test_execution_fn *)callback_test},
+  {"behavior_test", 0, (test_execution_fn *)behavior_test},
+  {"userdata_test", 0, (test_execution_fn *)userdata_test},
+  {"error", 0, (test_execution_fn *)error_test },
+  {"set", 0, (test_execution_fn *)set_test },
+  {"set2", 0, (test_execution_fn *)set_test2 },
+  {"set3", 0, (test_execution_fn *)set_test3 },
+  {"dump", 1, (test_execution_fn *)dump_test},
+  {"add", 1, (test_execution_fn *)add_test },
+  {"replace", 1, (test_execution_fn *)replace_test },
+  {"delete", 1, (test_execution_fn *)delete_test },
+  {"get", 1, (test_execution_fn *)get_test },
+  {"get2", 0, (test_execution_fn *)get_test2 },
+  {"get3", 0, (test_execution_fn *)get_test3 },
+  {"get4", 0, (test_execution_fn *)get_test4 },
+  {"partial mget", 0, (test_execution_fn *)get_test5 },
+  {"stats_servername", 0, (test_execution_fn *)stats_servername_test },
+  {"increment", 0, (test_execution_fn *)increment_test },
+  {"increment_with_initial", 1, (test_execution_fn *)increment_with_initial_test },
+  {"decrement", 0, (test_execution_fn *)decrement_test },
+  {"decrement_with_initial", 1, (test_execution_fn *)decrement_with_initial_test },
+  {"increment_by_key", 0, (test_execution_fn *)increment_by_key_test },
+  {"increment_with_initial_by_key", 1, (test_execution_fn *)increment_with_initial_by_key_test },
+  {"decrement_by_key", 0, (test_execution_fn *)decrement_by_key_test },
+  {"decrement_with_initial_by_key", 1, (test_execution_fn *)decrement_with_initial_by_key_test },
+  {"quit", 0, (test_execution_fn *)quit_test },
+  {"mget", 1, (test_execution_fn *)mget_test },
+  {"mget_result", 1, (test_execution_fn *)mget_result_test },
+  {"mget_result_alloc", 1, (test_execution_fn *)mget_result_alloc_test },
+  {"mget_result_function", 1, (test_execution_fn *)mget_result_function },
+  {"mget_execute", 1, (test_execution_fn *)mget_execute },
+  {"mget_end", 0, (test_execution_fn *)mget_end },
+  {"get_stats", 0, (test_execution_fn *)get_stats },
+  {"add_host_test", 0, (test_execution_fn *)add_host_test },
+  {"add_host_test_1", 0, (test_execution_fn *)add_host_test1 },
+  {"get_stats_keys", 0, (test_execution_fn *)get_stats_keys },
+  {"behavior_test", 0, (test_execution_fn *)get_stats_keys },
+  {"callback_test", 0, (test_execution_fn *)get_stats_keys },
+  {"version_string_test", 0, (test_execution_fn *)version_string_test},
+  {"bad_key", 1, (test_execution_fn *)bad_key_test },
+  {"memcached_server_cursor", 1, (test_execution_fn *)memcached_server_cursor_test },
+  {"read_through", 1, (test_execution_fn *)read_through },
+  {"delete_through", 1, (test_execution_fn *)delete_through },
+  {"noreply", 1, (test_execution_fn *)noreply_test},
+  {"analyzer", 1, (test_execution_fn *)analyzer_test},
 #ifdef HAVE_LIBMEMCACHEDUTIL
-  {"connectionpool", 1, connection_pool_test },
+  {"connectionpool", 1, (test_execution_fn *)connection_pool_test },
 #endif
-  {"test_get_last_disconnect", 1, test_get_last_disconnect},
+  {"test_get_last_disconnect", 1, (test_execution_fn *)test_get_last_disconnect},
   {0, 0, 0}
 };
 
 test_st async_tests[] ={
-  {"add", 1, add_wrapper },
+  {"add", 1, (test_execution_fn *)add_wrapper },
   {0, 0, 0}
 };
 
 test_st string_tests[] ={
-  {"string static with null", 0, string_static_null },
-  {"string alloc with null", 0, string_alloc_null },
-  {"string alloc with 1K", 0, string_alloc_with_size },
-  {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
-  {"string append", 0, string_alloc_append },
-  {"string append failure (too big)", 0, string_alloc_append_toobig },
-  {0, 0, 0}
+  {"string static with null", 0, (test_execution_fn *)string_static_null },
+  {"string alloc with null", 0, (test_execution_fn *)string_alloc_null },
+  {"string alloc with 1K", 0, (test_execution_fn *)string_alloc_with_size },
+  {"string alloc with malloc failure", 0, (test_execution_fn *)string_alloc_with_size_toobig },
+  {"string append", 0, (test_execution_fn *)string_alloc_append },
+  {"string append failure (too big)", 0, (test_execution_fn *)string_alloc_append_toobig },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st result_tests[] ={
-  {"result static", 0, result_static},
-  {"result alloc", 0, result_alloc},
-  {0, 0, 0}
+  {"result static", 0, (test_execution_fn *)result_static},
+  {"result alloc", 0, (test_execution_fn *)result_alloc},
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st version_1_2_3[] ={
-  {"append", 0, append_test },
-  {"prepend", 0, prepend_test },
-  {"cas", 0, cas_test },
-  {"cas2", 0, cas2_test },
-  {"append_binary", 0, append_binary_test },
-  {0, 0, 0}
+  {"append", 0, (test_execution_fn *)append_test },
+  {"prepend", 0, (test_execution_fn *)prepend_test },
+  {"cas", 0, (test_execution_fn *)cas_test },
+  {"cas2", 0, (test_execution_fn *)cas2_test },
+  {"append_binary", 0, (test_execution_fn *)append_binary_test },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st user_tests[] ={
-  {"user_supplied_bug1", 0, user_supplied_bug1 },
-  {"user_supplied_bug2", 0, user_supplied_bug2 },
-  {"user_supplied_bug3", 0, user_supplied_bug3 },
-  {"user_supplied_bug4", 0, user_supplied_bug4 },
-  {"user_supplied_bug5", 1, user_supplied_bug5 },
-  {"user_supplied_bug6", 1, user_supplied_bug6 },
-  {"user_supplied_bug7", 1, user_supplied_bug7 },
-  {"user_supplied_bug8", 1, user_supplied_bug8 },
-  {"user_supplied_bug9", 1, user_supplied_bug9 },
-  {"user_supplied_bug10", 1, user_supplied_bug10 },
-  {"user_supplied_bug11", 1, user_supplied_bug11 },
-  {"user_supplied_bug12", 1, user_supplied_bug12 },
-  {"user_supplied_bug13", 1, user_supplied_bug13 },
-  {"user_supplied_bug14", 1, user_supplied_bug14 },
-  {"user_supplied_bug15", 1, user_supplied_bug15 },
-  {"user_supplied_bug16", 1, user_supplied_bug16 },
+  {"user_supplied_bug1", 0, (test_execution_fn *)user_supplied_bug1 },
+  {"user_supplied_bug2", 0, (test_execution_fn *)user_supplied_bug2 },
+  {"user_supplied_bug3", 0, (test_execution_fn *)user_supplied_bug3 },
+  {"user_supplied_bug4", 0, (test_execution_fn *)user_supplied_bug4 },
+  {"user_supplied_bug5", 1, (test_execution_fn *)user_supplied_bug5 },
+  {"user_supplied_bug6", 1, (test_execution_fn *)user_supplied_bug6 },
+  {"user_supplied_bug7", 1, (test_execution_fn *)user_supplied_bug7 },
+  {"user_supplied_bug8", 1, (test_execution_fn *)user_supplied_bug8 },
+  {"user_supplied_bug9", 1, (test_execution_fn *)user_supplied_bug9 },
+  {"user_supplied_bug10", 1, (test_execution_fn *)user_supplied_bug10 },
+  {"user_supplied_bug11", 1, (test_execution_fn *)user_supplied_bug11 },
+  {"user_supplied_bug12", 1, (test_execution_fn *)user_supplied_bug12 },
+  {"user_supplied_bug13", 1, (test_execution_fn *)user_supplied_bug13 },
+  {"user_supplied_bug14", 1, (test_execution_fn *)user_supplied_bug14 },
+  {"user_supplied_bug15", 1, (test_execution_fn *)user_supplied_bug15 },
+  {"user_supplied_bug16", 1, (test_execution_fn *)user_supplied_bug16 },
 #ifndef __sun
   /*
   ** It seems to be something weird with the character sets..
@@ -5535,23 +5499,23 @@
   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
   ** so just disable the code for now...).
   */
-  {"user_supplied_bug17", 1, user_supplied_bug17 },
+  {"user_supplied_bug17", 1, (test_execution_fn *)user_supplied_bug17 },
 #endif
-  {"user_supplied_bug18", 1, user_supplied_bug18 },
-  {"user_supplied_bug19", 1, user_supplied_bug19 },
-  {"user_supplied_bug20", 1, user_supplied_bug20 },
-  {"user_supplied_bug21", 1, user_supplied_bug21 },
-  {"wrong_failure_counter_test", 1, wrong_failure_counter_test},
-  {0, 0, 0}
+  {"user_supplied_bug18", 1, (test_execution_fn *)user_supplied_bug18 },
+  {"user_supplied_bug19", 1, (test_execution_fn *)user_supplied_bug19 },
+  {"user_supplied_bug20", 1, (test_execution_fn *)user_supplied_bug20 },
+  {"user_supplied_bug21", 1, (test_execution_fn *)user_supplied_bug21 },
+  {"wrong_failure_counter_test", 1, (test_execution_fn *)wrong_failure_counter_test},
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st replication_tests[]= {
-  {"set", 1, replication_set_test },
-  {"get", 0, replication_get_test },
-  {"mget", 0, replication_mget_test },
-  {"delete", 0, replication_delete_test },
-  {"rand_mget", 0, replication_randomize_mget_test },
-  {0, 0, 0}
+  {"set", 1, (test_execution_fn *)replication_set_test },
+  {"get", 0, (test_execution_fn *)replication_get_test },
+  {"mget", 0, (test_execution_fn *)replication_mget_test },
+  {"delete", 0, (test_execution_fn *)replication_delete_test },
+  {"rand_mget", 0, (test_execution_fn *)replication_randomize_mget_test },
+  {0, 0, (test_execution_fn *)0}
 };
 
 /*
@@ -5561,82 +5525,88 @@
  *   http://bugs.launchpad.net/libmemcached
  */
 test_st regression_tests[]= {
-  {"lp:434484", 1, regression_bug_434484 },
-  {"lp:434843", 1, regression_bug_434843 },
-  {"lp:434843 buffered", 1, regression_bug_434843_buffered },
-  {"lp:421108", 1, regression_bug_421108 },
-  {"lp:442914", 1, regression_bug_442914 },
-  {"lp:447342", 1, regression_bug_447342 },
-  {"lp:463297", 1, regression_bug_463297 },
-  {0, 0, 0}
+  {"lp:434484", 1, (test_execution_fn *)regression_bug_434484 },
+  {"lp:434843", 1, (test_execution_fn *)regression_bug_434843 },
+  {"lp:434843 buffered", 1, (test_execution_fn *)regression_bug_434843_buffered },
+  {"lp:421108", 1, (test_execution_fn *)regression_bug_421108 },
+  {"lp:442914", 1, (test_execution_fn *)regression_bug_442914 },
+  {"lp:447342", 1, (test_execution_fn *)regression_bug_447342 },
+  {"lp:463297", 1, (test_execution_fn *)regression_bug_463297 },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st ketama_compatibility[]= {
-  {"libmemcached", 1, ketama_compatibility_libmemcached },
-  {"spymemcached", 1, ketama_compatibility_spymemcached },
-  {0, 0, 0}
+  {"libmemcached", 1, (test_execution_fn *)ketama_compatibility_libmemcached },
+  {"spymemcached", 1, (test_execution_fn *)ketama_compatibility_spymemcached },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st generate_tests[] ={
-  {"generate_pairs", 1, generate_pairs },
-  {"generate_data", 1, generate_data },
-  {"get_read", 0, get_read },
-  {"delete_generate", 0, delete_generate },
-  {"generate_buffer_data", 1, generate_buffer_data },
-  {"delete_buffer", 0, delete_buffer_generate},
-  {"generate_data", 1, generate_data },
-  {"mget_read", 0, mget_read },
-  {"mget_read_result", 0, mget_read_result },
-  {"mget_read_function", 0, mget_read_function },
-  {"cleanup", 1, cleanup_pairs },
-  {"generate_large_pairs", 1, generate_large_pairs },
-  {"generate_data", 1, generate_data },
-  {"generate_buffer_data", 1, generate_buffer_data },
-  {"cleanup", 1, cleanup_pairs },
-  {0, 0, 0}
+  {"generate_pairs", 1, (test_execution_fn *)generate_pairs },
+  {"generate_data", 1, (test_execution_fn *)generate_data },
+  {"get_read", 0, (test_execution_fn *)get_read },
+  {"delete_generate", 0, (test_execution_fn *)delete_generate },
+  {"generate_buffer_data", 1, (test_execution_fn *)generate_buffer_data },
+  {"delete_buffer", 0, (test_execution_fn *)delete_buffer_generate},
+  {"generate_data", 1, (test_execution_fn *)generate_data },
+  {"mget_read", 0, (test_execution_fn *)mget_read },
+  {"mget_read_result", 0, (test_execution_fn *)mget_read_result },
+  {"mget_read_function", 0, (test_execution_fn *)mget_read_function },
+  {"cleanup", 1, (test_execution_fn *)cleanup_pairs },
+  {"generate_large_pairs", 1, (test_execution_fn *)generate_large_pairs },
+  {"generate_data", 1, (test_execution_fn *)generate_data },
+  {"generate_buffer_data", 1, (test_execution_fn *)generate_buffer_data },
+  {"cleanup", 1, (test_execution_fn *)cleanup_pairs },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st consistent_tests[] ={
-  {"generate_pairs", 1, generate_pairs },
-  {"generate_data", 1, generate_data },
-  {"get_read", 0, get_read_count },
-  {"cleanup", 1, cleanup_pairs },
-  {0, 0, 0}
+  {"generate_pairs", 1, (test_execution_fn *)generate_pairs },
+  {"generate_data", 1, (test_execution_fn *)generate_data },
+  {"get_read", 0, (test_execution_fn *)get_read_count },
+  {"cleanup", 1, (test_execution_fn *)cleanup_pairs },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st consistent_weighted_tests[] ={
-  {"generate_pairs", 1, generate_pairs },
-  {"generate_data", 1, generate_data_with_stats },
-  {"get_read", 0, get_read_count },
-  {"cleanup", 1, cleanup_pairs },
-  {0, 0, 0}
+  {"generate_pairs", 1, (test_execution_fn *)generate_pairs },
+  {"generate_data", 1, (test_execution_fn *)generate_data_with_stats },
+  {"get_read", 0, (test_execution_fn *)get_read_count },
+  {"cleanup", 1, (test_execution_fn *)cleanup_pairs },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st hsieh_availability[] ={
-  {"hsieh_avaibility_test",0,hsieh_avaibility_test},
-  {0, 0, 0}
+  {"hsieh_avaibility_test", 0, (test_execution_fn *)hsieh_avaibility_test},
+  {0, 0, (test_execution_fn *)0}
+};
+
+test_st hash_sanity[] ={
+  {"hash sanity", 0, (test_execution_fn *)hash_sanity_test},
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st ketama_auto_eject_hosts[] ={
-  {"auto_eject_hosts", 1, auto_eject_hosts },
-  {"output_ketama_weighted_keys", 1, output_ketama_weighted_keys },
-  {0, 0, 0}
+  {"auto_eject_hosts", 1, (test_execution_fn *)auto_eject_hosts },
+  {"output_ketama_weighted_keys", 1, (test_execution_fn *)output_ketama_weighted_keys },
+  {0, 0, (test_execution_fn *)0}
 };
 
 test_st hash_tests[] ={
-  {"md5", 0, md5_run },
-  {"crc", 0, crc_run },
-  {"fnv1_64", 0, fnv1_64_run },
-  {"fnv1a_64", 0, fnv1a_64_run },
-  {"fnv1_32", 0, fnv1_32_run },
-  {"fnv1a_32", 0, fnv1a_32_run },
-  {"hsieh", 0, hsieh_run },
-  {"murmur", 0, murmur_run },
-  {"jenkis", 0, jenkins_run },
-  {0, 0, 0}
+  {"md5", 0, (test_execution_fn *)md5_run },
+  {"crc", 0, (test_execution_fn *)crc_run },
+  {"fnv1_64", 0, (test_execution_fn *)fnv1_64_run },
+  {"fnv1a_64", 0, (test_execution_fn *)fnv1a_64_run },
+  {"fnv1_32", 0, (test_execution_fn *)fnv1_32_run },
+  {"fnv1a_32", 0, (test_execution_fn *)fnv1a_32_run },
+  {"hsieh", 0, (test_execution_fn *)hsieh_run },
+  {"murmur", 0, (test_execution_fn *)murmur_run },
+  {"jenkis", 0, (test_execution_fn *)jenkins_run },
+  {0, 0, (test_execution_fn *)0}
 };
 
 collection_st collection[] ={
+  {"hash_sanity", 0, 0, hash_sanity},
   {"hsieh_availability",0,0,hsieh_availability},
   {"udp_setup", init_udp, 0, udp_setup_server_tests},
   {"udp_io", init_udp, 0, upd_io_tests},
@@ -5725,4 +5695,5 @@
   world->collections= collection;
   world->create= world_create;
   world->destroy= world_destroy;
+  world->is_libmemcached= true;
 }

=== added file 'tests/hash_results.h'
--- tests/hash_results.h	1970-01-01 00:00:00 +0000
+++ tests/hash_results.h	2009-12-11 17:27:14 +0000
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/**
+  @brief We list strings and results for testing different hashing algo in
+  this file.
+*/
+
+
+static const char *list_to_hash[]=
+{
+  "apple",
+  "beat",
+  "carrot",
+  "daikon",
+  "eggplant",
+  "flower",
+  "green",
+  "hide",
+  "ick",
+  "jack",
+  "kick",
+  "lime",
+  "mushrooms",
+  "nectarine",
+  "orange",
+  "peach",
+  "quant",
+  "ripen",
+  "strawberry",
+  "tang",
+  "up",
+  "volumne",
+  "when",
+  "yellow",
+  "zip",
+  NULL
+};
+
+static uint32_t md5_values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
+                                245758794U, 2550894432U, 121710495U, 3053817768U,
+                                1250994555U, 1862072655U, 2631955953U, 2951528551U,
+                                1451250070U, 2820856945U, 2060845566U, 3646985608U,
+                                2138080750U, 217675895U, 2230934345U, 1234361223U,
+                                3968582726U, 2455685270U, 1293568479U, 199067604U,
+                                2042482093U };
+
+static uint32_t crc_values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
+                                9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
+                                7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
+                                17300U, 28156U, 9192U, 20484U, 16925U };
+
+static uint32_t fnv1_64_values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
+                                    1722477987U, 2991193800U, 4147007314U, 3633179701U,
+                                    1805162104U, 3503289120U, 3395702895U, 3325073042U,
+                                    2345265314U, 3340346032U, 2722964135U, 1173398992U,
+                                    2815549194U, 2562818319U, 224996066U, 2680194749U,
+                                    3035305390U, 246890365U, 2395624193U, 4145193337U,
+                                    1801941682U };
+
+static uint32_t fnv1a_64_values[]= {  1488911807U, 2500855813U, 1510099634U, 1390325195U,
+                                      3647689787U, 3241528582U, 1669328060U, 2604311949U,
+                                      734810122U, 1516407546U, 560948863U, 1767346780U,
+                                      561034892U, 4156330026U, 3716417003U, 3475297030U,
+                                      1518272172U, 227211583U, 3938128828U, 126112909U,
+                                      3043416448U, 3131561933U, 1328739897U, 2455664041U,
+                                      2272238452U };
+
+static uint32_t fnv1_32_values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
+                                    2567703427U, 3787535528U, 4147287986U, 3500475733U,
+                                    344481048U, 3865235296U, 2181839183U, 119581266U,
+                                    510234242U, 4248244304U, 1362796839U, 103389328U,
+                                    1449620010U, 182962511U, 3554262370U, 3206747549U,
+                                    1551306158U, 4127558461U, 1889140833U, 2774173721U,
+                                    1180552018U };
+
+static uint32_t fnv1a_32_values[]= {  280767167U, 2421315013U, 3072375666U, 855001899U,
+                                      459261019U, 3521085446U, 18738364U, 1625305005U,
+                                      2162232970U, 777243802U, 3323728671U, 132336572U,
+                                      3654473228U, 260679466U, 1169454059U, 2698319462U,
+                                      1062177260U, 235516991U, 2218399068U, 405302637U,
+                                      1128467232U, 3579622413U, 2138539289U, 96429129U,
+                                      2877453236U };
+
+#ifdef HAVE_HSIEH_HASH
+static uint32_t hsieh_values[]= { 3738850110U, 3636226060U, 3821074029U, 3489929160U, 3485772682U, 80540287U,
+                                  1805464076U, 1895033657U, 409795758U, 979934958U, 3634096985U, 1284445480U,
+                                  2265380744U, 707972988U, 353823508U, 1549198350U, 1327930172U, 9304163U,
+                                  4220749037U, 2493964934U, 2777873870U, 2057831732U, 1510213931U, 2027828987U,
+                                  3395453351U };
+#else
+static uint32_t hsieh_values[]= {  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+#endif
+
+static uint32_t murmur_values[]= {  4142305122U, 734504955U, 3802834688U, 4076891445U,
+                                    387802650U, 560515427U, 3274673488U, 3150339524U,
+                                    1527441970U, 2728642900U, 3613992239U, 2938419259U,
+                                    2321988328U, 1145154116U, 4038540960U, 2224541613U,
+                                    264013145U, 3995512858U, 2400956718U, 2346666219U,
+                                    926327338U, 442757446U, 1770805201U, 560483147U,
+                                    3902279934U };
+
+static uint32_t jenkins_values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
+                                    3261968576U, 3515188778U, 4232909173U, 4288625128U,
+                                    1812047395U, 3689182164U, 2502979932U, 1214050606U,
+                                    2415988847U, 1494268927U, 1025545760U, 3920481083U,
+                                    4153263658U, 3824871822U, 3072759809U, 798622255U,
+                                    3065432577U, 1453328165U, 2691550971U, 3408888387U,
+                                    2629893356U };
+

=== added file 'tests/hashkit_functions.c'
--- tests/hashkit_functions.c	1970-01-01 00:00:00 +0000
+++ tests/hashkit_functions.c	2009-12-11 17:27:14 +0000
@@ -0,0 +1,363 @@
+/* libHashKit Functions Test
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libhashkit/hashkit.h>
+
+#include "test.h"
+
+#include "hash_results.h"
+
+static hashkit_st global_hashk;
+
+/**
+  @brief hash_test_st is a structure we use in testing. It is currently empty.
+*/
+typedef struct hash_test_st hash_test_st;
+
+struct hash_test_st
+{
+  bool _unused;
+};
+
+static test_return_t init_test(void *not_used __attribute__((unused)))
+{
+  hashkit_st hashk;
+  hashkit_st *hashk_ptr;
+
+  hashk_ptr= hashkit_create(&hashk);
+  test_truth(hashk_ptr);
+  test_truth(hashk_ptr == &hashk);
+  test_truth(hashkit_is_initialized(&hashk) == true);
+  test_truth(hashkit_is_allocated(hashk_ptr) == false);
+
+  hashkit_free(hashk_ptr);
+
+  test_truth(hashkit_is_initialized(&hashk) == false);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t allocation_test(void *not_used __attribute__((unused)))
+{
+  hashkit_st *hashk_ptr;
+
+  hashk_ptr= hashkit_create(NULL);
+  test_truth(hashk_ptr);
+  test_truth(hashkit_is_allocated(hashk_ptr) == true);
+  test_truth(hashkit_is_initialized(hashk_ptr) == true);
+  hashkit_free(hashk_ptr);
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t clone_test(hashkit_st *hashk)
+{
+  // First we make sure that the testing system is giving us what we expect.
+  assert(&global_hashk == hashk);
+
+  // Second we test if hashk is even valid
+  test_truth(hashkit_is_initialized(hashk) == true);
+
+  /* All null? */
+  {
+    hashkit_st *hashk_ptr;
+    hashk_ptr= hashkit_clone(NULL, NULL);
+    test_truth(hashk_ptr);
+    test_truth(hashkit_is_allocated(hashk_ptr) == true);
+    test_truth(hashkit_is_initialized(hashk_ptr) == true);
+    hashkit_free(hashk_ptr);
+  }
+
+  /* Can we init from null? */
+  {
+    hashkit_st *hashk_ptr;
+
+    hashk_ptr= hashkit_clone(NULL, hashk);
+
+    test_truth(hashk_ptr);
+    test_truth(hashkit_is_allocated(hashk_ptr) == true);
+    test_truth(hashkit_is_initialized(hashk_ptr) == true);
+
+    test_truth(hashk_ptr->distribution == hashk->distribution);
+    test_truth(hashk_ptr->continuum_count == hashk->continuum_count);
+    test_truth(hashk_ptr->continuum_points_count == hashk->continuum_points_count);
+    test_truth(hashk_ptr->list_size == hashk->list_size);
+    test_truth(hashk_ptr->context_size == hashk->context_size);
+    test_truth(hashk_ptr->continuum == NULL);
+    test_truth(hashk_ptr->hash_fn == hashk->hash_fn);
+    test_truth(hashk_ptr->active_fn == hashk->active_fn);
+    test_truth(hashk_ptr->continuum_hash_fn == hashk->continuum_hash_fn);
+    test_truth(hashk_ptr->continuum_key_fn == hashk->continuum_key_fn);
+    test_truth(hashk_ptr->sort_fn == hashk->sort_fn);
+    test_truth(hashk_ptr->weight_fn == hashk->weight_fn);
+    test_truth(hashk_ptr->list == hashk->list);
+
+    hashkit_free(hashk_ptr);
+  }
+
+  /* Can we init from struct? */
+  {
+    hashkit_st declared_clone;
+    hashkit_st *hash_clone;
+
+    hash_clone= hashkit_clone(&declared_clone, NULL);
+    test_truth(hash_clone);
+
+    hashkit_free(hash_clone);
+  }
+
+  /* Can we init from struct? */
+  {
+    hashkit_st declared_clone;
+    hashkit_st *hash_clone;
+    memset(&declared_clone, 0 , sizeof(hashkit_st));
+    hash_clone= hashkit_clone(&declared_clone, hashk);
+    test_truth(hash_clone);
+    hashkit_free(hash_clone);
+  }
+
+  return TEST_SUCCESS;
+}
+
+
+static test_return_t md5_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_md5(*ptr, strlen(*ptr));
+    test_truth(md5_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t crc_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_crc32(*ptr, strlen(*ptr));
+    assert(crc_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t fnv1_64_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_fnv1_64(*ptr, strlen(*ptr));
+    assert(fnv1_64_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t fnv1a_64_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_fnv1a_64(*ptr, strlen(*ptr));
+    assert(fnv1a_64_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t fnv1_32_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_fnv1_32(*ptr, strlen(*ptr));
+    assert(fnv1_32_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t fnv1a_32_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_fnv1a_32(*ptr, strlen(*ptr));
+    assert(fnv1a_32_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t hsieh_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+#ifdef HAVE_HSIEH_HASH
+    hash_val= hashkit_hsieh(*ptr, strlen(*ptr));
+#else
+    hash_val= 1;
+#endif
+    assert(hsieh_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t murmur_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_murmur(*ptr, strlen(*ptr));
+    assert(murmur_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t jenkins_run (hashkit_st *hashk __attribute__((unused)))
+{
+  uint32_t x;
+  const char **ptr;
+
+
+  for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+  {
+    uint32_t hash_val;
+
+    hash_val= hashkit_jenkins(*ptr, strlen(*ptr));
+    assert(jenkins_values[x] == hash_val);
+  }
+
+  return TEST_SUCCESS;
+}
+
+
+
+
+/**
+  @brief now we list out the tests.
+*/
+
+test_st allocation[]= {
+  {"init", 0, (test_execution_fn *)init_test},
+  {"create and free", 0, (test_execution_fn *)allocation_test},
+  {"clone", 0, (test_execution_fn *)clone_test},
+  {0, 0, 0}
+};
+
+test_st hash_tests[] ={
+  {"md5", 0, (test_execution_fn *)md5_run },
+  {"crc", 0, (test_execution_fn *)crc_run },
+  {"fnv1_64", 0, (test_execution_fn *)fnv1_64_run },
+  {"fnv1a_64", 0, (test_execution_fn *)fnv1a_64_run },
+  {"fnv1_32", 0, (test_execution_fn *)fnv1_32_run },
+  {"fnv1a_32", 0, (test_execution_fn *)fnv1a_32_run },
+  {"hsieh", 0, (test_execution_fn *)hsieh_run },
+  {"murmur", 0, (test_execution_fn *)murmur_run },
+  {"jenkis", 0, (test_execution_fn *)jenkins_run },
+  {0, 0, (test_execution_fn *)0}
+};
+
+/*
+ * The following test suite is used to verify that we don't introduce
+ * regression bugs. If you want more information about the bug / test,
+ * you should look in the bug report at
+ *   http://bugs.launchpad.net/libmemcached
+ */
+test_st regression[]= {
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"allocation", 0, 0, allocation},
+  {"regression", 0, 0, regression},
+  {"hashing", 0, 0, hash_tests},
+  {0, 0, 0, 0}
+};
+
+/* Prototypes for functions we will pass to test framework */
+void *world_create(void);
+void world_destroy(void *p);
+
+void *world_create(void)
+{
+  hashkit_st *hashk_ptr;
+
+  hashk_ptr= hashkit_create(&global_hashk);
+
+  assert(hashk_ptr == &global_hashk);
+
+  // First we test if hashk is even valid
+  assert(hashkit_is_initialized(hashk_ptr) == true);
+  assert(hashkit_is_allocated(hashk_ptr) == false);
+  assert(hashk_ptr->continuum == NULL);
+
+  return hashk_ptr;
+}
+
+
+void world_destroy(void *p)
+{
+  hashkit_st *hashk= (hashkit_st *)p;
+
+  // Did we get back what we expected?
+  assert(hashkit_is_initialized(hashk) == true);
+  assert(hashkit_is_allocated(hashk) == false);
+  hashkit_free(&global_hashk);
+}
+
+void get_world(world_st *world)
+{
+  world->collections= collection;
+  world->create= world_create;
+  world->destroy= world_destroy;
+}

=== modified file 'tests/output_plus.res'
--- tests/output_plus.res	2009-07-15 22:13:28 +0000
+++ tests/output_plus.res	2009-12-11 17:27:14 +0000
@@ -1,5 +0,0 @@
-servers localhost:11221,
-	localhost : 11221
-
-
-retvalue 1

=== modified file 'tests/plus.cpp'
--- tests/plus.cpp	2009-11-19 22:46:49 +0000
+++ tests/plus.cpp	2009-12-11 17:27:14 +0000
@@ -30,7 +30,7 @@
    test_return_t basic_behavior(memcached_st *memc);
    test_return_t mget_test(memcached_st *memc);
    memcached_return callback_counter(memcached_st *,
-                                     memcached_result_st *, 
+                                     memcached_result_st *,
                                      void *context);
    void *world_create(void);
    void world_destroy(void *p);
@@ -65,7 +65,7 @@
 
   assert((memcmp(&test_value[0], &value[0], test_value.size()) == 0));
 
-  /* 
+  /*
    * Simple test of the exceptions here...this should throw an exception
    * saying that the key is empty.
    */
@@ -109,7 +109,7 @@
 
   int_inc_value= uint64_t(atol(inc_value.c_str()));
   int_ret_value= uint64_t(atol(ret_string.c_str()));
-  assert(int_ret_value == int_inc_value); 
+  assert(int_ret_value == int_inc_value);
 
   rc= mcach.increment(key, 1, &int_ret_value);
   assert(rc == true);
@@ -153,7 +153,7 @@
 
 /* Count the results */
 memcached_return callback_counter(memcached_st *,
-                                  memcached_result_st *, 
+                                  memcached_result_st *,
                                   void *context)
 {
   unsigned int *counter= static_cast<unsigned int *>(context);
@@ -199,7 +199,7 @@
 
   callbacks[0]= &callback_counter;
   counter= 0;
-  rc= mc.fetchExecute(callbacks, static_cast<void *>(&counter), 1); 
+  rc= mc.fetchExecute(callbacks, static_cast<void *>(&counter), 1);
 
   assert(counter == 3);
 
@@ -274,12 +274,18 @@
 }
 
 test_st tests[] ={
-  { "basic", 0, basic_test },
-  { "basic_master_key", 0, basic_master_key_test },
-  { "increment_test", 0, increment_test },
-  { "mget", 1, mget_test },
-  { "mget_result_function", 1, mget_result_function },
-  { "basic_behavior", 0, basic_behavior },
+  { "basic", 0,
+    reinterpret_cast<test_execution_fn *>(basic_test) },
+  { "basic_master_key", 0,
+    reinterpret_cast<test_execution_fn *>(basic_master_key_test) },
+  { "increment_test", 0,
+    reinterpret_cast<test_execution_fn *>(increment_test) },
+  { "mget", 1,
+    reinterpret_cast<test_execution_fn *>(mget_test) },
+  { "mget_result_function", 1,
+    reinterpret_cast<test_execution_fn *>(mget_result_function) },
+  { "basic_behavior", 0,
+    reinterpret_cast<test_execution_fn *>(basic_behavior) },
   {0, 0, 0}
 };
 

=== modified file 'tests/test.c'
--- tests/test.c	2009-12-05 12:53:58 +0000
+++ tests/test.c	2009-12-11 17:27:14 +0000
@@ -1,3 +1,11 @@
+/* uTest
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
 /*
   Sample test application.
 */
@@ -57,7 +65,7 @@
   char *collection_to_run= NULL;
   char *wildcard= NULL;
   server_startup_st *startup_ptr;
-  memcached_server_st *servers;
+  memcached_server_st *servers= NULL;
   world_st world;
   collection_st *collection;
   collection_st *next;
@@ -72,8 +80,11 @@
   else
     world_ptr= NULL;
 
-  startup_ptr= (server_startup_st *)world_ptr;
-  servers= (memcached_server_st *)startup_ptr->servers;
+  if (world.is_libmemcached)
+  {
+    startup_ptr= (server_startup_st *)world_ptr;
+    servers= (memcached_server_st *)startup_ptr->servers;
+  }
 
   if (argc > 1)
     collection_to_run= argv[1];
@@ -94,7 +105,7 @@
     for (x= 0; run->name; run++)
     {
       unsigned int loop;
-      memcached_st *memc;
+      memcached_st *memc= NULL;
       memcached_return rc;
       struct timeval start_time, end_time;
       long int load_time;
@@ -104,22 +115,31 @@
 
       fprintf(stderr, "Testing %s", run->name);
 
-      memc= memcached_create(NULL);
-      test_truth(memc);
+      if (world.is_libmemcached)
+      {
+        memc= memcached_create(NULL);
+        test_truth(memc);
 
-      rc= memcached_server_push(memc, servers);
-      test_truth(rc == MEMCACHED_SUCCESS);
+        rc= memcached_server_push(memc, servers);
+        test_truth(rc == MEMCACHED_SUCCESS);
+      }
 
       if (run->requires_flush)
       {
-        memcached_flush(memc, 0);
-        memcached_quit(memc);
+        if (world.is_libmemcached)
+        {
+          memcached_flush(memc, 0);
+          memcached_quit(memc);
+        }
       }
 
-      for (loop= 0; loop < memcached_server_list_count(servers); loop++)
+      if (world.is_libmemcached)
       {
-        test_truth(memc->hosts[loop].fd == -1);
-        test_truth(memc->hosts[loop].cursor_active == 0);
+        for (loop= 0; loop < memcached_server_list_count(servers); loop++)
+        {
+          test_truth(memc->hosts[loop].fd == -1);
+          test_truth(memc->hosts[loop].cursor_active == 0);
+        }
       }
 
       if (next->pre)
@@ -134,7 +154,7 @@
       }
 
       gettimeofday(&start_time, NULL);
-      failed= run->function(memc);
+      failed= run->test_fn(world.is_libmemcached ? memc : world_ptr);
       gettimeofday(&end_time, NULL);
       load_time= timedif(end_time, start_time);
 
@@ -144,9 +164,11 @@
       if (next->post)
         (void)next->post(memc);
 
-      test_truth(memc);
+      if (world.is_libmemcached)
+        assert(memc);
 error:
-      memcached_free(memc);
+      if (world.is_libmemcached)
+        memcached_free(memc);
     }
   }
 

=== modified file 'tests/test.h'
--- tests/test.h	2009-12-03 15:22:16 +0000
+++ tests/test.h	2009-12-11 17:27:14 +0000
@@ -1,6 +1,15 @@
+/* uTest
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
 /*
   Structures for generic tests.
 */
+
 #ifdef	__cplusplus
 extern "C" {
 #endif
@@ -20,10 +29,12 @@
   TEST_MAXIMUM_RETURN /* Always add new error code before */
 } test_return_t;
 
+typedef test_return_t (test_execution_fn)(void *context);
+
 struct test_st {
   const char *name;
   unsigned int requires_flush;
-  test_return_t (*function)(memcached_st *memc);
+  test_execution_fn *test_fn;
 };
 
 struct collection_st {
@@ -37,6 +48,7 @@
   collection_st *collections;
   void *(*create)(void);
   void (*destroy)(void *collection_object);
+  bool is_libmemcached; // This will eventually go away
 };
 
 /* How we make all of this work :) */

=== modified file 'tests/udp.c'
--- tests/udp.c	2009-11-25 08:21:57 +0000
+++ tests/udp.c	2009-12-11 17:27:14 +0000
@@ -34,7 +34,7 @@
 }
 
 test_st tests[] ={
-  {"set", 1, set_test },
+  {"set", 1, (test_execution_fn *)set_test },
   {0, 0, 0}
 };