fsdb 0.5 → 0.6.0

data/junk/sync.rb

@@ -0,0 +1,327 @@
+#!/usr/bin/env ruby
+
+unless defined? Thread.exclusive
+  def Thread.exclusive
+    old = Thread.critical
+    begin
+      Thread.critical = true
+      return yield
+    ensure
+      Thread.critical = old
+    end
+  end
+end
+
+module FSDB
+
+# Synchronzer class based on standard sync.rb, which has some problems:
+# - waiters are not a strict queue (try_lock can jump the queue, after
+#   which the queue gets *rotated*). Race condition.
+# - doesn't use Thread.exclusive in enough places
+# - no way to make dead threads give up the mutex, which is crucial in a fork
+
+# based on standard sync.rb
+module Sync_m
+  # lock mode
+  UN = :UN
+  SH = :SH
+  EX = :EX
+  
+  # exceptions
+  class Err < StandardError
+    def Err.Fail(*opt)
+      fail self, sprintf(self::Message, *opt)
+    end
+    
+    class UnknownLocker < Err
+      Message = "Thread(%s) not locked."
+      def UnknownLocker.Fail(th)
+	super(th.inspect)
+      end
+    end
+    
+    class LockModeFailer < Err
+      Message = "Unknown lock mode(%s)"
+      def LockModeFailer.Fail(mode)
+	if mode.id2name
+	  mode = id2name
+	end
+	super(mode)
+      end
+    end
+  end
+  
+  def Sync_m.define_aliases(cl)
+    cl.module_eval %q{
+      alias locked? sync_locked?
+      alias shared? sync_shared?
+      alias exclusive? sync_exclusive?
+      alias lock sync_lock
+      alias unlock sync_unlock
+      alias try_lock sync_try_lock
+      alias synchronize sync_synchronize
+    }
+  end
+  
+  def Sync_m.append_features(cl)
+    super
+    unless cl.instance_of?(Module)
+      # do nothing for Modules
+      # make aliases and include the proper module.
+      define_aliases(cl)
+    end
+  end
+  
+  def Sync_m.extend_object(obj)
+    super
+    obj.sync_extended
+  end
+
+  def sync_extended
+    unless (defined? locked? and
+	    defined? shared? and
+	    defined? exclusive? and
+	    defined? lock and
+	    defined? unlock and
+	    defined? try_lock and
+	    defined? synchronize)
+      Sync_m.define_aliases(class<<self;self;end)
+    end
+    sync_initialize
+  end
+
+  # accessing
+  def sync_locked?
+    sync_mode != UN
+  end
+  
+  def sync_shared?
+    sync_mode == SH
+  end
+  
+  def sync_exclusive?
+    sync_mode == EX
+  end
+  
+  # locking methods.
+  def sync_try_lock(mode = EX)
+    return unlock if sync_mode == UN
+    
+    Thread.critical = true
+    ret = sync_try_lock_sub(sync_mode)
+    Thread.critical = false
+    ret
+  end
+  
+  def sync_lock(m = EX)
+    return unlock if m == UN
+
+    until (Thread.critical = true; sync_try_lock_sub(m))
+      if sync_sh_locker[Thread.current]
+	sync_upgrade_waiting.push [Thread.current, sync_sh_locker[Thread.current]]
+	sync_sh_locker.delete(Thread.current)
+      else
+	sync_waiting.push Thread.current
+      end
+      Thread.stop
+    end
+    Thread.critical = false
+    self
+  end
+  
+  def sync_unlock(m = EX)
+    Thread.critical = true
+    if sync_mode == UN
+      Thread.critical = false
+      Err::UnknownLocker.Fail(Thread.current)
+    end
+    
+    m = sync_mode if m == EX and sync_mode == SH
+    
+    runnable = false
+    case m
+    when UN
+      Thread.critical = false
+      Err::UnknownLocker.Fail(Thread.current)
+      
+    when EX
+      if sync_ex_locker == Thread.current
+	if (self.sync_ex_count = sync_ex_count - 1) == 0
+	  self.sync_ex_locker = nil
+	  if sync_sh_locker.include?(Thread.current)
+	    self.sync_mode = SH
+	  else
+	    self.sync_mode = UN
+	  end
+	  runnable = true
+	end
+      else
+	Err::UnknownLocker.Fail(Thread.current)
+      end
+      
+    when SH
+      if (count = sync_sh_locker[Thread.current]).nil?
+	Err::UnknownLocker.Fail(Thread.current)
+      else
+	if (sync_sh_locker[Thread.current] = count - 1) == 0 
+	  sync_sh_locker.delete(Thread.current)
+	  if sync_sh_locker.empty? and sync_ex_count == 0
+	    self.sync_mode = UN
+	    runnable = true
+	  end
+	end
+      end
+    end
+    
+    if runnable
+      if sync_upgrade_waiting.size > 0
+	for k, v in sync_upgrade_waiting
+	  sync_sh_locker[k] = v
+	end
+	wait = sync_upgrade_waiting
+	self.sync_upgrade_waiting = []
+	Thread.critical = false
+	
+	for w, v in wait
+	  w.run
+	end
+      else
+	wait = sync_waiting
+	self.sync_waiting = []
+	Thread.critical = false
+	for w in wait
+	  w.run
+	end
+      end
+    end
+    
+    Thread.critical = false
+    self
+  end
+  
+  def sync_synchronize(mode = EX)
+    begin
+      sync_lock(mode)
+      yield
+    ensure
+      sync_unlock
+    end
+  end
+
+  attr :sync_mode, true
+    
+  attr :sync_waiting, true
+  attr :sync_upgrade_waiting, true
+  attr :sync_sh_locker, true
+  attr :sync_ex_locker, true
+  attr :sync_ex_count, true
+    
+  private
+
+  def sync_initialize
+    @sync_mode = UN
+    @sync_waiting = []
+    @sync_upgrade_waiting = []
+    @sync_sh_locker = Hash.new
+    @sync_ex_locker = nil
+    @sync_ex_count = 0
+  end
+
+  def initialize(*args)
+    sync_initialize
+    super
+  end
+    
+  def sync_try_lock_sub(m)
+    case m
+    when SH
+      case sync_mode
+      when UN
+	self.sync_mode = m
+	sync_sh_locker[Thread.current] = 1
+	ret = true
+      when SH
+	count = 0 unless count = sync_sh_locker[Thread.current]
+	sync_sh_locker[Thread.current] = count + 1
+	ret = true
+      when EX
+	# in EX mode, lock will upgrade to EX lock
+	if sync_ex_locker == Thread.current
+	  self.sync_ex_count = sync_ex_count + 1
+	  ret = true
+	else
+	  ret = false
+	end
+      end
+    when EX
+      if sync_mode == UN or
+	sync_mode == SH && sync_sh_locker.size == 1 && sync_sh_locker.include?(Thread.current) 
+	self.sync_mode = m
+	self.sync_ex_locker = Thread.current
+	self.sync_ex_count = 1
+	ret = true
+      elsif sync_mode == EX && sync_ex_locker == Thread.current
+	self.sync_ex_count = sync_ex_count + 1
+	ret = true
+      else
+	ret = false
+      end
+    else
+      Thread.critical = false
+      Err::LockModeFailer.Fail mode
+    end
+    return ret
+  end
+end
+Synchronizer_m = Sync_m
+
+class Sync
+  #Sync_m.extend_class self
+  include Sync_m
+    
+  def initialize
+    super
+  end
+    
+  module ForkSafely
+    def fork
+      super do
+###        ObjectSpace.each_object(Sync) { |m| m.remove_dead_waiters }
+        yield
+      end
+    end
+  end
+end
+Synchronizer = Sync
+
+
+# FSDB users who fork should include ForkSafely or FSDB itself, or they
+# should make sure to call FSDB.fork instead of Kernel.fork. If you use
+# mutexes (outside of those in FSDB), they should be FSDB::Mutexes.
+module ForkSafely
+  include Sync::ForkSafely
+end
+include ForkSafely
+
+end # module FSDB
+
+
+if __FILE__ == $0
+  include FSDB::ForkSafely
+  
+  m = FSDB::Synchronizer.new
+  
+  EX = FSDB::Synchronizer::EX
+
+  Thread.new { m.synchronize(EX) { sleep 1 } }
+
+  fork do
+    m.synchronize(EX) {
+      puts "Didn't get here if you used standard sync or fork."
+    }
+  end
+
+  m.synchronize(EX) { puts "Got here." }
+
+  Process.wait
+end

data/junk/test-file-lock.html

@@ -0,0 +1,86 @@
+<?xml version="1.0" ?>
+<!DOCTYPE html 
+  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>Untitled</title>
+</head>
+<body>
+<p>require 'thread' # for exclusive
+require 'fsdb/file-lock'
+require 'fsdb/modex.rb'; Sync = FSDB::Modex</p>
+<p>include File::OpenLock</p>
+<p>process_count = 2
+thread_count  = 2
+rep_count     = (ARGV.shift || 10000).to_i
+modex = Sync.new</p>
+<p>test_file = '/tmp/test-file-lock.dat' ## also try NFS</p>
+<p>File.open(test_file, "w") {|f| Marshal.dump(0, f)}</p>
+<p>(0...process_count).each do</p>
+<pre>fork do
+
+  increments = 0
+
+  threads =
+    (0...thread_count).map do
+      Thread.new do
+        (0...rep_count).each do
+          if rand(100) &lt; 50
+            modex.synchronize(Sync::SH) do
+              open_read_lock(test_file) do |f|
+                str = f.read
+                data = Marshal.load(str)
+              end
+            end
+          else
+            modex.synchronize(Sync::EX) do
+              open_write_lock(test_file) do |f|
+                str = f.read
+                data = Marshal.load(str)
+                data += 1
+                f.rewind; f.truncate(0)
+                Marshal.dump(data, f)
+                f.flush
+                Thread.exclusive {increments += 1}
+              end
+            end
+          end
+        end
+      end
+    end
+
+  threads.each {|thread| thread.join}
+
+  File.open("#{test_file}#{Process.pid}", "w") do |f|
+    Marshal.dump(increments, f)
+  end
+
+end</pre>
+<p>end</p>
+<p>Thread.new do</p>
+<pre>count = 0
+loop do
+  puts count
+  sleep 1
+  count += 1
+end  </pre>
+<p>end</p>
+<p>increments = 0
+(0...process_count).each do</p>
+<pre>pid = Process.wait
+File.open("#{test_file}#{pid}", "r") do |f|
+  increments += Marshal.load(f)
+end</pre>
+<p>end</p>
+<p>data = File.open(test_file, "r") {|f| Marshal.load(f)}</p>
+<p>if data == increments</p>
+<pre>puts "Equal counts: #{data}"</pre>
+<p>else</p>
+<pre>puts "Not equal:"
+puts "  increments: #{increments}"
+puts "  data      : #{data}"</pre>
+<p>end</p>
+
+</body>
+</html>

data/junk/test-file-lock.rb

@@ -0,0 +1,84 @@
+require 'thread' # for exclusive
+require 'fsdb/file-lock'
+require 'fsdb/modex.rb'; Sync = FSDB::Modex
+#require 'sync'
+
+include File::OpenLock
+
+process_count = 2
+thread_count  = 2
+rep_count     = (ARGV.shift || 10000).to_i
+modex = Sync.new
+
+test_file = '/tmp/test-file-lock.dat' ## also try NFS
+
+File.open(test_file, "w") {|f| Marshal.dump(0, f)}
+
+(0...process_count).each do
+  fork do
+    
+    increments = 0
+    
+    threads =
+      (0...thread_count).map do
+        Thread.new do
+          (0...rep_count).each do
+            if rand(100) < 50
+              modex.synchronize(Sync::SH) do
+                open_read_lock(test_file) do |f|
+                  str = f.read
+                  data = Marshal.load(str)
+                end
+              end
+            else
+              modex.synchronize(Sync::EX) do
+                open_write_lock(test_file) do |f|
+                  str = f.read
+                  data = Marshal.load(str)
+                  data += 1
+                  f.rewind; f.truncate(0)
+                  Marshal.dump(data, f)
+                  f.flush
+                  Thread.exclusive {increments += 1}
+                end
+              end
+            end
+          end
+        end
+      end
+    
+    threads.each {|thread| thread.join}
+    
+    File.open("#{test_file}#{Process.pid}", "w") do |f|
+      Marshal.dump(increments, f)
+    end
+  
+  end
+end
+
+Thread.new do
+  count = 0
+  loop do
+    puts count
+    sleep 1
+    count += 1
+  end  
+end
+
+increments = 0
+(0...process_count).each do
+  pid = Process.wait
+  File.open("#{test_file}#{pid}", "r") do |f|
+    increments += Marshal.load(f)
+  end
+end
+
+data = File.open(test_file, "r") {|f| Marshal.load(f)}
+
+if data == increments
+  puts "Equal counts: #{data}"
+else
+  puts "Not equal:"
+  puts "  increments: #{increments}"
+  puts "  data      : #{data}"
+end