pezra-parallel_each 0.1.1

data/README.txt

@@ -0,0 +1,58 @@
+= paralleleach
+
+* http://github.com/pezra/parallel_each
+
+== DESCRIPTION:
+
+This is a set of Enumerable like methods that perform the blocks in parallel.  
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+    require 'rubygems'
+    require 'parallel_each'
+
+    (1..1000).p_each(15) do |i| 
+      # do something with i
+    end
+
+This is much like Enumerable#each except that the block would be
+executed in 15 different threads simultaneously.  On the green
+threaded MRI this can result in significant performance gains if the
+block is IO bound.  On native thread implementation the gains might be
+significant for CPU bound operations.
+
+== REQUIREMENTS:
+
+
+== INSTALL:
+
+* sudo gem install parallel_each
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Peter Williams
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/bounded_async_task_runner.rb

@@ -0,0 +1,86 @@
+class AsyncTaskError < Exception
+  attr_reader :cause
+  
+  def initialize(exception)
+    @cause = exception
+    super("Worker error: #{cause.message} (#{cause.class.name})")
+  end
+end
+
+
+class BoundedAsyncTaskRunner
+  attr_reader :max_workers
+
+  # Create a new BoundedAsyncTaskRunner.
+  #
+  # @param [Integer] max_workers the maximum number of asynchronous
+  #   tasks to simultaneously execute.
+  def initialize(max_workers=20)
+    @threads = Array.new
+    @max_workers = max_workers
+  end
+
+  # Execute the provided block asynchronously.  
+  #
+  # @param *args Objects to yield to the provided block when it is
+  #   invoked.
+  #
+  # @yield The task to execute asynchronously.
+  #
+  # @yieldparam *args The arguments passed into this method.
+  #
+  # @raise AsyncTaskError If any previously executed task has failed
+  #   (i.e. raised an error) an AsyncTaskError will be raised instead
+  #   of executing the async task.
+  def do(*args, &block)
+    purge_dead
+    until @threads.size < max_workers
+      purge_dead
+      break if @threads.size < max_workers
+      # We have still have the maximum number of active threads so we
+      # need to wait for one to finish.
+
+      @threads.first.join(0.1)  # Join on the oldest thread because it will probably finish first.
+    end
+    # We can start new thread without exceeding the threshold
+
+    thread_args = [block] + args
+
+    @threads << Thread.start([block] + args) do |args|
+      task = args.shift
+      
+      begin
+        task.call(*args)
+      rescue Exception => e
+        AsyncTaskError.new(e)
+      end
+    end
+  end
+  alias :do_async :do
+
+
+  # Blocks until all currently running tasks to complete.
+  #
+  # @raise AsyncTaskError If any previously executed task has failed
+  #   (i.e. raised an error) an AsyncTaskError will be raised.
+  def wait_for_all_to_finish
+    until @threads.empty?
+      @threads.first.join
+      purge_dead
+    end    
+  end
+
+  private
+  def purge_dead
+    @threads.each do |t|
+      next if t.alive?  # ignore the alive ones
+      
+      if t.value.kind_of?(AsyncTaskError)
+        raise(t.value)
+      else
+        @threads.delete(t)
+      end
+    end
+  end
+
+end

data/lib/parallel_each.rb

@@ -0,0 +1,14 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + './bounded_async_task_runner'
+
+module Enumerable
+  def p_each(max_tasks=20, &block)
+    runner = BoundedAsyncTaskRunner.new(max_tasks)
+
+    each do |item|
+      runner.do(item, &block)
+    end
+
+    runnder.wait_for_all_to_finish
+  end
+end

data/parallel_each.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name     = "parallel_each"
+  s.version  = "0.1.1"
+  s.date     = "2008-11-05"
+  s.summary  = "Parallelized Enumerable methods"
+  s.email    = "pezra@barelyenough.org"
+  s.homepage = "http://github.com/pezra/parallel_each"
+  s.description = "Provides enumerable methods with a configurable level of parallelism.  Suitable for parallelizing non-trivial operations on large Enumerables."
+  s.has_rdoc = true
+  s.authors  = ["Peter Williams"]
+  s.files    = ["README.txt", 
+		"parallel_each.gemspec", 
+		"lib/bounded_async_task_runner.rb", 
+		"lib/parallel_each.rb"]
+  s.test_files = ["spec/bounded_async_task_runner_spec.rb",
+     "spec/spec_helper.rb"]
+  s.rdoc_options = ["--main", "README.txt"]
+  s.extra_rdoc_files = ["README.txt"]
+end

data/spec/bounded_async_task_runner_spec.rb

@@ -0,0 +1,65 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + 'spec_helper'
+
+require 'bounded_async_task_runner'
+
+describe BoundedAsyncTaskRunner do
+  before do
+    @runner = BoundedAsyncTaskRunner.new(5)
+  end
+
+  describe "#do(&block)" do
+    it "should run tasks" do
+      out = Array.new
+
+      @runner.do(out) {|out| out << :marker}
+      @runner.wait_for_all_to_finish
+
+      out.should == [:marker]
+    end 
+
+    it "should run jobs as the same time" do
+      out = Array.new
+      
+      @runner.do(out) {|out| sleep(0.1); out << :a}
+      @runner.do(out) {|out| out << :b}
+      
+      @runner.wait_for_all_to_finish
+      out.should == [:b, :a]
+    end 
+
+    it "should raise exception if any tasks fail" do
+      lambda {
+        @runner.do { raise ArgumentError, "testing" }
+        @runner.wait_for_all_to_finish
+      }.should raise_error(AsyncTaskError, "Worker error: testing (ArgumentError)")
+    end 
+
+    it "should included exception raised by task AsyncTaskError exception" do
+      exception = ArgumentError.new("testing")
+      @runner.do(exception) { raise(exception) }
+      begin
+        @runner.wait_for_all_to_finish
+      rescue AsyncTaskError => e
+        e.cause.should == exception
+      end
+    end 
+
+    it "should not run more than the max number of tasks at any one moment" do
+      # I don't know how to test this...
+    end 
+  end
+
+  describe "#wait_for_all_to_finish" do
+    it "should not return until all tasks are finished" do
+      out = Array.new
+      
+      3.times do 
+        @runner.do(out) {|out| sleep(0.1); out << :a}
+      end
+      @runner.wait_for_all_to_finish
+
+      out.should == [:a, :a, :a]
+    end 
+  end 
+end 

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'pathname'
+require 'spec'
+
+$LOAD_PATH << Pathname(__FILE__).dirname + '../lib'
+
+Spec::Runner.configure do |config|
+
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: pezra-parallel_each
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Peter Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-05 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Provides enumerable methods with a configurable level of parallelism.  Suitable for parallelizing non-trivial operations on large Enumerables.
+email: pezra@barelyenough.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- README.txt
+- parallel_each.gemspec
+- lib/bounded_async_task_runner.rb
+- lib/parallel_each.rb
+has_rdoc: true
+homepage: http://github.com/pezra/parallel_each
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Parallelized Enumerable methods
+test_files: 
+- spec/bounded_async_task_runner_spec.rb
+- spec/spec_helper.rb