memcached-northscale 0.19.5.2

data/lib/memcached/rails.rb

@@ -0,0 +1,164 @@
+class Memcached
+
+  (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 = {
+      :logger => nil,
+      :string_return_types => false
+    }
+
+    attr_reader :logger
+
+    alias :servers= :set_servers
+
+    # See Memcached#new for details.
+    def initialize(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      servers = Array(
+        args.any? ? args.unshift : opts.delete(:servers)
+      ).flatten.compact
+
+      opts[:prefix_key] ||= opts[:namespace]
+      @logger = opts[:logger]
+      logger.info { "memcached #{VERSION} #{servers.inspect}" } if logger
+      super(servers, opts)
+    end
+
+    def servers
+      server_structs.map do |server|
+        Server.new server
+      end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # 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)
+    rescue
+    end
+
+    # Alternative to #get. Accepts a key and an optional options hash supporting the single option
+    # :raw.
+    def read(key, options = {})
+      get(key, options[:raw])
+    end
+
+    # 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)
+      true
+    rescue
+      false
+    end
+
+    alias :compare_and_swap :cas
+
+    # Wraps Memcached#get.
+    def get_multi(keys, raw=false)
+      get_orig(keys, !raw)
+    end
+
+    # Wraps Memcached#set.
+    def set(key, value, ttl=@default_ttl, raw=false)
+      super(key, value, ttl, !raw)
+      true
+    rescue
+      false
+    end
+
+    # Alternative to #set. Accepts a key, value, and an optional options hash supporting the 
+    # options :raw and :ttl.
+    def write(key, value, options = {})
+      set(key, value, options[:ttl] || @default_ttl, options[:raw])
+    end
+
+    # Wraps Memcached#add so that it doesn't raise.
+    def add(key, value, ttl=@default_ttl, raw=false)
+      super(key, value, ttl, !raw)
+      # This causes me physical pain.
+      opts[:string_return_types] ? "STORED\r\n" : true
+    rescue NotStored # This can still throw exceptions. What's the right behavior if the
+                     # server goes away?
+      opts[:string_return_types] ? "NOT STORED\r\n" : false
+    end
+
+    # Wraps Memcached#delete so that it doesn't raise.
+    def delete(key, expiry=0)
+      super(key)
+    rescue
+    end
+
+    # Wraps Memcached#incr so that it doesn't raise.
+    def incr(*args)
+      super
+    rescue
+    end
+
+    # Wraps Memcached#decr so that it doesn't raise.
+    def decr(*args)
+      super
+    rescue
+    end
+
+    # Wraps Memcached#append so that it doesn't raise.
+    def append(*args)
+      super
+    rescue
+    end
+
+    # Wraps Memcached#prepend so that it doesn't raise.
+    def prepend(*args)
+      super
+    rescue
+    end
+
+    alias :flush_all :flush
+
+    alias :"[]" :get
+    alias :"[]=" :set
+
+  end
+
+  class Server
+    def initialize(struct)
+      @struct = struct
+    end
+
+    def host
+      @struct.hostname
+    end
+
+    def port
+      @struct.port
+    end
+
+    def weight
+      @struct.weight
+    end
+
+    def multithreaded
+      true
+    end
+
+    def status
+      alive? ? 'CONNECTED' : 'NOT CONNECTED'
+    end
+
+    def inspect
+      "<Memcached::Rails::Server: %s:%d [%d] (%s)>" % [host, port, weight, status]
+    end
+
+    def alive?
+      @struct.fd != -1 || @struct.next_retry <= Time.now
+    end
+  end
+end

data/memcached-northscale.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{memcached-northscale}
+  s.version = "0.19.5.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sean Lynch"]
+  s.date = %q{2010-06-02}
+  s.description = %q{Test gem. Do not use unless you know what you're doing.}
+  s.email = %q{}
+  s.extensions = ["ext/extconf.rb"]
+  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", "ext/sasl.patch", "lib/memcached.rb", "lib/memcached/auth.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-northscale.gemspec"]
+  s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/memcached/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Memcached-northscale", "--main", "README"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{northscale}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Test gem. Do not use unless you know what you're doing.}
+  s.test_files = ["test/test_helper.rb", "test/unit/binding_test.rb", "test/unit/memcached_test.rb", "test/unit/rails_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/profile/benchmark.rb

@@ -0,0 +1,210 @@
+
+HERE = File.dirname(__FILE__)
+$LOAD_PATH << "#{HERE}/../../lib/"
+UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached') 
+
+require 'memcached'
+require 'benchmark'
+require 'rubygems'
+require 'ruby-debug' if ENV['DEBUG']
+begin; require 'memory'; rescue LoadError; end
+
+puts `uname -a`
+puts "Ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
+
+[ ["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
+
+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(loops = nil, stack_depth = nil)
+    @loops = (loops || 20000).to_i
+    @stack_depth = (stack_depth || 0).to_i
+    
+    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]
+    
+    reset_servers
+    reset_clients
+    
+    Benchmark.bm(36) do |x| 
+      @benchmark = x 
+    end
+  end
+
+  def run(level = @stack_depth)
+    level > 0 ? run(level - 1) : run_without_recursion
+  end
+  
+  private
+  
+  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
+    
+    benchmark_clients("get-multi") do |c|
+      c.get_multi @keys, true
+    end
+    
+    benchmark_clients("append") do |c|
+      c.append @k1, @m_value
+      c.append @k2, @m_value
+      c.append @k3, @m_value
+    end    
+    
+    benchmark_clients("delete") do |c|    
+      c.delete @k1
+      c.delete @k2
+      c.delete @k3
+    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(ENV["LOOPS"], ENV["STACK_DEPTH"]).run
+
+Process.memory.each do |key, value|
+  puts "#{key}: #{value/1024.0}M"
+end if Process.respond_to? :memory

data/test/profile/profile.rb

@@ -0,0 +1,14 @@
+
+require "#{File.dirname(__FILE__)}/../setup"
+
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
+require 'rubygems'
+require 'memcached'
+require 'ruby-prof'
+
+result = RubyProf.profile do  
+  load "#{HERE}/profile/valgrind.rb"
+end
+
+printer = RubyProf::GraphPrinter.new(result)
+printer.print(STDOUT, 0)

data/test/profile/valgrind.rb

@@ -0,0 +1,149 @@
+
+require "#{File.dirname(__FILE__)}/../setup"
+
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
+require 'memcached'
+require 'rubygems'
+
+GC.copy_on_write_friendly = true if GC.respond_to?("copy_on_write_friendly=")
+
+class Worker  
+  def initialize(method_name, iterations)
+    @method = method_name || 'mixed'
+    @i = (iterations || 10000).to_i
+    
+    puts "*** Running #{@method.inspect} test for #{@i} loops. ***"
+
+    @key1 = "key1-"*8  
+    @key2 = "key2-"*8  
+    
+    @value = []
+    @marshalled = Marshal.dump(@value)
+    
+    @opts = [
+      ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"], 
+      {
+        :buffer_requests => false,
+        :no_block => false,
+        :namespace => "namespace"
+      }
+    ]    
+    @cache = Memcached.new(*@opts)
+
+    @cache.set @key1, @value
+  end
+  
+  def work
+    case @method
+      when "set"
+        @i.times do
+          @cache.set @key1, @value
+        end
+      when "get"
+        @i.times do
+          @cache.get @key1
+        end
+      when "delete"
+        @i.times do
+          @cache.set @key1, @value
+          @cache.delete @key1
+        end
+      when "delete-miss"
+        @i.times do
+          @cache.delete @key1
+        end
+      when "get-miss"
+        @i.times do
+          begin
+            @cache.get @key2
+          rescue Memcached::NotFound
+          end
+        end
+      when "get-increasing"
+        one_k = "x"*1024
+        @i.times do |i|
+          @cache.set @key1, one_k*(i+1), 0, false
+          @cache.get @key1, false
+        end
+      when "get-miss-increasing"
+        @i.times do |i|
+          @cache.delete @key2 rescue nil
+          begin
+            @cache.get @key2
+          rescue Memcached::NotFound
+          end
+        end
+      when "add"
+        @i.times do
+          begin
+            @cache.delete @key1
+          rescue
+          end
+          @cache.add @key1, @value
+        end
+      when "add-present"
+        @cache.set @key1, @value
+        @i.times do
+          begin
+            @cache.add @key1, @value
+          rescue Memcached::NotStored
+          end
+        end
+      when "mixed"
+        @i.times do
+          @cache.set @key1, @value
+          @cache.get @key1
+        end
+      when "stats"
+        @i.times do
+          @cache.stats
+        end
+      when "multiget"
+        @i.times do
+          @cache.get([@key1, @key2])        
+        end
+      when "clone"
+        @i.times do
+          cache = @cache.clone
+        end
+      when "reset"
+        @i.times do
+          @cache.reset
+        end
+      when "servers"
+        @i.times do
+          @cache.servers
+        end
+      when "server_by_key"
+        @i.times do
+          @cache.server_by_key(@key1)
+        end
+      else
+        raise "No such method"
+    end
+    
+    puts "*** Garbage collect. ***"
+    10.times do       
+      GC.start
+      sleep 0.1
+    end
+
+    sts, server_sts, clients = 0, 0, 0
+    ObjectSpace.each_object(Memcached) { clients += 1 }
+    ObjectSpace.each_object(Rlibmemcached::MemcachedSt) { sts += 1 }  
+    ObjectSpace.each_object(Rlibmemcached::MemcachedServerSt) { server_sts += 1 }  
+    puts "*** Structs: #{sts} ***"
+    puts "*** Server structs: #{server_sts} ***"
+    puts "*** Clients: #{clients} ***"
+  end  
+end
+
+Worker.new(ENV['METHOD'], ENV['LOOPS']).work
+
+begin
+  require 'memory'
+  Process.memory.each do |key, value|
+    puts "#{key}: #{value/1024.0}M"
+  end
+rescue LoadError
+end