couchbase-jruby-client 0.1.0-java → 0.1.5-java

data/test/profile/Gemfile

@@ -1,6 +1,6 @@
-source :rubygems
+source 'https://rubygems.org'
 
-gem "memcached", "~> 1.3.6"
-gem "kgio", "~> 2.7.2"
-gem "dalli", "~> 1.1.4"
-gem "yajl-ruby", "~> 1.1.0"
+gem 'benchmark-ips'
+gem 'jrjackson',    '~> 0.2.3'
+gem 'multi_json',   '~> 1.0'
+gem 'atomic',       '~> 1.1.14'

data/test/profile/benchmark.rb

@@ -24,15 +24,12 @@
 #   show exceptions
 #
 
-require "rubygems"
-require "bundler/setup"
-
-require 'benchmark'
+require 'rubygems'
+require 'bundler/setup'
 
 $LOAD_PATH << File.join(File.dirname(__FILE__), "..", "..", "lib")
 require 'couchbase'
-require 'memcached'
-require 'dalli'
+require 'benchmark/ips'
 
 puts `uname -a`
 puts File.readlines('/proc/cpuinfo').sort.uniq.grep(/model name|cpu cores/) rescue nil
@@ -40,21 +37,13 @@ puts RUBY_DESCRIPTION
 
 class Bench
 
-  def initialize(loops = nil, stack_depth = nil)
-    @loops = (loops || 50000).to_i
-    @stack_depth = (stack_depth || 0).to_i
+  def initialize
 
     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)
+    @value = { 'im' => [ 'testing', 'stuff' ] }
 
-    puts "Small value size is: #{@m_value.size} bytes"
-    puts "Large value size is: #{@m_large_value.size} bytes"
+    puts "Raw value size is: #{@value.size} bytes"
 
     @keys = [
       @k1 = "Short",
@@ -64,132 +53,125 @@ class Bench
       @k5 = "Medium2" * 8,
       @k6 = "Long3" * 40]
 
-    reset_clients
+    @cb = Couchbase.new
+    @cl = @cb.client
 
-    Benchmark.bm(36) do |x|
-      @benchmark = x
+    # Ensure it is JITed
+    2_000.times do
+      @cb.set(@k1, 'a')
+      @cb.get(@k1)
     end
   end
 
-  def run(level = @stack_depth)
-    level > 0 ? run(level - 1) : run_without_recursion
-  end
-
-  private
-
-  def reset_clients
-    host = ENV['HOST'] || '127.0.0.1'
-    @clients = {
-      "dalli" => lambda { Dalli::Client.new("#{host}:11211", :marshal => true, :threadsafe => false) },
-      "memcached" => lambda { Memcached::Rails.new("#{host}:11211", :no_block => false, :buffer_requests => false, :binary_protocol => true) },
-      "memcached:buffer" => lambda { Memcached::Rails.new("#{host}:11211", :no_block => true, :buffer_requests => true, :binary_protocol => true) },
-      "couchbase" => lambda { Couchbase.new("http://#{host}:8091/pools/default/buckets/default", :default_format => :marshal) }
-    }
-  end
-
-  def benchmark_clients(test_name, populate_keys = true)
-    return if ENV["TEST"] and !test_name.include?(ENV["TEST"])
-
-    @clients.keys.each do |client_name|
-      next if ENV["CLIENT"] and !client_name.include?(ENV["CLIENT"])
-
-      kid = fork do
-        client = @clients[client_name].call
-        begin
-          if populate_keys
-            client.set @k1, @m_value
-            client.set @k2, @m_value
-            client.set @k3, @m_value
-          else
-            client.delete @k1
-            client.delete @k2
-            client.delete @k3
-          end
-
-          GC.disable
-          @benchmark.report("#{test_name}: #{client_name}") { @loops.times { yield client } }
-          STDOUT.flush
-        rescue Exception => e
-          puts "#{test_name}: #{client_name} => #{e.inspect}" if ENV["DEBUG"]
-        end
-        exit
+  def run
+    Benchmark.ips do |x|
+      x.report('jruby set') do
+        @cb.set @k1, @value
+        @cb.set @k2, @value
+        @cb.set @k3, @value
       end
-      Signal.trap("INT") { Process.kill("KILL", kid); exit }
-      Process.wait(kid)
-    end
-    puts
-  end
 
-  def run_without_recursion
-    benchmark_clients("set") do |c|
-      c.set @k1, @m_value
-      c.set @k2, @m_value
-      c.set @k3, @m_value
-    end
+      x.report('java set') do
+        @cl.set(@k1, MultiJson.dump(@value)).get
+        @cl.set(@k2, MultiJson.dump(@value)).get
+        @cl.set(@k3, MultiJson.dump(@value)).get
+      end
 
-    benchmark_clients("get") do |c|
-      c.get @k1
-      c.get @k2
-      c.get @k3
-    end
+      x.report('jruby get') do
+        @cb.get @k1
+        @cb.get @k2
+        @cb.get @k3
+      end
 
-    benchmark_clients("get_multi") do |c|
-      if c.respond_to?(:get_multi)
-        c.get_multi @keys
-      else
-        c.get @keys
+      x.report('java get') do
+        MultiJson.load @cl.get(@k1)
+        MultiJson.load @cl.get(@k2)
+        MultiJson.load @cl.get(@k3)
       end
-    end
 
-    benchmark_clients("append") do |c|
-      c.append @k1, @m_value
-      c.append @k2, @m_value
-      c.append @k3, @m_value
-    end
+      x.report('jruby get multi') do
+        @cb.get([@k1, @k2, @k3])
+      end
 
-    benchmark_clients("prepend") do |c|
-      c.prepend @k1, @m_value
-      c.prepend @k2, @m_value
-      c.prepend @k3, @m_value
-    end
+      x.report('java get multi') do
+        @cl.getBulk([@k1, @k2, @k3])
+      end
 
-    benchmark_clients("delete") do |c|
-      c.delete @k1
-      c.delete @k2
-      c.delete @k3
-    end
+      x.report('jruby delete') do
+        @cb.set @k1, ''
+        @cb.set @k2, ''
+        @cb.set @k3, ''
+        @cb.delete(@k1)
+        @cb.delete(@k2)
+        @cb.delete(@k3)
+      end
 
-    benchmark_clients("get_missing", false) do |c|
-      c.get @k1 rescue nil
-      c.get @k2 rescue nil
-      c.get @k3 rescue nil
-    end
+      x.report('java delete') do
+        @cl.set @k1, ''
+        @cl.set @k2, ''
+        @cl.set @k3, ''
+        @cl.delete @k1
+        @cl.delete @k2
+        @cl.delete @k3
+      end
 
-    benchmark_clients("append_missing", false) do |c|
-      c.append @k1, @m_value rescue nil
-      c.append @k2, @m_value rescue nil
-      c.append @k3, @m_value rescue nil
-    end
+      x.report('jruby get missing') do
+        @cb.get(@k1, quiet: true)
+        @cb.get(@k2, quiet: true)
+        @cb.get(@k3, quiet: true)
+      end
 
-    benchmark_clients("prepend_missing", false) do |c|
-      c.prepend @k1, @m_value rescue nil
-      c.prepend @k2, @m_value rescue nil
-      c.prepend @k3, @m_value rescue nil
-    end
+      x.report('java get missing') do
+        @cl.get @k1
+        @cl.get @k2
+        @cl.get @k3
+      end
 
-    benchmark_clients("set_large") do |c|
-      c.set @k1, @m_large_value
-      c.set @k2, @m_large_value
-      c.set @k3, @m_large_value
-    end
+      # x.report('jruby async set') do
+      #   @cb.run do
+      #     100.times do
+      #       @cb.set @k1, @value
+      #       @cb.set @k2, @value
+      #       @cb.set @k3, @value
+      #     end
+      #   end
+      # end
+
+      # x.report('java async set') do
+      #   futures = []
+      #   100.times do
+      #     futures << @cb.client.set(@k1, MultiJson.dump(@value))
+      #     futures << @cb.client.set(@k2, MultiJson.dump(@value))
+      #     futures << @cb.client.set(@k3, MultiJson.dump(@value))
+      #   end
+      #   futures.each(&:get)
+      # end
+
+      # x.report('jruby async get') do
+      #   @cb.run do
+      #     100.times do
+      #       @cb.get @k1
+      #       @cb.get @k2
+      #       @cb.get @k3
+      #     end
+      #   end
+      # end
+
+      # x.report('java async get') do
+      #   futures = []
+      #   100.times do
+      #     futures << @cb.client.asyncGet(@k1)
+      #     futures << @cb.client.asyncGet(@k2)
+      #     futures << @cb.client.asyncGet(@k3)
+      #   end
+      #   futures.each(&:get)
+      # end
 
-    benchmark_clients("get_large") do |c|
-      c.get @k1
-      c.get @k2
-      c.get @k3
     end
 
+    @cb.disconnect
   end
+
 end
 
-Bench.new(ENV["LOOPS"], ENV["STACK_DEPTH"]).run
+Bench.new.run

data/test/profile/profile.rb

@@ -0,0 +1,59 @@
+
+require 'rubygems'
+require 'bundler/setup'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "..", "lib")
+require 'couchbase'
+require 'jruby/profiler'
+
+puts `uname -a`
+puts File.readlines('/proc/cpuinfo').sort.uniq.grep(/model name|cpu cores/) rescue nil
+puts RUBY_DESCRIPTION
+
+class Profile
+
+  def initialize
+
+    puts "PID is #{Process.pid}"
+
+    @value = { 'im' => [ 'testing', 'stuff' ] }
+
+    puts "Raw value size is: #{@value.size} bytes"
+
+    @keys = [
+      @k1 = "Short",
+      @k2 = "Sym1-2-3::45" * 8,
+      @k3 = "Long" * 40,
+      @k4 = "Medium" * 8,
+      @k5 = "Medium2" * 8,
+      @k6 = "Long3" * 40]
+
+    @cb = Couchbase.new
+
+
+  end
+
+  def run
+    profile_data = JRuby::Profiler.profile do
+      2_000.times do
+        @cb.set(@k1, @value)
+        @cb.set(@k2, @value)
+        @cb.set(@k3, @value)
+      end
+
+      2_000.times do
+        @cb.get(@k1)
+        @cb.get(@k2)
+        @cb.get(@k3)
+      end
+    end
+
+    profile_printer = JRuby::Profiler::GraphProfilePrinter.new(profile_data)
+    profile_printer.printProfile(STDOUT)
+
+    @cb.disconnect
+  end
+
+end
+
+Profile.new.run

data/test/setup.rb

@@ -21,6 +21,9 @@ require 'couchbase'
 
 require 'socket'
 require 'open-uri'
+require 'ostruct'
+
+require 'pry'
 
 # Surpress connection logging
 # java_import java.lang.System
@@ -39,153 +42,18 @@ require 'open-uri'
 
 Minitest.after_run { Couchbase.disconnect }
 
-class CouchbaseServer
-  attr_accessor :host, :port, :num_nodes, :buckets_spec
-
-  def real?
-    true
-  end
-
-  def initialize(params = {})
-    @host, @port = ['localhost', 8091] #ENV['COUCHBASE_SERVER'].split(':')
-    @port = @port.to_i
-
-    if @host.nil? || @host.empty? || @port == 0
-      raise ArgumentError, "Check COUCHBASE_SERVER variable. It should be hostname:port"
-    end
-
-    @config = MultiJson.load(open("http://#{@host}:#{@port}/pools/default"))
-    @num_nodes = @config["nodes"].size
-    @buckets_spec = params[:buckets_spec] || "default:"  # "default:,protected:secret,cache::memcache"
-  end
-
-  def start
-    # flush all buckets
-    @buckets_spec.split(',') do |bucket|
-      name, password, _ = bucket.split(':')
-      connection = Couchbase.new(:hostname => @host,
-                                 :port => @port,
-                                 :username => name,
-                                 :bucket => name,
-                                 :password => password)
-      begin
-        connection.flush
-      rescue Couchbase::Error::NotSupported
-        # on recent server flush is disabled
-      ensure
-        connection.disconnect
-      end
-    end if ENV['COUCHBASE_FLUSH_BUCKETS']
-  end
-
-  def stop
-  end
-end
-
-class CouchbaseMock
-  Monitor = Struct.new(:pid, :client, :socket, :port)
-
-  attr_accessor :host, :port, :buckets_spec, :num_nodes, :num_vbuckets
-
-  def real?
-    false
-  end
-
-  def initialize(params = {})
-    @host = "127.0.0.1"
-    @port = 0
-    @num_nodes = 10
-    @num_vbuckets = 4096
-    @buckets_spec = "default:"  # "default:,protected:secret,cache::memcache"
-    params.each do |key, value|
-      send("#{key}=", value)
-    end
-    yield self if block_given?
-    if @num_vbuckets < 1 || (@num_vbuckets & (@num_vbuckets - 1) != 0)
-      raise ArgumentError, "Number of vbuckets should be a power of two and greater than zero"
-    end
-  end
-
-  def start
-    @monitor = Monitor.new
-    @monitor.socket = TCPServer.new(nil, 0)
-    @monitor.socket.listen(10)
-    _, @monitor.port, _, _ = @monitor.socket.addr
-    trap("CLD") do
-      puts "CouchbaseMock.jar died unexpectedly during startup"
-      exit(1)
-    end
-    @monitor.pid = fork
-    if @monitor.pid.nil?
-      rc = exec(command_line("--harakiri-monitor=:#{@monitor.port}"))
-    else
-      trap("CLD", "SIG_DFL")
-      @monitor.client, _ = @monitor.socket.accept
-      @port = @monitor.client.recv(100).to_i
-    end
-  end
-
-  def stop
-    @monitor.client.close
-    @monitor.socket.close
-    Process.kill("TERM", @monitor.pid)
-    Process.wait(@monitor.pid)
-  end
-
-  def failover_node(index, bucket = "default")
-    @monitor.client.send("failover,#{index},#{bucket}", 0)
-  end
-
-  def respawn_node(index, bucket = "default")
-    @monitor.client.send("respawn,#{index},#{bucket}", 0)
-  end
-
-  protected
-
-  def command_line(extra = nil)
-    cmd = "java -jar #{File.dirname(__FILE__)}/CouchbaseMock.jar"
-    cmd << " --host #{@host}" if @host
-    cmd << " --port #{@port}" if @port
-    cmd << " --nodes #{@num_nodes}" if @num_nodes
-    cmd << " --vbuckets #{@num_vbuckets}" if @num_vbuckets
-    cmd << " --buckets #{@buckets_spec}" if @buckets_spec
-    cmd << " #{extra}"
-    cmd
-  end
-end
-
 class MiniTest::Test
 
-  def start_mock(params = {})
-    mock = nil
-    if true # ENV['COUCHBASE_SERVER']
-      mock = CouchbaseServer.new(params)
-      if (params[:port] && mock.port != params[:port]) ||
-        (params[:host] && mock.host != params[:host]) ||
-        mock.buckets_spec != "default:"
-        skip("Unable to configure real cluster. Requested config is: #{params.inspect}")
-      end
-    else
-      mock = CouchbaseMock.new(params)
-    end
-    mock.start
-    mock
+  def cb
+    Couchbase.bucket
   end
 
-  def stop_mock(mock)
-    assert(mock)
-    mock.stop
-  end
-
-  def with_mock(params = {})
-    return
-    mock = nil
-    if block_given?
-      mock = start_mock(params)
-      yield mock
+  def with_configs(configs = {})
+    configs = Couchbase::Bucket::DEFAULT_OPTIONS.merge(configs)
+    if configs[:host].nil?
+      configs[:host] = configs[:hostname]
     end
-  ensure
-    stop_mock(mock) if mock
+    yield OpenStruct.new(configs)
   end
 
   def uniq_id(*suffixes)
@@ -195,7 +63,4 @@ class MiniTest::Test
     [test_id, @ids[test_id]].join("_")
   end
 
-  def after_teardown
-    GC.start
-  end
 end