in_threads 1.1.0 → 1.1.1

data/in_threads.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'in_threads'
-  s.version     = '1.1.0'
+  s.version     = '1.1.1'
   s.summary     = %q{Execute ruby code in parallel}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']

data/lib/in_threads.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'thwait'
 
 module Enumerable
   # Run enumerable method blocks in threads
@@ -26,8 +25,6 @@ module Enumerable
   end
 end
 
-# TODO: all ruby1.9.3 methods
-
 class InThreads
   (
     instance_methods.map(&:to_s) -
@@ -53,22 +50,17 @@ class InThreads
   end
 
   class << self
-    # List of instance_methods of Enumerable
-    def enumerable_methods
-      Enumerable.instance_methods.map(&:to_s)
-    end
-
     # Specify runner to use
     #
     #   use :run_in_threads_consecutive, :for => %w[all? any? none? one?]
     #
     # <tt>:for</tt> is required
-    # <tt>:ignore_undefined</tt> ignores methods which are not present in list returned by <tt>enumerable_methods</tt>
+    # <tt>:ignore_undefined</tt> ignores methods which are not present in <tt>Enumerable.instance_methods</tt>
     def use(runner, options)
       methods = Array(options[:for])
       raise 'no methods provided using :for option' if methods.empty?
       ignore_undefined = options[:ignore_undefined]
-      enumerable_methods = self.enumerable_methods
+      enumerable_methods = Enumerable.instance_methods.map(&:to_s)
       methods.each do |method|
         unless ignore_undefined && !enumerable_methods.include?(method)
           class_eval <<-RUBY
@@ -81,15 +73,8 @@ class InThreads
     end
   end
 
-  use :run_in_threads_block_result_irrelevant, :for => %w[each]
-  use :run_in_threads_consecutive, :for => %w[
-    all? any? none? one?
-    detect find find_index drop_while take_while
-    partition find_all select reject count
-    collect map group_by max_by min_by minmax_by sort_by
-    flat_map collect_concat
-  ], :ignore_undefined => true
-  use :run_in_threads_block_result_irrelevant, :for => %w[
+  use :run_in_threads_return_original_enum, :for => %w[each]
+  use :run_in_threads_return_original_enum, :for => %w[
     reverse_each
     each_with_index enum_with_index
     each_cons each_slice enum_cons enum_slice
@@ -97,6 +82,13 @@ class InThreads
     cycle
     each_entry
   ], :ignore_undefined => true
+  use :run_in_threads_consecutive, :for => %w[
+    all? any? none? one?
+    detect find find_index drop_while take_while
+    partition find_all select reject count
+    collect map group_by max_by min_by minmax_by sort_by
+    flat_map collect_concat
+  ], :ignore_undefined => true
   use :run_without_threads, :for => %w[
     inject reduce
     max min minmax sort
@@ -119,50 +111,15 @@ class InThreads
 
 protected
 
-  # Use ThreadsWait to limit number of threads
-  class ThreadLimiter
-    # Initialize with limit
-    def initialize(count)
-      @count = count
-      @waiter = ThreadsWait.new
-    end
-
-    # Without block behaves as <tt>new</tt>
-    # With block yields it with <tt>self</tt> and ensures running of <tt>finalize</tt>
-    def self.limit(count, &block)
-      limiter = new(count)
-      if block
-        begin
-          yield limiter
-        ensure
-          limiter.finalize
-        end
-      else
-        limiter
-      end
-    end
-
-    # Add thread to <tt>ThreadsWait</tt>, wait for finishing of one thread if limit reached
-    def add(thread)
-      if @waiter.threads.length + 1 >= @count
-        @waiter.join(thread)
-      else
-        @waiter.join_nowait(thread)
-      end
-    end
-
-    # Wait for waiting threads
-    def finalize
-      @waiter.all_waits
-    end
-  end
+  autoload :ThreadLimiter, 'in_threads/thread_limiter'
+  autoload :Filler, 'in_threads/filler'
 
   # Use for methods which don't use block result
-  def run_in_threads_block_result_irrelevant(enumerable, method, *args, &block)
+  def run_in_threads_return_original_enum(enumerable, method, *args, &block)
     if block
       ThreadLimiter.limit(thread_count) do |limiter|
         enumerable.send(method, *args) do |*block_args|
-          limiter.add(Thread.new(*block_args, &block))
+          limiter << Thread.new(*block_args, &block)
         end
       end
     else
@@ -174,19 +131,21 @@ protected
   def run_in_threads_consecutive(enumerable, method, *args, &block)
     if block
       begin
-        queue = Queue.new
+        enum_a, enum_b = Filler.new(enumerable, 2).extractors
+        results = Queue.new
         runner = Thread.new do
+          Thread.current.priority = -1
           ThreadLimiter.limit(thread_count) do |limiter|
-            enumerable.each do |object|
+            enum_a.each do |object|
               break if Thread.current[:stop]
               thread = Thread.new(object, &block)
-              queue << thread
-              limiter.add(thread)
+              results << thread
+              limiter << thread
             end
           end
         end
-        enumerable.send(method, *args) do |object|
-          queue.pop.value
+        enum_b.send(method, *args) do |object|
+          results.pop.value
         end
       ensure
         runner[:stop] = true

data/lib/in_threads/filler.rb

@@ -0,0 +1,55 @@
+require 'thread'
+
+class InThreads
+  class Filler
+    class Extractor
+      include Enumerable
+
+      def initialize(filler)
+        @filler = filler
+        @queue = []
+      end
+
+      def push(o)
+        @queue.push(o)
+      end
+
+      def each
+        begin
+          loop do
+            while @filler.synchronize{ @queue.empty? }
+              @filler.run
+            end
+            yield @filler.synchronize{ @queue.shift }
+          end
+        rescue ThreadError => e
+        end
+        nil # non reusable
+      end
+    end
+
+    attr_reader :extractors
+    def initialize(enum, extractor_count)
+      @extractors = Array.new(extractor_count){ Extractor.new(self) }
+      @mutex = Mutex.new
+      @filler = Thread.new do
+        enum.each do |o|
+          Thread.stop
+          synchronize do
+            @extractors.each do |extractor|
+              extractor.push(o)
+            end
+          end
+        end
+      end
+    end
+
+    def run
+      @filler.run
+    end
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+  end
+end

data/lib/in_threads/thread_limiter.rb

@@ -0,0 +1,41 @@
+require 'thwait'
+
+class InThreads
+  # Use ThreadsWait to limit number of threads
+  class ThreadLimiter
+    # Initialize with limit
+    def initialize(count)
+      @count = count
+      @waiter = ThreadsWait.new
+    end
+
+    # Without block behaves as <tt>new</tt>
+    # With block yields it with <tt>self</tt> and ensures running of <tt>finalize</tt>
+    def self.limit(count, &block)
+      limiter = new(count)
+      if block
+        begin
+          yield limiter
+        ensure
+          limiter.finalize
+        end
+      else
+        limiter
+      end
+    end
+
+    # Add thread to <tt>ThreadsWait</tt>, wait for finishing of one thread if limit reached
+    def <<(thread)
+      if @waiter.threads.length + 1 >= @count
+        @waiter.join(thread)
+      else
+        @waiter.join_nowait(thread)
+      end
+    end
+
+    # Wait for waiting threads
+    def finalize
+      @waiter.all_waits
+    end
+  end
+end

data/spec/in_threads_spec.rb

@@ -1,23 +1,22 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
 class Item
+  attr_reader :rand
   def initialize(i)
-    @i, @rand = i, rand
+    @i = i
+    @rand = Kernel.rand
+    @sleep = Kernel.rand
   end
 
   class MiddleMatcher
     def ===(item)
       raise "#{item.inspect} is not an Item" unless item.is_a?(Item)
-      (0.25..0.75) === item.instance_variable_get(:@rand)
+      (0.25..0.75) === item.rand
     end
   end
 
-  def work
-    sleep @rand * 0.008
-  end
-
   def value
-    work; @rand
+    sleep; rand
   end
 
   def check?
@@ -31,6 +30,12 @@ class Item
   def touch_n_check?(*args)
     touch(*args); check?
   end
+
+private
+
+  def sleep
+    Kernel.sleep @sleep * 0.01
+  end
 end
 
 class ValueItem < Item
@@ -40,7 +45,7 @@ class ValueItem < Item
   end
 
   def value
-    work; @value
+    sleep; @value
   end
 
   def check?
@@ -70,419 +75,444 @@ describe "in_threads" do
     Time.now - start
   end
 
-  (Enumerable.instance_methods - 10.times.in_threads.class.instance_methods).each do |method|
-    pending method
-  end
+  describe "consistency" do
+    describe "verifying params" do
+      it "should complain about using with non enumerable" do
+        proc{ InThreads.new(1) }.should raise_error(ArgumentError)
+      end
 
-  describe "verifying params" do
-    it "should complain about using with non enumerable" do
-      proc{ InThreads.new(1) }.should raise_error(ArgumentError)
-    end
+      [1..10, 10.times, {}, []].each do |o|
+        it "should complain about using with #{o.class}" do
+          proc{ InThreads.new(o) }.should_not raise_error
+        end
+      end
 
-    [1..10, 10.times, {}, []].each do |o|
-      it "should complain about using with #{o.class}" do
-        proc{ InThreads.new(o) }.should_not raise_error
+      it "should complain about using less than 2 threads" do
+        proc{ 10.times.in_threads(1) }.should raise_error(ArgumentError)
       end
-    end
 
-    it "should complain about using less than 2 threads" do
-      proc{ 10.times.in_threads(1) }.should raise_error(ArgumentError)
+      it "should not complain about using 2 or more threads" do
+        proc{ 10.times.in_threads(2) }.should_not raise_error
+      end
     end
 
-    it "should not complain about using 2 or more threads" do
-      proc{ 10.times.in_threads(2) }.should_not raise_error
-    end
-  end
+    describe "in_threads" do
+      it "should not change existing instance" do
+        threaded = enum.in_threads(10)
+        proc{ threaded.in_threads(20) }.should_not change(threaded, :thread_count)
+      end
 
-  describe "in_threads" do
-    it "should not change existing instance" do
-      threaded = enum.in_threads(10)
-      proc{ threaded.in_threads(20) }.should_not change(threaded, :thread_count)
+      it "should create new instance with different title when called on WithProgress" do
+        threaded = enum.in_threads(10)
+        tthreaded = threaded.in_threads(20)
+        threaded.thread_count.should == 10
+        tthreaded.thread_count.should == 20
+        tthreaded.class.should == threaded.class
+        tthreaded.object_id.should_not == threaded.object_id
+        tthreaded.enumerable.should == threaded.enumerable
+      end
     end
 
-    it "should create new instance with different title when called on WithProgress" do
-      threaded = enum.in_threads(10)
-      tthreaded = threaded.in_threads(20)
-      threaded.thread_count.should == 10
-      tthreaded.thread_count.should == 20
-      tthreaded.class.should == threaded.class
-      tthreaded.object_id.should_not == threaded.object_id
-      tthreaded.enumerable.should == threaded.enumerable
+    describe "thread count" do
+      let(:enum){ 100.times.map{ |i| ValueItem.new(i, i < 50) } }
+
+      %w[each map all?].each do |method|
+        it "should run in specified number of threads for #{method}" do
+          @thread_count = 0
+          @max_thread_count = 0
+          @mutex = Mutex.new
+          enum.in_threads(13).send(method) do |o|
+            @mutex.synchronize do
+              @thread_count += 1
+              @max_thread_count = [@max_thread_count, @thread_count].max
+            end
+            res = o.check?
+            @mutex.synchronize do
+              @thread_count -= 1
+            end
+            res
+          end
+          @thread_count.should == 0
+          @max_thread_count.should == 13
+        end
+      end
     end
-  end
 
-  describe "thread count" do
-    let(:enum){ 100.times.map{ |i| ValueItem.new(i, i < 50) } }
+    describe "underlying enumerable usage" do
+      class CheckEachCalls
+        include Enumerable
 
-    %w[each map all?].each do |method|
-      it "should run in specified number of threads for #{method}" do
-        @thread_count = 0
-        @max_thread_count = 0
-        @mutex = Mutex.new
-        enum.in_threads(13).send(method) do |o|
-          @mutex.synchronize do
-            @thread_count += 1
-            @max_thread_count = [@max_thread_count, @thread_count].max
-          end
-          res = o.check?
-          @mutex.synchronize do
-            @thread_count -= 1
+        def each
+          each_started
+          100.times.each do |i|
+            yield ValueItem.new(i, i < 50)
           end
-          res
         end
-        @thread_count.should == 0
-        @max_thread_count.should == 13
+      end
+      let(:enum){ CheckEachCalls.new }
+
+      %w[each map all?].each do |method|
+        it "should call underlying enumerable.each only once for #{method}" do
+          enum.should_receive(:each_started).once
+          enum.in_threads(13).send(method, &:check?)
+        end
       end
     end
   end
 
-  describe "each" do
-    it "should return same enum after running" do
-      enum.in_threads.each(&:value).should == enum
+  describe "methods" do
+    (Enumerable.instance_methods - 10.times.in_threads.class.instance_methods).each do |method|
+      pending method
     end
 
-    it "should execute block for each element" do
-      enum.each{ |o| o.should_receive(:touch).once }
-      enum.in_threads.each(&:touch_n_value)
-    end
+    describe "each" do
+      it "should return same enum after running" do
+        enum.in_threads.each(&:value).should == enum
+      end
 
-    it "should run faster with threads" do
-      measure{ enum.in_threads.each(&:work) }.should < measure{ enum.each(&:work) } * speed_coef
-    end
+      it "should execute block for each element" do
+        enum.each{ |o| o.should_receive(:touch).once }
+        enum.in_threads.each(&:touch_n_value)
+      end
 
-    it "should run faster with more threads" do
-      measure{ enum.in_threads(10).each(&:work) }.should < measure{ enum.in_threads(2).each(&:work) } * speed_coef
-    end
+      it "should run faster with threads" do
+        measure{ enum.in_threads.each(&:value) }.should < measure{ enum.each(&:value) } * speed_coef
+      end
+
+      it "should run faster with more threads" do
+        measure{ enum.in_threads(10).each(&:value) }.should < measure{ enum.in_threads(2).each(&:value) } * speed_coef
+      end
 
-    it "should return same enum without block" do
-      enum.in_threads.each.to_a.should == enum.each.to_a
+      it "should return same enum without block" do
+        enum.in_threads.each.to_a.should == enum.each.to_a
+      end
     end
-  end
 
-  %w[each_with_index enum_with_index].each do |method|
-    describe_enum_method method do
-      let(:runner){ proc{ |o, i| o.value } }
+    %w[each_with_index enum_with_index].each do |method|
+      describe_enum_method method do
+        let(:runner){ proc{ |o, i| o.value } }
+
+        it "should return same result with threads" do
+          enum.in_threads.send(method, &runner).should == enum.send(method, &runner)
+        end
+
+        it "should fire same objects" do
+          enum.send(method){ |o, i| o.should_receive(:touch).with(i).once }
+          enum.in_threads.send(method){ |o, i| o.touch_n_value(i) }
+        end
+
+        it "should run faster with threads" do
+          measure{ enum.in_threads.send(method, &runner) }.should < measure{ enum.send(method, &runner) } * speed_coef
+        end
+
+        it "should return same enum without block" do
+          enum.in_threads.send(method).to_a.should == enum.send(method).to_a
+        end
+      end
+    end
 
+    describe "reverse_each" do
       it "should return same result with threads" do
-        enum.in_threads.send(method, &runner).should == enum.send(method, &runner)
+        enum.in_threads.reverse_each(&:value).should == enum.reverse_each(&:value)
       end
 
-      it "should fire same objects" do
-        enum.send(method){ |o, i| o.should_receive(:touch).with(i).once }
-        enum.in_threads.send(method){ |o, i| o.touch_n_value(i) }
+      it "should fire same objects in reverse order" do
+        @order = mock('order', :notify => nil)
+        @order.should_receive(:notify).with(enum.last).ordered
+        @order.should_receive(:notify).with(enum[enum.length / 2]).ordered
+        @order.should_receive(:notify).with(enum.first).ordered
+        enum.reverse_each{ |o| o.should_receive(:touch).once }
+        @mutex = Mutex.new
+        enum.in_threads.reverse_each do |o|
+          @mutex.synchronize{ @order.notify(o) }
+          o.touch_n_value
+        end
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.send(method, &runner) }.should < measure{ enum.send(method, &runner) } * speed_coef
+        measure{ enum.in_threads.reverse_each(&:value) }.should < measure{ enum.reverse_each(&:value) } * speed_coef
       end
 
       it "should return same enum without block" do
-        enum.in_threads.send(method).to_a.should == enum.send(method).to_a
+        enum.in_threads.reverse_each.to_a.should == enum.reverse_each.to_a
       end
     end
-  end
 
-  describe "reverse_each" do
-    it "should return same result with threads" do
-      enum.in_threads.reverse_each(&:value).should == enum.reverse_each(&:value)
-    end
+    %w[
+      all? any? none? one?
+      detect find find_index drop_while take_while
+    ].each do |method|
+      describe method do
+        let(:enum){ 100.times.map{ |i| ValueItem.new(i, i % 2 == 1) } }
 
-    it "should fire same objects in reverse order" do
-      @order = mock('order', :notify => nil)
-      @order.should_receive(:notify).with(enum.last).ordered
-      @order.should_receive(:notify).with(enum[enum.length / 2]).ordered
-      @order.should_receive(:notify).with(enum.first).ordered
-      enum.reverse_each{ |o| o.should_receive(:touch).once }
-      @mutex = Mutex.new
-      enum.in_threads.reverse_each do |o|
-        @mutex.synchronize{ @order.notify(o) }
-        o.touch_n_value
-      end
-    end
+        it "should return same result with threads" do
+          enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
+        end
 
-    it "should run faster with threads" do
-      measure{ enum.in_threads.reverse_each(&:value) }.should < measure{ enum.reverse_each(&:value) } * speed_coef
-    end
+        it "should fire same objects but not all" do
+          a = []
+          enum.send(method) do |o|
+            a << o
+            o.check?
+          end
 
-    it "should return same enum without block" do
-      enum.in_threads.reverse_each.to_a.should == enum.reverse_each.to_a
-    end
-  end
+          @a = []
+          @mutex = Mutex.new
+          enum.in_threads.send(method){ |o| @mutex.synchronize{ @a << o }; o.check? }
 
-  %w[
-    all? any? none? one?
-    detect find find_index drop_while take_while
-  ].each do |method|
-    describe method do
-      let(:enum){ 100.times.map{ |i| ValueItem.new(i, i % 2 == 1) } }
+          @a.length.should >= a.length
+          @a.length.should <= enum.length * 0.5
+        end
 
-      it "should return same result with threads" do
-        enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
+        it "should run faster with threads" do
+          boolean = %w[all? drop_while take_while].include?(method)
+          enum = 30.times.map{ |i| ValueItem.new(i, boolean) }
+          measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+        end
       end
+    end
 
-      it "should fire same objects but not all" do
-        a = []
-        enum.send(method) do |o|
-          a << o
-          o.check?
+    %w[partition find_all select reject count].each do |method|
+      describe method do
+        it "should return same result with threads" do
+          enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
         end
 
-        @a = []
-        @mutex = Mutex.new
-        enum.in_threads.send(method){ |o| @mutex.synchronize{ @a << o }; o.check? }
-
-        @a.length.should >= a.length
-        @a.length.should <= enum.length / 2
-      end
+        it "should fire same objects" do
+          enum.send(method){ |o| o.should_receive(:touch).once }
+          enum.in_threads.send(method, &:touch_n_check?)
+        end
 
-      it "should run faster with threads" do
-        value = %w[all? drop_while take_while].include?(method)
-        enum = 30.times.map{ |i| ValueItem.new(i, value) }
-        measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+        it "should run faster with threads" do
+          measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+        end
       end
     end
-  end
 
-  %w[partition find_all select reject count].each do |method|
-    describe method do
-      it "should return same result with threads" do
-        enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
-      end
+    %w[collect map group_by max_by min_by minmax_by sort_by].each do |method|
+      describe method do
+        it "should return same result with threads" do
+          enum.in_threads.send(method, &:value).should == enum.send(method, &:value)
+        end
 
-      it "should fire same objects" do
-        enum.send(method){ |o| o.should_receive(:touch).once }
-        enum.in_threads.send(method, &:touch_n_check?)
-      end
+        it "should fire same objects" do
+          enum.send(method){ |o| o.should_receive(:touch).once; 0 }
+          enum.in_threads.send(method, &:touch_n_value)
+        end
 
-      it "should run faster with threads" do
-        measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+        it "should run faster with threads" do
+          measure{ enum.in_threads.send(method, &:value) }.should < measure{ enum.send(method, &:value) } * speed_coef
+        end
       end
     end
-  end
 
-  %w[collect map group_by max_by min_by minmax_by sort_by].each do |method|
-    describe method do
-      it "should return same result with threads" do
-        enum.in_threads.send(method, &:value).should == enum.send(method, &:value)
-      end
+    %w[each_cons each_slice enum_slice enum_cons].each do |method|
+      describe_enum_method method do
+        let(:runner){ proc{ |a| a.each(&:value) } }
 
-      it "should fire same objects" do
-        enum.send(method){ |o| o.should_receive(:touch).once; 0 }
-        enum.in_threads.send(method, &:touch_n_value)
-      end
+        it "should fire same objects" do
+          enum.send(method, 3){ |a| a.first.should_receive(:touch).with(a).once }
+          enum.in_threads.send(method, 3){ |a| a.first.touch_n_value(a) }
+        end
 
-      it "should run faster with threads" do
-        measure{ enum.in_threads.send(method, &:value) }.should < measure{ enum.send(method, &:value) } * speed_coef
+        it "should return same with block" do
+          enum.in_threads.send(method, 3, &runner).should == enum.send(method, 3, &runner)
+        end
+
+        it "should run faster with threads" do
+          measure{ enum.in_threads.send(method, 3, &runner) }.should < measure{ enum.send(method, 3, &runner) } * speed_coef
+        end
+
+        it "should return same without block" do
+          enum.in_threads.send(method, 3).to_a.should == enum.send(method, 3).to_a
+        end
       end
     end
-  end
 
-  %w[each_cons each_slice enum_slice enum_cons].each do |method|
-    describe_enum_method method do
+    describe "zip" do
       let(:runner){ proc{ |a| a.each(&:value) } }
 
       it "should fire same objects" do
-        enum.send(method, 3){ |a| a.first.should_receive(:touch).with(a).once }
-        enum.in_threads.send(method, 3){ |a| a.first.touch_n_value(a) }
+        enum.zip(enum, enum){ |a| a.first.should_receive(:touch).with(a).once }
+        enum.in_threads.zip(enum, enum){ |a| a.first.touch_n_value(a) }
       end
 
       it "should return same with block" do
-        enum.in_threads.send(method, 3, &runner).should == enum.send(method, 3, &runner)
+        enum.in_threads.zip(enum, enum, &runner).should == enum.zip(enum, enum, &runner)
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.send(method, 3, &runner) }.should < measure{ enum.send(method, 3, &runner) } * speed_coef
+        measure{ enum.in_threads.zip(enum, enum, &runner) }.should < measure{ enum.zip(enum, enum, &runner) } * speed_coef
       end
 
       it "should return same without block" do
-        enum.in_threads.send(method, 3).to_a.should == enum.send(method, 3).to_a
+        enum.in_threads.zip(enum, enum).should == enum.zip(enum, enum)
       end
     end
-  end
-
-  describe "zip" do
-    let(:runner){ proc{ |a| a.each(&:value) } }
-
-    it "should fire same objects" do
-      enum.zip(enum, enum){ |a| a.first.should_receive(:touch).with(a).once }
-      enum.in_threads.zip(enum, enum){ |a| a.first.touch_n_value(a) }
-    end
-
-    it "should return same with block" do
-      enum.in_threads.zip(enum, enum, &runner).should == enum.zip(enum, enum, &runner)
-    end
-
-    it "should run faster with threads" do
-      measure{ enum.in_threads.zip(enum, enum, &runner) }.should < measure{ enum.zip(enum, enum, &runner) } * speed_coef
-    end
-
-    it "should return same without block" do
-      enum.in_threads.zip(enum, enum).should == enum.zip(enum, enum)
-    end
-  end
-
-  describe "cycle" do
-    it "should fire same objects" do
-      enum.cycle(1){ |o| o.should_receive(:touch).exactly(3).times }
-      enum.in_threads.cycle(3, &:touch_n_value)
-    end
-
-    it "should run faster with threads" do
-      measure{ enum.in_threads.cycle(3, &:work) }.should < measure{ enum.cycle(3, &:work) } * speed_coef
-    end
-
-    it "should return same enum without block" do
-      enum.in_threads.cycle(3).to_a.should == enum.cycle(3).to_a
-    end
-  end
 
-  describe "grep" do
-    let(:matcher){ Item::MiddleMatcher.new }
-
-    it "should fire same objects" do
-      enum.each{ |o| o.should_receive(:touch).exactly(matcher === o ? 1 : 0).times }
-      enum.in_threads.grep(matcher, &:touch_n_value)
-    end
+    describe "cycle" do
+      it "should fire same objects" do
+        enum.cycle(1){ |o| o.should_receive(:touch).exactly(3).times }
+        enum.in_threads.cycle(3, &:touch_n_value)
+      end
 
-    it "should return same with block" do
-      enum.in_threads.grep(matcher, &:value).should == enum.grep(matcher, &:value)
-    end
+      it "should run faster with threads" do
+        measure{ enum.in_threads.cycle(3, &:value) }.should < measure{ enum.cycle(3, &:value) } * speed_coef
+      end
 
-    it "should run faster with threads" do
-      measure{ enum.in_threads.grep(matcher, &:value) }.should < measure{ enum.grep(matcher, &:value) } * speed_coef
+      it "should return same enum without block" do
+        enum.in_threads.cycle(3).to_a.should == enum.cycle(3).to_a
+      end
     end
 
-    it "should return same without block" do
-      enum.in_threads.grep(matcher).should == enum.grep(matcher)
-    end
-  end
+    describe "grep" do
+      let(:matcher){ Item::MiddleMatcher.new }
 
-  describe_enum_method "each_entry" do
-    class EachEntryYielder
-      include Enumerable
-      def each
-        10.times{ yield 1 }
-        10.times{ yield 2, 3 }
-        10.times{ yield }
+      it "should fire same objects" do
+        enum.each{ |o| o.should_receive(:touch).exactly(matcher === o ? 1 : 0).times }
+        enum.in_threads.grep(matcher, &:touch_n_value)
       end
-    end
-
-    let(:enum){ EachEntryYielder.new }
-    let(:runner){ proc{ |o| ValueItem.new(0, o).work } }
 
-    it "should return same result with threads" do
-      enum.in_threads.each_entry(&runner).should == enum.each_entry(&runner)
-    end
+      it "should return same with block" do
+        enum.in_threads.grep(matcher, &:value).should == enum.grep(matcher, &:value)
+      end
 
-    it "should execute block for each element" do
-      @order = mock('order')
-      @order.should_receive(:notify).with(1).exactly(10).times.ordered
-      @order.should_receive(:notify).with([2, 3]).exactly(10).times.ordered
-      @order.should_receive(:notify).with(nil).exactly(10).times.ordered
-      @mutex = Mutex.new
-      enum.in_threads.each_entry do |o|
-        @mutex.synchronize{ @order.notify(o) }
-        runner[]
+      it "should run faster with threads" do
+        measure{ enum.in_threads.grep(matcher, &:value) }.should < measure{ enum.grep(matcher, &:value) } * speed_coef
       end
-    end
 
-    it "should run faster with threads" do
-      measure{ enum.in_threads.each_entry(&runner) }.should < measure{ enum.each_entry(&runner) } * speed_coef
+      it "should return same without block" do
+        enum.in_threads.grep(matcher).should == enum.grep(matcher)
+      end
     end
 
-    it "should return same enum without block" do
-      enum.in_threads.each_entry.to_a.should == enum.each_entry.to_a
-    end
-  end
+    describe_enum_method "each_entry" do
+      class EachEntryYielder
+        include Enumerable
+        def each
+          10.times{ yield 1 }
+          10.times{ yield 2, 3 }
+          10.times{ yield }
+        end
+      end
 
-  %w[flat_map collect_concat].each do |method|
-    describe_enum_method method do
-      let(:enum){ 20.times.map{ |i| Item.new(i) }.each_slice(3) }
-      let(:runner){ proc{ |a| a.map(&:value) } }
+      let(:enum){ EachEntryYielder.new }
+      let(:runner){ proc{ |o| ValueItem.new(0, o).value } }
 
       it "should return same result with threads" do
-        enum.in_threads.send(method, &runner).should == enum.send(method, &runner)
+        enum.in_threads.each_entry(&runner).should == enum.each_entry(&runner)
       end
 
-      it "should fire same objects" do
-        enum.send(method){ |a| a.each{ |o| o.should_receive(:touch).with(a).once } }
-        enum.in_threads.send(method){ |a| a.each{ |o| o.touch_n_value(a) } }
+      it "should execute block for each element" do
+        @order = mock('order')
+        @order.should_receive(:notify).with(1).exactly(10).times.ordered
+        @order.should_receive(:notify).with([2, 3]).exactly(10).times.ordered
+        @order.should_receive(:notify).with(nil).exactly(10).times.ordered
+        @mutex = Mutex.new
+        enum.in_threads.each_entry do |o|
+          @mutex.synchronize{ @order.notify(o) }
+          runner[]
+        end
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.send(method, &runner) }.should < measure{ enum.send(method, &runner) } * speed_coef
+        measure{ enum.in_threads.each_entry(&runner) }.should < measure{ enum.each_entry(&runner) } * speed_coef
       end
 
       it "should return same enum without block" do
-        enum.in_threads.send(method).to_a.should == enum.send(method).to_a
+        enum.in_threads.each_entry.to_a.should == enum.each_entry.to_a
       end
     end
-  end
 
-  context "unthreaded" do
-    %w[inject reduce].each do |method|
-      describe method do
-        it "should return same result" do
-          combiner = proc{ |memo, o| memo + o.value }
-          enum.in_threads.send(method, 0, &combiner).should == enum.send(method, 0, &combiner)
+    %w[flat_map collect_concat].each do |method|
+      describe_enum_method method do
+        let(:enum){ 20.times.map{ |i| Item.new(i) }.each_slice(3) }
+        let(:runner){ proc{ |a| a.map(&:value) } }
+
+        it "should return same result with threads" do
+          enum.in_threads.send(method, &runner).should == enum.send(method, &runner)
         end
-      end
-    end
 
-    %w[max min minmax sort].each do |method|
-      describe method do
-        it "should return same result" do
-          comparer = proc{ |a, b| a.value <=> b.value }
-          enum.in_threads.send(method, &comparer).should == enum.send(method, &comparer)
+        it "should fire same objects" do
+          enum.send(method){ |a| a.each{ |o| o.should_receive(:touch).with(a).once } }
+          enum.in_threads.send(method){ |a| a.each{ |o| o.touch_n_value(a) } }
+        end
+
+        it "should run faster with threads" do
+          measure{ enum.in_threads.send(method, &runner) }.should < measure{ enum.send(method, &runner) } * speed_coef
+        end
+
+        it "should return same enum without block" do
+          enum.in_threads.send(method).to_a.should == enum.send(method).to_a
         end
       end
     end
 
-    %w[to_a entries].each do |method|
-      describe method do
-        it "should return same result" do
-          enum.in_threads.send(method).should == enum.send(method)
+    context "unthreaded" do
+      %w[inject reduce].each do |method|
+        describe method do
+          it "should return same result" do
+            combiner = proc{ |memo, o| memo + o.value }
+            enum.in_threads.send(method, 0, &combiner).should == enum.send(method, 0, &combiner)
+          end
         end
       end
-    end
 
-    %w[drop take].each do |method|
-      describe method do
-        it "should return same result" do
-          enum.in_threads.send(method, 2).should == enum.send(method, 2)
+      %w[max min minmax sort].each do |method|
+        describe method do
+          it "should return same result" do
+            comparer = proc{ |a, b| a.value <=> b.value }
+            enum.in_threads.send(method, &comparer).should == enum.send(method, &comparer)
+          end
         end
       end
-    end
 
-    %w[first].each do |method|
-      describe method do
-        it "should return same result" do
-          enum.in_threads.send(method).should == enum.send(method)
-          enum.in_threads.send(method, 3).should == enum.send(method, 3)
+      %w[to_a entries].each do |method|
+        describe method do
+          it "should return same result" do
+            enum.in_threads.send(method).should == enum.send(method)
+          end
         end
       end
-    end
 
-    %w[include? member?].each do |method|
-      describe method do
-        it "should return same result" do
-          enum.in_threads.send(method, enum[10]).should == enum.send(method, enum[10])
+      %w[drop take].each do |method|
+        describe method do
+          it "should return same result" do
+            enum.in_threads.send(method, 2).should == enum.send(method, 2)
+          end
         end
       end
-    end
 
-    describe_enum_method "each_with_object" do
-      let(:runner){ proc{ |o, h| h[o.value] = true } }
+      %w[first].each do |method|
+        describe method do
+          it "should return same result" do
+            enum.in_threads.send(method).should == enum.send(method)
+            enum.in_threads.send(method, 3).should == enum.send(method, 3)
+          end
+        end
+      end
 
-      it "should return same result" do
-        enum.in_threads.each_with_object({}, &runner).should == enum.each_with_object({}, &runner)
+      %w[include? member?].each do |method|
+        describe method do
+          it "should return same result" do
+            enum.in_threads.send(method, enum[10]).should == enum.send(method, enum[10])
+          end
+        end
       end
-    end
 
-    %w[chunk slice_before].each do |method|
-      describe_enum_method method do
+      describe_enum_method "each_with_object" do
+        let(:runner){ proc{ |o, h| h[o.value] = true } }
+
         it "should return same result" do
-          enum.in_threads.send(method, &:check?).to_a.should == enum.send(method, &:check?).to_a
+          enum.in_threads.each_with_object({}, &runner).should == enum.each_with_object({}, &runner)
+        end
+      end
+
+      %w[chunk slice_before].each do |method|
+        describe_enum_method method do
+          it "should return same result" do
+            enum.in_threads.send(method, &:check?).to_a.should == enum.send(method, &:check?).to_a
+          end
         end
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: in_threads
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 1
   - 1
-  - 0
-  version: 1.1.0
+  - 1
+  version: 1.1.1
 platform: ruby
 authors: 
 - Ivan Kuchin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-08 00:00:00 Z
+date: 2011-12-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -45,6 +45,8 @@ files:
 - README.markdown
 - in_threads.gemspec
 - lib/in_threads.rb
+- lib/in_threads/filler.rb
+- lib/in_threads/thread_limiter.rb
 - spec/in_threads_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/toy/in_threads
@@ -76,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: in_threads
-rubygems_version: 1.8.11
+rubygems_version: 1.8.12
 signing_key: 
 specification_version: 3
 summary: Execute ruby code in parallel