vinted-memcached 1.8.3 → 1.8.5

data/test/profile/benchmark.rb

@@ -1,280 +0,0 @@
-Bundler.require(:benchmark)
-
-HERE = File.dirname(__FILE__)
-$LOAD_PATH << "#{HERE}/../../lib/"
-UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached')
-JRUBY = defined?(JRUBY_VERSION)
-
-require 'ffi/times' if JRUBY
-require 'memcached'
-require 'benchmark'
-require 'rubygems'
-require 'ruby-debug' if ENV['DEBUG'] && !JRUBY
-if ENV['PROFILE']
-  require 'ruby-prof'
-  require 'fileutils'
-  FileUtils.mkdir_p 'profiles'
-end
-begin; require 'memory'; rescue LoadError; end
-
-
-puts `uname -a`
-puts `ruby -v`
-puts `env | egrep '^RUBY'`
-puts "Ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
-
-[
-  ["memcached"],
-  ["remix-stash", "remix/stash"],
-  [JRUBY ? "jruby-memcache-client" : "memcache-client", "memcache"],
-  ["kgio"], ["dalli"]
-].each do |gem_name, requirement|
-  begin
-    require requirement || gem_name
-    gem gem_name
-    puts "Loaded #{gem_name} #{Gem.loaded_specs[gem_name].version.to_s rescue nil}"
-  rescue LoadError
-  end
-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 Dalli::ClientCompat < Dalli::Client
-  def set(*args)
-    super(*args[0..2])
-  end
-  def get(*args)
-    super(args.first)
-  end
-  def get_multi(*args)
-    super(args.first)
-  end
-  def append(*args)
-    super
-  rescue Dalli::DalliError
-  end
-  def prepend(*args)
-    super
-  rescue Dalli::DalliError
-  end
-  def exist?(key)
-    !get(key).nil?
-  end
-end
-
-class Bench
-
-  def initialize(loops = nil, stack_depth = nil)
-    @loops = (loops || 50000).to_i
-    @stack_depth = (stack_depth || 0).to_i
-
-    puts "PID is #{Process.pid}"
-    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
-    # Other clients
-    @clients = {
-      "mclient:ascii" => MemCache.new(['127.0.0.1:43042', '127.0.0.1:43043']),
-      "stash:bin" => Remix::Stash.new(:root),
-      "dalli:bin" => Dalli::ClientCompat.new(['127.0.0.1:43042', '127.0.0.1:43043'], :marshal => false, :threadsafe => false)}
-
-    # Us
-    @clients.merge!({
-      "libm:ascii" => Memcached::Rails.new(
-        ['127.0.0.1:43042', '127.0.0.1:43043'],
-        :buffer_requests => false, :no_block => false, :namespace => "namespace"),
-      "libm:ascii:pipeline" => Memcached::Rails.new(
-        ['127.0.0.1:43042', '127.0.0.1:43043'],
-        :no_block => true, :buffer_requests => true, :noreply => true, :namespace => "namespace"),
-      "libm:ascii:udp" => Memcached::Rails.new(
-        ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"],
-        :buffer_requests => false, :no_block => false, :namespace => "namespace"),
-      "libm:bin" => 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:bin:buffer" => Memcached::Rails.new(
-        ['127.0.0.1:43042', '127.0.0.1:43043'],
-        :no_block => true, :buffer_requests => true, :namespace => "namespace", :binary_protocol => true)})
-  end
-
-  def benchmark_clients(test_name, populate_keys = true)
-    return if ENV["TEST"] and !test_name.include?(ENV["TEST"])
-
-    @clients.keys.sort.each do |client_name|
-      next if ENV["CLIENT"] and !client_name.include?(ENV["CLIENT"])
-      next if client_name == "stash" and test_name == "set-large" # Don't let stash break the world
-
-      client = @clients[client_name]
-      begin
-        if populate_keys
-          client.set @k1, @m_value, 0, true
-          client.set @k2, @m_value, 0, true
-          client.set @k3, @m_value, 0, true
-        else
-          client.delete @k1
-          client.delete @k2
-          client.delete @k3
-        end
-
-        # Force any JITs to run
-        10003.times { yield client }
-
-        GC.disable if !JRUBY
-        RubyProf.start if ENV['PROFILE']
-        @benchmark.report("#{test_name}: #{client_name}") { @loops.times { yield client } }
-        if ENV['PROFILE']
-          prof = RubyProf::MultiPrinter.new(RubyProf.stop)
-          prof.print(:path => 'profiles', :profile => "#{test_name}-#{client_name.gsub(':','-')}")
-        end
-      rescue Exception => e
-        puts "#{test_name}: #{client_name} => #{e.inspect}" if ENV["DEBUG"]
-        reset_clients
-      end
-      GC.enable if !JRUBY
-    end
-    puts
-  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 * 5).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("prepend") do |c|
-      c.prepend @k1, @m_value
-      c.prepend @k2, @m_value
-      c.prepend @k3, @m_value
-    end
-
-    benchmark_clients("delete") do |c|
-      c.delete @k1
-      c.delete @k2
-      c.delete @k3
-    end
-
-    benchmark_clients("exist") do |c|
-      c.exist? @k1
-      c.exist? @k2
-      c.exist? @k3
-    end
-
-    benchmark_clients("get-missing", false) do |c|
-      c.get @k1
-      c.get @k2
-      c.get @k3
-    end
-
-    benchmark_clients("append-missing", false) do |c|
-      c.append @k1, @m_value
-      c.append @k2, @m_value
-      c.append @k3, @m_value
-    end
-
-    benchmark_clients("prepend-missing", false) do |c|
-      c.prepend @k1, @m_value
-      c.prepend @k2, @m_value
-      c.prepend @k3, @m_value
-    end
-
-    benchmark_clients("exist-missing", false) do |c|
-      c.exist? @k1
-      c.exist? @k2
-      c.exist? @k3
-    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
-
-    if defined?(Memcached) && !ENV['TEST'] && !ENV['CLIENT']
-      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
-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/c_profiler.rb

@@ -1,14 +0,0 @@
-require "#{File.dirname(__FILE__)}/../setup"
-
-$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
-require 'memcached'
-
-profile = "/tmp/memcached_#{Memcached::VERSION}_c"
-
-system("env CPUPROFILE_FREQUENCY=500 CPUPROFILE=#{profile}.out DYLD_INSERT_LIBRARIES=/opt/local/lib/libprofiler.dylib ruby -r#{File.dirname(__FILE__)}/exercise -e \"Worker.new('mixed', 200000).work\"")
-
-ruby = `which ruby`.chomp
-
-system("pprof --nodefraction=0.0000001 --text #{ruby} #{profile}.out")
-system("pprof --nodefraction=0.0000001 --pdf #{ruby} #{profile}.out > #{profile}.pdf")
-system("open #{profile}.pdf")

data/test/profile/exercise.rb

@@ -1,185 +0,0 @@
-
-require "#{File.dirname(__FILE__)}/../setup"
-
-$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
-require 'memcached'
-require 'rubygems'
-require 'ostruct'
-
-GC.copy_on_write_friendly = true if GC.respond_to?("copy_on_write_friendly=")
-
-class Worker
-  def initialize(method_name, iterations, with_memory = 'false')
-    @method = method_name || 'mixed'
-    @i = (iterations || 10000).to_i
-    @with_memory = with_memory
-
-    puts "*** Running #{@method.inspect} test for #{@i} loops. ***"
-
-    @key1 = "key1--------------------------------"
-    @key2 = "key2--------------------------------"
-    @key3 = "key3--------------------------------"
-
-    @value = OpenStruct.new(
-      :a => 1, :b => 2, "array" => [1, 2, 3], "hash" => {:badger => 1}
-    )
-    @marshalled = Marshal.dump(@value)
-
-    @opts = [
-      ['localhost:43042', 'localhost:43043', 'localhost:43044'],
-      {
-        :buffer_requests => true,
-        :no_block => true,
-        :noreply => false,
-        :namespace => "namespace"
-      }
-    ]
-    @cache = Memcached::Rails.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
-          @cache.get @key2
-        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
-          @cache.get @key2
-        end
-      when "add"
-        @i.times do
-          @cache.delete @key1
-          @cache.add @key1, @value
-        end
-      when "add-present"
-        @cache.set @key1, @value
-        @i.times do
-          @cache.add @key1, @value
-        end
-      when "mixed"
-        @i.times do
-          @cache.set @key1, @value
-          @cache.set @key2, @value
-          @cache.get @key1
-          @cache.get @key3
-          @cache.get [@key1, @key2, @key3]
-          @cache.prepend @key1, @marshalled
-          @cache.prepend @key2, @marshalled
-          @cache.delete @key1
-          @cache.delete @key2
-        end
-      when "everything"
-        @i.times do
-          @cache.set @key1, @value
-          @cache.set @key2, @value
-          @cache.get @key1
-          @cache.get @key3
-          @cache.get [@key1, @key2, @key3]
-          @cache.prepend @key1, @marshalled
-          @cache.prepend @key2, @marshalled
-          @cache.delete @key1
-          @cache.delete @key2
-          @cache.prepend @key1, @marshalled
-          @cache.prepend @key2, @marshalled
-          @cache.get @key1
-          @cache.get @key3
-          cache = Memcached::Rails.new(*@opts)
-          cache = @cache.clone
-          servers = @cache.servers
-          server = @cache.server_by_key(@key1)
-          @cache.stats
-        end
-        @i.times do
-          @cache.reset
-        end
-        system("killall -9 memcached")
-        @i.times do
-          @cache.set @key1, @value rescue nil
-          @cache.get @key3 rescue nil
-          @cache.delete @key2 rescue nil
-        end
-      when "stats"
-        @cache.stats
-      when "multiget"
-        @i.times do
-          @cache.get([@key1, @key2, @key3])
-        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
-      when "server_error"
-        @i.times do
-          begin
-            @cache.set @key1, "I'm big" * 1000000
-          rescue
-          end
-        end
-      else
-        raise "No such method"
-    end
-
-    @cache = nil
-
-    if @with_memory == "true"
-      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 "*** memcached_st structs: #{sts} ***"
-      puts "*** memcached_server_st structs: #{server_sts} ***"
-      puts "*** Memcached instances: #{clients} ***"
-
-      begin;
-        require 'memory'
-        Process.memory.each { |key, value| puts "#{key}: #{value/1024.0}M" }
-      rescue LoadError
-      end
-    end
-  end
-end

data/test/profile/rb_profiler.rb

@@ -1,21 +0,0 @@
-
-require "#{File.dirname(__FILE__)}/../setup"
-
-$LOAD_PATH << "#{File.dirname(__FILE__)}/../../lib/"
-
-ENV['CPUPROFILE_FREQUENCY'] = '500'
-require 'memcached'
-require 'rubygems'
-require 'perftools'
-require "#{HERE}/profile/exercise"
-
-profile = "/tmp/memcached_#{Memcached::VERSION}_rb"
-worker = Worker.new('mixed', 200000)
-
-PerfTools::CpuProfiler.start("#{profile}.out") do
-  worker.work
-end
-
-system("pprof.rb --nodefraction=0.0000001 --text #{profile}.out")
-system("pprof.rb --nodefraction=0.0000001 --edgefraction=0.0000001 --pdf #{profile}.out > #{profile}.pdf")
-system("open #{profile}.pdf")

data/test/profile/valgrind.rb

@@ -1,10 +0,0 @@
-require "#{File.dirname(__FILE__)}/../setup"
-
-COMMAND =  "--dsymutil=yes ruby -r#{File.dirname(__FILE__)}/exercise.rb -e \"Worker.new(ENV['TEST'] || 'everything', (ENV['LOOPS'] || 50).to_i, 'true').work\""
-
-case ENV["TOOL"]
-when nil, "memcheck":
-  exec("valgrind --tool=memcheck --error-limit=no --undef-value-errors=no --leak-check=full --show-reachable=no --num-callers=15 --track-fds=yes --workaround-gcc296-bugs=yes --leak-resolution=med --max-stackframe=7304328 #{COMMAND}")
-when "massif":
-  exec("valgrind --tool=massif --time-unit=B #{COMMAND}")
-end

data/test/setup.rb

@@ -1,30 +0,0 @@
-
-unless defined? UNIX_SOCKET_NAME
-  HERE = File.dirname(__FILE__)
-  UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached')
-
-  # Kill memcached
-  system("killall -9 memcached")
-
-  # Start memcached
-  verbosity = (ENV['DEBUG'] ? "-vv" : "")
-  log = "/tmp/memcached.log"
-  memcached = ENV['MEMCACHED_COMMAND'] || 'memcached'
-  system ">#{log}"
-
-  # TCP memcached
-  (43042..43046).each do |port|
-    cmd = "#{memcached} #{verbosity} -U 0 -p #{port} >> #{log} 2>&1 &"
-    raise "'#{cmd}' failed to start" unless system(cmd)
-  end
-  # UDP memcached
-  (43052..43053).each do |port|
-    cmd = "#{memcached} #{verbosity} -U #{port} -p 0 >> #{log} 2>&1 &"
-    raise "'#{cmd}' failed to start" unless system(cmd)
-  end
-  # Domain socket memcached
-  (0..1).each do |i|
-    cmd = "#{memcached} -M -s #{UNIX_SOCKET_NAME}#{i} #{verbosity} >> #{log} 2>&1 &"
-    raise "'#{cmd}' failed to start" unless system(cmd)
-  end
-end

data/test/test_helper.rb

@@ -1,18 +0,0 @@
-$LOAD_PATH << "#{File.dirname(__FILE__)}/../lib"
-
-require 'socket'
-require 'benchmark'
-
-require 'rubygems'
-require 'ruby-debug' if ENV['DEBUG']
-require 'memcached'
-
-require 'test/unit'
-require 'test/unit/assertions'
-require 'mocha/test_unit'
-require 'ostruct'
-
-UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached') unless defined? UNIX_SOCKET_NAME
-
-class GenericClass
-end

data/test/unit/binding_test.rb

@@ -1,8 +0,0 @@
-
-require File.expand_path("#{File.dirname(__FILE__)}/../test_helper")
-
-class BindingTest < Test::Unit::TestCase
-  def test_libmemcached_loaded
-    assert_nothing_raised { Rlibmemcached }
-  end
-end