memcached 0.16.3 → 0.17

data/BENCHMARKS

@@ -7,51 +7,114 @@ You can easily run your own benchmarks, as long as you have memcached itself on
 
 == x86-64 OS X
 
-These benchmarks were run on an OS X 10.5 Core 2 Duo machine (10,000 iterations):
+These benchmarks were run on an OS X 10.5 Core 2 Duo machine:
 
   Ruby 1.8.7p174
-  Loaded memcached 0.16.3
-  Loaded memcache-client 1.7.4
-
-                                           user     system      total        real
-  set:plain:noblock:memcached:net      0.260000   0.110000   0.370000 (  0.941733)
-  set:plain:noblock:memcached:uds      0.250000   0.060000   0.310000 (  0.470593)
-  set:plain:memcached:net              0.640000   1.040000   1.680000 (  4.352426)
-  set:plain:memcached:uds              0.500000   0.560000   1.060000 (  2.130330)
-  set:plain:memcache-client            7.500000   3.160000  10.660000 ( 11.394051)
-  set:ruby:noblock:memcached:net       0.430000   0.070000   0.500000 (  1.393856)
-  set:ruby:noblock:memcached:uds       0.440000   0.040000   0.480000 (  0.751106)
-  set:ruby:memcached:net               0.890000   0.910000   1.800000 (  5.539385)
-  set:ruby:memcached:uds               0.790000   0.610000   1.400000 (  3.257946)
-  set:ruby:memcache-client             7.710000   3.160000  10.870000 ( 11.494342)
-  get:plain:memcached:net              0.730000   0.940000   1.670000 (  4.305591)
-  get:plain:memcached:uds              0.610000   0.580000   1.190000 (  2.225602)
-  get:plain:memcache-client            8.960000   3.110000  12.070000 ( 13.710735)
-  get:ruby:memcached:net               0.910000   0.980000   1.890000 (  4.364018)
-  get:ruby:memcached:uds               0.750000   0.570000   1.320000 (  2.236862)
-  get:ruby:memcache-client             9.310000   3.180000  12.490000 ( 13.077060)
-  multiget:ruby:memcached:net          0.510000   0.350000   0.860000 (  1.471429)
-  multiget:ruby:memcached:uds          0.500000   0.260000   0.760000 (  1.138027)
-  multiget:ruby:memcache-client        4.840000   1.110000   5.950000 (  6.511808)
-  get-miss:ruby:memcached:net          0.960000   1.030000   1.990000 (  4.510132)
-  get-miss:ruby:memcached:uds          0.830000   0.640000   1.470000 (  2.708862)
-  get-miss:ruby:memcache-client        7.810000   3.190000  11.000000 ( 11.390215)
-  append-miss:ruby:memcached:net       1.000000   1.030000   2.030000 (  4.923893)
-  append-miss:ruby:memcached:uds       0.890000   0.680000   1.570000 (  3.202743)
-  append-miss:ruby:memcache-client     7.740000   3.180000  10.920000 ( 11.339136)
-  mixed:ruby:noblock:memcached:net     1.800000   2.370000   4.170000 (  8.616549)
-  mixed:ruby:noblock:memcached:uds     1.410000   1.090000   2.500000 (  5.035893)
-  mixed:ruby:memcached:net             1.830000   1.900000   3.730000 (  9.046367)
-  mixed:ruby:memcached:uds             1.570000   1.190000   2.760000 (  6.583020)
-  mixed:ruby:memcache-client          17.910000   6.440000  24.350000 ( 24.946386)
-  hash:murmur                          0.040000   0.000000   0.040000 (  0.039152)
-  hash:default                         0.040000   0.000000   0.040000 (  0.041841)
-  hash:jenkins                         0.050000   0.000000   0.050000 (  0.052283)
-  hash:md5                             0.090000   0.000000   0.090000 (  0.092901)
-  hash:crc                             0.040000   0.000000   0.040000 (  0.037710)
-  hash:fnv1a_32                        0.050000   0.000000   0.050000 (  0.047746)
-  hash:hsieh                           0.020000   0.000000   0.020000 (  0.020477)
-  hash:fnv1_32                         0.050000   0.000000   0.050000 (  0.046204)
-  hash:fnv1_64                         0.100000   0.000000   0.100000 (  0.106735)
-  hash:fnv1a_64                        0.060000   0.000000   0.060000 (  0.054646)
+  Loaded memcached 0.17
+  Loaded binary42-remix-stash 0.9.5
+  Loaded memcache-client 1.7.5
+  Loops is 40000
+  Stack depth is 0
+  Small value size is: 13 bytes
+  Large value size is: 4158 bytes
+
+                                            user     system      total        real
+  set:libm                              1.360000   2.120000   3.480000 (  8.952505)
+  set:libm:binary                       1.180000   2.100000   3.280000 (  7.692065)
+  set:libm:noblock                      0.590000   0.240000   0.830000 (  1.863921)
+  set:libm:noblock_binary               0.470000   0.220000   0.690000 (  1.678243)
+  set:libm:udp                          1.140000   1.150000   2.290000 (  4.835305)
+  set:ruby                             15.440000   6.330000  21.770000 ( 22.136843)
+  set:stash                             5.780000   2.040000   7.820000 ( 13.748268)
+  get:libm                              1.600000   2.000000   3.600000 (  8.112166)
+  get:libm:binary                       1.360000   2.150000   3.510000 (  7.829266)
+  get:libm:noblock                      1.820000   2.630000   4.450000 (  8.971191)
+  get:libm:noblock_binary               1.560000   2.650000   4.210000 (  8.114088)
+  get:libm:udp                          1.350000   1.140000   2.490000 (  4.878485)
+  get:ruby                             18.640000   6.370000  25.010000 ( 25.925459)
+  get:stash                             5.120000   1.990000   7.110000 ( 11.850485)
+  get-multi:libm                        1.770000   1.320000   3.090000 (  4.790793)
+  get-multi:libm:binary                 1.730000   1.740000   3.470000 (  5.655120)
+  get-multi:libm:noblock                1.820000   1.330000   3.150000 (  4.841084)
+  get-multi:libm:noblock_binary         1.740000   1.760000   3.500000 (  5.616970)
+  get-multi:libm:udp                    1.690000   0.960000   2.650000 (  3.551923)
+  get-multi:ruby                       21.380000   4.400000  25.780000 ( 26.017883)
+  append:libm                           1.500000   2.180000   3.680000 ( 14.658051)
+  append:libm:binary                    1.300000   2.110000   3.410000 ( 13.626305)
+  append:libm:noblock                   1.850000   2.870000   4.720000 ( 45.167145)
+  append:libm:noblock_binary            1.640000   2.870000   4.510000 ( 44.614596)
+  append:libm:udp                       1.260000   1.170000   2.430000 ( 11.556293)
+  append:ruby                          16.770000   7.310000  24.080000 ( 29.525815)
+  delete:libm                           1.890000   2.080000   3.970000 (  8.368548)
+  delete:libm:binary                    1.730000   2.090000   3.820000 (  7.799952)
+  delete:libm:noblock                   0.850000   0.890000   1.740000 (  2.530108)
+  delete:libm:noblock_binary            0.710000   0.780000   1.490000 (  2.390600)
+  delete:libm:udp                       1.700000   1.310000   3.010000 (  6.508360)
+  delete:ruby                          15.670000   6.330000  22.000000 ( 22.226087)
+  delete:stash                          4.970000   2.010000   6.980000 ( 11.726916)
+  get-missing:libm                      2.070000   2.060000   4.130000 (  8.937420)
+  get-missing:libm:binary               2.010000   2.090000   4.100000 (  8.506150)
+  get-missing:libm:noblock              2.270000   2.770000   5.040000 (  9.485592)
+  get-missing:libm:noblock_binary       2.220000   2.760000   4.980000 (  9.226826)
+  get-missing:libm:udp                  1.830000   1.300000   3.130000 (  7.135699)
+  get-missing:ruby                     16.130000   6.380000  22.510000 ( 22.888698)
+  get-missing:stash                     5.030000   2.030000   7.060000 ( 11.556793)
+  append-missing:libm                   2.210000   2.070000   4.280000 ( 10.386632)
+  append-missing:libm:binary            2.000000   2.060000   4.060000 (  9.135312)
+  append-missing:libm:noblock           2.400000   2.740000   5.140000 ( 10.821778)
+  append-missing:libm:noblock_binary    2.200000   2.770000   4.970000 (  9.699192)
+  append-missing:libm:udp               1.970000   1.320000   3.290000 (  7.668878)
+  append-missing:ruby                  15.970000   6.470000  22.440000 ( 22.912466)
+  set-large:libm                        1.460000   2.210000   3.670000 (  9.517034)
+  set-large:libm:binary                 1.260000   2.270000   3.530000 (  9.098769)
+  set-large:libm:noblock                0.980000   0.890000   1.870000 (  3.304075)
+  set-large:libm:noblock_binary         0.840000   0.890000   1.730000 (  3.444305)
+  set-large:libm:udp                    1.250000   1.330000   2.580000 (  6.924254)
+  set-large:ruby                       16.960000   6.490000  23.450000 ( 23.964380)
+  get-large:libm                        2.280000   2.450000   4.730000 (  9.908532)
+  get-large:libm:binary                 2.080000   2.530000   4.610000 (  8.966637)
+  get-large:libm:noblock                2.410000   2.850000   5.260000 ( 11.066391)
+  get-large:libm:noblock_binary         2.200000   2.910000   5.110000 ( 10.328922)
+  get-large:libm:udp                    2.010000   1.430000   3.440000 (  6.679192)
+  get-large:ruby                       21.790000   7.370000  29.160000 ( 29.578987)
+  get-large:stash                       5.430000   2.020000   7.450000 ( 11.967011)
+  set-ruby:libm                         1.800000   1.990000   3.790000 (  9.511387)
+  set-ruby:libm:binary                  1.610000   2.000000   3.610000 (  8.502297)
+  set-ruby:libm:noblock                 0.910000   0.200000   1.110000 (  2.083001)
+  set-ruby:libm:noblock_binary          0.750000   0.210000   0.960000 (  1.895510)
+  set-ruby:libm:udp                     1.530000   1.170000   2.700000 (  6.148442)
+  set-ruby:ruby                        16.290000   6.400000  22.690000 ( 23.672254)
+  set-ruby:stash                        5.570000   2.020000   7.590000 ( 13.381661)
+  get-ruby:libm                         1.920000   1.950000   3.870000 (  9.042716)
+  get-ruby:libm:binary                  1.640000   1.980000   3.620000 (  7.987886)
+  get-ruby:libm:noblock                 2.140000   2.600000   4.740000 ( 10.280036)
+  get-ruby:libm:noblock_binary          1.870000   2.590000   4.460000 (  9.213013)
+  get-ruby:libm:udp                     1.660000   1.170000   2.830000 (  5.762381)
+  get-ruby:ruby                        19.760000   6.500000  26.260000 ( 27.573109)
+  get-ruby:stash                        5.480000   2.010000   7.490000 ( 12.349059)
+  set-ruby-large:libm                  33.820000   2.340000  36.160000 ( 43.061537)
+  set-ruby-large:libm:binary           33.430000   2.260000  35.690000 ( 41.940845)
+  set-ruby-large:libm:noblock          34.170000   0.930000  35.100000 ( 35.632694)
+  set-ruby-large:libm:noblock_binary   34.010000   0.930000  34.940000 ( 35.383141)
+  set-ruby-large:libm:udp              33.150000   1.430000  34.580000 ( 39.521448)
+  set-ruby-large:ruby                  48.830000   6.560000  55.390000 ( 55.750071)
+  set-ruby-large:stash                 38.660000   2.230000  40.890000 ( 46.957838)
+  get-ruby-large:libm                  23.570000   2.340000  25.910000 ( 32.166590)
+  get-ruby-large:libm:binary           23.420000   2.510000  25.930000 ( 31.953854)
+  get-ruby-large:libm:noblock          23.840000   3.040000  26.880000 ( 32.919639)
+  get-ruby-large:libm:noblock_binary   23.570000   2.970000  26.540000 ( 32.210027)
+  get-ruby-large:libm:udp              23.210000   1.460000  24.670000 ( 29.284808)
+  get-ruby-large:ruby                  41.170000   7.560000  48.730000 ( 49.507358)
+  get-ruby-large:stash                 25.760000   2.540000  28.300000 ( 33.998493)
+  hash:fnv1a_64                         0.240000   0.000000   0.240000 (  0.247813)
+  hash:murmur                           0.190000   0.000000   0.190000 (  0.193039)
+  hash:default                          0.220000   0.000000   0.220000 (  0.216573)
+  hash:jenkins                          0.220000   0.000000   0.220000 (  0.222694)
+  hash:md5                              0.390000   0.000000   0.390000 (  0.395159)
+  hash:crc                              0.210000   0.000000   0.210000 (  0.216457)
+  hash:hsieh                            0.100000   0.000000   0.100000 (  0.104386)
+  hash:fnv1_32                          0.220000   0.000000   0.220000 (  0.216769)
+  hash:fnv1a_32                         0.230000   0.000000   0.230000 (  0.237016)
+  hash:fnv1_64                          0.450000   0.010000   0.460000 (  0.454704)
+
 

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v0.17. Update to libmemcached 0.32. Update Darwin version string for Snow Leopard final. Improve benchmarks. Add Memcached::Rails#append and #prepend, alias all original Memcached methods to _orig, and add set_servers= accessor for compatibility.
+
 v0.16.3. Optimize append/prepend on miss.
 
 v0.16.2. Fix memory leak.

data/Manifest

@@ -1,20 +1,21 @@
 BENCHMARKS
 CHANGELOG
-COMPATIBILITY
+LICENSE
+Manifest
+README
+Rakefile
+TODO
 ext/extconf.rb
-ext/libmemcached-0.31.tar.gz
+ext/libmemcached-0.32.tar.gz
+ext/libmemcached.patch
 ext/rlibmemcached.i
 ext/rlibmemcached_wrap.c
+lib/memcached.rb
 lib/memcached/behaviors.rb
 lib/memcached/exceptions.rb
 lib/memcached/integer.rb
 lib/memcached/memcached.rb
 lib/memcached/rails.rb
-lib/memcached.rb
-LICENSE
-Manifest
-Rakefile
-README
 test/profile/benchmark.rb
 test/profile/profile.rb
 test/profile/valgrind.rb
@@ -24,4 +25,3 @@ test/test_helper.rb
 test/unit/binding_test.rb
 test/unit/memcached_test.rb
 test/unit/rails_test.rb
-TODO

data/ext/extconf.rb

@@ -9,7 +9,7 @@ DARWIN = `uname -sp` == "Darwin i386\n"
 # is there a better way to do this?
 archflags = if ENV['ARCHFLAGS']
   ENV['ARCHFLAGS']
-elsif Config::CONFIG['host_os'] == 'darwin10.0'
+elsif Config::CONFIG['host_os'] =~ /darwin10\.0\.*/
   "-arch i386 -arch x86_64"
 elsif Config::CONFIG['host_os'] =~ /darwin/
   "-arch i386 -arch ppc"
@@ -35,6 +35,10 @@ if !ENV["EXTERNAL_LIB"]
       puts "Building libmemcached."
       puts(cmd = "tar xzf #{BUNDLE} 2>&1")
       raise "'#{cmd}' failed" unless system(cmd)
+      
+      puts "Patching libmemcached."
+      puts(cmd = "patch -p1 < libmemcached.patch")
+      raise "'#{cmd}' failed" unless system(cmd)
 
       Dir.chdir(BUNDLE_PATH) do
         

data/ext/libmemcached.patch

@@ -0,0 +1,270 @@
+
+diff --git a/libmemcached-0.32/libmemcached/memcached_response.c b/libmemcached/libmemcached/memcached_response.c
+--- a/libmemcached-0.32/libmemcached/memcached_response.c
++++ b/libmemcached/libmemcached/memcached_response.c
+@@ -496,6 +496,8 @@
+     case PROTOCOL_BINARY_RESPONSE_E2BIG:
+     case PROTOCOL_BINARY_RESPONSE_EINVAL:
+     case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
++      rc= MEMCACHED_NOTSTORED;
++      break;
+     case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
+     case PROTOCOL_BINARY_RESPONSE_ENOMEM:
+     default:
+diff --git a/libmemcached-0.32/libmemcached/memcached.c b/libmemcached/libmemcached/memcached.c
+--- a/libmemcached-0.32/libmemcached/memcached.c
++++ b/libmemcached/libmemcached/memcached.c
+@@ -50,6 +50,9 @@ void memcached_free(memcached_st *ptr)
+   if (ptr->continuum)
+     ptr->call_free(ptr, ptr->continuum);
+ 
++  if (ptr->live_host_indices)
++    ptr->call_free(ptr, ptr->live_host_indices);
++
+   if (ptr->is_allocated)
+     ptr->call_free(ptr, ptr);
+   else
+diff --git a/libmemcached-0.32/libmemcached/memcached.h b/libmemcached/libmemcached/memcached.h
+--- a/libmemcached-0.32/libmemcached/memcached.h
++++ b/libmemcached/libmemcached/memcached.h
+@@ -112,6 +112,9 @@ struct memcached_st {
+   memcached_trigger_delete_key delete_trigger;
+   char prefix_key[MEMCACHED_PREFIX_KEY_MAX_SIZE];
+   uint32_t number_of_replicas;
++  uint32_t number_of_live_hosts;
++  uint32_t *live_host_indices;
++  uint32_t live_host_indices_size;
+ };
+ 
+ LIBMEMCACHED_API
+diff --git a/libmemcached-0.32/libmemcached/memcached_connect.c b/libmemcached/libmemcached/memcached_connect.c
+--- a/libmemcached-0.32/libmemcached/memcached_connect.c
++++ b/libmemcached/libmemcached/memcached_connect.c
+@@ -273,7 +272,6 @@ static memcached_return network_connect(memcached_server_st *ptr)
+           (void)fcntl(ptr->fd, F_SETFL, flags & ~O_NONBLOCK);
+ 
+         WATCHPOINT_ASSERT(ptr->cursor_active == 0);
+-        ptr->server_failure_counter= 0;
+         return MEMCACHED_SUCCESS;
+       }
+       use = use->ai_next;
+@@ -282,21 +280,13 @@ static memcached_return network_connect(memcached_server_st *ptr)
+ 
+   if (ptr->fd == -1)
+   {
+-    /* Failed to connect. schedule next retry */
+-    if (ptr->root->retry_timeout)
+-    {
+-      struct timeval next_time;
+-
+-      if (gettimeofday(&next_time, NULL) == 0)
+-        ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
+-    }
+-    ptr->server_failure_counter+= 1;
++    ptr->server_failure_counter ++;
+     if (ptr->cached_errno == 0)
+       return MEMCACHED_TIMEOUT;
++      
+     return MEMCACHED_ERRNO; /* The last error should be from connect() */
+   }
+ 
+-  ptr->server_failure_counter= 0;
+   return MEMCACHED_SUCCESS; /* The last error should be from connect() */
+ }
+ 
+@@ -315,7 +305,7 @@ memcached_return memcached_connect(memcached_server_st *ptr)
+     gettimeofday(&next_time, NULL);
+ 
+     /* if we've had too many consecutive errors on this server, mark it dead. */
+-    if (ptr->server_failure_counter > ptr->root->server_failure_limit)
++    if (ptr->server_failure_counter >= ptr->root->server_failure_limit)
+     {
+       ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
+       ptr->server_failure_counter= 0;
+diff --git a/libmemcached-0.32/libmemcached/memcached_get.h b/libmemcached/libmemcached/memcached_get.h
+diff --git a/libmemcached-0.32/libmemcached/memcached_hash.c b/libmemcached/libmemcached/memcached_hash.c
+index 129d761..3a7fa55 100644
+--- a/libmemcached-0.32/libmemcached/memcached_hash.c
++++ b/libmemcached/libmemcached/memcached_hash.c
+@@ -11,6 +11,7 @@ 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_live_host_index(memcached_st *ptr, uint32_t num);
+ 
+ uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm)
+ {
+@@ -146,10 +144,10 @@ static uint32_t dispatch_host(memcached_st *ptr, uint32_t hash)
+         right= begin;
+       return right->index;
+     } 
+-  case MEMCACHED_DISTRIBUTION_MODULA:
+-    return hash % ptr->number_of_hosts;
++  case MEMCACHED_DISTRIBUTION_MODULA:  
++    return memcached_live_host_index(ptr, hash);
+   case MEMCACHED_DISTRIBUTION_RANDOM:
+-    return (uint32_t) random() % ptr->number_of_hosts;
++    return memcached_live_host_index(ptr, (int)random());
+   default:
+     WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
+     return hash % ptr->number_of_hosts;
+@@ -201,6 +199,19 @@ uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_
+   return dispatch_host(ptr, hash);
+ }
+ 
++uint32_t memcached_live_host_index(memcached_st *ptr, uint32_t num)
++{
++  if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS)) {
++    if (ptr->number_of_live_hosts > 0) {
++      return ptr->live_host_indices[num % ptr->number_of_live_hosts];
++    } else {
++      return 0;  /* FIXME:  we should do something different if every server's dead, but I dunno what. */
++    }
++  } else {
++    return num % ptr->number_of_hosts;
++  }
++}
++
+ static uint32_t internal_generate_hash(const char *key, size_t key_length)
+ {
+   const char *ptr= key;
+diff --git a/libmemcached-0.32/libmemcached/memcached_hosts.c b/libmemcached/libmemcached/memcached_hosts.c
+--- a/libmemcached-0.32/libmemcached/memcached_hosts.c
++++ b/libmemcached/libmemcached/memcached_hosts.c
+@@ -7,6 +7,7 @@ static memcached_return server_add(memcached_st *ptr, const char *hostname,
+                                    uint32_t weight,
+                                    memcached_connection type);
+ memcached_return update_continuum(memcached_st *ptr);
++memcached_return update_live_host_indices(memcached_st *ptr);
+ 
+ static int compare_servers(const void *p1, const void *p2)
+ {
+@@ -44,8 +45,12 @@ memcached_return run_distribution(memcached_st *ptr)
+   case MEMCACHED_DISTRIBUTION_MODULA:
+     if (ptr->flags & MEM_USE_SORT_HOSTS)
+       sort_hosts(ptr);
++    if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS))
++      update_live_host_indices(ptr);
+     break;
+   case MEMCACHED_DISTRIBUTION_RANDOM:
++    if (memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS))
++      update_live_host_indices(ptr);
+     break;
+   default:
+     WATCHPOINT_ASSERT(0); /* We have added a distribution without extending the logic */
+@@ -85,6 +90,46 @@ static uint32_t ketama_server_hash(const char *key, unsigned int key_length, int
+     | (results[0 + alignment * 4] & 0xFF);
+ }
+ 
++memcached_return update_live_host_indices(memcached_st *ptr)
++{
++  uint32_t host_index;
++  struct timeval now;
++  uint32_t i = 0;
++  memcached_server_st *list;
++
++  if (gettimeofday(&now, NULL) != 0)
++  {
++    ptr->cached_errno = errno;
++    return MEMCACHED_ERRNO;
++  }
++
++  if (ptr->live_host_indices == NULL) {
++    ptr->live_host_indices = (uint32_t *)ptr->call_malloc(ptr, sizeof(uint32_t) * ptr->number_of_live_hosts);
++    ptr->live_host_indices_size = ptr->number_of_live_hosts;
++  }
++
++  /* somehow we added some hosts.  Shouldn't get here much, if at all. */
++  if (ptr->live_host_indices_size < ptr->number_of_hosts ) {
++    ptr->live_host_indices = (uint32_t *)ptr->call_realloc(ptr, ptr->live_host_indices,  sizeof(uint32_t) * ptr->number_of_live_hosts);
++    ptr->live_host_indices_size = ptr->number_of_live_hosts;
++  }
++
++  if (ptr->live_host_indices == NULL)
++    return MEMCACHED_FAILURE;
++
++  list = ptr->hosts;
++  for (host_index= 0; host_index < ptr->number_of_hosts; ++host_index)
++    {
++      if (list[host_index].next_retry <= now.tv_sec) {
++        ptr->live_host_indices[i++] = host_index;
++      } else if (ptr->next_distribution_rebuild == 0 || list[host_index].next_retry < ptr->next_distribution_rebuild) {
++          ptr->next_distribution_rebuild= list[host_index].next_retry;
++      }
++    }
++  ptr->number_of_live_hosts = i;
++  return MEMCACHED_SUCCESS;
++}
++
+ static int continuum_item_cmp(const void *t1, const void *t2)
+ {
+   memcached_continuum_item_st *ct1= (memcached_continuum_item_st *)t1;
+@@ -111,8 +156,8 @@ memcached_return update_continuum(memcached_st *ptr)
+   uint32_t pointer_per_server= MEMCACHED_POINTS_PER_SERVER;
+   uint32_t pointer_per_hash= 1;
+   uint64_t total_weight= 0;
+-  uint64_t is_ketama_weighted= 0;
+-  uint64_t is_auto_ejecting= 0;
++  uint32_t is_ketama_weighted= 0;
++  uint32_t is_auto_ejecting= 0;
+   uint32_t points_per_server= 0;
+   uint32_t live_servers= 0;
+   struct timeval now;
+diff --git a/libmemcached-0.32/libmemcached/memcached_storage.c b/libmemcached/libmemcached/memcached_storage.c
+index ecefc56..ee79a7e 100644
+--- a/libmemcached-0.32/libmemcached/memcached_storage.c
++++ b/libmemcached/libmemcached/memcached_storage.c
+@@ -135,22 +135,16 @@ static inline memcached_return memcached_send(memcached_st *ptr,
+   }
+ 
+   if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
+-  {
+-    rc= MEMCACHED_WRITE_FAILURE;
+-    goto error;
+-  }
++    return MEMCACHED_WRITE_FAILURE;
+ 
+   /* Send command header */
+   rc=  memcached_do(&ptr->hosts[server_key], buffer, write_length, 0);
+   if (rc != MEMCACHED_SUCCESS)
+-    goto error;
++    return rc;
+ 
+   /* Send command body */
+   if ((sent_length= memcached_io_write(&ptr->hosts[server_key], value, value_length, 0)) == -1)
+-  {
+-    rc= MEMCACHED_WRITE_FAILURE;
+-    goto error;
+-  }
++    return MEMCACHED_WRITE_FAILURE;
+ 
+   if ((ptr->flags & MEM_BUFFER_REQUESTS) && verb == SET_OP)
+     to_write= 0;
+@@ -158,10 +152,7 @@ static inline memcached_return memcached_send(memcached_st *ptr,
+     to_write= 1;
+ 
+   if ((sent_length= memcached_io_write(&ptr->hosts[server_key], "\r\n", 2, to_write)) == -1)
+-  {
+-    rc= MEMCACHED_WRITE_FAILURE;
+-    goto error;
+-  }
++    return MEMCACHED_WRITE_FAILURE;
+ 
+   if (ptr->flags & MEM_NOREPLY)
+     return (to_write == 0) ? MEMCACHED_BUFFERED : MEMCACHED_SUCCESS;
+@@ -170,15 +161,8 @@ static inline memcached_return memcached_send(memcached_st *ptr,
+     return MEMCACHED_BUFFERED;
+ 
+   rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+-
+   if (rc == MEMCACHED_STORED)
+-    return MEMCACHED_SUCCESS;
+-  else 
+-    return rc;
+-
+-error:
+-  memcached_io_reset(&ptr->hosts[server_key]);
+-
++    return MEMCACHED_SUCCESS;  
+   return rc;
+ }