higgs 0.1.4 → 0.1.5

data/test/test_lock.rb

@@ -3,23 +3,24 @@
 require 'higgs/lock'
 require 'higgs/thread'
 require 'test/unit'
-require 'thwait'
+
+Thread.abort_on_exception = true if $DEBUG
 
 module Higgs::Test
   module LockManagerTest
     include Higgs
 
     # for ident(1)
-    CVS_ID = '$Id: test_lock.rb 652 2007-10-22 15:23:50Z toki $'
+    CVS_ID = '$Id: test_lock.rb 746 2008-01-20 13:29:24Z toki $'
 
-    WORK_COUNT = 100
+    WORK_COUNT = 1000
     THREAD_COUNT = 10
 
     def test_read_transaction_single_thread
       v = "foo"
       WORK_COUNT.times do
         @lock_manager.transaction(true) {|lock_handler|
-          lock_handler.lock(:foo)
+          lock_handler.lock(:foo, :data, 0)
           assert_equal("foo", v)
         }
       end
@@ -29,7 +30,8 @@ module Higgs::Test
       count = 0
       WORK_COUNT.times do
         @lock_manager.transaction{|lock_handler|
-          lock_handler.lock(:foo)
+          lock_handler.lock(:foo, :data, 0)
+          check_collision(lock_handler, [ :foo, :data ] => 0)
           count += 1
         }
       end
@@ -44,10 +46,10 @@ module Higgs::Test
       THREAD_COUNT.times{|i|
         th_grp.add Thread.new{
           @lock_manager.transaction(true) {|lock_handler|
-            lock_handler.lock(:foo)
+            lock_handler.lock(:foo, :data, 0)
             barrier.wait
             WORK_COUNT.times do |j|
-              assert_equal("foo", v, "read transaction: #{i}.#{j}")
+              assert_equal("foo", v, "read transaction: #{i}-#{j}")
             end
           }
         }
@@ -61,6 +63,9 @@ module Higgs::Test
 
     def test_write_transaction_multithread
       count = 0
+      mvcc_last_cnum = 0
+      mvcc_old_values = {}
+      mvcc_lock = Mutex.new
       th_grp = ThreadGroup.new
       barrier = Barrier.new(THREAD_COUNT + 1)
 
@@ -68,10 +73,24 @@ module Higgs::Test
         th_grp.add Thread.new{
           barrier.wait
           WORK_COUNT.times do
-            @lock_manager.transaction{|lock_handler|
-              lock_handler.lock(:foo)
-              count += 1
-            }
+            begin
+              @lock_manager.transaction{|lock_handler|
+                curr_cnum = mvcc_last_cnum # save at first
+                lock_handler.lock(:foo, :data, curr_cnum)
+                next_count = mvcc_lock.synchronize{ mvcc_old_values[curr_cnum] || count }
+                next_count += 1
+                lock_handler.critical{
+                  check_collision(lock_handler, [ :foo, :data ] => mvcc_last_cnum)
+                  mvcc_lock.synchronize{
+                    mvcc_old_values[mvcc_last_cnum] = count
+                  }
+                  count = next_count
+                  mvcc_last_cnum += 1 # increment at last
+                }
+              }
+            rescue LockManager::CollisionError
+              retry
+            end
           end
         }
       end
@@ -85,16 +104,22 @@ module Higgs::Test
 
     def test_read_write_transaction_multithread
       count = 0
+      mvcc_last_cnum = 0
+      mvcc_old_values = {}
+      mvcc_lock = Mutex.new
       th_grp = ThreadGroup.new
       barrier = Barrier.new(THREAD_COUNT * 2 + 1)
 
       THREAD_COUNT.times{|i|
         th_grp.add Thread.new{
           @lock_manager.transaction(true) {|lock_handler|
-            lock_handler.lock(:foo)
+            curr_cnum = mvcc_last_cnum # save at first
+            lock_handler.lock(:foo, :data, curr_cnum)
             barrier.wait
             WORK_COUNT.times do |j|
-              assert_equal(0, count, "read transaction: #{i}.#{j}")
+              assert_equal(curr_cnum,
+                           mvcc_lock.synchronize { mvcc_old_values[curr_cnum] || count },
+                           "read transaction: #{i}-#{j}")
             end
           }
         }
@@ -104,10 +129,26 @@ module Higgs::Test
         th_grp.add Thread.new{
           barrier.wait
           WORK_COUNT.times do
-            @lock_manager.transaction{|lock_handler|
-              lock_handler.lock(:foo)
-              count += 1
-            }
+            begin
+              @lock_manager.transaction{|lock_handler|
+                curr_cnum = mvcc_last_cnum # save at first
+                lock_handler.lock(:foo, :data, curr_cnum)
+                next_count = mvcc_lock.synchronize{
+                  mvcc_old_values[curr_cnum] || count
+                }
+                next_count += 1
+                lock_handler.critical{
+                  check_collision(lock_handler, [ :foo, :data ] => mvcc_last_cnum)
+                  mvcc_lock.synchronize{
+                    mvcc_old_values[mvcc_last_cnum] = count
+                  }
+                  count = next_count
+                  mvcc_last_cnum += 1 # increment at last
+                }
+              }
+            rescue LockManager::CollisionError
+              retry
+            end
           end
         }
       end
@@ -152,8 +193,12 @@ module Higgs::Test
     end
 
     def test_read_write_exclusive_multithread
-      v = 'foo'
+      state = :transaction
       count = 0
+      ex_count = 0
+      mvcc_last_cnum = 0
+      mvcc_old_values = {}
+      mvcc_lock = Mutex.new
       th_grp = ThreadGroup.new
       barrier = Barrier.new(THREAD_COUNT * 3 + 1)
 
@@ -162,8 +207,13 @@ module Higgs::Test
           barrier.wait
           WORK_COUNT.times do |j|
             @lock_manager.transaction(true) {|lock_handler|
-              lock_handler.lock(:foo)
-              assert_equal('foo', v, "read transaction: #{i}.#{j}")
+              assert_equal(:transaction, state)
+              curr_cnum = mvcc_last_cnum # save at first
+              lock_handler.lock(:foo, :data, curr_cnum)
+              assert_equal(curr_cnum,
+                           mvcc_lock.synchronize{ mvcc_old_values[curr_cnum] || count },
+                           "read transaction: #{i}-#{j}")
+              assert_equal(:transaction, state)
             }
           end
         }
@@ -173,13 +223,27 @@ module Higgs::Test
         th_grp.add Thread.new{
           barrier.wait
           WORK_COUNT.times do |j|
-            @lock_manager.transaction{|lock_handler|
-              lock_handler.lock(:foo)
-              assert_equal('foo', v, "write transaction: #{i}.#{j}")
-              v = 'bar'
-              v = 'foo'
-              count += 1
-            }
+            begin
+              @lock_manager.transaction{|lock_handler|
+                assert_equal(:transaction, state)
+                curr_cnum = mvcc_last_cnum # save at first
+                lock_handler.lock(:foo, :data, curr_cnum)
+                next_count = mvcc_lock.synchronize{ mvcc_old_values[curr_cnum] || count }
+                next_count += 1
+                lock_handler.critical{
+                  check_collision(lock_handler, [ :foo, :data ] => mvcc_last_cnum)
+                  mvcc_lock.synchronize{
+                    mvcc_old_values[mvcc_last_cnum] = count
+                  }
+                  count = next_count
+                  ex_count += 1
+                  mvcc_last_cnum += 1 # increment at last
+                }
+                assert_equal(:transaction, state)
+              }
+            rescue LockManager::CollisionError
+              retry
+            end
           end
         }
       }
@@ -189,10 +253,10 @@ module Higgs::Test
           barrier.wait
           WORK_COUNT.times do |j|
             @lock_manager.exclusive{
-              assert_equal('foo', v, "exclusive: #{i}.#{j}")
-              v = 'baz'
-              v = 'foo'
-              count += 1
+              save_state = state
+              state = :exclusive
+              ex_count += 1
+              state = save_state
             }
           end
         }
@@ -202,111 +266,8 @@ module Higgs::Test
       for t in th_grp.list
         t.join
       end
-      assert_equal('foo', v)
-      assert_equal(THREAD_COUNT * WORK_COUNT * 2, count)
-    end
-  end
-
-  class GiantLockManagerTest < Test::Unit::TestCase
-    include Higgs
-    include LockManagerTest
-
-    # for ident(1)
-    CVS_ID = '$Id: test_lock.rb 652 2007-10-22 15:23:50Z toki $'
-
-    def setup
-      @lock_manager = GiantLockManager.new
-    end
-
-    def test_write_read_transaction_multithread
-      count = 0
-      th_grp = ThreadGroup.new
-      barrier = Barrier.new(THREAD_COUNT + 2)
-
-      th_grp.add Thread.new{
-        @lock_manager.transaction{|lock_handler|
-          lock_handler.lock(:foo)
-          barrier.wait
-          THREAD_COUNT.times do
-            WORK_COUNT.times do
-              count += 1
-            end
-          end
-        }
-      }
-
-      THREAD_COUNT.times{|i|
-        th_grp.add Thread.new{
-          barrier.wait          # different point from FineGrainLockManager
-          @lock_manager.transaction(true) {|lock_handler|
-            lock_handler.lock(:foo)
-            assert_equal(THREAD_COUNT * WORK_COUNT, count, "read transaction: #{i}")
-          }
-        }
-      }
-
-      barrier.wait
-      for t in th_grp.list
-        t.join
-      end
-    end
-  end
-
-  class FineGrainLockManagerTest < Test::Unit::TestCase
-    include Higgs
-    include LockManagerTest
-
-    # for ident(1)
-    CVS_ID = '$Id: test_lock.rb 652 2007-10-22 15:23:50Z toki $'
-
-    def setup
-      @lock_manager = FineGrainLockManager.new
-    end
-
-    def test_write_read_transaction_multithread
-      count = 0
-      th_grp = ThreadGroup.new
-      barrier = Barrier.new(THREAD_COUNT + 2)
-
-      th_grp.add Thread.new{
-        @lock_manager.transaction{|lock_handler|
-          lock_handler.lock(:foo)
-          barrier.wait
-          THREAD_COUNT.times do
-            WORK_COUNT.times do
-              count += 1
-            end
-          end
-        }
-      }
-
-      THREAD_COUNT.times{|i|
-        th_grp.add Thread.new{
-          @lock_manager.transaction(true) {|lock_handler|
-            barrier.wait   # different point from GiantLockManager
-            lock_handler.lock(:foo)
-            assert_equal(THREAD_COUNT * WORK_COUNT, count, "read transaction: #{i}")
-          }
-        }
-      }
-
-      barrier.wait
-      for t in th_grp.list
-        t.join
-      end
-    end
-  end
-
-  class GiantLockManagerNoDeadLockTest < Test::Unit::TestCase
-    include Higgs
-
-    # for ident(1)
-    CVS_ID = '$Id: test_lock.rb 652 2007-10-22 15:23:50Z toki $'
-
-    WORK_COUNT = 1000
-
-    def setup
-      @lock_manager = GiantLockManager.new
+      assert_equal(THREAD_COUNT * WORK_COUNT, count)
+      assert_equal(THREAD_COUNT * WORK_COUNT * 2, ex_count)
     end
 
     def test_transaction_no_dead_lock
@@ -316,8 +277,9 @@ module Higgs::Test
         barrier.wait
         WORK_COUNT.times do
           @lock_manager.transaction{|lock_handler|
-            lock_handler.lock(:foo)
-            lock_handler.lock(:bar)
+            lock_handler.lock(:foo, :data, 0)
+            lock_handler.lock(:bar, :data, 0)
+            check_collision(lock_handler, [ :foo, :data ] => 0, [ :bar, :data ] => 0)
           }
         end
       }
@@ -326,8 +288,9 @@ module Higgs::Test
         barrier.wait
         WORK_COUNT.times do
           @lock_manager.transaction{|lock_handler|
-            lock_handler.lock(:bar)
-            lock_handler.lock(:foo)
+            lock_handler.lock(:bar, :data, 1)
+            lock_handler.lock(:foo, :data, 1)
+            check_collision(lock_handler, [ :foo, :data ] => 1, [ :bar, :data ] => 1)
           }
         end
       }
@@ -338,65 +301,41 @@ module Higgs::Test
     end
   end
 
-  class FineGrainLockManagerDeadLockTest < Test::Unit::TestCase
+  class GiantLockManagerTest < Test::Unit::TestCase
     include Higgs
+    include LockManagerTest
 
     # for ident(1)
-    CVS_ID = '$Id: test_lock.rb 652 2007-10-22 15:23:50Z toki $'
+    CVS_ID = '$Id: test_lock.rb 746 2008-01-20 13:29:24Z toki $'
 
     def setup
-      @lock_manager = FineGrainLockManager.new(:spin_lock_count   => 10,
-                                               :try_lock_limit    => 0.1,
-                                               :try_lock_interval => 0.001)
+      @lock_manager = GiantLockManager.new
     end
 
-    def test_transaction_dead_lock
-      barrier = Barrier.new(3)
-
-      m1 = Mutex.new
-      end_of_t1 = false
+    def check_collision(lock_handler, expected_cnum)
+      lock_handler.check_collision{|key, type|
+        flunk("not to reach.")
+      }
+    end
+  end
 
-      m2 = Mutex.new
-      end_of_t2 = false
+  class OptimisticLockManagerTest < Test::Unit::TestCase
+    include Higgs
+    include LockManagerTest
 
-      t1 = Thread.new{
-        barrier.wait
-        begin
-          until (m2.synchronize{ end_of_t2 })
-            @lock_manager.transaction{|lock_handler|
-              lock_handler.lock(:foo)
-              sleep(0.03)
-              lock_handler.lock(:bar)
-            }
-          end
-        ensure
-          m1.synchronize{ end_of_t1 = true }
-        end
-      }
+    # for ident(1)
+    CVS_ID = '$Id: test_lock.rb 746 2008-01-20 13:29:24Z toki $'
 
-      t2 = Thread.new{
-        barrier.wait
-        begin
-          until (m1.synchronize{ end_of_t1 })
-            @lock_manager.transaction{|lock_handler|
-              lock_handler.lock(:bar)
-              sleep(0.07)
-              lock_handler.lock(:foo)
-            }
-          end
-        ensure
-          m2.synchronize{ end_of_t2 = true }
-        end
-      }
+    def setup
+      @lock_manager = OptimisticLockManager.new
+    end
 
-      barrier.wait
-      assert_raise(LockManager::TryLockTimeoutError) {
-        t1.join
-        t2.join
+    def check_collision(lock_handler, expected_cnum)
+      lock_handler.check_collision{|key, type|
+        key_pair = [ key, type ]
+        expected_cnum.delete(key_pair) or flunk("not defined key: `#{key}(#{type})'")
       }
-
-      # join threads without exception
-      ThreadsWait.all_waits(t1, t2)
+      assert_equal({}, expected_cnum)
     end
   end
 end

data/test/test_replication.rb

@@ -9,6 +9,8 @@ require 'higgs/tman'
 require 'logger'
 require 'test/unit'
 
+Thread.abort_on_exception = true if $DEBUG
+
 module Higgs::Test
   module ReplicationTest
     include Higgs