fsdb 0.6.0 → 0.6.1

data/junk/sync.rb

@@ -1,327 +0,0 @@
-#!/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

@@ -1,86 +0,0 @@
-<?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

@@ -1,84 +0,0 @@
-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