consistent-hashing 0.1.0 → 0.2.0

data/README.md

@@ -1,13 +1,14 @@
 consistent-hashing
 ==================
 
-A generic implementation of the Consistent Hashing algorithm.
+A generic implementation of the Consistent Hashing algorithm using an AVL tree.
 
 Features
 --------
 
 * set number of replicas to create multiple virtual points in the ring for each node
 * nodes can be arbitrary data (e.g. a Memcache client instance)
+* fast performance through using an AVL tree internally
 
 Examples
 --------

data/Rakefile

@@ -15,4 +15,5 @@ Bones {
   email    'liebler.dominik@googlemail.com'
   url      'https://github.com/domnikl/consistent-hashing'
   ignore_file  '.gitignore'
+  depend_on 'avl_tree'
 }

data/benchmark/benchmark.rb

@@ -0,0 +1,42 @@
+$:.unshift(File.join(File.dirname(__FILE__), %w{.. lib}))
+
+require 'benchmark'
+require 'ipaddr'
+require 'consistent_hashing'
+
+def ip(offset)
+  address = IPAddr.new('10.0.0.0').to_i + offset
+  [24, 16, 8, 0].collect {|b| (address >> b) & 255}.join('.')
+end
+
+def rand_client_id()
+  (rand * 1_000_000).to_int
+end
+
+def benchmark_insertions_lookups()
+  # The initial ring implementation using a combination of hash and sorted list
+  # had the following results when benchmarked:
+  #                  user     system      total        real
+  # Insertions:  1.260000   0.000000   1.260000 (  1.259346)
+  # Look ups:   20.080000   0.020000  20.100000 ( 20.111773)
+  #
+  # The ring implementation using an AVLTree has the following results
+  # when benchmarked on the same system:
+  #                  user     system      total        real
+  # Insertions:  0.060000   0.000000   0.060000 (  0.062302)
+  # Look ups:    1.020000   0.000000   1.020000 (  1.028172)
+  #
+  # The performance improvement is ~20x for both insertions and lookups.
+
+  Benchmark.bm(10) do |x|
+    ring = ConsistentHashing::Ring.new(replicas: 200)
+    x.report("Insertions:") {for i in 1..1_000; ring << ip(i); end}
+    x.report("Look ups:  ") do
+      for i in 1..100_000
+        ring.point_for(rand_client_id)
+      end
+    end
+  end
+end
+
+benchmark_insertions_lookups

data/lib/consistent_hashing.rb

@@ -10,7 +10,8 @@ module ConsistentHashing
   def self.load_lib
     require File.join(LIBPATH, 'consistent_hashing', 'virtual_point')
     require File.join(LIBPATH, 'consistent_hashing', 'ring')
+    require File.join(LIBPATH, 'consistent_hashing', 'avl_tree')
   end
 end
 
-ConsistentHashing.load_lib
+ConsistentHashing.load_lib

data/lib/consistent_hashing/avl_tree.rb

@@ -0,0 +1,49 @@
+require 'avl_tree'
+
+module ConsistentHashing
+  class AVLTree < ::AVLTree
+
+    def minimum_pair()
+      # Return the key with the smallest key value.
+      return nil if @root.empty?
+
+      current_node = @root
+      while not current_node.left.empty?
+        current_node = current_node.left
+      end
+
+      [current_node.key, current_node.value]
+    end
+
+    def next_gte_pair(key)
+      # Returns the key/value pair with a key that follows the provided key in
+      # sorted order.
+      node = next_gte_node(@root, key)
+      [node.key, node.value] if not node.empty?
+    end
+
+    protected
+
+    def next_gte_node(node, key)
+      return AVLTree::Node::EMPTY if node.empty?
+
+      if key < node.key
+        # The current key qualifies as after the provided key. However, we need
+        # to check the tree on the left to see if there's a key in there also
+        # greater than the provided key but less than the current key.
+        after = next_gte_node(node.left, key)
+        after = node if after.empty?
+      elsif key > node.key
+        # The current key will not be after the provided key, but something
+        # in the right branch maybe. Check the right branch for the first key
+        # larger than our value.
+        after = next_gte_node(node.right, key)
+      elsif node.key == key
+        # An exact match qualifies as the next largest node.
+        after = node
+      end
+
+      return after
+    end
+  end
+end

data/lib/consistent_hashing/ring.rb

@@ -10,8 +10,7 @@ module ConsistentHashing
     # Public: returns a new ring object
     def initialize(nodes = [], replicas = 3)
       @replicas = replicas
-      @sorted_keys = []
-      @ring = Hash.new
+      @ring = AVLTree.new
 
       nodes.each { |node| add(node) }
     end
@@ -31,11 +30,8 @@ module ConsistentHashing
         key = hash_key(node, i)
 
         @ring[key] = VirtualPoint.new(node, key)
-        @sorted_keys << key
       end
 
-      @sorted_keys.sort!
-
       self
     end
     alias :<< :add
@@ -47,7 +43,6 @@ module ConsistentHashing
         key = hash_key(node, i)
 
         @ring.delete key
-        @sorted_keys.delete key
       end
 
       self
@@ -58,14 +53,10 @@ module ConsistentHashing
     #
     def point_for(key)
       return nil if @ring.empty?
-
       key = hash_key(key)
-
-      @sorted_keys.each do |i|
-        return @ring[i] if key <= i
-      end
-
-      @ring[@sorted_keys[0]]
+      _, value = @ring.next_gte_pair(key)
+      _, value = @ring.minimum_pair unless value
+      value
     end
 
     # Public: gets the node where to store the key
@@ -100,4 +91,4 @@ module ConsistentHashing
       Digest::MD5.hexdigest(key.to_s)[0..16].hex
     end
   end
-end
+end

data/test/consistent_hashing/test_avl_tree.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), %w{ .. test_consistent_hashing})
+
+class TestAVLTree < ConsistentHashing::TestCase
+  AVLTree = ConsistentHashing::AVLTree
+
+  def test_minimum_returns_nil_if_empty
+    tree = AVLTree.new
+    assert_nil tree.minimum_pair
+  end
+
+  def test_minimum_returns_root_node_if_only_node
+    tree = AVLTree.new
+    tree[0]= 1
+    assert_equal(tree.minimum_pair, [0, 1])
+  end
+
+  def test_minimum_returns_left_most_leaf
+    tree = AVLTree.new
+    1.upto(10) do |i|
+      tree[i] = i.to_s
+    end
+
+    assert_equal(tree.minimum_pair, [1, "1"])
+  end
+
+  def test_next_gte_pair_returns_nil_if_empty
+    tree = AVLTree.new
+    assert_nil tree.next_gte_pair("some key")
+  end
+
+  def test_next_gte_pair_finds_exact_match_key
+    tree = AVLTree.new
+    1.upto(10) do |i|
+      tree[i] = i.to_s
+    end
+
+    1.upto(10) do |i|
+      assert_equal(tree.next_gte_pair(i), [i, i.to_s])
+    end
+  end
+
+  def test_next_gte_pair_finds_slightly_larger_key
+    tree = AVLTree.new
+    (2..11).step(2) do |i|
+      tree[i] = i.to_s
+    end
+
+    (1..10).step(2) do |i|
+      assert_equal(tree.next_gte_pair(i), [i + 1, (i + 1).to_s])
+    end
+  end
+
+  def test_next_gte_pair_returns_nil_if_no_larger_keys
+    tree = AVLTree.new
+    (2..11).step(2) do |i|
+      tree[i] = i.to_s
+    end
+
+    assert_nil tree.next_gte_pair(12)
+  end
+end
+

data/test/consistent_hashing/test_ring.rb

@@ -51,34 +51,4 @@ class TestRing < ConsistentHashing::TestCase
   def test_point_for
     assert_equal "C", @ring.node_for(@examples["C"])
   end
-
-  def test_arbitrary_node_data
-    nodes = [
-      {"host" => "192.168.1.101"},
-      {"host" => "192.168.1.102"},
-      {"host" => "192.168.1.103"}
-    ]
-
-    ring = ConsistentHashing::Ring.new(nodes)
-    assert_equal 9, ring.length
-
-    ring_nodes = ring.nodes
-    assert_equal 3, ring_nodes.length
-    assert_equal "192.168.1.102", ring_nodes[1]['host']
-  end
-
-  def test_points
-    nodes = [
-      {"host" => "192.168.1.101"},
-      {"host" => "192.168.1.102"},
-      {"host" => "192.168.1.103"}
-    ]
-
-    ring = ConsistentHashing::Ring.new(nodes)
-    points = ring.points
-
-    assert_equal 9, points.length
-    assert_not_equal 0, points[0].index
-    assert_equal "192.168.1.101", points[0].node['host']
-  end
-end
+end

data/version.txt

@@ -1 +1 @@
-0.1.0
+0.2.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: consistent-hashing
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-15 00:00:00.000000000 Z
+date: 2012-09-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: avl_tree
+  requirement: &70236637210800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70236637210800
 - !ruby/object:Gem::Dependency
   name: bones
-  requirement: &70147185310840 !ruby/object:Gem::Requirement
+  requirement: &70236637209960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,8 +32,9 @@ dependencies:
         version: 3.8.0
   type: :development
   prerelease: false
-  version_requirements: *70147185310840
-description: A generic implementation of the Consistent Hashing algorithm.
+  version_requirements: *70236637209960
+description: A generic implementation of the Consistent Hashing algorithm using an
+  AVL tree.
 email: liebler.dominik@googlemail.com
 executables: []
 extensions: []
@@ -33,9 +45,12 @@ files:
 - History.txt
 - README.md
 - Rakefile
+- benchmark/benchmark.rb
 - lib/consistent_hashing.rb
+- lib/consistent_hashing/avl_tree.rb
 - lib/consistent_hashing/ring.rb
 - lib/consistent_hashing/virtual_point.rb
+- test/consistent_hashing/test_avl_tree.rb
 - test/consistent_hashing/test_ring.rb
 - test/consistent_hashing/test_virtual_point.rb
 - test/test_consistent_hashing.rb
@@ -65,8 +80,10 @@ rubyforge_project: consistent-hashing
 rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
-summary: A generic implementation of the Consistent Hashing algorithm.
+summary: A generic implementation of the Consistent Hashing algorithm using an AVL
+  tree.
 test_files:
+- test/consistent_hashing/test_avl_tree.rb
 - test/consistent_hashing/test_ring.rb
 - test/consistent_hashing/test_virtual_point.rb
 - test/test_consistent_hashing.rb