lru_redux 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f230b3f99aa8b6685b92b965735ab60f21cdd173
-  data.tar.gz: 0e7c60bcfd0e91283c135eefa51f4374bb3392c1
+  metadata.gz: b3f0297d9fe3517fc8618150089f1fd9c7be2e52
+  data.tar.gz: fe4b97bb0935477011f09063e4e5372a3ff88f8a
 SHA512:
-  metadata.gz: 498a398539d0ef6d0160f9ccdd6f150178701f332bd812298f942b3d68a17495e90f408771e498af245a2ff70222faea9871ed2346f45c3543a4da02b992489c
-  data.tar.gz: a4c98d69dcc3ed3884aded54d944f18c60c3ecce2a75e91de0894e052f59381e6d9082061a41de2d22dba9e29cc29564e6130eff500186ed20fd5b91e5623c0f
+  metadata.gz: 955339b2b777e904ac433848202155590815863804f71e48ff78f1f8077c365bada7dcc4a4050301c482a1d21e96ec28165b2bb1b817966da4d539e281df65a7
+  data.tar.gz: adde05c954aa10c9c708c64d06787aff921e883b92400e736a3027452cd327b6b47dea3da0c6af069567e10ffb7a7d5ca56bb125a720ecd22cbbc2dde4a59c03

data/README.md

@@ -26,9 +26,14 @@ Or install it yourself as:
 require 'lru_redux'
 
 # non thread safe
-cache = LruRedux::Cache(100)
+cache = LruRedux::Cache.new(100)
 cache[:a] = "1"
 cache[:b] = "2"
+
+cache.to_a
+# [[:b,"2"],[:a,"1"]]
+# note the order matters here, last accessed is first
+
 cache[:a] # a pushed to front
 # "1"
 
@@ -36,10 +41,20 @@ cache.to_a
 # [[:a,"1"],[:b,"2"]]
 cache.delete(:a)
 cache.each {|k,v| p "#{k} #{v}"}
-# nothing
+# b 2
+
 cache.max_size(200) # cache now stores 200 items
 cache.clear # cache has no items
 
+cache.getset(:a){1}
+cache.to_a
+#[[:a,1]]
+
+# already set so don't call block
+cache.getset(:a){99}
+cache.to_a
+#[[:a,1]]
+
 # for thread safe access, all methods on cache
 # are protected with a mutex
 cache = LruRedux::ThreadSafeCache(100)
@@ -48,24 +63,24 @@ cache = LruRedux::ThreadSafeCache(100)
 
 ## Benchmarks
 
-see: benchmark directory
+see: benchmark directory (a million random lookup / store)
 
 ```
 sam@ubuntu:~/Source/lru_redux/bench$ ruby ./bench.rb
 Rehearsal ---------------------------------------------------------
-thread safe lru        27.640000   0.370000  28.010000 ( 28.049021)
-lru gem                 2.460000   0.000000   2.460000 (  2.454292)
-lru_cache gem           2.170000   0.000000   2.170000 (  2.174306)
-lru_redux gem           1.530000   0.020000   1.550000 (  1.552481)
-lru_redux thread safe   2.610000   0.070000   2.680000 (  2.684895)
------------------------------------------------ total: 36.870000sec
+thread safe lru        27.940000   0.020000  27.960000 ( 28.026869)
+lru gem                 2.250000   0.010000   2.260000 (  2.256652)
+lru_cache gem           1.980000   0.000000   1.980000 (  1.979244)
+lru_redux gem           1.190000   0.000000   1.190000 (  1.187640)
+lru_redux thread safe   2.480000   0.000000   2.480000 (  2.486314)
+----------------------------------------------- total: 35.870000sec
 
                             user     system      total        real
-thread safe lru        28.170000   0.280000  28.450000 ( 28.465008)
-lru gem                 2.330000   0.000000   2.330000 (  2.328316)
-lru_cache gem           2.140000   0.000000   2.140000 (  2.142749)
-lru_redux gem           1.640000   0.000000   1.640000 (  1.643732)
-lru_redux thread safe   2.590000   0.000000   2.590000 (  2.600422)
+thread safe lru        28.010000   0.000000  28.010000 ( 28.023534)
+lru gem                 2.250000   0.000000   2.250000 (  2.256425)
+lru_cache gem           1.920000   0.000000   1.920000 (  1.925362)
+lru_redux gem           1.170000   0.000000   1.170000 (  1.170970)
+lru_redux thread safe   2.480000   0.000000   2.480000 (  2.488169)
 
 ```
 
@@ -80,6 +95,11 @@ lru_redux thread safe   2.590000   0.000000   2.590000 (  2.600422)
 
 ## Changlog
 
+###version 0.0.5 - 23-April-2013
+
+- Added getset and fetch
+- Optimised implementation so it 20-30% faster on Ruby 1.9+
+
 ###version 0.0.4 - 23-April-2013
 
 - Initial version

data/lib/lru_redux.rb

@@ -1,4 +1,14 @@
-module LruRedux; end
+module LruRedux
+  def self.is_19?
+    major,minor = RUBY_VERSION.split(".").map{|a| a.to_i}
+    major > 1 || (major == 1 && minor > 8)
+  end
+end
+
 require "lru_redux/version"
-require "lru_redux/cache"
+if LruRedux.is_19?
+  require "lru_redux/cache19"
+else
+  require "lru_redux/cache"
+end
 require "lru_redux/thread_safe_cache"

data/lib/lru_redux/cache.rb

@@ -1,3 +1,5 @@
+
+
 class LruRedux::Cache
 
   # for high efficiency nodes in double linked list are stored in arrays
@@ -20,6 +22,26 @@ class LruRedux::Cache
     end
   end
 
+  def getset(key)
+    node = @data[key]
+    if node
+      move_to_head(node)
+      node[2]
+    else
+     self[key] = yield
+    end
+  end
+
+  def fetch(key)
+    node = @data[key]
+    if node
+      move_to_head(node)
+      node[2]
+    else
+     yield if block_given?
+    end
+  end
+
   def [](key)
     node = @data[key]
     if node

data/lib/lru_redux/cache19.rb

@@ -0,0 +1,88 @@
+# Ruby 1.9 makes our life easier, Hash is already ordered
+#
+# This is an ultra efficient 1.9 freindly implementation
+class LruRedux::Cache
+  def initialize(max_size)
+    @max_size = max_size
+    @data = {}
+  end
+
+  def max_size=(size)
+    raise ArgumentError.new(:max_size) if @max_size < 1
+    @max_size = size
+    if @max_size < @data.size
+      @data.keys[0..@max_size-@data.size].each do |k|
+        @data.delete(k)
+      end
+    end
+  end
+
+  def getset(key)
+    found = true
+    value = @data.delete(key){ found = false }
+    if found
+      @data[key] = value
+    else
+      @data[key] = yield
+      @data.delete(@data.first[0]) if @data.length > @max_size
+    end
+  end
+
+  def fetch(key)
+    found = true
+    value = @data.delete(key){ found = false }
+    if found
+      @data[key] = value
+    else
+      yield if block_given?
+    end
+  end
+
+  def [](key)
+    found = true
+    value = @data.delete(key){ found = false }
+    if found
+      @data[key] = value
+    else
+      nil
+    end
+  end
+
+  def []=(key,val)
+    @data.delete(key)
+    @data[key] = val
+    @data.delete(@data.first[0]) if @data.length > @max_size
+    val
+  end
+
+  def each
+    @data.reverse.each do |pair|
+      yield pair
+    end
+  end
+
+  # used further up the chain, non thread safe each
+  alias_method :each_unsafe, :each
+
+  def to_a
+    @data.to_a.reverse
+  end
+
+  def delete(k)
+    @data.delete(k)
+  end
+
+  def clear
+    @data.clear
+  end
+
+  def count
+    @data.count
+  end
+
+
+  # for cache validation only, ensures all is sound
+  def valid?
+    true
+  end
+end

data/lib/lru_redux/thread_safe_cache.rb

@@ -15,6 +15,6 @@ class LruRedux::ThreadSafeCache < LruRedux::Cache
     end
   end
 
-  synchronize :[], :[]=, :each, :to_a, :delete, :count, :valid?, :max_size
+  synchronize :[], :[]=, :each, :to_a, :delete, :count, :valid?, :max_size, :fetch, :getset
 
 end

data/lib/lru_redux/version.rb

@@ -1,3 +1,3 @@
 module LruRedux
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/test/cache_test.rb

@@ -21,6 +21,25 @@ class CacheTest < MiniTest::Unit::TestCase
     assert_nil @c[:a]
   end
 
+  def test_fetch
+    @c[:a] = nil
+    @c[:b] = 2
+    assert_equal @c.fetch(:a){1}, nil
+    assert_equal @c.fetch(:c){3}, 3
+
+    assert_equal [[:a,nil],[:b,2]], @c.to_a
+  end
+
+  def test_getset
+   @c.getset(:a){1}
+   @c.getset(:b){2}
+   assert_equal @c.getset(:a){11}, 1
+   @c.getset(:c){3}
+   @c.getset(:d){4}
+
+    assert_equal [[:d,4],[:c,3],[:a,1]], @c.to_a
+  end
+
   def test_pushes_lru_to_back
     @c[:a] = 1
     @c[:b] = 2

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lru_redux
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Sam Saffron
@@ -110,6 +110,7 @@ files:
 - bench/bench.rb
 - lib/lru_redux.rb
 - lib/lru_redux/cache.rb
+- lib/lru_redux/cache19.rb
 - lib/lru_redux/thread_safe_cache.rb
 - lib/lru_redux/version.rb
 - lru_redux.gemspec
@@ -135,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.0.rc.2
 signing_key: 
 specification_version: 4
 summary: An efficient implementation of an lru cache