comp_tree 0.5.2 → 0.7.0

data/lib/comp_tree/bucket_ipc.rb

@@ -1,151 +0,0 @@
-
-require 'drb'
-require 'thread'
-
-require 'comp_tree/retriable_fork'
-require 'comp_tree/diagnostic'
-require 'comp_tree/tap'
-
-module CompTree
-  module BucketIPC
-    class Bucket
-      include Diagnostic
-      include RetriableFork
-
-      def initialize(address, timeout, wait_interval)
-        trace "Making bucket with address #{address}"
-        
-        @remote_pid = fork {
-          own_object = Class.new {
-            attr_accessor(:contents)
-          }.new
-          server = DRb.start_service(address, own_object)
-          debug {
-            server.verbose = true
-          }
-          DRb.thread.join
-        }
-
-        @remote_object = DRbObject.new_with_uri(address)
-        @address = address
-        @timeout = timeout
-        @wait_interval = wait_interval
-      end
-      
-      attr_accessor(:timeout, :wait_interval)
-      attr_reader(:address)
-      
-      def contents=(new_contents)
-        connect {
-          @remote_object.contents = new_contents
-        }
-      end
-      
-      def contents
-        connect {
-          @remote_object.contents
-        }
-      end
-      
-      def stop
-        Process.kill("TERM", @remote_pid)
-      end
-      
-      private
-      
-      def connect
-        begin
-          return yield
-        rescue DRb::DRbConnError
-          start = Time.now
-          begin
-            Kernel.sleep(@wait_interval)
-            return yield
-          rescue DRb::DRbConnError
-            if Time.now - start > @timeout
-              raise
-            end
-            retry
-          end
-        end
-      end
-    end
-
-    class DriverBase
-      def initialize(addresses, timeout, wait_interval)
-        begin
-          @buckets = addresses.map { |address|
-            Bucket.new(address, timeout, wait_interval)
-          }
-          if block_given?
-            yield @buckets
-          end
-        ensure
-          if block_given?
-            stop
-          end
-        end
-      end
-      
-      def stop
-        if defined?(@buckets)
-          @buckets.each { |bucket|
-            bucket.stop
-          }
-        end
-      end
-    end
-
-    class Driver < DriverBase
-      DEFAULTS = {
-        :timeout => 0.5,
-        :wait_interval => 0.05,
-        :port_start => 18181,
-      }
-
-      module BucketCounter
-        @mutex = Mutex.new
-        @count = 0
-        class << self
-          def increment_count
-            @mutex.synchronize {
-              @count += 1
-            }
-          end
-
-          def map_indexes(num_buckets)
-            Array.new.tap { |result|
-              num_buckets.times {
-                result << yield(increment_count)
-              }
-            }
-          end
-        end
-      end
-
-      def initialize(num_buckets, opts_in = {})
-        opts = DEFAULTS.merge(opts_in)
-
-        addresses = 
-          if RetriableFork::HAVE_FORK
-            #
-            # Assume the existence of fork implies a unix machine.
-            #
-            require 'drb/unix'
-            basename = "drbunix://#{Dir.tmpdir}/bucket.#{Process.pid}.#{rand}"
-            BucketCounter.map_indexes(num_buckets) { |index|
-              "#{basename}.#{index}"
-            }
-          else
-            #
-            # Fallback: use the default socket.
-            #
-            BucketCounter.map_indexes(num_buckets) { |index|
-              "druby://localhost:#{opts[:port_start] + index}"
-            }
-          end
-        super(addresses, opts[:timeout], opts[:wait_interval])
-      end
-    end
-  end
-end

data/lib/comp_tree/diagnostic.rb

@@ -1,44 +0,0 @@
-
-require 'comp_tree/tap'
-
-module CompTree
-  module Diagnostic
-    def show(desc = nil, stream = STDOUT, &block)
-      if desc
-        stream.puts(desc)
-      end
-      if block
-        expression = block.call
-        eval(expression, block.binding).tap { |result|
-          stream.printf("%-16s => %s\n", expression, result.inspect)
-        }
-      end
-    end
-
-    if $DEBUG
-      def debug
-        yield
-      end
-
-      def debugging?
-        true
-      end
-
-      def trace(desc = nil, &block)
-        if desc
-          show("#{desc}.".sub(%r!\.\.+\Z!, ""), STDERR, &block)
-        else
-          show(nil, STDERR, &block)
-        end
-      end
-    else
-      # non-$DEBUG
-      def debug ; end
-      def debugging? ; end
-      def trace(*args) ; end
-    end
-
-    extend self
-  end
-end
-

data/lib/comp_tree/misc.rb

@@ -1,61 +0,0 @@
-
-require 'thread'
-
-module CompTree
-  module Misc
-    def let
-      yield self
-    end
-
-    def singleton_class
-      class << self
-        self
-      end
-    end
-
-    module Gensym
-      @mutex = Mutex.new
-      @count = 0
-
-      def gensym(prefix = nil)
-        count = Gensym.module_eval {
-          @mutex.synchronize {
-            @count += 1
-          }
-        }
-        "#{prefix || :G}_#{count}".to_sym
-      end
-    end
-    include Gensym
-
-    def call_private(method, *args, &block)
-      instance_eval { send(method, *args, &block) }
-    end
-
-    def with_warnings(value = true)
-      previous = $VERBOSE
-      $VERBOSE = value
-      begin
-        yield
-      ensure
-        $VERBOSE = previous
-      end
-    end
-
-    def no_warnings(&block)
-      with_warnings(false, &block)
-    end
-
-    def abort_on_exception(value = true)
-      previous = Thread.abort_on_exception
-      Thread.abort_on_exception = value
-      begin
-        yield
-      ensure
-        Thread.abort_on_exception = previous
-      end
-    end
-
-    extend self
-  end
-end

data/lib/comp_tree/retriable_fork.rb

@@ -1,42 +0,0 @@
-
-module CompTree
-  module RetriableFork
-    HAVE_FORK = lambda {
-      begin
-        process_id = fork { }
-        Process.wait(process_id)
-      rescue NotImplementedError
-        return false
-      end
-      true
-    }.call
-
-    def fork(retry_wait = 10, retry_max = 10, &block)
-      num_retries = 0
-      begin
-        Process.fork(&block)
-      rescue Errno::EAGAIN
-        num_retries += 1
-        if num_retries == retry_max
-          message = %Q{
-            ****************************************************************
-            Maximum number of EAGAIN signals reached (#{retry_max})
-            ****************************************************************
-
-            Either increase your process limit permission (consult your
-            OS manual) or run this script as superuser.
-  
-            ****************************************************************
-          }
-          STDERR.puts(message.gsub(%r!^[ \t]+!, ""))
-          raise
-        end
-        STDERR.puts "Caught EGAIN. Retrying in #{retry_wait} seconds."
-        sleep(retry_wait)
-        retry
-      end
-    end
-    module_function :fork
-  end
-end
-

data/lib/comp_tree/tap.rb

@@ -1,9 +0,0 @@
-
-unless respond_to? :tap
-  module Kernel
-    def tap
-      yield self
-      self
-    end
-  end
-end

data/lib/comp_tree/task_node.rb

@@ -1,22 +0,0 @@
-
-module CompTree
-  #
-  # TaskNode is a Node which discards its results
-  #
-  class TaskNode < Node
-    def compute #:nodoc:
-      @function.call
-      true
-    end
-
-    class << self
-      #
-      # TaskNode always returns true.
-      #
-      def discard_result?
-        true
-      end
-    end
-  end
-end
-

data/test/all.rb

@@ -1,12 +0,0 @@
-
-require 'rbconfig'
-
-Dir["#{File.dirname(__FILE__)}/test_*.rb"].map { |file|
-  File.expand_path(file)
-}.each { |file|
-  # spawn separate processes to avoid EAGAIN signals on fork
-  ruby = File.join(
-    Config::CONFIG["bindir"],
-    Config::CONFIG["RUBY_INSTALL_NAME"])
-  system(ruby, file)
-}

data/test/test_bucketipc.rb

@@ -1,72 +0,0 @@
-
-$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
-
-require 'test/unit'
-require 'comp_tree/bucket_ipc'
-
-Thread.abort_on_exception = true
-
-class BucketTest < Test::Unit::TestCase
-  include CompTree::RetriableFork
-
-  def each_bucket(num_buckets, &block)
-    if HAVE_FORK
-      CompTree::BucketIPC::Driver.new(num_buckets) { |buckets|
-        buckets.each { |bucket|
-          yield bucket
-        }
-      }
-    end
-  end
-
-  def test_1_no_fork
-    each_bucket(10) { |bucket|
-      local = bucket.contents = :before
-      bucket.contents = :after
-      assert_equal(local, :before)
-      assert_equal(bucket.contents, :after)
-    }
-  end
-
-  def test_2_fork
-    each_bucket(10) { |bucket|
-      local = bucket.contents = :before
-      process_id = fork {
-        bucket.contents = :after
-      }
-      Process.wait(process_id)
-      assert_equal(local, :before)
-      assert_equal(bucket.contents, :after)
-    }
-  end
-
-  def each_base_test
-    [
-     :test_1_no_fork,
-     :test_2_fork,
-    ].each { |method|
-      yield method
-    }
-  end
-  
-  def test_3_thread
-    each_base_test { |method|
-      Thread.new {
-        send(method)
-      }.join
-    }
-  end
-
-  def test_4_thread_flood
-    each_base_test { |method|
-      (0...10).map {
-        Thread.new {
-          send(method)
-        }
-      }.each { |thread|
-        thread.join
-      }
-    }
-  end
-end
-