forkandreturn 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,20 @@
+0.2.0 (27-07-2008)
+
+* Removed Enumerable#concurrent() and
+  Enumerable#clustered_concurrent(). (Use
+  Enumerable#concurrent_collect() and
+  Enumerable#clustered_concurrent_collect() instead,
+  respectively.)
+
+* Fixed the clustering of empty enumerables.
+
+* Added File.owned?(), so the temporary file with the
+  intermediate results can't be replaced by other people.
+
+* Reduced the overhead of the clustering.
+
+* Reduced the overhead of Marshal.
+
 0.1.1 (19-07-2008)
 
 * Added example.txt.

data/README

@@ -1,8 +1,12 @@
-ForkAndReturn implements a couple of methods that simplifies
+ForkAndReturn implements a couple of methods that simplify
 running a block of code in a subprocess. The result (Ruby
 object or exception) of the block will be available in the
 parent process.
 
+ForkAndReturn also enriches Enumerable with a couple of methods
+(e.g. Enumerable#concurrent_collect()), in order to simplify
+the concurrent execution of a block for a collection of objects.
+
 The intermediate return value (or exception) will be
 Marshal'led to disk. This means that it is possible to
 (concurrently) run thousands of child process, with a relative

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/forkandreturn/enumerable.rb

@@ -74,14 +74,14 @@ module Enumerable
     if number_of_clusters < 1
       self.concurrent_collect(number_of_clusters, &block)
     else
-      clusters	= []		# One cluster per thread.
-      last_pos	= nil
+      clusters	= []	# One cluster per fork.
+      last_pos	= -1
       res	= []
 
-      self.each_with_index do |object, pos|
-        (clusters[pos%number_of_clusters] ||= []) << object
+      self.each do |object|
+        last_pos += 1
 
-        last_pos	= pos
+        (clusters[last_pos%number_of_clusters] ||= []) << object
       end
 
       clusters.concurrent_collect(-1) do |cluster|
@@ -96,7 +96,7 @@ module Enumerable
         res.concat(array)
       end
 
-      res[0..last_pos]	# Remove padding nils.
+      res[0..last_pos]	# Remove padding nil.
     end
   end
 
@@ -140,8 +140,6 @@ module Enumerable
     self
   end
 
-  alias concurrent			concurrent_collect
   alias concurrent_map			concurrent_collect
-  alias clustered_concurrent		clustered_concurrent_collect
   alias clustered_concurrent_map	clustered_concurrent_collect
 end

data/lib/forkandreturn/forkandreturn.rb

@@ -1,4 +1,4 @@
-# ForkAndReturn implements a couple of methods that simplifies running a block of code in a subprocess.
+# ForkAndReturn implements a couple of methods that simplify running a block of code in a subprocess.
 # The result (Ruby object or exception) of the block will be available in the parent process.
 #
 # The intermediate return value (or exception) will be Marshal'led to disk.
@@ -27,14 +27,14 @@ module ForkAndReturn
   #  [1, 2, 3, 4].collect do |object|
   #    Thread.fork do
   #      ForkAndReturn.fork_and_return do
-  #        2*object
+  #        object*2
   #      end
   #    end
   #  end.collect do |thread|
   #    thread.value
   #  end   # ===> [2, 4, 6, 8]
   #
-  # This runs each "2*object" in a seperate process.
+  # This runs each "object*2" statement in a seperate process, concurrently.
   # Hopefully, the processes are spread over all available CPU's.
   # That's a simple way of parallel processing!
   # (Although Enumerable#concurrent_collect() is even simpler...)
@@ -53,6 +53,18 @@ module ForkAndReturn
   # If you call it, the WAITing, LOADing and RESULTing (explained in fork_and_return_core()) will be performed in one go.
   #
   # <i>*args</i> is passed to the block.
+  #
+  # Example:
+  #
+  #  [1, 2, 3, 4].collect do |object|
+  #    ForkAndReturn.fork_and_return_later do
+  #      object*2
+  #    end
+  #  end.collect do |wait|
+  #    wait.call
+  #  end   # ===> [2, 4, 6, 8]
+  #
+  # This runs each "object*2" statement in a seperate process, concurrently.
 
   def self.fork_and_return_later(*args, &block)
     wait	= fork_and_return_core(*args, &block)
@@ -72,10 +84,51 @@ module ForkAndReturn
   # If you call RESULT-lambda, the result of the child process will be handled.
   # This means either "return the return value of the block" or "raise the exception"
   #
+  # fork_and_return_core() is coded like this:
+  #
+  #  def fork_and_return_core
+  #    # Fork a process.
+  #
+  #    lambda do
+  #      # Wait for the result.
+  #
+  #      lambda do
+  #        # Load the result and delete the temp file.
+  #
+  #        lambda do
+  #          # Handle the result.
+  #        end
+  #      end
+  #    end
+  #  end
+  #
+  # fork_and_return_core() is used like this:
+  #
+  #  wait   = ForkAndReturn.fork_and_return_core{raise "BOOM"}
+  #  load   = wait.call
+  #  result = load.call
+  #  value  = result.call   # This is were the exception "BOOM" is raised.
+  #
   # at_exit blocks defined in the child itself will be executed in the child,
   # whereas at_exit blocks defined in the parent won't be executed in the child.
   #
   # <i>*args</i> is passed to the block.
+  #
+  # Example:
+  #
+  #  [1, 2, 3, 4].collect do |object|
+  #    ForkAndReturn.fork_and_return do
+  #      object*2
+  #    end
+  #  end.collect do |wait|
+  #    wait.call
+  #  end.collect do |load|
+  #    load.call
+  #  end.collect do |result|
+  #    result.call
+  #  end   # ===> [2, 4, 6, 8]
+  #
+  # This runs each "object*2" statement in a seperate process, concurrently.
 
   def self.fork_and_return_core(*args, &block)
     file	= Util.tempfile
@@ -113,7 +166,11 @@ module ForkAndReturn
 
       lambda do			# Load the result and delete the temp file.
         begin
-          ok, res	= File.open(file, "rb"){|f| Marshal.load(f)}
+          if File.owned?(file)
+            ok, res	= File.open(file, "rb"){|f| Marshal.load(f.read)}
+          else
+            ok, res	= false, WorkerError.new("you're not the owner of the temporary file")
+          end
         rescue Errno::ENOENT	# No such file or directory
           ok, res	= false, WorkerError.new("the worker hasn't returned a result")
         rescue EOFError		# end of file reached

data/test/test.rb

@@ -92,6 +92,16 @@ class ForkAndReturnEnumerableTest < Test::Unit::TestCase
   class ForkAndReturnEnumerableTestException < StandardError
   end
 
+  def test_empty_array
+    assert_equal([], [].concurrent_collect(0){2})
+    assert_equal([], [].concurrent_collect(3){2})
+    assert_equal([], [].concurrent_collect(-1){2})
+
+    assert_equal([], [].clustered_concurrent_collect(0){2})
+    assert_equal([], [].clustered_concurrent_collect(3){2})
+    assert_equal([], [].clustered_concurrent_collect(-1){2})
+  end
+
   def test_array
     data	= (1..10).to_a
     block	= lambda{|n| n**n}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: forkandreturn
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Erik Veenstra
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-19 00:00:00 +02:00
+date: 2008-07-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: threadlimiter
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -51,7 +52,7 @@ rdoc_options:
 - CHANGELOG
 - example.txt
 - --title
-- forkandreturn (0.1.1)
+- forkandreturn (0.2.0)
 - --main
 - README
 require_paths: 
@@ -71,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: forkandreturn
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Runs a block of code in a seperate process and collects the result later. Includes a lot of convenient methods on Enumerable.