moneta 0.7.0 → 0.7.1

data/.gitignore

@@ -1,7 +1,11 @@
+.yardoc
+doc
 attic
 spec/tmp
 *~
 *.swp
 *.rdb
+.#*
+benchmarks/*.histogram
 benchmarks/bench.*
 Gemfile.lock

data/.travis.yml

@@ -17,7 +17,12 @@ before_install:
 env:
   - "TASK=test:parallel"
   - "TASK=test:non_parallel"
-  - "TASK=benchmarks"
+  - "TASK=benchmarks CONFIG=uniform_small"
+  - "TASK=benchmarks CONFIG=uniform_medium"
+  - "TASK=benchmarks CONFIG=uniform_large"
+  - "TASK=benchmarks CONFIG=normal_small"
+  - "TASK=benchmarks CONFIG=normal_medium"
+  - "TASK=benchmarks CONFIG=normal_large"
 matrix:
   allow_failures:
 #    - rvm: ruby-head
@@ -28,12 +33,40 @@ matrix:
   exclude:
     - rvm: jruby
       env: "TASK=test:parallel"
-    - rvm: 1.8.7
-      env: "TASK=benchmarks"
     - rvm: jruby
-      env: "TASK=benchmarks"
+      env: "TASK=benchmarks CONFIG=uniform_small"
+    - rvm: jruby
+      env: "TASK=benchmarks CONFIG=uniform_medium"
+    - rvm: jruby
+      env: "TASK=benchmarks CONFIG=uniform_large"
+    - rvm: jruby
+      env: "TASK=benchmarks CONFIG=normal_small"
+    - rvm: jruby
+      env: "TASK=benchmarks CONFIG=normal_medium"
+    - rvm: jruby
+      env: "TASK=benchmarks CONFIG=normal_large"
+    - rvm: rbx-18mode
+      env: "TASK=benchmarks CONFIG=uniform_small"
+    - rvm: rbx-18mode
+      env: "TASK=benchmarks CONFIG=uniform_medium"
+    - rvm: rbx-18mode
+      env: "TASK=benchmarks CONFIG=uniform_large"
     - rvm: rbx-18mode
-      env: "TASK=benchmarks"
+      env: "TASK=benchmarks CONFIG=normal_small"
+    - rvm: rbx-18mode
+      env: "TASK=benchmarks CONFIG=normal_medium"
+    - rvm: rbx-18mode
+      env: "TASK=benchmarks CONFIG=normal_large"
+    - rvm: rbx-19mode
+      env: "TASK=benchmarks CONFIG=uniform_small"
+    - rvm: rbx-19mode
+      env: "TASK=benchmarks CONFIG=uniform_medium"
+    - rvm: rbx-19mode
+      env: "TASK=benchmarks CONFIG=uniform_large"
+    - rvm: rbx-19mode
+      env: "TASK=benchmarks CONFIG=normal_small"
+    - rvm: rbx-19mode
+      env: "TASK=benchmarks CONFIG=normal_medium"
     - rvm: rbx-19mode
-      env: "TASK=benchmarks"
+      env: "TASK=benchmarks CONFIG=normal_large"
 script: "bundle exec rake $TASK"

data/CHANGES

@@ -0,0 +1,18 @@
+0.7.1
+
+  * Memcached: Use binary protocol and no base64 encoding of the keys
+  * Transformer: Remove newlines from base64 encodes values
+  * Server: Add method #run which will block and #running? to allow forking
+  * SDBM: #store might raise errors (Don't use SDBM, it is unstable!)
+  * Add #decrement method
+  * Fix #fetch to handle false correctly
+  * Fix Expires middleware to handle boolean and nil values correctly
+  * Base64 encode Riak keys since Riak needs valid UTF-8 for the REST interface
+
+0.7.0
+
+  * Major rewrite by Daniel Mendler
+
+0.6.0
+
+  * First public release by Yehuda Katz

data/README.md

@@ -2,15 +2,15 @@
 
 [![Build Status](https://secure.travis-ci.org/minad/moneta.png?branch=master)](http://travis-ci.org/minad/moneta) [![Dependency Status](https://gemnasium.com/minad/moneta.png?travis)](https://gemnasium.com/minad/moneta) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/minad/moneta)
 
-Moneta provides a standard interface for interacting with various kinds of key/value stores. Moneta is very feature rich:
+Moneta provides a standard interface for interacting with various kinds of key/value stores. A short overview of the features:
 
 * Supports a lot of backends (See below)
-* Supports proxies (Similar to [Rack middlewares](http://rack.github.com/))
-* Custom serialization via `Moneta::Transformer` proxy (Marshal/JSON/YAML and many more)
-* Custom key transformation via `Moneta::Transformer` proxy
-* Value compression via `Moneta::Transformer` proxy (Zlib, Snappy, LZMA, ...)
+* Allows a full configuration of the serialization -> compression -> adapter stack using proxies (Similar to [Rack middlewares](http://rack.github.com/))
+    * Configurable serialization via `Moneta::Transformer` proxy (Marshal/JSON/YAML and many more)
+    * Configurable value compression via `Moneta::Transformer` proxy (Zlib, Snappy, LZMA, ...)
+    * Configurable key transformation via `Moneta::Transformer` proxy
 * Expiration for all stores (Added via proxy `Moneta::Expires` if not supported natively)
-* Atomic incrementation and decrementation for most stores (Method `#increment`)
+* Atomic incrementation and decrementation for most stores (Method `#increment` and `#decrement`)
 * Includes a very simple key/value server (`Moneta::Server`) and client (`Moneta::Adapters::Client`)
 * Integration with [Rails](http://rubyonrails.org/), [Rack](http://rack.github.com/) as cookie and session store and [Rack-Cache](https://github.com/rtomayko/rack-cache)
 
@@ -110,6 +110,10 @@ Special transformers:
 
 ## Moneta API
 
+The Moneta API is purposely extremely similar to the Hash API with a few minor additions.
+There are the additional methods `#load`, `#increment`, `#decrement` and `#close`. Every method takes also a optional
+option hash. In order so support an identical API across stores, Moneta does not support iteration or partial matches.
+
 ~~~
 #initialize(options)                      options differs per-store, and is used to set up the store.
 
@@ -134,14 +138,15 @@ Special transformers:
 #increment(key, amount = 1, options = {}) increment numeric value. This is a atomic operation
                                           which is not supported by all stores. Returns current value.
 
+#decrement(key, amount = 1, options = {}) increment numeric value. This is a atomic operation
+                                          which is not supported by all stores. Returns current value.
+                                          This is just syntactic sugar for incrementing with a negative value.
+
 #clear(options = {})                      clear all keys in this store.
 
 #close                                    close database connection.
 ~~~
 
-The Moneta API is purposely extremely similar to the Hash API. In order so support an
-identical API across stores, it does not support iteration or partial matches.
-
 ### Creating a Store
 
 There is a simple interface to create a store using `Moneta.new`:
@@ -205,35 +210,36 @@ The stores support the `#increment` which allows atomic increments of unsigned i
 a non existing value, it will be created. If you increment a non integer value an exception will be raised.
 
 ~~~ ruby
-store.increment('counter') => 1 # counter created
-store.increment('counter') => 2
-store.increment('counter', -1) => 1
-store.increment('counter', 13) => 14
-store.increment('counter', 0) => 14
+store.increment('counter')     # returns 1, counter created
+store.increment('counter')     # returns 2
+store.increment('counter', -1) # returns 1
+store.increment('counter', 13) # returns 14
+store.increment('counter', 0)  # returns 14
+store.decrement('counter')     # returns 13
 store['name'] = 'Moneta'
-store.increment('name') => Exception
+store.increment('name')        # raises an Exception
 ~~~
 
 If you want to access the counter value you have to use raw access to the datastore. This is only important
-if you have a `Moneta::Transformer` somewhere in your proxy chain which transforms the values e.g. with `Marshal`.
+if you have a `Moneta::Transformer` somewhere in your proxy stack which transforms the values e.g. with `Marshal`.
 
 ~~~ ruby
-store.increment('counter') => 1 # counter created
-store.load('counter', :raw => true) => '1'
+store.increment('counter')          # returns 1, counter created
+store.load('counter', :raw => true) # returns 1
 
 store.store('counter', '10', :raw => true)
-store.increment('counter') => 11
+store.increment('counter') # returns 11
 ~~~
 
 Fortunately there is a nicer way to do this using some syntactic sugar!
 
 ~~~ ruby
-store.increment('counter') => 1 # counter created
-store.raw['counter'] => '1'
-store.raw.load('counter') => '1'
+store.increment('counter') # returns 1, counter created
+store.raw['counter']       # returns 1
+store.raw.load('counter')  # returns 1
 
 store.raw['counter'] = '10'
-store.increment('counter') => 11
+store.increment('counter') # returns 11
 ~~~
 
 You can also keep the `raw` store in a variable and use it like this:
@@ -241,12 +247,12 @@ You can also keep the `raw` store in a variable and use it like this:
 ~~~ ruby
 counters = store.raw
 
-counters.increment('counter') => 1 # counter created
-counters['counter'] => '1'
-counters.load('counter') => '1'
+counters.increment('counter') # returns 1, counter created
+counters['counter']           # returns 1
+counters.load('counter')      # returns 1
 
 counters['counter'] = '10'
-counters.increment('counter') => 11
+counters.increment('counter') # returns 11
 ~~~
 
 Stores which support incrementation (you have to use `Moneta::Lock` if you want to use the store in a multithreading environment.)
@@ -280,7 +286,7 @@ Stores which don't support incrementation:
 For raw data access as described before the class `Moneta::OptionMerger` is used. It works like this:
 
 ~~~ ruby
-# All methods after `with` get the options passed
+# All methods after 'with' get the options passed
 store.with(:raw => true).load('key')
 
 # You can also specify the methods
@@ -293,8 +299,8 @@ store.raw.load('key')
 # Access substore where all keys get a prefix
 substore = store.prefix('sub')
 substore['key'] = 'value'
-store['key'] => nil
-store['subkey'] => 'value'
+store['key']    # returns nil
+store['subkey'] # returns 'value'
 
 # Set expiration time for all keys
 short_lived_store = long_lived_store.expires(60)
@@ -408,7 +414,9 @@ config.cache_store :moneta_store, :store => Moneta.build do
 end
 ~~~
 
-## Advanced - Build your own key value server
+## Advanced
+
+### Build your own key value server
 
 You can use Moneta to build your own key/value server which is shared between
 multiple processes. If you run the following code in two different processes,
@@ -432,6 +440,36 @@ store = Moneta.build do
 end
 ~~~
 
+If you want to go further, you might want to take a look at `Moneta::Server` and `Moneta::Adapters::Client` which
+are used by `Moneta::Shared` and provide the networking communication. But be aware that they are experimental
+and subjected to change. They provide an acceptable performance (for being ruby only), but don't have a stable protocol yet.
+
+You might wonder why I didn't use [DRb](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/drb/rdoc/DRb.html) to implement server and client -
+in fact my first versions used it, but with much worse performance and it was real fun to implement the networking directly :)
+There is still much room for improvement and experiments, try [EventMachine](http://eventmachine.rubyforge.org/),
+try [Kgio](http://bogomips.org/kgio/), ...
+
+### ToyStore ORM
+
+If you want something more advanced to handle your objects and relations,
+use John Nunemaker's [ToyStore](https://github.com/jnunemaker/toystore) which works
+together with Moneta. Assuming that `Person` is a `ToyStore::Object` you can
+add persistence using Moneta as follows:
+
+~~~ ruby
+# Use the Moneta Redis backend
+Person.adapter :memory, Moneta.new(:Redis)
+~~~
+
+## Testing and Benchmarks
+
+Testing is done using [Travis-CI](http://travis-ci.org/minad/moneta). Currently we support Ruby 1.8.7 and 1.9.3.
+
+Benchmarks for each store are done on [Travis-CI](http://travis-ci.org/minad/moneta) for each build. Take a look there
+to compare the speed of the different key value stores for different key/value sizes and size distributions.
+Feel free to add your own configurations! The impact of Moneta should be minimal since it is only a thin layer
+on top of the different stores.
+
 ## More information
 
 * http://yehudakatz.com/2009/02/12/whats-the-point/

data/Rakefile

@@ -32,7 +32,7 @@ end
 
 task :benchmarks do
   Dir.chdir('benchmarks')
-  ruby('run.rb')
+  ruby("run.rb #{ENV['CONFIG']}")
 end
 
 task :default => :test

data/SPEC.md

@@ -51,6 +51,12 @@ Behaves the same as <code>[]=</code>, but allows the client to send additional o
 ### <code>increment(key[Object], amount[Integer] = 1, options[Hash] => {}) => Integer(value)</code>
 
 Increments a value atomically. This method is not supported by all stores and might raise a <code>NotImplementedError</code>.
+This method MUST accept negative values, but the result MUST be unsigned.
+
+### <code>decrement(key[Object], amount[Integer] = 1, options[Hash] => {}) => Integer(value)</code>
+
+Decrements a value atomically. This method is not supported by all stores and might raise a <code>NotImplementedError</code>.
+This method MUST accept negative values, but the result MUST be unsigned.
 
 ### <code>clear(options[Hash] => {})</code>
 

data/benchmarks/run.rb

@@ -4,35 +4,8 @@ $: << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'benchmark'
 require 'moneta'
 
-begin
-  require 'dm-core'
-  DataMapper.setup(:default, :adapter => :in_memory)
-rescue LoadError => ex
-  puts "Failed to load DataMapper - #{ex.message}"
-end
-
-begin
-  server = Moneta::Server.new(Moneta.new(:Memory))
-rescue
-  puts "Failed to start Moneta server - #{ex.message}"
-end
-
-class Array
-  def random_index
-    rand(size)
-  end
-
-  def random_value
-    self[random_index]
-  end
-
-  def random_subset(n)
-    (1..n).map{|x| random_value }
-  end
-end
-
-stores = {
-  :ActiveRecord => { :connection => { :adapter  => 'sqlite3', :database => 'bench.activerecord' } },
+STORES = {
+  :ActiveRecord => { :connection => { :adapter  => 'sqlite3', :database => ':memory:' } },
   :Cassandra => {},
   :Client => {},
   :Couch => {},
@@ -41,7 +14,6 @@ stores = {
   :File => { :dir => 'bench.file' },
   :GDBM => { :file => 'bench.gdbm' },
   :HBase => {},
-  :HBase => {},
   :HashFile => { :dir => 'bench.hashfile' },
   :LRUHash => {},
   :LevelDB => { :dir => 'bench.leveldb' },
@@ -53,143 +25,273 @@ stores = {
   :PStore => { :file => 'bench.pstore' },
   :Redis => {},
   :Riak => {},
-  :SDBM => { :file => 'bench.sdbm' },
+  # SDBM is unstable
+  # :SDBM => { :file => 'bench.sdbm' },
   :Sequel => { :db => 'sqlite:/' },
-  :Sqlite => { :file => 'bench.sqlite' },
-  :YAML => { :file => 'bench.yaml' },
+  :Sqlite => { :file => ':memory:' },
+  # YAML is so fucking slow
+  # :YAML => { :file => 'bench.yaml' },
+}
+
+CONFIGS = {
+  :uniform_small => {
+    :runs => 3,
+    :keys => 1000,
+    :min_key_length => 1,
+    :max_key_length => 32,
+    :key_dist => :uniform,
+    :min_val_length => 0,
+    :max_val_length => 256,
+    :val_dist => :uniform
+  },
+  :uniform_medium => {
+    :runs => 3,
+    :keys => 100,
+    :min_key_length => 3,
+    :max_key_length => 200,
+    :key_dist => :uniform,
+    :min_val_length => 0,
+    :max_val_length => 1024,
+    :val_dist => :uniform
+  },
+  :uniform_large => {
+    :runs => 3,
+    :keys => 100,
+    :min_key_length => 3,
+    :max_key_length => 200,
+    :key_dist => :uniform,
+    :min_val_length => 0,
+    :max_val_length => 10240,
+    :val_dist => :uniform
+  },
+  :normal_small => {
+    :runs => 3,
+    :keys => 1000,
+    :min_key_length => 1,
+    :max_key_length => 32,
+    :key_dist => :normal,
+    :min_val_length => 0,
+    :max_val_length => 256,
+    :val_dist => :normal
+  },
+  :normal_medium => {
+    :runs => 3,
+    :keys => 100,
+    :min_key_length => 3,
+    :max_key_length => 200,
+    :key_dist => :normal,
+    :min_val_length => 0,
+    :max_val_length => 1024,
+    :val_dist => :normal
+  },
+  :normal_large => {
+    :runs => 3,
+    :keys => 100,
+    :min_key_length => 3,
+    :max_key_length => 200,
+    :key_dist => :normal,
+    :min_val_length => 0,
+    :max_val_length => 10240,
+    :val_dist => :normal
+  },
 }
 
-stats, keys, data, errors, summary = {}, [], [], [], []
-dict = 'ABCDEFGHIJKLNOPQRSTUVWXYZabcdefghijklnopqrstuvwxyz123456789'.split('')
-vlen_min, vlen_max, vlen_total, vlen_average = 99999, 0, 0, 0
-klen_min, klen_max, klen_total, klen_average = 99999, 0, 0, 0
+config_name = ARGV.size == 1 ? ARGV.first.to_sym : :uniform_medium
+unless config = CONFIGS[config_name]
+  puts "Configuration #{config_name} not found"
+  exit
+end
+
+DICT = 'ABCDEFGHIJKLNOPQRSTUVWXYZabcdefghijklnopqrstuvwxyz123456789'.freeze
+
+class String
+  def random(n)
+    (1..n).map { self[rand(size),1] }.join
+  end
+end
+
+class Array
+  def sum
+    inject(0, &:+)
+  end
 
-RUNS = 3
-KEYS = 100
-MIN_KEY_SIZE = 3
-MAX_KEY_SIZE = 64
-MIN_VALUE_SIZE = 1
-MAX_VALUE_SIZE = 1024 * 10
+  def randomize
+    rest, result = dup, []
+    result << rest.slice!(rand(rest.size)) until result.size == size
+    result
+  end
+end
 
-puts '======================================================================'
-puts 'Comparison of write/read between Moneta Stores'
-puts '======================================================================'
+Process.fork do
+  begin
+    Moneta::Server.new(Moneta.new(:Memory)).run
+  rescue Exception => ex
+    puts "\e[31mFailed to start Moneta server - #{ex.message}\e[0m"
+  end
+end
+sleep 1 # Wait for server
 
-stores.each do |name, options|
+STORES.each do |name, options|
   begin
+    if name == :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
+      require 'riak'
+      Riak.disable_list_keys_warnings = true
+    end
+
     cache = Moneta.new(name, options.dup)
     cache['test'] = 'test'
   rescue Exception => ex
-    puts "#{name} not benchmarked - #{ex.message}"
-    stores.delete(name)
+    puts "\e[31m#{name} not benchmarked - #{ex.message}\e[0m"
+    STORES.delete(name)
   ensure
     cache.close if cache
   end
 end
 
-puts 'Data loading...'
-KEYS.times do |x|
-  klen = rand(MAX_KEY_SIZE - MIN_KEY_SIZE) + MIN_KEY_SIZE
-  vlen = rand(MAX_VALUE_SIZE - MIN_VALUE_SIZE) + MIN_VALUE_SIZE
+HEADER = "\n                         Minimum  Maximum    Total  Average    Ops/s"
+SEPARATOR = '=' * 68
 
-  key = dict.random_subset(klen).join
-  value = dict.random_subset(vlen).join
-  keys << key
-  data << [key, value]
+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
+
+module Rand
+  extend self
+
+  def normal_rand(mean, stddev)
+    # Box-Muller transform
+    theta = 2 * Math::PI * (rand(1e10) / 1e10)
+    scale = stddev * Math.sqrt(-2 * Math.log(1 - (rand(1e10) / 1e10)))
+    [mean + scale * Math.cos(theta),
+     mean + scale * Math.sin(theta)]
+  end
+
+  def uniform(min, max)
+    rand(max - min) + min
+  end
+
+  def normal(min, max)
+    mean = (min + max) / 2
+    stddev = (max - min) / 4
+    loop do
+      val = normal_rand(mean, stddev)
+      return val.first if val.first >= min && val.first <= max
+      return val.last if val.last >= min && val.last <= max
+    end
+  end
+end
+
+stats, data, summary = {}, {}, []
+
+until data.size == config[:keys]
+  key = DICT.random(Rand.send(config[:key_dist], config[:min_key_length], config[:max_key_length]))
+  data[key] = DICT.random(Rand.send(config[:val_dist], config[:min_val_length], config[:max_val_length]))
+end
 
-  vlen_min = value.size if value.size < vlen_min
-  vlen_max = value.size if value.size > vlen_max
-  vlen_total = vlen_total + value.size
+key_lengths, val_lengths = data.keys.map(&:size), data.values.map(&:size)
+data = data.to_a
 
-  klen_min = key.size if key.size < klen_min
-  klen_max = key.size if key.size > klen_max
-  klen_total = klen_total + key.size
+def write_histogram(file, sizes)
+  min = sizes.min
+  delta = sizes.max - min
+  histogram = []
+  sizes.each do |s|
+    s = 10 * (s - min) / delta
+    histogram[s] ||= 0
+    histogram[s] += 1
+  end
+  File.open(file, 'w') do |f|
+    histogram.each_with_index { |n,i| f.puts "#{i*delta/10+min} #{n}" }
+  end
 end
-vlen_average = vlen_total / KEYS
 
-puts '----------------------------------------------------------------------'
-puts "Total keys: #{keys.size}, unique: #{keys.uniq.size}"
-puts '----------------------------------------------------------------------'
-puts '                  Minimum    Maximum      Total    Average        xps '
-puts '----------------------------------------------------------------------'
-puts 'Key Length     % 10i % 10i % 10i % 10i ' % [klen_min, klen_max, klen_total, klen_average]
-puts 'Value Length   % 10i % 10i % 10i % 10i ' % [vlen_min, vlen_max, vlen_total, vlen_average]
+write_histogram('key.histogram', key_lengths)
+write_histogram('value.histogram', val_lengths)
+
+puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34mComputing keys and values...\n\e[34m#{SEPARATOR}\e[0m"
+puts %{                         Minimum  Maximum    Total  Average}
+puts 'Key Length              % 8d % 8d % 8d % 8d ' % [key_lengths.min, key_lengths.max, key_lengths.sum, key_lengths.sum / data.size]
+puts 'Value Length            % 8d % 8d % 8d % 8d ' % [val_lengths.min, val_lengths.max, val_lengths.sum, val_lengths.sum / data.size]
 
-stores.each do |name, options|
+STORES.each do |name, options|
   begin
-    puts '======================================================================'
-    puts name
-    puts '----------------------------------------------------------------------'
+    puts "\n\e[1m\e[34m#{SEPARATOR}\n\e[34m#{name}\n\e[34m#{SEPARATOR}\e[0m"
+
     cache = Moneta.new(name, options.dup)
 
     stats[name] = {
-      :writes => [],
-      :reads => [],
-      :totals => [],
-      :averages => [],
+      :write => [],
+      :read => [],
+      :sum => [],
+      :error => []
     }
 
-    RUNS.times do |round|
-      cache.clear
-      print "[#{round + 1}] W"
-      m1 = Benchmark.measure do
-        KEYS.times do
-          key, value = data.random_value
-          cache[key] = value
+    %w(Rehearse Measure).each do |type|
+      state = ''
+      print "%s [%#{2 * config[:runs]}s] " % [type, state]
+
+      config[:runs].times do |run|
+        cache.clear
+        print "%s[%-#{2 * config[:runs]}s] " % ["\b" * (2 * config[:runs] + 3), state << 'W']
+
+        data = data.randomize
+        m1 = Benchmark.measure do
+          data.each {|k,v| cache[k] = v }
         end
-      end
-      stats[name][:writes] << m1.real
-      print 'R '
-      m2 = Benchmark.measure do
-        KEYS.times do
-          key, value = data.random_value
-          res = cache[key]
-          errors << [name, key, value, res] unless res == value
+
+        print "%s[%-#{2 * config[:runs]}s] " % ["\b" * (2 * config[:runs] + 3), state << 'R']
+
+        data = data.randomize
+        error = 0
+        m2 = Benchmark.measure do
+          data.each do |k, v|
+            error += 1 if v != cache[k]
+          end
+        end
+
+        if type == 'Measure'
+          stats[name][:write] << m1.real
+          stats[name][:error] << error
+          stats[name][:read] << m2.real
+          stats[name][:sum] << (m1.real + m2.real)
         end
       end
-      stats[name][:reads] << m2.real
-      stats[name][:totals] << (m1.real + m2.real)
-      stats[name][:averages] << (m1.real + m2.real)
     end
-    puts ''
-    puts '----------------------------------------------------------------------'
-    puts '                  Minimum    Maximum      Total    Average        xps '
-    puts '----------------------------------------------------------------------'
-    tcmin, tcmax, tctot, tcavg = 99999, 0, 0, 0
-    [:writes, :reads].each do |sname|
-      cmin, cmax, ctot, cavg = 99999, 0, 0, 0
-      stats[name][sname].each do |val|
-        cmin = val if val < cmin
-        tcmin = val if val < tcmin
-        cmax = val if val > cmax
-        tcmax = val if val > tcmax
-        ctot = ctot + val
-        tctot = tctot + val
-      end
-      cavg = ctot / RUNS
-      puts '%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f ' % ["#{name} #{sname}", cmin, cmax, ctot, cavg, KEYS / cavg]
+
+    puts HEADER
+    [:write, :read, :sum].each do |i|
+      total = stats[name][i].sum
+      ops = (config[:runs] * data.size) / total
+      line = '%-17.17s %-5s % 8d % 8d % 8d % 8d % 8d' %
+        [name, i, stats[name][i].min * 1000, stats[name][i].max * 1000,
+         total * 1000, total * 1000 / config[:runs], ops]
+      summary << [-ops, line << "\n"] if i == :sum
+      puts line
     end
-    tcavg = tctot / (RUNS * 2)
-    puts '%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f ' % ["#{name} avgs", tcmin, tcmax, tctot, tcavg, KEYS / tcavg]
-    summary << [name, tcmin, tcmax, tctot, tcavg, KEYS / tcavg]
-  rescue Exception => ex
-    puts "Failed to benchmark #{name} - #{ex.message}"
+
+    errors = stats[name][:error].sum
+    if errors > 0
+      puts "\e[31m%-23.23s % 8d % 8d % 8d % 8d\e[0m" %
+        ['Read errors', stats[name][:error].min, stats[name][:error].max, errors, errors / config[:runs]]
+    else
+      puts "\e[32mNo read errors"
+    end
+  rescue StandardError => ex
+    puts "\n\e[31mFailed to benchmark #{name} - #{ex.message}\e[0m\n"
   ensure
     cache.close if cache
   end
 end
-puts '----------------------------------------------------------------------'
-if errors.size > 0
-  puts "Errors : #{errors.size}"
-#  puts errors.inspect
-else
-  puts 'No errors in reading!'
-end
-puts '======================================================================'
-puts "Summary: #{RUNS} runs, #{KEYS} keys"
-puts '======================================================================'
-puts '                  Minimum    Maximum      Total    Average        xps '
-puts '----------------------------------------------------------------------'
-summary.each do |sry|
-  puts '%-14.14s % 10.4f % 10.4f % 10.4f % 10.4f % 10.4f ' % sry
+
+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"
+summary.sort_by(&:first).each do |entry|
+  puts entry.last
 end