higgs 0.1.4 → 0.1.5

data/ChangeLog

@@ -1,3 +1,85 @@
+2008-01-20  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/version.rb: version 0.1.5.
+
+	* lib/higgs/tman.rb (Higgs::TransactionManager class): uncheck
+	nested transaction.
+
+2008-01-14  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* merge from development branch of MVCC (higgs_develop_mvcc).
+
+2008-01-11  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class): inner class name is
+	changed.
+
+2008-01-09  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class): lock collision
+	reduced by read-write lock.
+
+	* lib/higgs/storage.rb (Higgs::Storage class): change number lock
+	for MVCC-cache access.
+
+2008-01-05  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/storage.rb (Higgs::Storage class): backing store on
+	update is obsolete.  string_only method is obsolete.
+
+	* lib/higgs/tman.rb (Higgs::TransactionManager class): MVCC-transaction.
+
+2008-01-04  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/lock.rb: critical section in transaction.
+
+	* lib/higgs/lock.rb: Higgs::FineGrainLockManager class is
+	obsolete.  Higgs::OptimisticLockManager class is new. lock of each
+	type. check_collision method is new. unlock method is obsolete.
+
+2008-01-01  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class): resource of cache
+	accessor is releaseable in transaction.
+
+2007-12-30  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class): added
+	write_old_values method to cache accessor. fixed a bug of each_key
+	method.
+
+2007-12-24  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class): cache of each type.
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class): MVCC-cache access
+	logic is implemented.
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class):
+	NOTE: MVCC-cache access order.
+	read access: 1. source storage. -> 2. cache entry.
+	write access: 1. cache entry. -> 2. source storage.
+	(it is assumed that multithreaded read-write access of ruby's Hash
+	is atomic)
+
+	* test/test_cache_mvcc.rb: 
+
+2007-12-05  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/storage.rb (Higgs::Storage class): backing store on
+	update.
+
+2007-12-01  TOKI Yoshinori  <toki@freedom.ne.jp>
+
+	* lib/higgs/cache.rb (Higgs::MVCCCache class): cache for
+	Multi-Version Concurrency Control
+
+	* test/test_tman_mvcc.rb: test of MVCC for
+	Higgs::TransactionManager class.
+
+	* development branch of MVCC (higgs_develop_mvcc).
+	branched from trunk:r695.
+
 2007-11-28  TOKI Yoshinori  <toki@freedom.ne.jp>
 
 	* lib/higgs/version.rb: version 0.1.4.

data/README

@@ -1,2 +1,5 @@
 please run `ruby mkrdoc.rb' or `rake rdoc', and see api/index.html by
 your browser.
+
+Web: http://higgs.rubyforge.org
+E-Mail: TOKI Yoshinori <toki@freedom.ne.jp>

data/lib/higgs/cache.rb

@@ -1,8 +1,8 @@
 # = cache utilities
 #
 # Author:: $Author: toki $
-# Date:: $Date: 2007-10-31 00:36:09 +0900 (Wed, 31 Oct 2007) $
-# Revision:: $Revision: 659 $
+# Date:: $Date: 2008-01-14 00:55:53 +0900 (Mon, 14 Jan 2008) $
+# Revision:: $Revision: 742 $
 #
 # == license
 #   :include:LICENSE
@@ -16,7 +16,7 @@ module Higgs
   # = cache by Least Recently Used strategy
   class LRUCache
     # for ident(1)
-    CVS_ID = '$Id: cache.rb 659 2007-10-30 15:36:09Z toki $'
+    CVS_ID = '$Id: cache.rb 742 2008-01-13 15:55:53Z toki $'
 
     extend Forwardable
 
@@ -73,7 +73,7 @@ module Higgs
   # = multi-thread safe cache
   class SharedWorkCache
     # for ident(1)
-    CVS_ID = '$Id: cache.rb 659 2007-10-30 15:36:09Z toki $'
+    CVS_ID = '$Id: cache.rb 742 2008-01-13 15:55:53Z toki $'
 
     def initialize(cache={}, &work)
       unless (work) then
@@ -109,6 +109,163 @@ module Higgs
       r ? true : false
     end
   end
+
+  # = cache for Multi-Version Concurrency Control
+  class MVCCCache
+    extend Forwardable
+
+    def initialize
+      @lock = Mutex.new
+      @snapshots = {}
+    end
+
+    # for debug
+    def_delegator :@snapshots, :empty?
+
+    def write_old_values(cnum, write_list)
+      @lock.synchronize{
+        @snapshots.each_value do |snapshot|
+          lock = snapshot[:lock].write_lock
+          cache = snapshot[:cache]
+          lock.synchronize{
+            for ope, key, type, value in write_list
+              case (ope)
+              when :value
+                if (cache.key? key) then
+                  if (cache[key] != :none && ! (cache[key].key? type)) then
+                    cache[key][type] = { :value => value, :cnum => cnum }
+                  end
+                else
+                  cache[key] = { type => { :value => value, :cnum => cnum } }
+                end
+              when :none
+                unless (cache.key? key) then
+                  cache[key] = :none
+                end
+              else
+                raise "unknown operation: #{ope}"
+              end
+            end
+          }
+        end
+      }
+      nil
+    end
+
+    def ref_count_up(cnum)
+      @lock.synchronize{
+        @snapshots[cnum] = { :lock => ReadWriteLock.new, :cache => {}, :ref_count => 0 } unless (@snapshots.key? cnum)
+        @snapshots[cnum][:ref_count] += 1
+        return @snapshots[cnum][:lock].read_lock, @snapshots[cnum][:cache]
+      }
+    end
+
+    def ref_count_down(cnum)
+      @lock.synchronize{
+        @snapshots[cnum][:ref_count] -= 1
+        @snapshots.delete(cnum) if (@snapshots[cnum][:ref_count] == 0)
+      }
+      nil
+    end
+
+    class Snapshot
+      def initialize(parent)
+        @parent = parent
+      end
+
+      def ref_count_up(cnum)
+        @cnum = cnum
+        @lock, @cache = @parent.ref_count_up(@cnum)
+        nil
+      end
+
+      def ref_count_down
+        @cnum or raise 'not initialized'
+        @parent.ref_count_down(@cnum)
+        @cnum = @lock = @cache = nil
+      end
+
+      def change_number
+        @cnum
+      end
+
+      def cached?(key)
+        @cache.key? key
+      end
+
+      def cache_key?(key)
+        (@cache.key? key) && (@cache[key] != :none)
+      end
+
+      def each_cache_key
+        @cache.each_key do |key|
+          if (@cache[key] != :none) then
+            yield(key)
+          end
+        end
+        nil
+      end
+
+      def key?(store, key)
+        (store.key? key) && ! (cached? key) || (cache_key? key)
+      end
+
+      def keys(store)
+        key_set = {}
+        store.each_key do |key|
+          unless (cached? key) then
+            key_set[key] = true
+          end
+        end
+        each_cache_key do |key|
+          key_set[key] = true
+        end
+        key_set.keys
+      end
+
+      def each_key(store)
+        for key in keys(store)
+          yield(key)
+        end
+        nil
+      end
+
+      def fetch(key, type)
+        @lock.synchronize{
+          if (@cache.key? key) then
+            if (@cache[key] != :none) then
+              if (cache_entry = @cache[key][type]) then
+                cache_entry[:value]
+              else
+                yield
+              end
+            else
+              nil
+            end
+          else
+            yield
+          end
+        }
+      end
+
+      def write_old_values(write_list)
+        @parent.write_old_values(@cnum, write_list)
+        nil
+      end
+    end
+
+    def transaction(cnum)
+      r = nil
+      snapshot = Snapshot.new(self)
+      snapshot.ref_count_up(cnum)
+      begin
+        r = yield(snapshot)
+      ensure
+        snapshot.ref_count_down
+      end
+      r
+    end
+  end
 end
 
 # Local Variables:

data/lib/higgs/lock.rb

@@ -1,14 +1,13 @@
 # = multi-thread lock manager
 #
 # Author:: $Author: toki $
-# Date:: $Date: 2007-10-23 00:23:50 +0900 (Tue, 23 Oct 2007) $
-# Revision:: $Revision: 652 $
+# Date:: $Date: 2008-01-14 00:55:53 +0900 (Mon, 14 Jan 2008) $
+# Revision:: $Revision: 742 $
 #
 # == license
 #   :include:LICENSE
 #
 
-require 'forwardable'
 require 'higgs/cache'
 require 'higgs/exceptions'
 require 'singleton'
@@ -18,187 +17,131 @@ module Higgs
   # = multi-thread lock manager
   class LockManager
     # for ident(1)
-    CVS_ID = '$Id: lock.rb 652 2007-10-22 15:23:50Z toki $'
+    CVS_ID = '$Id: lock.rb 742 2008-01-13 15:55:53Z toki $'
 
     include Exceptions
 
     class Error < HiggsError
     end
 
-    class TryLockTimeoutError < Error
+    class CollisionError < Error
     end
 
-    SPIN_LOCK_COUNT = 100
-    TRY_LOCK_LIMIT = 10
-    TRY_LOCK_INTERVAL = 0.1
-
-    RAND_GEN = proc{|seed|
-      n = seed
-      cycle = 0xFFFF
-      proc{
-        n = (n * 37549 + 12345) % cycle
-        n.to_f / cycle
-      }
-    }
+    class NoWorkLockHandler
+      include Singleton
 
-    def initialize(options={})
-      @spin_lock_count = options[:spin_lock_count] || SPIN_LOCK_COUNT
-      @try_lock_limit = options[:try_lock_limit] || TRY_LOCK_LIMIT
-      @try_lock_interval = options[:try_lock_interval] || TRY_LOCK_INTERVAL
-      @rand_gen = options[:random_number_generator] || RAND_GEN
-    end
+      def lock(key, type, cnum)
+        self
+      end
 
-    attr_reader :spin_lock_count
-    attr_reader :try_lock_limit
-    attr_reader :try_lock_interval
+      def check_collision       # :yields: key
+        self
+      end
 
-    def new_rand(seed)
-      @rand_gen.call(seed)
+      def critical
+        yield
+      end
     end
 
-    def self.try_lock(lock, attrs)
-      t0 = Time.now
-      c = attrs.spin_lock_count
-      while (c > 0)
-        if (lock.try_lock) then
-          return
-        end
-        c -= 1
+    class CriticalRegionLockHandler
+      def initialize(critical_lock)
+        @critical_lock = critical_lock
       end
 
-      if (attrs.try_lock_limit > 0) then
-        rand = attrs.new_rand(::Thread.current.object_id ^ t0.to_i)
-        while (Time.now - t0 < attrs.try_lock_limit)
-          if (lock.try_lock) then
-            return
-          end
-          sleep(attrs.try_lock_interval * rand.call)
-        end
-        raise TryLockTimeoutError, 'expired'
-      else
-        # brave man who doesn't fear deadlock.
-        lock.lock
+      def lock(key, type, cnum)
+        self
       end
-    end
-  end
 
-  class GiantLockManager < LockManager
-    # for ident(1)
-    CVS_ID = '$Id: lock.rb 652 2007-10-22 15:23:50Z toki $'
+      def check_collision       # :yields: key
+        self
+      end
 
-    def initialize(*args)
-      super
-      @rw_lock = ReadWriteLock.new
+      def critical
+        @critical_lock.synchronize{ yield }
+      end
     end
 
-    class NoWorkLockHandler
-      include Singleton
+    class CollisionCheckLockHandler < CriticalRegionLockHandler
+      def initialize(*args)
+        super
+        @cnum_map = {}
+      end
 
-      def lock(key)
+      def lock(key, type, cnum)
+        key_pair = [ key, type ]
+        if (@cnum_map[key_pair] && @cnum_map[key_pair] != cnum) then
+          raise "unexpected changed cnum at`#{key}(#{type})': #{@cnum_map[key].inspect} -> #{cnum.inspect}"
+        end
+        @cnum_map[key_pair] = cnum
         self
       end
 
-      def unlock(key)
+      def check_collision
+        for (key, type), cnum in @cnum_map
+          last_cnum = yield(key, type)
+          if (cnum != last_cnum) then
+            raise CollisionError, "`#{key}(#{type})' is changed (cnum: #{cnum.inspect} -> #{last_cnum.inspect}) by other transaction and this transaction may be retried."
+          end
+        end
         self
       end
     end
 
-    def transaction(read_only=false)
-      if (read_only) then
-        lock = @rw_lock.read_lock
-      else
-        lock = @rw_lock.write_lock
-      end
-      r = nil
-      lock.synchronize{
-        r = yield(NoWorkLockHandler.instance)
-      }
-      r
+    def initialize
+      @tx_lock = ReadWriteLock.new
     end
 
     def exclusive
       r = nil
-      @rw_lock.write_lock.synchronize{
+      @tx_lock.write_lock.synchronize{
         r = yield
       }
       r
     end
   end
 
-  class FineGrainLockManager < LockManager
+  class GiantLockManager < LockManager
     # for ident(1)
-    CVS_ID = '$Id: lock.rb 652 2007-10-22 15:23:50Z toki $'
+    CVS_ID = '$Id: lock.rb 742 2008-01-13 15:55:53Z toki $'
 
     def initialize(*args)
       super
-      @tx_lock = ReadWriteLock.new
-      @cache = SharedWorkCache.new{|key| ReadWriteLock.new }
+      @write_lock = Mutex.new
     end
 
-    class LockHandler
-      def initialize(attrs, cache)
-        @attrs = attrs
-        @cache = cache
-        @lock_map = {}
-      end
-
-      def lock_list
-        @lock_map.values
-      end
-
-      def unlock(key)
-        if (lock = @lock_map.delete(key)) then
-          lock.unlock
+    def transaction(read_only=false)
+      r = nil
+      @tx_lock.read_lock.synchronize{
+        if (read_only) then
+          r = yield(NoWorkLockHandler.instance)
         else
-          raise "not locked key: #{key}"
+          @write_lock.synchronize{
+            r = yield(NoWorkLockHandler.instance)
+          }
         end
-        self
-      end
+      }
+      r
     end
+  end
 
-    class ReadOnlyLockHandler < LockHandler
-      def lock(key)
-        r_lock = @cache[key].read_lock
-        LockManager.try_lock(r_lock, @attrs)
-        @lock_map[key] = r_lock
-        self
-      end
-    end
+  class OptimisticLockManager < LockManager
+    # for ident(1)
+    CVS_ID = '$Id: lock.rb 742 2008-01-13 15:55:53Z toki $'
 
-    class ReadWriteLockHandler < LockHandler
-      def lock(key)
-        w_lock = @cache[key].write_lock
-        LockManager.try_lock(w_lock, @attrs)
-        @lock_map[key] = w_lock
-        self
-      end
+    def initialize(*args)
+      super
+      @critical_lock = Mutex.new
     end
 
     def transaction(read_only=false)
-      if (read_only) then
-        lock_handler = ReadOnlyLockHandler.new(self, @cache)
-      else
-        lock_handler = ReadWriteLockHandler.new(self, @cache)
-      end
-
       r = nil
       @tx_lock.read_lock.synchronize{
-        begin
-          r = yield(lock_handler)
-        ensure
-          for lock in lock_handler.lock_list
-            lock.unlock
-          end
+        if (read_only) then
+          lock_handler = CriticalRegionLockHandler.new(@critical_lock)
+        else
+          lock_handler = CollisionCheckLockHandler.new(@critical_lock)
         end
-      }
-
-      r
-    end
-
-    def exclusive
-      r = nil
-      @tx_lock.write_lock.synchronize{
-        r = yield
+        r = yield(lock_handler)
       }
       r
     end