threadlimiter 0.1.0 → 0.1.1

data/CHANGELOG

@@ -0,0 +1,9 @@
+0.1.1 (27-07-2008)
+
+* Fixed the clustering of empty enumerables.
+
+* Reduced the overhead of the clustering.
+
+0.1.0 (13-07-2008)
+
+* First release.

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/threadlimiter/enumerable.rb

@@ -29,13 +29,13 @@ module Enumerable
       threaded_collect(number_of_clusters, &block)
     else
       clusters	= []	# One cluster per thread.
-      last_pos	= nil
+      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.threaded_collect(-1) do |cluster|
@@ -50,7 +50,7 @@ module Enumerable
         res.concat(array)
       end
 
-      res[0..last_pos]	# Remove padding nils.
+      res[0..last_pos]	# Remove padding nil.
     end
   end
 

data/lib/threadlimiter/threadlimiter.rb

@@ -4,7 +4,7 @@
 # ThreadLimiter isn't a thread pool. Each fork really starts a new thread.
 
 class ThreadLimiter
-  # Initialize the ThreadLimter.
+  # Initialize the ThreadLimiter.
   # The optional parameter <i>limit</i> is the maximum number of concurrently running threads.
   # Set <i>limit</i> to -1 or 0 to fork threads without limiting the number of concurrently running threads.
 

data/test/test.rb

@@ -17,9 +17,8 @@ class ThreadLimiterTest < Test::Unit::TestCase
 
     assert_equal([Thread], threads.collect{|t| t.class}.uniq)
 
-    output	= threads.collect{|t| t.value}
 
-    assert_equal(input.to_a	, output)
+    assert_equal(input.to_a	, threads.collect{|t| t.value})
     assert_equal(0		, threadlimiter.instance_eval{@running})
     assert_equal(limit		, threadlimiter.instance_eval{@limit})
   end
@@ -41,140 +40,116 @@ class ThreadLimiterEnumerableTest < Test::Unit::TestCase
   def test_with_empty_enumerables
     assert_equal([], [].threaded_collect(10){2})
     assert_equal([], [].threaded_collect(-1){2})
-    assert_equal([], [].threaded_collect(0){2})
-  end
-
-  def test_threaded_collect_with_no_arguments_with_no_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(-1){2}
-    should_be	= input.collect{2}
-
-    assert_equal(should_be, output)
-  end
+    assert_equal([], [].threaded_collect( 0){2})
 
-  def test_threaded_collect_with_no_arguments_with_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(10){2}
-    should_be	= input.collect{2}
-
-    assert_equal(should_be, output)
+    assert_equal([], [].clustered_threaded_collect(10){2})
+    assert_equal([], [].clustered_threaded_collect(-1){2})
+    assert_equal([], [].clustered_threaded_collect( 0){2})
   end
 
-  def test_threaded_collect_with_no_arguments_with_zero_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(0){2}
+  def test_threaded_collect_with_no_arguments
+    input	= (1..100).to_a
     should_be	= input.collect{2}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.threaded_collect(10){2})
+    assert_equal(should_be, input.threaded_collect(-1){2})
+    assert_equal(should_be, input.threaded_collect( 0){2})
   end
 
-  def test_threaded_collect_with_one_argument_with_no_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(-1){|x| x * 2}
+  def test_threaded_collect_with_one_argument
+    input	= (1..100).to_a
     should_be	= input.collect{|x| x * 2}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.threaded_collect(10){|x| x * 2})
+    assert_equal(should_be, input.threaded_collect(-1){|x| x * 2})
+    assert_equal(should_be, input.threaded_collect( 0){|x| x * 2})
   end
 
-  def test_threaded_collect_with_one_argument_with_limit
+  def test_threaded_collect_with_two_arguments
     input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(10){|x| x * 2}
-    should_be	= input.collect{|x| x * 2}
+    should_be	= input.collect{|x, y| (x*y) % 2 == 0}
 
-    assert_equal(should_be, output)
-  end
-
-  def test_threaded_collect_with_one_argument_with_zero_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(0){|x| x * 2}
-    should_be	= input.collect{|x| x * 2}
-
-    assert_equal(should_be, output)
-  end
-
-  def test_threaded_collect_with_two_arguments_with_no_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(-1){|x, y| x * y}
-    should_be	= input.collect{|x, y| x * y}
-
-    assert_equal(should_be, output)
-  end
-
-  def test_threaded_collect_with_two_arguments_with_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(10){|x, y| x * y}
-    should_be	= input.collect{|x, y| x * y}
-
-    assert_equal(should_be, output)
-  end
-
-  def test_threaded_collect_with_two_arguments_with_zero_limit
-    input	= (1..100).zip(101..200)
-    output	= input.threaded_collect(0){|x, y| x * y}
-    should_be	= input.collect{|x, y| x * y}
-
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.threaded_collect(10){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.threaded_collect(-1){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.threaded_collect( 0){|x, y| (x*y) % 2 == 0})
   end
 
   def test_threaded_select
     input	= (1..100).zip(101..200)
-    output	= input.threaded_select{|x, y| (x*y) % 2 == 0}
     should_be	= input.select{|x, y| (x*y) % 2 == 0}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.threaded_select(10){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.threaded_select(-1){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.threaded_select( 0){|x, y| (x*y) % 2 == 0})
   end
 
   def test_threaded_reject
     input	= (1..100).zip(101..200)
-    output	= input.threaded_reject{|x, y| (x*y) % 2 == 0}
     should_be	= input.reject{|x, y| (x*y) % 2 == 0}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.threaded_reject(10){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.threaded_reject(-1){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.threaded_reject( 0){|x, y| (x*y) % 2 == 0})
   end
 
   def test_threaded_each
     input	= (1..100).zip(101..200)
-    output	= input.threaded_each{|x, y| (x*y) % 2 == 0}
 
-    assert_equal(input, output)
+    assert_equal(input, input.threaded_each(10){|x, y| (x*y) % 2 == 0})
+    assert_equal(input, input.threaded_each(-1){|x, y| (x*y) % 2 == 0})
+    assert_equal(input, input.threaded_each( 0){|x, y| (x*y) % 2 == 0})
+  end
+
+  def test_clustered_threaded_collect_with_no_argument
+    input	= (1..100).to_a
+    should_be	= input.collect{2}
+
+    assert_equal(should_be, input.clustered_threaded_collect(10){2})
+    assert_equal(should_be, input.clustered_threaded_collect(-1){2})
+    assert_equal(should_be, input.clustered_threaded_collect( 0){2})
   end
 
   def test_clustered_threaded_collect_with_one_argument
-    input	= (1..100).zip(101..200)
-    output	= input.clustered_threaded_collect(10){|x| x * 2}
+    input	= (1..100).to_a
     should_be	= input.collect{|x| x * 2}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.clustered_threaded_collect(10){|x| x * 2})
+    assert_equal(should_be, input.clustered_threaded_collect(-1){|x| x * 2})
+    assert_equal(should_be, input.clustered_threaded_collect( 0){|x| x * 2})
   end
 
   def test_clustered_threaded_collect_with_two_arguments
     input	= (1..100).zip(101..200)
-    output	= input.clustered_threaded_collect(10){|x, y| x * y}
     should_be	= input.collect{|x, y| x * y}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.clustered_threaded_collect(10){|x, y| x * y})
+    assert_equal(should_be, input.clustered_threaded_collect(-1){|x, y| x * y})
+    assert_equal(should_be, input.clustered_threaded_collect( 0){|x, y| x * y})
   end
 
   def test_clustered_threaded_select
     input	= (1..100).zip(101..200)
-    output	= input.clustered_threaded_select(10){|x, y| (x*y) % 2 == 0}
     should_be	= input.select{|x, y| (x*y) % 2 == 0}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.clustered_threaded_select(10){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.clustered_threaded_select(-1){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.clustered_threaded_select( 0){|x, y| (x*y) % 2 == 0})
   end
 
   def test_clustered_threaded_reject
     input	= (1..100).zip(101..200)
-    output	= input.clustered_threaded_reject(10){|x, y| (x*y) % 2 == 0}
     should_be	= input.reject{|x, y| (x*y) % 2 == 0}
 
-    assert_equal(should_be, output)
+    assert_equal(should_be, input.clustered_threaded_reject(10){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.clustered_threaded_reject(-1){|x, y| (x*y) % 2 == 0})
+    assert_equal(should_be, input.clustered_threaded_reject( 0){|x, y| (x*y) % 2 == 0})
   end
 
   def test_clustered_threaded_each
     input	= (1..100).zip(101..200)
-    output	= input.clustered_threaded_each(10){|x, y| (x*y) % 2 == 0}
 
-    assert_equal(input, output)
+    assert_equal(input, input.clustered_threaded_each(10){|x, y| (x*y) % 2 == 0})
+    assert_equal(input, input.clustered_threaded_each(-1){|x, y| (x*y) % 2 == 0})
+    assert_equal(input, input.clustered_threaded_each( 0){|x, y| (x*y) % 2 == 0})
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: threadlimiter
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Erik Veenstra
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-12 00:00:00 +02:00
+date: 2008-07-27 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -29,6 +29,7 @@ files:
 - README
 - LICENSE
 - VERSION
+- CHANGELOG
 has_rdoc: true
 homepage: http://www.erikveen.dds.nl/threadlimiter/index.html
 post_install_message: 
@@ -36,8 +37,9 @@ rdoc_options:
 - README
 - LICENSE
 - VERSION
+- CHANGELOG
 - --title
-- threadlimiter (0.1.0)
+- threadlimiter (0.1.1)
 - --main
 - README
 require_paths: 
@@ -57,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: threadlimiter
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Fork threads like Thread.fork, but limit the number of concurrently running threads.