higgs 0.1.0

data/misc/thread_bench/lock_bench.rb

@@ -0,0 +1,132 @@
+#!/usr/local/bin/ruby
+
+# for ident(1)
+CVS_ID = '$Id: lock_bench.rb 559 2007-09-25 15:20:20Z toki $'
+
+$: << File.join(File.dirname($0), '..', '..', 'lib')
+
+require 'benchmark'
+require 'higgs/thread'
+require 'monitor'
+require 'sync'
+require 'thread'
+
+loop_count = (ARGV.shift || '1000').to_i
+thread_count = (ARGV.shift || '10').to_i
+puts "#{$0}: LOOP:#{loop_count}, THREAD:#{thread_count}"
+
+Benchmark.bm(30) do |x|
+  [ [ Mutex.new,   'Mutex' ],
+    [ Monitor.new, 'Monitor' ],
+    [ Higgs::ReadWriteLock.new.read_lock, 'ReadWriteLock (read:M)' ],
+    [ Higgs::ReadWriteLock.new.write_lock, 'ReadWriteLock (write:M)' ]
+  ].each do |m, name|
+    barrier = Higgs::Barrier.new(thread_count + 1)
+    th_grp = ThreadGroup.new
+    thread_count.times do
+      th_grp.add Thread.new{
+        barrier.wait
+        loop_count.times do
+          m.synchronize{
+            # nothing to do.
+          }
+        end
+      }
+    end
+
+    x.report(name) {
+      barrier.wait
+      for t in th_grp.list
+        t.join
+      end
+    }
+  end
+
+  r_lock, w_lock = Higgs::ReadWriteLock.new.to_a
+  barrier = Higgs::Barrier.new(thread_count + 1)
+  th_grp = ThreadGroup.new
+  (thread_count - 1).times do
+    th_grp.add Thread.new{
+      barrier.wait
+      loop_count.times do
+        r_lock.synchronize{
+          # nothing to do.
+        }
+      end
+    }
+  end
+  th_grp.add Thread.new{
+    barrier.wait
+    loop_count.times do
+      w_lock.synchronize{
+        # nothing to do.
+      }
+    end
+  }
+
+  x.report('ReadWriteLock (read:M/write:1)') {
+    barrier.wait
+    for t in th_grp.list
+      t.join
+    end
+  }
+
+  [ [ Sync::SH, 'Sync (read:M)' ],
+    [ Sync::EX, 'Sync (write:M)' ]
+  ].each do |mode, name|
+    s = Sync.new
+    barrier = Higgs::Barrier.new(thread_count + 1)
+    th_grp = ThreadGroup.new
+    thread_count.times do
+      th_grp.add Thread.new{
+        barrier.wait
+        loop_count.times do
+          s.synchronize(mode) {
+            # nothing to do.
+          }
+        end
+      }
+    end
+
+    x.report(name) {
+      barrier.wait
+      for t in th_grp.list
+        t.join
+      end
+    }
+  end
+
+  s = Sync.new
+  barrier = Higgs::Barrier.new(thread_count + 1)
+  th_grp = ThreadGroup.new
+  (thread_count - 1).times do
+    th_grp.add Thread.new{
+      barrier.wait
+      loop_count.times do
+        s.synchronize(Sync::SH) {
+          # nothing to do.
+        }
+      end
+    }
+  end
+  th_grp.add Thread.new{
+    barrier.wait
+    loop_count.times do
+      s.synchronize(Sync::EX) {
+        # nothing to do.
+      }
+    end
+  }
+
+  x.report('Sync (read:M/write:1)') {
+    barrier.wait
+    for t in th_grp.list
+      t.join
+    end
+  }
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/mkrdoc.rb

@@ -0,0 +1,8 @@
+#!/usr/local/bin/ruby
+
+CVS_ID = '$Id: mkrdoc.rb 564 2007-09-27 16:10:25Z toki $'			# for ident(1)
+
+require 'yaml'
+
+rdoc_opts = YAML.load(IO.read('rdoc.yml'))
+system 'rdoc', *(rdoc_opts['CommonOptions'] + rdoc_opts['CommandLineOptions']).flatten

data/rdoc.yml

@@ -0,0 +1,13 @@
+CommonOptions:
+  - -SNa
+  - [ -i, . ]
+  - [ -m, Higgs ]
+
+CommandLineOptions:
+  - [ -i, lib ]
+  - [ -x, misc ]
+  - [ -x, mkrdoc ]
+  - [ -x, pkg ]
+  - [ -x, sample ]
+  - [ -x, test ]
+  - [ -o, api ]

data/sample/count.rb

@@ -0,0 +1,60 @@
+#!/usr/local/bin/ruby
+
+require 'higgs'
+require 'higgs/thread'          # for Higgs::Barrier
+
+num_of_write_threads = (ARGV.shift || '10').to_i
+num_of_count = (ARGV.shift || '100').to_i
+
+Higgs::Store.open('count') {|st|
+  st.transaction(true) {|tx|
+    puts "start - #{Time.now}"
+    p tx[:count]
+    puts ''
+  }
+
+  th_grp = ThreadGroup.new
+  barrier = Higgs::Barrier.new(num_of_write_threads + 2)
+  is_print = true
+
+  num_of_write_threads.times do
+    th_grp.add Thread.new{
+      barrier.wait
+      num_of_count.times do
+        st.transaction{|tx|
+          tx[:count] = 0 unless (tx.key? :count)
+          tx[:count] += 1
+        }
+      end
+    }
+  end
+
+  th_read = Thread.new{
+    barrier.wait
+    while (is_print)
+      st.transaction(true) {|tx|
+        p tx[:count]
+      }
+      sleep(0.1)
+    end
+  }
+
+  barrier.wait
+  for t in th_grp.list
+    t.join
+  end
+
+  is_print = false
+  th_read.join
+
+  st.transaction(true) {|tx|
+    puts ''
+    puts "last - #{Time.now}"
+    p tx[:count]
+  }
+}
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/sample/dbmtest.rb

@@ -0,0 +1,38 @@
+#!/usr/local/bin/ruby
+
+require 'higgs'
+
+Higgs::DBM.open('test') {|dbm|
+  dbm.transaction{|tx|
+    keys = tx.keys
+    if (keys.length > 0) then
+      for k in keys
+        puts "-"
+        puts "key: #{k}"
+        puts "value: #{tx[k]}"
+        tx.each_property(k) do |name, value|
+          case (name)
+          when Symbol
+            puts "system_property[#{name}]: #{value}"
+          when String
+            puts "custom_property[#{name}]: #{value}"
+          else
+            raise "unexpected property name: #{name}"
+          end
+        end
+      end
+    else
+      tx['foobar'] = 'FB'
+      tx.set_property('foobar', 'number', 0)
+      tx['baz'] = 'BZ'
+      tx.set_property('baz', 'number', 1)
+      tx['quux'] = 'QX'
+      tx.set_property('quux', 'number', 2)
+    end
+  }
+}
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/Rakefile

@@ -0,0 +1,45 @@
+# for ident(1)
+CVS_ID = '$Id: Rakefile 561 2007-09-26 15:46:49Z toki $'
+
+LIB_DIR = File.join(File.dirname(__FILE__), '..', 'lib')
+RCOV_DIR = File.join(File.dirname(__FILE__), 'coverage')
+
+task :default => [ :test ]
+
+task :test do
+  ruby '-I', LIB_DIR, 'run.rb'
+end
+
+task :rcov do
+  rm_rf RCOV_DIR
+  sh 'rcov', '-I', LIB_DIR, '-x', 'rcov\.rb,run\.rb', 'run.rb'
+end
+
+task :optional do
+  for opt_rb in Dir['optional/*.rb']
+    symlnk_rb = File.basename(opt_rb)
+    unless (File.symlink? symlnk_rb) then
+      ln_s opt_rb, symlnk_rb, :verbose => true
+    end
+  end
+end
+
+task :clean do
+  rm_rf RCOV_DIR
+end
+
+task :clean_optional do
+  for opt_rb in Dir['optional/*.rb']
+    symlnk_rb = File.basename(opt_rb)
+    rm_f symlnk_rb
+  end
+end
+
+rule '.test' => [ '.rb' ] do |t|
+  ruby '-I', LIB_DIR, 'run.rb', '^' + Regexp.quote(t.source) + '$'
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/run.rb

@@ -0,0 +1,32 @@
+#!/usr/local/bin/ruby
+
+$: << File.dirname(__FILE__)
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+# for ident(1)
+CVS_ID = '$Id: run.rb 575 2007-09-29 08:13:51Z toki $'
+
+mask = //                       # any match
+if ($0 == __FILE__) then
+  if (ARGV.length > 0 && ARGV[0] !~ /^-/) then
+    mask = Regexp.compile(ARGV.shift)
+  end
+end
+
+test_dir, this_name = File.split(__FILE__)
+for test_rb in Dir.entries(test_dir).sort
+  case (test_rb)
+  when this_name
+    # skip
+  when /^test_.*\.rb$/
+    if (test_rb =~ mask) then
+      puts "load #{test_rb}"
+      require File.join(test_dir, test_rb)
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_block.rb

@@ -0,0 +1,163 @@
+#!/usr/local/bin/ruby
+
+require 'digest/sha2'
+require 'fileutils'
+require 'higgs/block'
+require 'test/unit'
+
+module Higgs::Test
+  class BlockTest < Test::Unit::TestCase
+    include Higgs::Block
+
+    # for ident(1)
+    CVS_ID = '$Id: test_block.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @io = File.open('block.test_io', 'w+')
+      @io.binmode
+    end
+
+    def teardown
+      @io.close unless @io.closed?
+      FileUtils.rm_f('block.test_io')
+    end
+
+    def test_single_head_write_read
+      body = 'foo'
+      body_cksum_bin = Digest::SHA512.digest(body)
+      head_write(@io, 'FOO', body.length, 'SHA512', body_cksum_bin)
+
+      @io.seek(0)
+      r = head_read(@io, 'FOO')
+      assert_equal(body.length,    r[0])
+      assert_equal('SHA512',       r[1])
+      assert_equal(body_cksum_bin, r[2])
+    end
+
+    def test_single_block_write_read
+      body = 'foo'
+      block_write(@io, 'FOO', body)
+
+      @io.seek(0)
+      assert_equal(body, block_read(@io, 'FOO'))
+    end
+
+    def test_many_block_write_read
+      data_list = (0..12).map{|i| 'Z' * 2**i }.map{|s| [ s[0..-2], s, s + 'Z' ] }.flatten
+      for s in data_list
+        block_write(@io, 'FOO', s)
+      end
+
+      i = 0
+      @io.seek(0)
+      while (s = block_read(@io, 'FOO'))
+        assert(! data_list.empty?, "nth:#{i}")
+        assert_equal(data_list.shift, s)
+      end
+      assert(data_list.empty?)
+    end
+
+    def test_empty_read
+      assert_nil(head_read(@io, 'FOO'))
+      assert_nil(block_read(@io, 'FOO'))
+    end
+
+    def test_head_read_BrokenError_short_read
+      @io.write("\x00")
+      @io.seek(0)
+      assert_raise(BrokenError) {
+        head_read(@io, 'FOO')
+      }
+    end
+
+    def test_head_read_BrokenError_broken_head_block
+      body = 'foo'
+      body_cksum_bin = Digest::SHA512.digest(body)
+      head_write(@io, 'FOO', body.length, 'SHA512', body_cksum_bin)
+
+      @io.seek(511)
+      @io.write("\xFF")
+      @io.seek(0)
+
+      assert_raise(BrokenError) {
+        head_read(@io, 'FOO')
+      }
+    end
+
+    def test_head_read_BrokenError_unknown_magic_symbol
+      body = 'foo'
+      body_cksum_bin = Digest::SHA512.digest(body)
+      head_write(@io, 'BAR', body.length, 'SHA512', body_cksum_bin)
+      @io.seek(0)
+
+      assert_raise(BrokenError) {
+        head_read(@io, 'FOO')
+      }
+    end
+
+    def test_block_read_BrokenError_short_unexpected_EOF_1
+      block_write(@io, 'FOO', 'foo')
+      @io.truncate(512)
+      @io.seek(0)
+      assert_raise(BrokenError) {
+        block_read(@io, 'FOO')
+      }
+    end
+
+    def test_block_read_BrokenError_short_read_1
+      block_write(@io, 'FOO', 'foo')
+      @io.truncate(513)
+      @io.seek(0)
+      assert_raise(BrokenError) {
+        block_read(@io, 'FOO')
+      }
+    end
+
+    def test_block_read_BrokenError_short_unexpected_EOF_2
+      block_write(@io, 'FOO', 'foo')
+      @io.truncate(515)
+      @io.seek(0)
+      assert_raise(BrokenError) {
+        block_read(@io, 'FOO')
+      }
+    end
+
+    def test_block_read_BrokenError_short_read_2
+      block_write(@io, 'FOO', 'foo')
+      @io.truncate(1023)
+      @io.seek(0)
+      assert_raise(BrokenError) {
+        block_read(@io, 'FOO')
+      }
+    end
+
+    def test_block_read_BrokenError_unknown_body_cksum_type
+      body = 'foo'
+      block_write(@io, 'FOO', body)
+      @io.seek(0)
+      head_write(@io, 'FOO', body.length, 'UNKNOWN', Digest::SHA512.digest(body))
+      @io.seek(0)
+
+      assert_raise(BrokenError) {
+        block_read(@io, 'FOO')
+      }
+    end
+
+    def test_block_read_BrokenError_unknown_body_cksum_error
+      body = 'foo'
+      block_write(@io, 'FOO', body)
+      @io.seek(0)
+      head_write(@io, 'FOO', body.length, 'SHA512', '')
+      @io.seek(0)
+
+      assert_raise(BrokenError) {
+        block_read(@io, 'FOO')
+      }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_cache.rb

@@ -0,0 +1,214 @@
+#!/usr/local/bin/ruby
+
+require 'higgs/cache'
+require 'higgs/thread'
+require 'test/unit'
+require 'timeout'
+
+module Higgs::Test
+  class LRUCacheTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_cache.rb 559 2007-09-25 15:20:20Z toki $'
+
+    CACHE_LIMIT_SIZE = 10
+
+    def setup
+      @cache = LRUCache.new(CACHE_LIMIT_SIZE)
+    end
+
+    def test_store_and_fetch
+      @cache[:foo] = 'apple'
+      @cache[:bar] = 'banana'
+      @cache[:baz] = 'orange'
+      assert_equal('apple',  @cache[:foo])
+      assert_equal('banana', @cache[:bar])
+      assert_equal('orange', @cache[:baz])
+    end
+
+    def test_fetch_not_defined_value
+      assert_nil(@cache[:foo])
+      assert_nil(@cache[:bar])
+      assert_nil(@cache[:baz])
+    end
+
+    def test_delete
+      @cache[:foo] = 'apple'
+      @cache[:bar] = 'banana'
+      @cache[:baz] = 'orange'
+      @cache.delete(:bar)
+      assert_equal('apple',  @cache[:foo])
+      assert_equal(nil,      @cache[:bar])
+      assert_equal('orange', @cache[:baz])
+    end
+
+    def test_LRU_read
+      CACHE_LIMIT_SIZE.times do |i|
+        @cache[i] = i.to_s
+      end
+      CACHE_LIMIT_SIZE.times do |i|
+        assert_equal(i.to_s, @cache[i], "#{i}")
+      end
+
+      old_key = 0
+      last_key = CACHE_LIMIT_SIZE - 1
+      new_key = CACHE_LIMIT_SIZE
+
+      @cache[new_key] = new_key.to_s
+      assert_equal(nil,           @cache[old_key])
+      assert_equal(last_key.to_s, @cache[last_key])
+      assert_equal(new_key.to_s,  @cache[new_key])
+    end
+
+    def test_LRU_write
+      CACHE_LIMIT_SIZE.times do |i|
+        @cache[i] = i.to_s
+      end
+      (0...CACHE_LIMIT_SIZE).to_a.reverse_each do |i|
+        @cache[i] = i.to_s
+      end
+
+      old_key = CACHE_LIMIT_SIZE - 1
+      last_key = 0
+      new_key = CACHE_LIMIT_SIZE
+
+      @cache[new_key] = new_key.to_s
+      assert_equal(nil,           @cache[old_key])
+      assert_equal(last_key.to_s, @cache[last_key])
+      assert_equal(new_key.to_s,  @cache[new_key])
+    end
+  end
+
+  class SharedWorkCacheTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_cache.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @calc_calls = 0
+      @cache = SharedWorkCache.new{|key| calc(key) }
+    end
+
+    def calc(n)
+      @calc_calls += 1
+      @s = 0                    # @s's scope is over multi-threading
+      for i in 1..n
+        @s += i
+      end
+      @s
+    end
+
+    def test_calc
+      assert_equal(1, calc(1))
+      assert_equal(1, @calc_calls)
+
+      assert_equal(3, calc(2))
+      assert_equal(2, @calc_calls)
+
+      assert_equal(6, calc(3))
+      assert_equal(3, @calc_calls)
+
+      assert_equal(10, calc(4))
+      assert_equal(4, @calc_calls)
+
+      assert_equal(15, calc(5))
+      assert_equal(5, @calc_calls)
+    end
+
+    def test_fetch
+      100.times do |i|
+        assert_equal(1,  @cache[1], "loop(#{i})")
+        assert_equal(3,  @cache[2], "loop(#{i})")
+        assert_equal(6,  @cache[3], "loop(#{i})")
+        assert_equal(10, @cache[4], "loop(#{i})")
+        assert_equal(15, @cache[5], "loop(#{i})")
+        assert_equal(5, @calc_calls)
+      end
+    end
+
+    def test_delete
+      assert_equal(false, @cache.delete(5))
+      assert_equal(15, @cache[5])
+      assert_equal(1, @calc_calls)
+
+      assert_equal(true, @cache.delete(5))
+      assert_equal(15, @cache[5])
+      assert_equal(2, @calc_calls, 'reload')
+    end
+
+    NUM_OF_THREADS = 10
+    WORK_COUNT = 10000
+
+    def calc_race_condition
+      barrier = Higgs::Barrier.new(NUM_OF_THREADS + 1)
+      th_grp = ThreadGroup.new
+
+      result_list = [ nil ] * NUM_OF_THREADS
+      NUM_OF_THREADS.times{|i|  # `i' should be local scope of thread block
+        th_grp.add Thread.new{
+          barrier.wait
+          result_list[i] = calc(WORK_COUNT)
+        }
+      }
+
+      barrier.wait
+      for t in th_grp.list
+        t.join
+      end
+
+      expected_value = calc(WORK_COUNT)
+      result_list.find{|v| v != expected_value }
+    end
+    private :calc_race_condition
+
+    def test_multi_thread_fetch
+      count = 0
+      timeout(10) {
+        begin
+          count += 1
+        end until (calc_race_condition)
+      }
+
+      @calc_calls = 0
+      expected_result = calc(WORK_COUNT)
+      assert_equal(1, @calc_calls)
+
+      count.times do |n|
+        barrier = Higgs::Barrier.new(NUM_OF_THREADS + 1)
+        th_grp = ThreadGroup.new
+        NUM_OF_THREADS.times{|i|  # `i' should be local scope of thread block
+          th_grp.add Thread.new{
+            barrier.wait
+            assert_equal(expected_result, @cache[WORK_COUNT], "#{n}th: th#{i}")
+          }
+        }
+
+        barrier.wait
+        for t in th_grp.list
+          t.join
+        end
+        assert_equal(2, @calc_calls, "#{n}th")
+      end
+    end
+  end
+
+  class SharedWorkCacheNoWorkBlockTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_cache.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def test_no_work_block
+      assert_raise(RuntimeError) {
+        SharedWorkCache.new
+      }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: