innertube 1.0.1 → 1.0.2

data/lib/innertube.rb

@@ -153,6 +153,7 @@ module Innertube
       @iterator.synchronize do
         until targets.empty?
           @lock.synchronize do
+            @element_released.wait(@iterator) if targets.all? {|e| e.locked? }
             unlocked, targets = targets.partition {|e| e.unlocked? }
             unlocked.each {|e| e.lock }
           end
@@ -164,7 +165,6 @@ module Innertube
               e.unlock
             end
           end
-          @element_released.wait(@iterator) unless targets.empty?
         end
       end
     end

data/lib/innertube/version.rb

@@ -1,3 +1,3 @@
 module Innertube
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/spec/innertube_spec.rb

@@ -1,103 +1,102 @@
 require 'spec_helper'
 require 'thread'
+require 'thwait'
 
 describe Innertube::Pool do
-  let(:pool_members) { subject.instance_variable_get(:@pool) }
-
-  describe 'basics' do
-    subject do
-      described_class.new(lambda { [0] }, lambda { |x| })
+  def wait_all(threads)
+    message "Waiting on #{threads.size} threads: "
+    ThreadsWait.all_waits(*threads) do |t|
+      message "<#{threads.index(t) + 1}> "
     end
+    message "\n"
+  end
 
-    it 'yields a new object' do
-      subject.take do |x|
-        x.should == [0]
-      end
+  let(:pool_members) { pool.instance_variable_get(:@pool) }
+
+  let(:pool) { described_class.new(lambda { [0] }, lambda { |x| }) }
+
+  it 'yields a new object when the pool is empty' do
+    pool.take do |x|
+      x.should == [0]
     end
+  end
 
-    it 'retains a single object for serial access' do
-      n = 100
-      n.times do |i|
-        subject.take do |x|
-          x.should == [i]
-          x[0] += 1
-        end
+  it 'retains a single object for serial access' do
+    n = 100
+    n.times do |i|
+      pool.take do |x|
+        x.should == [i]
+        x[0] += 1
       end
-      subject.size.should == 1
     end
+    pool.size.should == 1
+  end
 
-    it 'should be re-entrant' do
-      n = 10
-      n.times do |i|
-        subject.take do |x|
-          x.replace [1]
-          subject.take do |y|
-            y.replace [2]
-            subject.take do |z|
-              z.replace [3]
-              subject.take do |t|
-                t.replace [4]
-              end
+  it 'should be re-entrant' do
+    n = 10
+    n.times do |i|
+      pool.take do |x|
+        x.replace [1]
+        pool.take do |y|
+          y.replace [2]
+          pool.take do |z|
+            z.replace [3]
+            pool.take do |t|
+              t.replace [4]
             end
           end
         end
       end
-      subject.instance_variable_get(:@pool).map { |e| e.object.first }.sort.should == [1,2,3,4]
     end
+    pool_members.map { |e| e.object.first }.sort.should == [1,2,3,4]
+  end
 
 
-    it 'should unlock when exceptions are raised' do
-      begin
-        subject.take do |x|
-          x << 1
-          subject.take do |y|
-            x << 2
-            y << 3
-            raise
-          end
+  it 'should unlock when exceptions are raised' do
+    begin
+      pool.take do |x|
+        x << 1
+        pool.take do |y|
+          x << 2
+          y << 3
+          raise
         end
-      rescue
       end
-      pool_members.should be_all {|e| not e.owner }
-      pool_members.map { |e| e.object }.should =~ [[0,1,2],[0,3]]
+    rescue
     end
+    pool_members.should be_all {|e| not e.owner }
+    pool_members.map { |e| e.object }.should =~ [[0,1,2],[0,3]]
+  end
 
-    context 'when BadResource is raised' do
-      subject do
-        described_class.new(lambda do
-                              m = mock('resource')
-                              m.should_receive(:close)
-                              m
-                            end,
-                            lambda do |res|
-                              res.close
-                            end)
-      end
+  context 'when BadResource is raised' do
+    let(:pool) do
+      described_class.new(lambda { mock('resource').tap {|m| m.should_receive(:close) } },
+                          lambda { |res| res.close })
+    end
 
-      it 'should delete' do
-        lambda do
-          subject.take do |x|
-            raise Innertube::Pool::BadResource
-          end
-        end.should raise_error(Innertube::Pool::BadResource)
-        subject.size.should == 0
-      end
+    it 'should remove the member from the pool' do
+      lambda do
+        pool.take do |x|
+          raise Innertube::Pool::BadResource
+        end
+      end.should raise_error(Innertube::Pool::BadResource)
+      pool_members.size.should == 0
     end
   end
 
-  describe 'threads' do
-    subject {
-      described_class.new(lambda { [] }, lambda { |x| })
-    }
+
+  context 'threaded access' do
+    let!(:pool) { described_class.new(lambda { [] }, lambda { |x| }) }
 
     it 'should allocate n objects for n concurrent operations' do
       # n threads concurrently allocate and sign objects from the pool
       n = 10
       readyq = Queue.new
       finishq = Queue.new
+
       threads = (0...n).map do
         Thread.new do
-          subject.take do |x|
+          pool.take do |x|
             readyq << 1
             x << Thread.current
             finishq.pop
@@ -105,16 +104,18 @@ describe Innertube::Pool do
         end
       end
 
+      # Give the go-ahead to all threads
       n.times { readyq.pop }
+
+      # Let all threads finish
       n.times { finishq << 1 }
 
       # Wait for completion
-      threads.each do |t|
-        t.join
-      end
+      ThreadsWait.all_waits(*threads)
 
       # Should have taken exactly n objects to do this
-      subject.size.should == n
+      pool_members.size.should == n
+
       # And each one should be signed exactly once
       pool_members.map do |e|
         e.object.size.should == 1
@@ -124,16 +125,17 @@ describe Innertube::Pool do
 
     it 'take with filter and default' do
       n = 10
-      subject = described_class.new(lambda { [] }, lambda { |x| })
+      pool = described_class.new(lambda { [] }, lambda { |x| })
 
       # Allocate several elements of the pool
       q = Queue.new
+      finishq = Queue.new
       threads = (0...n).map do |i|
         Thread.new do
-          subject.take do |a|
-            a << i
+          pool.take do |a|
             q << 1
-            sleep 0.02
+            a << i
+            finishq.pop
           end
         end
       end
@@ -141,29 +143,32 @@ describe Innertube::Pool do
       # Wait for all threads to have acquired an element
       n.times { q.pop }
 
-      threads.each do |t|
-        t.join
-      end
+      # Let all threads finish
+      n.times { finishq << 1 }
+
+      # Wait for completion
+      # threads.each {|t| t.join }
+      ThreadsWait.all_waits(*threads)
 
       # Get and delete existing even elements
-      got = Set.new
+      got = []
       (n / 2).times do
         begin
-          subject.take(
-                       :filter => lambda { |x| x.first.even? },
-                       :default => [:default]
-                       ) do |x|
+          pool.take(
+                    :filter => lambda { |x| x.first.even? },
+                    :default => [:default]
+                    ) do |x|
             got << x.first
             raise Innertube::Pool::BadResource
           end
         rescue Innertube::Pool::BadResource
         end
       end
-      got.should == (0...n).select(&:even?).to_set
+      got.should =~ (0...n).select(&:even?)
 
       # This time, no even elements exist, so we should get the default.
-      subject.take(:filter => lambda { |x| x.first.even? },
-                   :default => :default) do |x|
+      pool.take(:filter => lambda { |x| x.first.even? },
+                :default => :default) do |x|
         x.should == :default
       end
     end
@@ -174,7 +179,7 @@ describe Innertube::Pool do
       threads = (0..n).map do
         Thread.new do
           psleep = 0.75 * rand # up to 50ms sleep
-          subject.take do |a|
+          pool.take do |a|
             started << 1
             a << rand
             sleep psleep
@@ -185,114 +190,209 @@ describe Innertube::Pool do
       n.times { started.pop }
       touched = []
 
-      subject.each do |e|
-        touched << e
-      end
+      pool.each {|e| touched << e }
 
-      threads.each do |t|
-        t.join
-      end
+      wait_all threads
 
-      touched.should be_all {|item| pool_members.find {|e| e.object == item } }
+      touched.should be_all {|item| pool_members.any? {|e| e.object == item } }
     end
 
-    it 'should clear' do
-      n = 10
-      subject = described_class.new(
-                                    lambda { mock('connection').tap {|m| m.should_receive(:teardown) }},
-                                    lambda { |b| b.teardown }
-                                    )
+    context 'clearing the pool' do
+      let(:pool) do
+        described_class.new(lambda { mock('connection').tap {|m| m.should_receive(:teardown) }},
+                            lambda { |b| b.teardown })
+      end
 
-      # Allocate several elements of the pool
-      q = Queue.new
-      threads = (0...n).map do |i|
-        Thread.new do
-          subject.take do |a|
-            q << 1
-            sleep 0.1
+      it 'should remove all elements' do
+        n = 10
+        q, fq = Queue.new, Queue.new
+
+        # Allocate several elements of the pool
+        threads = (0...n).map do |i|
+          Thread.new do
+            pool.take do |a|
+              q << i
+              sleep(rand * 0.5)
+              message "W<#{i}> "
+              fq.pop
+              message "X<#{i}> "
+            end
           end
         end
-      end
 
-      # Wait for all threads to have acquired an element
-      n.times { q.pop }
+        # Wait for all threads to have acquired an element
+        n.times { message "S<#{q.pop}> " }
+
+        # Start a thread to push stuff onto the finish queue, allowing
+        # the worker threads to exit
+        pusher = Thread.new do
+          n.times do |i|
+            message "R<#{i}> "
+            fq << 1
+            sleep(rand * 0.1)
+          end
+        end
 
-      # Clear the pool while threads still have elements checked out
-      subject.clear
-      pool_members.should be_empty
+        # Clear the pool while threads still have elements checked out
+        message "S<C> "
+        pool.clear
+        message "X<C> "
 
-      # Wait for threads to complete
-      threads.each do |t|
-        t.join
+        # Wait for threads to complete
+        wait_all(threads + [pusher])
+        pool_members.should be_empty
       end
     end
 
-    it 'should delete_if' do
-      n = 10
-      subject = described_class.new(
-                                    lambda { [] },
-                                    lambda { |x| }
-                                    )
+    context 'conditionally deleting members' do
+      let(:pool) { described_class.new( lambda { [] }, lambda { |x| } ) }
+      it 'should remove them from the pool' do
+        n = 10
+
+        # Allocate several elements of the pool
+        q = Queue.new
+        threads = (0...n).map do |i|
+          Thread.new do
+            pool.take do |a|
+              message "S<#{i}> "
+              a << i
+              q << i
+              Thread.pass
+            end
+          end
+        end
 
-      # Allocate several elements of the pool
-      q = Queue.new
+        # Wait for all threads to have acquired an element
+        n.times { message "X<#{q.pop}> " }
+
+        # Delete odd elements
+        pool.delete_if do |x|
+          x.first.odd?
+        end
+
+        # Verify odds are gone.
+        pool_members.all? do |x|
+          x.object.first.even?
+        end.should == true
+
+        # Wait for threads
+        wait_all threads
+      end
+    end
+
+    it 'iteration race-condition regression', :timeout => 60 do
+      # This simulates a race-condition where the condition variable
+      # waited on by the iterator until an element is released might
+      # be signaled before the iterator begins waiting, thus dropping
+      # the signal and sending the iterator into an infinite wait.
+
+      # First we pick a largish random thread count, and split it into
+      # threads that release before the iterator starts (split) and
+      # ones that release while the iterator is busy (rest).
+      n = rand(250)
+      split = rand(n)
+      rest = n - split
+
+      message "[#{n}:#{split}] "
+      # We use two queues to signal between the main thread and the
+      # workers, and a queue to communicate with the iterator thread
+      sq, fq, iq = Queue.new, Queue.new, Queue.new
+
+      # Start all the worker threads
       threads = (0...n).map do |i|
         Thread.new do
-          subject.take do |a|
-            a << i
-            q << 1
-            sleep 0.02
+          pool.take do |e|
+            # Signal to the main thread that we're inside the take
+            sq << i+1
+            # Block waiting on the main thread. When reactivated, log
+            # the exit of the thread
+            fq.pop
+            message "X<#{i+1}> "
+            sq << Thread.current
           end
         end
       end
 
-      # Wait for all threads to have acquired an element
-      n.times { q.pop }
+      # Wait for all workers to start up, log their startup to the console
+      n.times { message "S<#{sq.pop}> " }
 
-      # Delete odd elements
-      subject.delete_if do |x|
-        x.first.odd?
-      end
+      message "[all started] "
 
-      # Verify odds are gone.
-      pool_members.all? do |x|
-        x.object.first.even?
-      end.should == true
+      # Now signal for the first group to continue
+      finished = []
+      split.times { fq << 1; finished << sq.pop }
+      wait_all finished
 
-      # Wait for threads
-      threads.each do |t|
-        t.join
+      message "[first group #{split}] "
+
+      # Start the iterator thread
+      iterator = Thread.new do
+        Thread.current[:wait] = true
+        pool.each do |e|
+          # Block in the first iteration so the other workers can exit
+          # while the iterator is not waiting on the condition variable
+          if Thread.current[:wait]
+            sq << 'i'
+            iq.pop
+            Thread.current[:wait] = false
+          end
+          # Make sure we've touched every element of the pool by
+          # modifying every entry.
+          e << 1
+        end
+        message "X<i> "
       end
+
+      # Wait on the iterator thread to start
+      message "S<#{sq.pop}> "
+
+      # Now signal the remaining workers to finish, and wait on all
+      # workers to exit (even ones that exited in the first pass)
+      finished.clear
+      rest.times { fq << 1; finished << sq.pop }
+      wait_all(finished)
+
+      message "[second group #{rest}] "
+
+      # Now signal the iterator to continue, and wait for it to exit
+      iq << 1
+      wait_all([ iterator ])
+
+      # Finally, verify that all elements of the pool were touched by
+      # the iterator
+      pool_members.each {|e| e.object.size.should == 1 }
     end
 
-    it 'stress test', :slow => true do
-      n = 100
-      psleep = 0.8
-      tsleep = 0.01
-      rounds = 100
+    it 'stress test', :timeout => 60 do
+      n = rand(400)
+      passes = rand(20)
+      rounds = rand(200)
+      breaker = rand
+      message "[#{n}t:#{rounds}r:#{passes}p:#{'%0.5f' % breaker}b] "
 
       threads = (0...n).map do
         Thread.new do
           rounds.times do |i|
-            subject.take do |a|
+            pool.take do |a|
               a.should == []
               a << Thread.current
               a.should == [Thread.current]
 
-              # Sleep and check
-              while rand < psleep
-                sleep tsleep
+              # Pass and check
+              passes.times do
+                Thread.pass
+                # Nobody else should get ahold of this while I'm idle
                 a.should == [Thread.current]
+                break if rand > breaker
               end
 
               a.delete Thread.current
+              message "."
             end
           end
         end
       end
-      threads.each do |t|
-        t.join
-      end
+      wait_all threads
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,13 +4,16 @@ require 'rubygems'
 require 'rspec'
 require 'innertube'
 
+require 'support/verbose_formatter'
+require 'support/timeout'
+
 RSpec.configure do |config|
   config.mock_with :rspec
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
-
   if defined?(::Java)
-    config.seed = Time.now.utc
+    seed = Time.now.utc
+    config.seed = seed
   else
     config.order = :random
   end

data/spec/support/timeout.rb

@@ -0,0 +1,15 @@
+require 'timeout'
+
+RSpec.configure do |config|
+  config.include Timeout
+  config.around(:each) do |example|
+    time = example.metadata[:timeout] || 30
+    begin
+      timeout(time, Timeout::Error) do
+        example.run
+      end
+    rescue Timeout::Error => e
+      example.send :set_exception, e
+    end
+  end
+end

data/spec/support/verbose_formatter.rb

@@ -0,0 +1,112 @@
+require 'rspec/core/formatters/base_text_formatter'
+
+class VerboseFormatter < RSpec::Core::Formatters::BaseTextFormatter
+  attr_reader :column, :current_indentation
+  def initialize(*args)
+    super
+    @mutex = Mutex.new
+    @column = @current_indentation = 0
+  end
+
+  def start(count)
+    super
+    output.puts
+    output.puts "Running suite with seed #{RSpec.configuration.seed}\n"
+    output.puts
+  end
+
+  def example_group_started(example_group)
+    super
+    # $stderr.puts example_group.metadata.inspect
+    output.puts "#{padding}#{example_group.metadata[:example_group][:description_args].first}"
+    indent!
+  end
+
+  def example_group_finished(example_group)
+    super
+    outdent!
+  end
+
+  def example_started(example)
+    output.puts "#{padding}#{example.description}:"
+    indent!
+  end
+
+  def message(m)
+    @mutex.synchronize do
+      messages = m.split(/\r?\n/).reject {|s| s.empty? }
+      messages.each do |message|
+        if column + message.length > max_columns
+          output.puts
+          @column = current_indentation
+        end
+        if at_left_margin?
+          output.print "#{padding}#{message}"
+        else
+          output.print message
+        end
+        @column += message.length
+      end
+    end
+  end
+
+  def example_passed(example)
+    super
+    print_example_result green("PASS")
+  end
+
+  def example_failed(example)
+    super
+    print_example_result red("FAIL")
+  end
+
+  def example_pending(example)
+    super
+    print_example_result yellow("PENDING: #{example.metadata[:execution_result][:pending_message]}")
+  end
+
+  private
+  def print_example_result(text)
+    output.puts unless at_left_margin?
+    output.puts "#{padding}#{text}"
+    output.puts
+    outdent!
+  end
+
+  def at_left_margin?
+    column == current_indentation
+  end
+
+  def max_columns
+    @max_columns ||= ENV.include?('COLUMNS') ? ENV['COLUMNS'].to_i : 72
+  end
+
+  def indent_width
+    2
+  end
+
+  def padding
+    ' ' * current_indentation
+  end
+
+  def indent!
+    @current_indentation += indent_width
+    @column = @current_indentation
+  end
+
+  def outdent!
+    @current_indentation -= indent_width
+    @column = @current_indentation
+  end
+end
+
+module ExposeFormatter
+  def message(string)
+    RSpec.configuration.formatters.first.message(string)
+  end
+end
+
+RSpec.configure do |config|
+  config.include ExposeFormatter
+  config.add_formatter VerboseFormatter
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: innertube
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-01 00:00:00.000000000 Z
+date: 2012-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -44,6 +44,8 @@ files:
 - README.md
 - spec/innertube_spec.rb
 - spec/spec_helper.rb
+- spec/support/timeout.rb
+- spec/support/verbose_formatter.rb
 - .gitignore
 homepage: http://github.com/basho/innertube
 licenses: []
@@ -72,4 +74,6 @@ summary: A thread-safe resource pool, originally borne in riak-client (Ripple).
 test_files:
 - spec/innertube_spec.rb
 - spec/spec_helper.rb
+- spec/support/timeout.rb
+- spec/support/verbose_formatter.rb
 - .gitignore