memcached 0.16.3 → 0.17

data/ext/rlibmemcached_wrap.c

@@ -6486,181 +6486,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_MemcachedSt_number_of_live_hosts_set(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  uint32_t arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_live_hosts", 1, self )); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  {
-    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","number_of_live_hosts", 2, argv[0] )); 
-    }  
-    if (!argp2) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","number_of_live_hosts", 2, argv[0]));
-    } else {
-      arg2 = *((uint32_t *)(argp2));
-    }
-  }
-  if (arg1) (arg1)->number_of_live_hosts = arg2;
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedSt_number_of_live_hosts_get(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  uint32_t result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","number_of_live_hosts", 1, self )); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  result =  ((arg1)->number_of_live_hosts);
-  {
-    vresult = UINT2NUM(result);
-  }
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedSt_live_host_indices_set(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  uint32_t *arg2 = (uint32_t *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices", 1, self )); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_uint32_t, SWIG_POINTER_DISOWN |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t *","live_host_indices", 2, argv[0] )); 
-  }
-  arg2 = (uint32_t *)(argp2);
-  if (arg1) (arg1)->live_host_indices = arg2;
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedSt_live_host_indices_get(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  uint32_t *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices", 1, self )); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  result = (uint32_t *) ((arg1)->live_host_indices);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint32_t, 0 |  0 );
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedSt_live_host_indices_size_set(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  uint32_t arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices_size", 1, self )); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  {
-    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_uint32_t,  0 );
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "uint32_t","live_host_indices_size", 2, argv[0] )); 
-    }  
-    if (!argp2) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "uint32_t","live_host_indices_size", 2, argv[0]));
-    } else {
-      arg2 = *((uint32_t *)(argp2));
-    }
-  }
-  if (arg1) (arg1)->live_host_indices_size = arg2;
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_MemcachedSt_live_host_indices_size_get(int argc, VALUE *argv, VALUE self) {
-  struct memcached_st *arg1 = (struct memcached_st *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  uint32_t result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_memcached_st, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct memcached_st *","live_host_indices_size", 1, self )); 
-  }
-  arg1 = (struct memcached_st *)(argp1);
-  result =  ((arg1)->live_host_indices_size);
-  {
-    vresult = UINT2NUM(result);
-  }
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
 _wrap_MemcachedSt_allocate(VALUE self) {
@@ -12607,7 +12432,7 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   
   SWIG_RubyInitializeTrackings();
   rb_define_const(mRlibmemcached, "MEMCACHED_VERSION_STRING_LENGTH", SWIG_From_int((int)(24)));
-  rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.31"));
+  rb_define_const(mRlibmemcached, "LIBMEMCACHED_VERSION_STRING", SWIG_FromCharPtr("0.32"));
   
   cMemcachedAnalysisSt.klass = rb_define_class_under(mRlibmemcached, "MemcachedAnalysisSt", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_memcached_analysis_st, (void *) &cMemcachedAnalysisSt);
@@ -12769,12 +12594,6 @@ SWIGEXPORT void Init_rlibmemcached(void) {
   rb_define_method(cMemcachedSt.klass, "prefix_key", _wrap_MemcachedSt_prefix_key_get, -1);
   rb_define_method(cMemcachedSt.klass, "number_of_replicas=", _wrap_MemcachedSt_number_of_replicas_set, -1);
   rb_define_method(cMemcachedSt.klass, "number_of_replicas", _wrap_MemcachedSt_number_of_replicas_get, -1);
-  rb_define_method(cMemcachedSt.klass, "number_of_live_hosts=", _wrap_MemcachedSt_number_of_live_hosts_set, -1);
-  rb_define_method(cMemcachedSt.klass, "number_of_live_hosts", _wrap_MemcachedSt_number_of_live_hosts_get, -1);
-  rb_define_method(cMemcachedSt.klass, "live_host_indices=", _wrap_MemcachedSt_live_host_indices_set, -1);
-  rb_define_method(cMemcachedSt.klass, "live_host_indices", _wrap_MemcachedSt_live_host_indices_get, -1);
-  rb_define_method(cMemcachedSt.klass, "live_host_indices_size=", _wrap_MemcachedSt_live_host_indices_size_set, -1);
-  rb_define_method(cMemcachedSt.klass, "live_host_indices_size", _wrap_MemcachedSt_live_host_indices_size_get, -1);
   cMemcachedSt.mark = 0;
   cMemcachedSt.destroy = (void (*)(void *)) memcached_free;
   cMemcachedSt.trackObjects = 0;

data/lib/memcached.rb

@@ -20,9 +20,8 @@ require 'rlibmemcached'
 
 class Memcached
   Lib = Rlibmemcached
-  REQUIRED_VERSION = File.read("#{File.dirname(__FILE__)}/../COMPATIBILITY")[/:: ([\d\.]+)/, 1]
-  RECEIVED_VERSION = Lib.memcached_lib_version
-  raise "libmemcached #{REQUIRED_VERSION} required; you somehow linked to #{RECEIVED_VERSION}." unless REQUIRED_VERSION == RECEIVED_VERSION
+  raise "libmemcached 0.32 required; you somehow linked to #{Lib.memcached_lib_version}." unless "0.32" == Lib.memcached_lib_version
+  VERSION = File.read("#{File.dirname(__FILE__)}/../CHANGELOG")[/v([\d\.]+)\./, 1]
 end
 
 require 'memcached/integer'

data/lib/memcached/memcached.rb

@@ -78,7 +78,7 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
 
 =end
 
-  def initialize(servers, opts = {})
+  def initialize(servers = "localhost:11211", opts = {})
     @struct = Lib::MemcachedSt.new
     Lib.memcached_create(@struct)
 
@@ -104,8 +104,8 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
     end
 
     # Read timeouts
-    options[:rcv_timeout] ||= options[:timeout]
-    options[:poll_timeout] ||= options[:timeout]
+    options[:rcv_timeout] ||= options[:timeout] || 0
+    options[:poll_timeout] ||= options[:timeout] || 0
 
     # Set the behaviors on the struct
     set_behaviors
@@ -126,6 +126,31 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
     end
   end
 
+  # Set the server list.
+  # FIXME Does not necessarily free any existing server structs.
+  def set_servers(servers)
+    Array(servers).each_with_index do |server, index|
+      # Socket
+      if server.is_a?(String) and File.socket?(server)
+        args = [@struct, server, options[:default_weight].to_i]
+        check_return_code(Lib.memcached_server_add_unix_socket_with_weight(*args))
+      # Network
+      elsif server.is_a?(String) and server =~ /^[\w\d\.-]+(:\d{1,5}){0,2}$/
+        host, port, weight = server.split(":")
+        args = [@struct, host, port.to_i, (weight || options[:default_weight]).to_i]                
+        if options[:use_udp] #
+          check_return_code(Lib.memcached_server_add_udp_with_weight(*args))
+        else
+          check_return_code(Lib.memcached_server_add_with_weight(*args))
+        end
+      else
+        raise ArgumentError, "Servers must be either in the format 'host:port[:weight]' (e.g., 'localhost:11211' or  'localhost:11211:10') for a network server, or a valid path to a Unix domain socket (e.g., /var/run/memcached)."
+      end
+    end
+    # For inspect
+    @servers = send(:servers)
+  end
+
   # Return the array of server strings used to configure this instance.
   def servers
     server_structs.map do |server|
@@ -427,30 +452,6 @@ Please note that when pipelining is enabled, setter and deleter methods do not r
     inspect_server(server) if server
   end
 
-  # Set the servers on the struct.
-  def set_servers(servers)
-    Array(servers).each_with_index do |server, index|
-      # Socket
-      if server.is_a?(String) and File.socket?(server)
-        args = [@struct, server, options[:default_weight].to_i]
-        check_return_code(Lib.memcached_server_add_unix_socket_with_weight(*args))
-      # Network
-      elsif server.is_a?(String) and server =~ /^[\w\d\.-]+(:\d{1,5}){0,2}$/
-        host, port, weight = server.split(":")
-        args = [@struct, host, port.to_i, (weight || options[:default_weight]).to_i]                
-        if options[:use_udp] #
-          check_return_code(Lib.memcached_server_add_udp_with_weight(*args))
-        else
-          check_return_code(Lib.memcached_server_add_with_weight(*args))
-        end
-      else
-        raise ArgumentError, "Servers must be either in the format 'host:port[:weight]' (e.g., 'localhost:11211' or  'localhost:11211:10') for a network server, or a valid path to a Unix domain socket (e.g., /var/run/memcached)."
-      end
-    end
-    # For inspect
-    @servers = send(:servers)
-  end
-
   # Set the behaviors on the struct from the current options.
   def set_behaviors
     BEHAVIORS.keys.each do |behavior|

data/lib/memcached/rails.rb

@@ -1,13 +1,14 @@
-
 class Memcached
 
-  alias :get_multi :get #:nodoc:
+  (instance_methods - NilClass.instance_methods).each do |method_name|
+    eval("alias :'#{method_name}_orig' :'#{method_name}'")
+  end
 
   # A legacy compatibility wrapper for the Memcached class. It has basic compatibility with the <b>memcache-client</b> API.
   class Rails < ::Memcached
-    
-    DEFAULTS = {}
-         
+
+    alias :servers= :set_servers
+
     # See Memcached#new for details.
     def initialize(*args)
       opts = args.last.is_a?(Hash) ? args.pop : {}
@@ -16,10 +17,10 @@ class Memcached
       ).flatten.compact
 
       opts[:prefix_key] ||= opts[:namespace]
-      super(servers, DEFAULTS.merge(opts))      
+      super(servers, opts)
     end
-    
-    # Wraps Memcached#get so that it doesn't raise. This has the side-effect of preventing you from 
+
+    # Wraps Memcached#get so that it doesn't raise. This has the side-effect of preventing you from
     # storing <tt>nil</tt> values.
     def get(key, raw=false)
       super(key, !raw)
@@ -29,56 +30,68 @@ class Memcached
     # Wraps Memcached#cas so that it doesn't raise. Doesn't set anything if no value is present.
     def cas(key, ttl=@default_ttl, raw=false, &block)
       super(key, ttl, !raw, &block)
-    rescue NotFound    
+    rescue NotFound
     end
-    
-    alias :compare_and_swap :cas    
-    
+
+    alias :compare_and_swap :cas
+
     # Wraps Memcached#get.
     def get_multi(keys, raw=false)
-      super(keys, !raw)
+      get_orig(keys, !raw)
     end
-    
+
     # Wraps Memcached#set.
     def set(key, value, ttl=@default_ttl, raw=false)
       super(key, value, ttl, !raw)
     end
 
-    # Wraps Memcached#add so that it doesn't raise. 
+    # Wraps Memcached#add so that it doesn't raise.
     def add(key, value, ttl=@default_ttl, raw=false)
       super(key, value, ttl, !raw)
       true
     rescue NotStored
-      false    
+      false
     end
-    
-    # Wraps Memcached#delete so that it doesn't raise. 
+
+    # Wraps Memcached#delete so that it doesn't raise.
     def delete(key)
       super
     rescue NotFound
     end
-    
-    # Wraps Memcached#incr so that it doesn't raise. 
+
+    # Wraps Memcached#incr so that it doesn't raise.
     def incr(*args)
       super
     rescue NotFound
     end
 
-    # Wraps Memcached#decr so that it doesn't raise. 
+    # Wraps Memcached#decr so that it doesn't raise.
     def decr(*args)
       super
     rescue NotFound
     end
-    
+
+    # Wraps Memcached#append so that it doesn't raise.
+    def append(*args)
+      super
+    rescue NotStored
+    end
+
+    # Wraps Memcached#prepend so that it doesn't raise.
+    def prepend(*args)
+      super
+    rescue NotStored
+    end
+
     # Namespace accessor.
     def namespace
       options[:prefix_key]
     end
-    
+
     alias :flush_all :flush
 
     alias :"[]" :get
-    alias :"[]=" :set    
-    
+    alias :"[]=" :set
+
   end
 end

data/memcached.gemspec

@@ -2,17 +2,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{memcached}
-  s.version = "0.16.3"
+  s.version = "0.17"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Evan Weaver"]
   s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
-  s.date = %q{2009-09-04}
+  s.date = %q{2009-09-21}
   s.description = %q{An interface to the libmemcached C client.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]
-  s.extra_rdoc_files = ["BENCHMARKS", "CHANGELOG", "COMPATIBILITY", "lib/memcached/behaviors.rb", "lib/memcached/exceptions.rb", "lib/memcached/memcached.rb", "lib/memcached/rails.rb", "lib/memcached.rb", "LICENSE", "README", "TODO"]
-  s.files = ["BENCHMARKS", "CHANGELOG", "COMPATIBILITY", "ext/extconf.rb", "ext/libmemcached-0.31.tar.gz", "ext/rlibmemcached.i", "ext/rlibmemcached_wrap.c", "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", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/binding_test.rb", "test/unit/memcached_test.rb", "test/unit/rails_test.rb", "TODO", "memcached.gemspec"]
+  s.extra_rdoc_files = ["BENCHMARKS", "CHANGELOG", "LICENSE", "README", "TODO", "lib/memcached.rb", "lib/memcached/behaviors.rb", "lib/memcached/exceptions.rb", "lib/memcached/memcached.rb", "lib/memcached/rails.rb"]
+  s.files = ["BENCHMARKS", "CHANGELOG", "LICENSE", "Manifest", "README", "Rakefile", "TODO", "ext/extconf.rb", "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", "test/profile/benchmark.rb", "test/profile/profile.rb", "test/profile/valgrind.rb", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/binding_test.rb", "test/unit/memcached_test.rb", "test/unit/rails_test.rb", "memcached.gemspec"]
   s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/memcached/}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Memcached", "--main", "README"]
   s.require_paths = ["lib", "ext"]

data/test/profile/benchmark.rb

@@ -9,506 +9,202 @@ require 'rubygems'
 require 'ruby-debug' if ENV['DEBUG']
 begin; require 'memory'; rescue LoadError; end
 
-ARGV << "--with-memcached" << "--with-memcache-client" if ARGV.join !~ /--with/
-
 puts `uname -a`
 puts "Ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
 
-ARGV.each do |flag|
-  require_name = flag[/--with-(\w+)/, 1]
-  gem_name = flag[/--with-(.*)$/, 1]
-  begin
-    require require_name
-    gem gem_name
-    puts "Loaded #{$1} #{Gem.loaded_specs[gem_name].version.to_s rescue nil}"
-  rescue LoadError
-  end
+[ ["memcached", "memcached"], 
+  ["binary42-remix-stash", "remix/stash"], 
+  # ["astro-remcached", "remcached"], # Clobbers the "Memcached" constant
+  ["memcache-client", "memcache"]].each do |gem_name, requirement|
+  require requirement
+  gem gem_name
+  puts "Loaded #{gem_name} #{Gem.loaded_specs[gem_name].version.to_s rescue nil}"
 end
 
-recursion = ARGV.grep(/--recursion/).first[/(\d+)/, 1].to_i rescue 0
+class Remix::Stash
+  # Remix::Stash API doesn't let you set servers
+  @@clusters = {:default => Remix::Stash::Cluster.new(['127.0.0.1:43042', '127.0.0.1:43043'])}
+end
 
 class Bench
 
-  def initialize(recursion)
-
-    @recursion = recursion
-    puts "Recursion level is #{@recursion}"
+  def initialize(loops = nil, stack_depth = nil)
+    @loops = (loops || 20000).to_i
+    @stack_depth = (stack_depth || 0).to_i
     
-    # We'll use a simple @value to try to avoid spending time in Marshal,
-    # which is a constant penalty that both clients have to pay
-    @value = []
-    @marshalled = Marshal.dump(@value)
+    puts "Loops is #{@loops}"
+    puts "Stack depth is #{@stack_depth}"
+        
+    @m_value = Marshal.dump(
+      @small_value = ["testing"])    
+    @m_large_value = Marshal.dump(
+      @large_value = [{"test" => "1", "test2" => "2", Object.new => "3", 4 => 4, "test5" => 2**65}] * 2048)
+
+    puts "Small value size is: #{@m_value.size} bytes"
+    puts "Large value size is: #{@m_large_value.size} bytes"
+
+    @keys = [
+      @k1 = "Short",
+      @k2 = "Sym1-2-3::45" * 8,
+      @k3 = "Long" * 40,
+      @k4 = "Medium" * 8,
+      @k5 = "Medium2" * 8,
+      @k6 = "Long3" * 40]
     
-    @opts_networked = [
-      ['127.0.0.1:43042', '127.0.0.1:43043'],
-      {:buffer_requests => false, :no_block => false, :namespace => "namespace"}
-    ]
-    @opt_unix = [
-      ["#{UNIX_SOCKET_NAME}0","#{UNIX_SOCKET_NAME}1"],
-      {:buffer_requests => false, :no_block => false, :namespace => "namespace"}
-    ]
-    @key1 = "Short"
-    @key2 = "Sym1-2-3::45"*8
-    @key3 = "Long"*40
-    @key4 = "Medium"*8
-    # 5 and 6 are only used for multiget miss test
-    @key5 = "Medium2"*8 
-    @key6 = "Long3"*40 
+    reset_servers
+    reset_clients
     
-    system("ruby #{HERE}/../setup.rb")
-    sleep(1)
+    Benchmark.bm(36) do |x| 
+      @benchmark = x 
+    end
   end
 
-  def run(level = @recursion)
-    level > 0 ? run(level - 1) : benchmark
+  def run(level = @stack_depth)
+    level > 0 ? run(level - 1) : run_without_recursion
   end
   
   private
   
-  def benchmark    
-    Benchmark.bm(35) do |x|
-    
-      n = (ENV["LOOPS"] || 10000).to_i
-    
-      if defined? Memcached
-        @m = Memcached.new(
-        @opts_networked[0],
-        @opts_networked[1].merge(:no_block => true, :buffer_requests => true)
-        )
-        x.report("set:plain:noblock:memcached:net") do
-          n.times do
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-          end
-        end
-        @m = Memcached.new(
-        @opt_unix[0],
-        @opt_unix[1].merge(:no_block => true, :buffer_requests => true)
-        )
-        x.report("set:plain:noblock:memcached:uds") do
-          n.times do
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-          end
-        end
-        @m = Memcached.new(*@opts_networked)
-        x.report("set:plain:memcached:net") do
-          n.times do
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-          end
-        end # if false
-        @m = Memcached.new(*@opt_unix)
-        x.report("set:plain:memcached:uds") do
-          n.times do
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-            @m.set @key1, @marshalled, 0, false
-            @m.set @key2, @marshalled, 0, false
-            @m.set @key3, @marshalled, 0, false
-          end
-        end
-      end
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("set:plain:memcache-client") do
-          n.times do
-            @m.set @key1, @marshalled, 0, true
-            @m.set @key2, @marshalled, 0, true
-            @m.set @key3, @marshalled, 0, true
-            @m.set @key1, @marshalled, 0, true
-            @m.set @key2, @marshalled, 0, true
-            @m.set @key3, @marshalled, 0, true
-          end
-        end
-      end
-    
-      if defined? Memcached
-        @m = Memcached.new(
-        @opts_networked[0],
-        @opts_networked[1].merge(:no_block => true, :buffer_requests => true)
-        )
-        x.report("set:ruby:noblock:memcached:net") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-          end
-        end
-        @m = Memcached.new(
-        @opt_unix[0],
-        @opt_unix[1].merge(:no_block => true, :buffer_requests => true)
-        )
-        x.report("set:ruby:noblock:memcached:uds") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-          end
-        end
-        @m = Memcached.new(*@opts_networked)
-        x.report("set:ruby:memcached:net") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-          end
-        end # if false
-        @m = Memcached.new(*@opt_unix)
-        x.report("set:ruby:memcached:uds") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-          end
-        end
-      end
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("set:ruby:memcache-client") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-          end
-        end
+  def reset_servers
+    system("ruby #{HERE}/../setup.rb")
+    sleep(1)
+  end
+  
+  def reset_clients
+    @clients = {
+       "libm" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+       "libm:noblock" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :no_block => true, :buffer_requests => true, :namespace => "namespace"),
+       "libm:udp" => Memcached::Rails.new(
+         ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"],
+         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+       "libm:binary" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :buffer_requests => false, :no_block => false, :namespace => "namespace", :binary_protocol => true),
+       "libm:noblock_binary" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :no_block => true, :buffer_requests => true, :namespace => "namespace", :binary_protocol => true),
+       "ruby" => MemCache.new(['127.0.0.1:43042', '127.0.0.1:43043'], :namespace => "namespace"),
+       "stash" => Remix::Stash.new(:root)}
+  end
+  
+  
+  def benchmark_clients(test_name, clients = @clients)
+    clients.keys.sort.each do |client_name|
+      next if client_name == "stash" and test_name == "set-large" # Don't let stash break the world
+      client = clients[client_name]
+      begin
+        yield client
+        @benchmark.report("#{test_name}:#{client_name}") { @loops.times { yield client } }
+      rescue => e
+        # puts "#{test_name}:#{client_name} => #{e.class}"
+        # reset_clients
+      end
+    end
+  end
+  
+  def benchmark_hashes(hashes, test_name)
+    hashes.each do |hash_name, int|
+      @m = Memcached::Rails.new(:hash => hash_name)
+      @benchmark.report("#{test_name}:#{hash_name}") do
+        @loops.times { yield int }
       end
+    end  
+  end
+  
+  def run_without_recursion
+    benchmark_clients("set") do |c|
+      c.set @k1, @m_value, 0, true
+      c.set @k2, @m_value, 0, true
+      c.set @k3, @m_value, 0, true
+    end
+
+    benchmark_clients("get") do |c|
+      c.get @k1, true
+      c.get @k2, true
+      c.get @k3, true
+    end
     
-      if defined? Memcached
-        @m = Memcached.new(*@opts_networked)
-        x.report("get:plain:memcached:net") do
-          n.times do
-            @m.get @key1, false
-            @m.get @key2, false
-            @m.get @key3, false
-            @m.get @key1, false
-            @m.get @key2, false
-            @m.get @key3, false
-          end
-        end
-        @m = Memcached.new(*@opt_unix)
-        x.report("get:plain:memcached:uds") do
-          n.times do
-            @m.get @key1, false
-            @m.get @key2, false
-            @m.get @key3, false
-            @m.get @key1, false
-            @m.get @key2, false
-            @m.get @key3, false
-          end
-        end
-      end
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("get:plain:memcache-client") do
-          n.times do
-            @m.get @key1, true
-            @m.get @key2, true
-            @m.get @key3, true
-            @m.get @key1, true
-            @m.get @key2, true
-            @m.get @key3, true
-          end
-        end
-      end
+    benchmark_clients("get-multi") do |c|
+      c.get_multi @keys, true
+    end
     
-      if defined? Memcached
-        @m = Memcached.new(*@opts_networked)
-        x.report("get:ruby:memcached:net") do
-          n.times do
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-          end
-        end
-        @m = Memcached.new(*@opt_unix)
-        x.report("get:ruby:memcached:uds") do
-          n.times do
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-          end
-        end
-      end
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("get:ruby:memcache-client") do
-          n.times do
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-          end
-        end
-      end
-
-      if defined? Memcached
-        @m = Memcached.new(*@opts_networked)
-
-        # Avoid rebuilding the array every request
-        keys = [@key1, @key2, @key3, @key4, @key5, @key6]
-
-        x.report("multiget:ruby:memcached:net") do
-          n.times do
-            @m.get keys
-          end
-        end
-        @m = Memcached.new(*@opt_unix)
-
-        # Avoid rebuilding the array every request
-        keys = [@key1, @key2, @key3, @key4, @key5, @key6]
-
-        x.report("multiget:ruby:memcached:uds") do
-          n.times do
-            @m.get keys
-          end
-        end
-      end
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("multiget:ruby:memcache-client") do
-          n.times do
-            # We don't use the keys array because splat is slow
-            @m.get_multi @key1, @key2, @key3, @key4, @key5, @key6
-          end
-        end
-      end
+    benchmark_clients("append") do |c|
+      c.append @k1, @m_value
+      c.append @k2, @m_value
+      c.append @k3, @m_value
+    end    
     
-      if defined? Memcached
-        @m = Memcached.new(*@opts_networked)
-        x.report("get-miss:ruby:memcached:net") do
-          n.times do
-            begin @m.delete @key1; rescue Memcached::NotFound; end
-            begin @m.delete @key2; rescue Memcached::NotFound; end
-            begin @m.delete @key3; rescue Memcached::NotFound; end
-            begin @m.get @key1; rescue Memcached::NotFound; end
-            begin @m.get @key2; rescue Memcached::NotFound; end
-            begin @m.get @key3; rescue Memcached::NotFound; end
-          end
-        end
-        @m = Memcached.new(*@opt_unix)
-        x.report("get-miss:ruby:memcached:uds") do
-          n.times do
-            begin @m.delete @key1; rescue Memcached::NotFound; end
-            begin @m.delete @key2; rescue Memcached::NotFound; end
-            begin @m.delete @key3; rescue Memcached::NotFound; end
-            begin @m.get @key1; rescue Memcached::NotFound; end
-            begin @m.get @key2; rescue Memcached::NotFound; end
-            begin @m.get @key3; rescue Memcached::NotFound; end
-          end
-        end
-      end      
-
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("get-miss:ruby:memcache-client") do
-          n.times do
-            begin @m.delete @key1; rescue; end
-            begin @m.delete @key2; rescue; end
-            begin @m.delete @key3; rescue; end
-            begin @m.get @key1; rescue; end
-            begin @m.get @key2; rescue; end
-            begin @m.get @key3; rescue; end
-          end
-        end
-      end
-      
-      if defined? Memcached
-        @m = Memcached.new(*@opts_networked)
-        x.report("append-miss:ruby:memcached:net") do
-          n.times do
-            begin @m.delete @key1; rescue Memcached::NotFound; end
-            begin @m.delete @key2; rescue Memcached::NotFound; end
-            begin @m.delete @key3; rescue Memcached::NotFound; end
-            begin @m.append @key1, @value; rescue Memcached::NotStored; end
-            begin @m.append @key2, @value; rescue Memcached::NotStored; end
-            begin @m.append @key3, @value; rescue Memcached::NotStored; end
-          end
-        end
-        @m = Memcached.new(*@opt_unix)
-        x.report("append-miss:ruby:memcached:uds") do
-          n.times do
-            begin @m.delete @key1; rescue Memcached::NotFound; end
-            begin @m.delete @key2; rescue Memcached::NotFound; end
-            begin @m.delete @key3; rescue Memcached::NotFound; end
-            begin @m.append @key1, @value; rescue Memcached::NotStored; end
-            begin @m.append @key2, @value; rescue Memcached::NotStored; end
-            begin @m.append @key3, @value; rescue Memcached::NotStored; end
-          end
-        end
-      end
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("append-miss:ruby:memcache-client") do
-          n.times do
-            begin @m.delete @key1; rescue; end
-            begin @m.delete @key2; rescue; end
-            begin @m.delete @key3; rescue; end
-            begin @m.append @key1, @value; rescue; end
-            begin @m.append @key2, @value; rescue; end
-            begin @m.append @key3, @value; rescue; end
-          end
-        end
-      end
-                      
-      if defined? Memcached
-        @m = Memcached.new(
-        @opts_networked[0],
-        @opts_networked[1].merge(:no_block => true, :buffer_requests => true)
-        )
-        x.report("mixed:ruby:noblock:memcached:net") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.set @key1, @value
-            @m.get @key1
-            @m.set @key2, @value
-            @m.get @key2
-            @m.set @key3, @value
-            @m.get @key3
-          end
-        end
-        @m = Memcached.new(
-        @opt_unix[0],
-        @opt_unix[1].merge(:no_block => true, :buffer_requests => true)
-        )
-        x.report("mixed:ruby:noblock:memcached:uds") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.set @key1, @value
-            @m.get @key1
-            @m.set @key2, @value
-            @m.get @key2
-            @m.set @key3, @value
-            @m.get @key3
-          end
-        end
-        @m = Memcached.new(*@opts_networked)
-        x.report("mixed:ruby:memcached:net") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.set @key1, @value
-            @m.get @key1
-            @m.set @key2, @value
-            @m.get @key2
-            @m.set @key3, @value
-            @m.get @key3
-          end
-        end # if false
-        @m = Memcached.new(*@opt_unix)
-        x.report("mixed:ruby:memcached:uds") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.set @key1, @value
-            @m.get @key1
-            @m.set @key2, @value
-            @m.get @key2
-            @m.set @key3, @value
-            @m.get @key3
-          end
-        end # if false
-      end
-      if defined? MemCache
-        @m = MemCache.new(*@opts_networked)
-        x.report("mixed:ruby:memcache-client") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.set @key1, @value
-            @m.get @key1
-            @m.set @key2, @value
-            @m.get @key2
-            @m.set @key3, @value
-            @m.get @key3
-          end
-        end
-      end
+    benchmark_clients("delete") do |c|    
+      c.delete @k1
+      c.delete @k2
+      c.delete @k3
+    end
     
-      if defined? Memcached
-        unless ARGV.include? "--no-hash"
-          Memcached::HASH_VALUES.each do |mode, int|
-            @m = Memcached.new(@opt_unix[0], @opt_unix[1].merge(:hash => mode))
-            x.report("hash:#{mode}") do
-              n.times do
-                Rlibmemcached.memcached_generate_hash_rvalue(@key1, int)
-                Rlibmemcached.memcached_generate_hash_rvalue(@key2, int)
-                Rlibmemcached.memcached_generate_hash_rvalue(@key3, int)
-                Rlibmemcached.memcached_generate_hash_rvalue(@key4, int)
-                Rlibmemcached.memcached_generate_hash_rvalue(@key5, int)
-                Rlibmemcached.memcached_generate_hash_rvalue(@key6, int)
-              end
-            end
-          end
-        end
-      end
-
-    end    
+    benchmark_clients("get-missing") do |c|
+      c.get @k1
+      c.get @k2
+      c.get @k3
+    end
+
+    benchmark_clients("append-missing") do |c|
+      c.append @k1, @m_value
+      c.append @k2, @m_value
+      c.append @k3, @m_value
+    end
+
+    benchmark_clients("set-large") do |c|
+      c.set @k1, @m_large_value, 0, true
+      c.set @k2, @m_large_value, 0, true
+      c.set @k3, @m_large_value, 0, true
+    end
+
+    benchmark_clients("get-large") do |c|
+      c.get @k1, true
+      c.get @k2, true
+      c.get @k3, true
+    end
+
+    benchmark_clients("set-ruby") do |c|
+      c.set @k1, @value
+      c.set @k2, @value
+      c.set @k3, @value
+    end
+
+    benchmark_clients("get-ruby") do |c|
+      c.get @k1
+      c.get @k2
+      c.get @k3
+    end
+
+    benchmark_clients("set-ruby-large") do |c|
+      c.set @k1, @large_value
+      c.set @k2, @large_value
+      c.set @k3, @large_value
+    end
+
+    benchmark_clients("get-ruby-large") do |c|
+      c.get @k1
+      c.get @k2
+      c.get @k3
+    end
+     
+    benchmark_hashes(Memcached::HASH_VALUES, "hash") do |i|
+      Rlibmemcached.memcached_generate_hash_rvalue(@k1, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k2, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k3, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k4, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k5, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k6, i)    
+    end
   end
 end
 
-Bench.new(recursion).run
+Bench.new(ENV["LOOPS"], ENV["STACK_DEPTH"]).run
 
-if Process.respond_to? :memory
-  Process.memory.each do |key, value|
-    puts "#{key}: #{value/1024.0}M"
-  end
-end
+Process.memory.each do |key, value|
+  puts "#{key}: #{value/1024.0}M"
+end if Process.respond_to? :memory