moneta 1.0.0 → 1.5.1

data/script/benchmarks

@@ -4,6 +4,10 @@ $: << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'benchmark'
 require 'moneta'
 require 'fileutils'
+require 'active_support'
+require 'active_support/cache/moneta_store'
+
+require_relative '../spec/restserver.rb'
 
 class String
   def random(n)
@@ -11,65 +15,244 @@ class String
   end
 end
 
-class Array
-  def sum
-    inject(0, &:+)
-  end
-
-  def mean
-    sum / size
-  end
+def mean arr
+  arr.sum / arr.length
+end
 
-  def stddev
-    m = mean
-    Math.sqrt(map {|s| (s - m) ** 2 }.mean)
-  end
+def stddev arr
+  m = mean(arr)
+  Math.sqrt(mean(arr.map {|s| (s - m) ** 2 }))
 end
 
 class MonetaBenchmarks
   DIR = __FILE__ + '.tmp'
 
-  STORES = {
+  mysql_username = ENV['MONETA_MYSQL_USERNAME'] || 'root'
+  mysql_password = ENV['MONETA_MYSQL_PASSWORD']
+  mysql_database1 = ENV['MONETA_MYSQL_DATABSASE1'] || 'moneta'
+  mysql_database2 = ENV['MONETA_MYSQL_DATABSASE2'] || 'moneta2'
+
+  postgres_username = ENV['MONETA_POSTGRES_USERNAME'] || 'postgres'
+  postgres_database1 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta1'
+  postgres_database2 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta2'
+
+  couch_login = ENV['COUCH_LOGIN'] || 'admin'
+  couch_password = ENV['COUCH_PASSWORD'] || 'password'
+
+  STORES = [
     # SDBM accepts only very short key/value pairs (1k for both)
-    # SDBM: { file: "#{DIR}/sdbm" },
+    {name: "SDBM", sizes: [:small], options: {file: "#{DIR}/sdbm"}},
     # YAML is too slow
-    # YAML: { file: "#{DIR}/yaml" },
-    ActiveRecord: { table: 'activerecord', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), username: 'root', database: 'moneta' } },
-    Cassandra: {},
-    Client: {},
-    Couch: {},
-    DBM: { file: "#{DIR}/dbm" },
-    DataMapper: { setup: 'mysql://root:@localhost/moneta', table: 'datamapper' },
-    Daybreak: { file: "#{DIR}/daybreak" },
-    File: { dir: "#{DIR}/file" },
-    GDBM: { file: "#{DIR}/gdbm" },
-    HBase: {},
-    HashFile: { dir: "#{DIR}/hashfile" },
-    KyotoCabinet: { file: "#{DIR}/kyotocabinet.kch" },
-    LRUHash: {},
-    LevelDB: { dir: "#{DIR}/leveldb" },
-    LocalMemCache: { file: "#{DIR}/lmc" },
-    LMDB: { dir: "#{DIR}/lmdb" },
-    MemcachedDalli: {},
-    MemcachedNative: {},
-    Memory: {},
-    MongoMoped: {},
-    MongoOfficial: {},
-    PStore: { file: "#{DIR}/pstore" },
-    Redis: {},
-    RestClient: { url: 'http://localhost:8808/' },
-    Riak: {},
-    Sequel: { table: 'sequel',
-      db: (defined?(JRUBY_VERSION) ?
-              'jdbc:mysql://localhost/moneta?user=root' :
-              'mysql2://root:@localhost/moneta') },
-    Sqlite: { file: ':memory:' },
-    TDB: { file: "#{DIR}/tdb" },
-    TokyoCabinet: { file: "#{DIR}/tokyocabinet" },
-    TokyoTyrant: {},
-  }
+    #{name: "YAML", options: {file: "#{DIR}/yaml"}},
+    {
+      name: "ActiveRecord (MySQL)",
+      adapter: :ActiveRecord,
+      options: {
+        table: 'activerecord',
+        connection: {
+          adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+          username: mysql_username,
+          database: mysql_database1
+        }
+      }
+    },
+    {
+      name: "ActiveRecord (Postgres)",
+      adapter: :ActiveRecord,
+      options: {
+        table: 'activerecord',
+        connection: {
+          adapter: (defined?(JRUBY_VERSION) ? 'jdbcpostgresql' : 'postgresql'),
+          database: postgres_database1,
+          username: postgres_username
+        }
+      }
+    },
+    {
+      name: "ActiveRecord (Sqlite)",
+      adapter: :ActiveRecord,
+      options: {
+        table: 'activerecord',
+        connection: {
+          adapter: (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'),
+          database: "#{DIR}/activerecord_sqlite.db"
+        }
+      }
+    },
+    {
+      name: "ActiveSupportCache (Memory)",
+      adapter: :ActiveSupportCache,
+      options: {
+        backend: ::ActiveSupport::Cache::MemoryStore.new
+      }
+    },
+    {
+      name: "ActiveSupportCache (Redis)",
+      adapter: :ActiveSupportCache,
+      options: {
+        backend: ::ActiveSupport::Cache::RedisCacheStore.new
+      }
+    },
+    {
+      name: "ActiveSupportCache (Moneta Memory)",
+      adapter: :ActiveSupportCache,
+      options: {
+        backend: ::ActiveSupport::Cache::MonetaStore.new(store: Moneta.new(:Memory))
+      }
+    },
+    {
+      name: "ActiveSupportCache (Moneta Redis)",
+      adapter: :ActiveSupportCache,
+      options: {
+        backend: ::ActiveSupport::Cache::MonetaStore.new(store: Moneta.new(:Redis))
+      }
+    },
+    {name: "Cassandra"},
+    {name: "Client (Memory)", adapter: :Client},
+    {
+      name: "Couch",
+      options: {
+        backend: if defined?(JRUBY_VERSION)
+                   require 'faraday/adapter/manticore'
+                   ::Faraday.new("http://127.0.0.1:5984/moneta") { |f| f.adapter :manticore }
+                 end,
+        login: couch_login,
+        password: couch_password
+      },
+      clear_options: { compact: true, await_compact: true },
+    },
+    {
+      name: "DBM",
+      options: {file: "#{DIR}/dbm"}
+    },
+    {
+      name: "DataMapper",
+      options: {
+        setup: "mysql://#{mysql_username}:@localhost/#{mysql_database1}",
+        table: 'datamapper'
+      }
+    },
+    {
+      name: "Daybreak",
+      options: { file: "#{DIR}/daybreak" },
+    },
+    {
+      name: "File",
+      options: {
+        dir: "#{DIR}/file"
+      }
+    },
+    {name: "GDBM", options: {file: "#{DIR}/gdbm"}},
+    {name: "HBase"},
+    {name: "HashFile", options: { dir: "#{DIR}/hashfile" }},
+    {name: "KyotoCabinet", options: { file: "#{DIR}/kyotocabinet.kch" }},
+    {name: "LRUHash"},
+    {name: "LevelDB", options: { dir: "#{DIR}/leveldb" }},
+    {name: "LocalMemCache", options: { file: "#{DIR}/lmc" }},
+    {
+      name: "LMDB",
+      options: {
+        dir: "#{DIR}/lmdb",
+        writemap: true,
+        mapasync: true,
+        nometasync: true,
+        mapsize: 4096 * 3e2
+      }
+    },
+    {name: "MemcachedDalli"},
+    unless defined?(JRUBY_VERSION)
+      {name: "MemcachedNative"}
+    end,
+    {name: "Memory"},
+    {name: "Mongo"},
+    {name: "PStore", options: { file: "#{DIR}/pstore" }},
+    {name: "Redis"},
+    {
+      name: "RestClient (Memory)",
+      adapter: :RestClient,
+      options: {
+        url: 'http://127.0.0.1:8808/moneta',
+        backend: if defined?(JRUBY_VERSION)
+                   require 'faraday/adapter/manticore'
+                   ::Faraday.new("http://127.0.0.1:8808/moneta") { |f| f.adapter :manticore }
+                 end
+      }
+    },
+    {name: "Riak"},
+    {
+      name: "Sequel (MySQL)",
+      adapter: :Sequel,
+      options: {
+        table: 'sequel',
+        db: (defined?(JRUBY_VERSION) ?
+          "jdbc:mysql://localhost/#{mysql_database1}?user=#{mysql_username}" :
+          "mysql2://#{mysql_username}:@localhost/#{mysql_database1}")
+      }
+    },
+    {
+      name: "Sequel (Postgres)",
+      adapter: :Sequel,
+      options:
+        if defined?(JRUBY_VERSION)
+          {db: "jdbc:postgresql://localhost/#{postgres_database1}?user=#{postgres_username}"}
+        else
+          {
+            db: "postgres://localhost/#{postgres_database1}",
+            user: postgres_username
+          }
+        end.merge(table: 'sequel')
+    },
+    {
+      name: "Sequel (HStore)",
+      adapter: :Sequel,
+      options:
+        if defined?(JRUBY_VERSION)
+          {db: "jdbc:postgresql://localhost/#{postgres_database1}?user=#{postgres_username}"}
+        else
+          {
+            db: "postgres://localhost/#{postgres_database1}",
+            user: postgres_username
+          }
+        end.merge(table: 'sequel_hstore', hstore: 'row')
+    },
+    {
+      name: "Sequel (Sqlite)",
+      adapter: :Sequel,
+      options: {
+        table: 'sequel',
+        db: "#{defined?(JRUBY_VERSION) && 'jdbc:'}sqlite://#{DIR}/sequel"
+      }
+    },
+    {
+      name: "Sqlite (Memory)",
+      adapter: :Sqlite,
+      options: {
+        file: ':memory:'
+      }
+    },
+    {
+      name: "Sqlite (File)",
+      adapter: :Sqlite,
+      options: {
+        file: "#{DIR}/sqlite"
+      }
+    },
+    {name: "TDB", options: { file: "#{DIR}/tdb" }},
+    {name: "TokyoCabinet", options: { file: "#{DIR}/tokyocabinet" }},
+    {name: "TokyoTyrant", options: {port: 10431}},
+  ].compact
 
   CONFIGS = {
+    test: {
+      runs: 2,
+      keys: 10,
+      min_key_len: 1,
+      max_key_len: 32,
+      key_dist: :uniform,
+      min_val_len: 0,
+      max_val_len: 256,
+      val_dist: :uniform
+    },
     uniform_small: {
       runs: 3,
       keys: 1000,
@@ -133,8 +316,6 @@ class MonetaBenchmarks
   }
 
   DICT = 'ABCDEFGHIJKLNOPQRSTUVWXYZabcdefghijklnopqrstuvwxyz123456789'.freeze
-  HEADER = "\n                         Minimum  Maximum    Total     Mean   Stddev    Ops/s"
-  SEPARATOR = '=' * 77
 
   module Rand
     extend self
@@ -162,6 +343,14 @@ class MonetaBenchmarks
     end
   end
 
+  def header
+    (" " * @name_len) + "       Minimum  Maximum    Total     Mean   Stddev    Ops/s"
+  end
+
+  def separator
+    "=" * header.length
+  end
+
   def parallel(&block)
     if defined?(JRUBY_VERSION)
       Thread.new(&block)
@@ -185,63 +374,67 @@ class MonetaBenchmarks
   end
 
   def start_servers
-    parallel do
-      begin
-        Moneta::Server.new(Moneta.new(:Memory)).run
-      rescue Exception => ex
-        puts "\e[31mFailed to start Moneta server - #{ex.message}\e[0m"
+    @moneta_server_handle =
+      parallel do
+        begin
+          Moneta::Server.new(Moneta.new(:Memory)).run
+        rescue => ex
+          puts "\e[31mFailed to start Moneta server - #{ex.message}\e[0m"
+        end
       end
-    end
 
-    parallel do
-      begin
-        require 'rack'
-        require 'webrick'
-        require 'rack/moneta_rest'
+    @restserver_handle = start_restserver(8808)
 
-        # Keep webrick quiet
-        ::WEBrick::HTTPServer.class_eval do
-          def access_log(config, req, res); end
-        end
-        ::WEBrick::BasicLog.class_eval do
-          def log(level, data); end
-        end
+    @tokyotyrant_handle = spawn("ttserver -port 10431 -le -log #{DIR}/tokyotyrant.log #{DIR}/tokyotyrant.tch")
 
-        Rack::Server.start(app: Rack::Builder.app do
-                             use Rack::Lint
-                             run Rack::MonetaRest.new(store: :Memory)
-                           end,
-                           environment: :none,
-                           server: :webrick,
-                           Port: 8808)
-      rescue Exception => ex
-        puts "\e[31mFailed to start Rack server - #{ex.message}\e[0m"
-      end
+    Signal.trap "INT" do
+      stop_servers
+      exit
     end
 
     sleep 1 # Wait for servers
   end
 
+  def stop_servers
+    if @restserver_handle
+      stop_restserver(@restserver_handle)
+      @restserver_handle = nil
+    end
+
+    case @moneta_server_handle
+    when Thread
+      Thread.kill @moneta_server_handle
+    when Integer
+      Process.kill "TERM", @moneta_server_handle
+      Process.wait @moneta_server_handle
+    end
+
+    Process.kill "TERM", @tokyotyrant_handle
+  end
+
   def test_stores
-    STORES.each do |name, options|
+    @stores.select! do |spec|
+      adapter = spec[:adapter] || spec[:name].to_sym
+      options = spec[:options] || {}
       begin
-        if name == :DataMapper
+        if adapter == :DataMapper
           begin
             require 'dm-core'
             DataMapper.setup(:default, adapter: :in_memory)
           rescue LoadError => ex
             puts "\e[31mFailed to load DataMapper - #{ex.message}\e[0m"
           end
-        elsif name == :Riak
+        elsif adapter == :Riak
           require 'riak'
           Riak.disable_list_keys_warnings = true
         end
 
-        cache = Moneta.new(name, options.dup)
+        cache = Moneta.new(adapter, options.dup)
         cache['test'] = 'test'
+        true
       rescue Exception => ex
-        puts "\e[31m#{name} not benchmarked - #{ex.message}\e[0m"
-        STORES.delete(name)
+        puts "\e[31m#{spec[:name]} not benchmarked - #{ex.message}\e[0m"
+        false
       ensure
         (cache.close rescue nil) if cache
       end
@@ -260,26 +453,26 @@ class MonetaBenchmarks
     write_histogram("#{DIR}/key.histogram", key_lens)
     write_histogram("#{DIR}/value.histogram", val_lens)
 
-    puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34mComputing keys and values...\n\e[34m#{SEPARATOR}\e[0m"
-    puts %{                         Minimum  Maximum    Total     Mean   Stddev}
-    puts 'Key Length              % 8d % 8d % 8d % 8d % 8d' % [key_lens.min, key_lens.max, key_lens.sum, key_lens.mean, key_lens.stddev]
-    puts 'Value Length            % 8d % 8d % 8d % 8d % 8d' % [val_lens.min, val_lens.max, val_lens.sum, val_lens.mean, val_lens.stddev]
+    puts "\n\e[1m\e[34m#{separator}\n\e[34mComputing keys and values...\n\e[34m#{separator}\e[0m"
+    puts " " * @name_len + %{                Minimum  Maximum    Total     Mean   Stddev}
+    puts 'Key Length'.ljust(@name_len) + '               % 8d % 8d % 8d % 8d % 8d' % [key_lens.min, key_lens.max, key_lens.sum, mean(key_lens), stddev(key_lens)]
+    puts 'Value Length'.ljust(@name_len) + '               % 8d % 8d % 8d % 8d % 8d' % [val_lens.min, val_lens.max, val_lens.sum, mean(val_lens), stddev(val_lens)]
   end
 
   def print_config
-    puts "\e[1m\e[36m#{SEPARATOR}\n\e[36mConfig #{@config_name}\n\e[36m#{SEPARATOR}\e[0m"
+    puts "\e[1m\e[36m#{separator}\n\e[36mConfig #{@config_name}\n\e[36m#{separator}\e[0m"
     @config.each do |k,v|
       puts '%-16s = %-10s' % [k,v]
     end
   end
 
   def print_store_stats(name)
-    puts HEADER
+    puts "\n" + header
     [:write, :read, :sum].each do |i|
       ops = (1000 * @config[:runs] * @data.size) / @stats[name][i].sum
-      line = '%-17.17s %-5s % 8d % 8d % 8d % 8d % 8d % 8d' %
+      line = "%-#{@name_len-1}.#{@name_len-1}s %-5s % 8d % 8d % 8d % 8d % 8d % 8d" %
         [name, i, @stats[name][i].min, @stats[name][i].max, @stats[name][i].sum,
-         @stats[name][i].mean, @stats[name][i].stddev, ops]
+         mean(@stats[name][i]), stddev(@stats[name][i]), ops]
       @summary << [-ops, line << "\n"] if i == :sum
       puts line
     end
@@ -293,10 +486,13 @@ class MonetaBenchmarks
     end
   end
 
-  def benchmark_store(name, options)
-    puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34m#{name}\n\e[34m#{SEPARATOR}\e[0m"
+  def benchmark_store(spec)
+    name = spec[:name]
+    adapter = spec[:adapter] || spec[:name].to_sym
+    options = spec[:options] || {}
+    puts "\n\e[1m\e[34m#{separator}\n\e[34m#{name}\n\e[34m#{separator}\e[0m"
 
-    store = Moneta.new(name, options.dup)
+    store = Moneta.new(adapter, options.dup)
 
     @stats[name] = {
       write: [],
@@ -310,7 +506,7 @@ class MonetaBenchmarks
       print "%s [%#{2 * @config[:runs]}s] " % [type, state]
 
       @config[:runs].times do |run|
-        store.clear
+        store.clear(spec[:clear_options] || {})
 
         @data.shuffle!
         m1 = Benchmark.measure do
@@ -346,14 +542,14 @@ class MonetaBenchmarks
   end
 
   def run_benchmarks
-    STORES.each do |name, options|
-      benchmark_store(name, options)
+    @stores.each do |spec|
+      benchmark_store(spec)
       sleep 1
     end
   end
 
   def print_summary
-    puts "\n\e[1m\e[36m#{SEPARATOR}\n\e[36mSummary #{@config_name}: #{@config[:runs]} runs, #{@data.size} keys\n\e[36m#{SEPARATOR}\e[0m#{HEADER}\n"
+    puts "\n\e[1m\e[36m#{separator}\n\e[36mSummary #{@config_name}: #{@config[:runs]} runs, #{@data.size} keys\n\e[36m#{separator}\e[0m\n#{header}\n"
     @summary.sort_by(&:first).each do |entry|
       puts entry.last
     end
@@ -366,6 +562,20 @@ class MonetaBenchmarks
       exit
     end
 
+    @size = @config_name.to_s.split('_').last.to_sym
+    @stores =
+      if ENV['MONETA_STORES']
+        store_names = ENV['MONETA_STORES'].split(/,\s*/)
+        STORES.select { |spec| store_names.any? { |name| name == spec[:name] } }
+      elsif ENV['MONETA_STORES_MATCHING']
+        r = Regexp.new(ENV['MONETA_STORES_MATCHING'])
+        STORES.select { |spec| spec[:name].match(r) }
+      else
+        STORES
+      end.select { |spec| !spec.key?(:sizes) || spec[:sizes].include?(@size) }
+
+    @name_len = (@stores.map { |spec| spec[:name] }.map(&:length) + ["Value Length".length]).max + 2
+
     # Disable jruby stdout pollution by memcached
     if defined?(JRUBY_VERSION)
       require 'java'
@@ -387,6 +597,7 @@ class MonetaBenchmarks
     generate_data
     run_benchmarks
     print_summary
+    stop_servers
     FileUtils.rm_rf(DIR)
   end
 end

data/script/contributors

@@ -1,7 +1,12 @@
-#!/bin/sh
-git log --format='%aN <%aE>' |\
-sed -e 's/hiddenbek/Scott Wadden/g' |\
-sed -e 's/Asmod4n/Hendrik Beskow/' |\
-grep -v 'hannes.georg@xing.com\|spotapov\|yehuda-katzs-mac\|wycats ' |\
-sort -u | sort > CONTRIBUTORS
+#!/usr/bin/env ruby
 
+contributors = `git log --format='%aN <%aE>'`
+  .gsub(/hiddenbek/, 'Scott Wadden')
+  .gsub(/Asmod4n/, 'Hendrik Beskow')
+  .lines
+  .uniq
+  .reject { |line| line.match? /asppsa@gmail.com|hannes.georg@xing.com|spotapov|yehuda-katzs-mac|wycats / }
+  .sort { |str1, str2| str1.casecmp(str2) }
+
+file = File.open('CONTRIBUTORS', 'w')
+file << contributors.join