concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/spec/concurrent/processor_count_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe '#processor_count' do
+
+    it 'retuns a positive integer' do
+      Concurrent::processor_count.should be_a Integer
+      Concurrent::processor_count.should >= 1
+    end
+  end
+
+  describe '#physical_processor_count' do
+
+    it 'retuns a positive integer' do
+      Concurrent::physical_processor_count.should be_a Integer
+      Concurrent::physical_processor_count.should >= 1
+    end
+  end
+end

data/spec/concurrent/promise_spec.rb

@@ -1,32 +1,26 @@
 require 'spec_helper'
 require_relative 'obligation_shared'
-require_relative 'uses_global_thread_pool_shared'
 
 module Concurrent
 
   describe Promise do
 
-    let!(:thread_pool_user){ Promise }
-    it_should_behave_like Concurrent::UsesGlobalThreadPool
+    let(:executor) { PerThreadExecutor.new }
 
-    let(:empty_root) { Promise.new { nil } }
+    let(:empty_root) { Promise.new(executor: executor){ nil } }
     let!(:fulfilled_value) { 10 }
     let!(:rejected_reason) { StandardError.new('mojo jojo') }
 
     let(:pending_subject) do
-      Promise.new{ sleep(0.3); fulfilled_value }.execute
+      Promise.new(executor: executor){ sleep(0.3); fulfilled_value }.execute
     end
 
     let(:fulfilled_subject) do
-      Promise.fulfill(fulfilled_value)
+      Promise.fulfill(fulfilled_value, executor: executor)
     end
 
     let(:rejected_subject) do
-      Promise.reject( rejected_reason )
-    end
-
-    before(:each) do
-      Promise.thread_pool = FixedThreadPool.new(1)
+      Promise.reject(rejected_reason, executor: executor)
     end
 
     it_should_behave_like :obligation
@@ -74,28 +68,28 @@ module Concurrent
 
       describe '.new' do
         it 'should return an unscheduled Promise' do
-          p = Promise.new { nil }
+          p = Promise.new(executor: executor){ nil }
           p.should be_unscheduled
         end
       end
 
       describe '.execute' do
         it 'creates a new Promise' do
-          p = Promise.execute{ nil }
+          p = Promise.execute(executor: executor){ nil }
           p.should be_a(Promise)
         end
 
         it 'passes the block to the new Promise' do
-          p = Promise.execute { 20 }
+          p = Promise.execute(executor: executor){ 20 }
           sleep(0.1)
           p.value.should eq 20
         end
 
         it 'calls #execute on the new Promise' do
           p = double('promise')
-          Promise.stub(:new).with(any_args).and_return(p)
+          Promise.stub(:new).with({executor: executor}).and_return(p)
           p.should_receive(:execute).with(no_args)
-          Promise.execute{ nil }
+          Promise.execute(executor: executor){ nil }
         end
       end
     end
@@ -105,15 +99,14 @@ module Concurrent
       context 'unscheduled' do
 
         it 'sets the promise to :pending' do
-          p = Promise.new { sleep(0.1) }.execute
+          p = Promise.new(executor: executor){ sleep(0.1) }.execute
           p.should be_pending
         end
 
         it 'posts the block given in construction' do
-          Promise.thread_pool.should_receive(:post).with(any_args)
-          Promise.new { nil }.execute
+          executor.should_receive(:post).with(any_args)
+          Promise.new(executor: executor){ nil }.execute
         end
-
       end
 
       context 'pending' do
@@ -124,19 +117,17 @@ module Concurrent
         end
 
         it 'does not posts again' do
-          Promise.thread_pool.should_receive(:post).with(any_args).once
+          executor.should_receive(:post).with(any_args).once
           pending_subject.execute
         end
-
       end
 
-
       describe 'with children' do
 
-        let(:root) { Promise.new { sleep(0.1); nil } }
-        let(:c1) { root.then { nil } }
-        let(:c2) { root.then { nil } }
-        let(:c2_1) { c2.then { nil } }
+        let(:root) { Promise.new(executor: executor){ sleep(0.1); nil } }
+        let(:c1) { root.then { sleep(0.1); nil } }
+        let(:c2) { root.then { sleep(0.1); nil } }
+        let(:c2_1) { c2.then { sleep(0.1); nil } }
 
         context 'when called on the root' do
           it 'should set all promises to :pending' do
@@ -156,7 +147,6 @@ module Concurrent
             [root, c1, c2, c2_1].each { |p| p.should be_pending }
           end
         end
-
       end
     end
 
@@ -186,7 +176,7 @@ module Concurrent
 
       context 'unscheduled' do
 
-        let(:p1) { Promise.new {nil} }
+        let(:p1) { Promise.new(executor: executor){nil} }
         let(:child) { p1.then{} }
 
         it 'returns a new promise' do
@@ -225,7 +215,6 @@ module Concurrent
           child = fulfilled_subject.then(Proc.new{ 7 }) { |v| v + 5 }
           child.value.should eq fulfilled_value + 5
         end
-
       end
 
       context 'rejected' do
@@ -240,7 +229,6 @@ module Concurrent
           child = rejected_subject.then(Proc.new{ 7 }) { |v| v + 5 }
           child.value.should eq 7
         end
-
       end
 
       it 'can be called more than once' do
@@ -276,13 +264,13 @@ module Concurrent
 
       it 'passes the result of each block to all its children' do
         expected = nil
-        Promise.new{ 20 }.then{ |result| expected = result }.execute
+        Promise.new(executor: executor){ 20 }.then{ |result| expected = result }.execute
         sleep(0.1)
         expected.should eq 20
       end
 
       it 'sets the promise value to the result if its block' do
-        root = Promise.new{ 20 }
+        root = Promise.new(executor: executor){ 20 }
         p = root.then{ |result| result * 2}.execute
         sleep(0.1)
         root.value.should eq 20
@@ -290,26 +278,26 @@ module Concurrent
       end
 
       it 'sets the promise state to :fulfilled if the block completes' do
-        p = Promise.new{ 10 * 2 }.then{|result| result * 2}.execute
+        p = Promise.new(executor: executor){ 10 * 2 }.then{|result| result * 2}.execute
         sleep(0.1)
         p.should be_fulfilled
       end
 
       it 'passes the last result through when a promise has no block' do
         expected = nil
-        Promise.new{ 20 }.then(Proc.new{}).then{|result| expected = result}.execute
+        Promise.new(executor: executor){ 20 }.then(Proc.new{}).then{|result| expected = result}.execute
         sleep(0.1)
         expected.should eq 20
       end
 
       it 'uses result as fulfillment value when a promise has no block' do
-        p = Promise.new{ 20 }.then(Proc.new{}).execute
+        p = Promise.new(executor: executor){ 20 }.then(Proc.new{}).execute
         sleep(0.1)
         p.value.should eq 20
       end
 
       it 'can manage long chain' do
-        root = Promise.new { 20 }
+        root = Promise.new(executor: executor){ 20 }
         p1 = root.then { |b| b * 3 }
         p2 = root.then { |c| c + 2 }
         p3 = p1.then { |d| d + 7 }
@@ -328,26 +316,26 @@ module Concurrent
 
       it 'passes the reason to all its children' do
         expected = nil
-        Promise.new{ raise ArgumentError }.then(Proc.new{ |reason| expected = reason }).execute
+        Promise.new(executor: executor){ raise ArgumentError }.then(Proc.new{ |reason| expected = reason }).execute
         sleep(0.1)
         expected.should be_a ArgumentError
       end
 
       it 'sets the promise value to the result if its block' do
-        root = Promise.new{ raise ArgumentError }
+        root = Promise.new(executor: executor){ raise ArgumentError }
         p = root.then(Proc.new{ |reason| 42 }).execute
         sleep(0.1)
         p.value.should eq 42
       end
 
       it 'sets the promise state to :rejected if the block completes' do
-        p = Promise.new{ raise ArgumentError }.execute
+        p = Promise.new(executor: executor){ raise ArgumentError }.execute
         sleep(0.1)
         p.should be_rejected
       end
 
       it 'uses reason as rejection reason when a promise has no rescue callable' do
-        p = Promise.new{ raise ArgumentError }.then { |val| val }.execute
+        p = Promise.new(executor: ImmediateExecutor.new){ raise ArgumentError }.then{ |val| val }.execute
         sleep(0.1)
         p.should be_rejected
         p.reason.should be_a ArgumentError

data/spec/concurrent/ruby_cached_thread_pool_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require_relative 'cached_thread_pool_shared'
+
+module Concurrent
+
+  describe RubyCachedThreadPool do
+
+    subject do
+      described_class.new(
+        max_threads: 5,
+        overflow_policy: :discard,
+        gc_interval: 0
+      )
+    end
+
+    after(:each) do
+      subject.kill
+      sleep(0.1)
+    end
+
+    it_should_behave_like :cached_thread_pool
+
+    context 'garbage collection' do
+
+      subject{ described_class.new(idletime: 1, max_threads: 5, gc_interval: 0) }
+
+      it 'removes from pool any thread that has been idle too long' do
+        3.times { subject << proc{ sleep(0.1) } }
+        sleep(0.1)
+        subject.length.should eq 3
+        sleep(2)
+        subject << proc{ nil }
+        sleep(0.1)
+        subject.length.should < 3
+      end
+
+      it 'removes from pool any dead thread' do
+        3.times { subject << proc{ sleep(0.1); raise Exception } }
+        sleep(0.1)
+        subject.length.should eq 3
+        sleep(2)
+        subject << proc{ nil }
+        sleep(0.1)
+        subject.length.should < 3
+      end
+    end
+
+    context 'worker creation and caching' do
+
+      subject{ described_class.new(idletime: 1, max_threads: 5) }
+
+      it 'creates new workers when there are none available' do
+        subject.length.should eq 0
+        5.times{ sleep(0.1); subject << proc{ sleep(1) } }
+        sleep(1)
+        subject.length.should eq 5
+      end
+
+      it 'uses existing idle threads' do
+        5.times{ subject << proc{ sleep(0.1) } }
+        sleep(1)
+        subject.length.should >= 5
+        3.times{ subject << proc{ sleep(1) } }
+        sleep(0.1)
+        subject.length.should >= 5
+      end
+    end
+  end
+end

data/spec/concurrent/ruby_fixed_thread_pool_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require_relative 'fixed_thread_pool_shared'
+
+module Concurrent
+
+  describe RubyFixedThreadPool do
+
+    subject { described_class.new(5, overflow_policy: :discard) }
+
+    after(:each) do
+      subject.kill
+      sleep(0.1)
+    end
+
+    it_should_behave_like :fixed_thread_pool
+
+    context 'exception handling' do
+
+      it 'restarts threads that experience exception' do
+        count = subject.length
+        count.times{ subject << proc{ raise StandardError } }
+        sleep(1)
+        subject.length.should eq count
+      end
+    end
+
+    context 'worker creation and caching' do
+
+      it 'creates new workers when there are none available' do
+        pool = described_class.new(5)
+        pool.current_length.should eq 0
+        5.times{ pool << proc{ sleep(1) } }
+        sleep(0.1)
+        pool.current_length.should eq 5
+        pool.kill
+      end
+    end
+  end
+end

data/spec/concurrent/ruby_thread_pool_executor_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+require_relative 'thread_pool_executor_shared'
+
+module Concurrent
+
+  describe RubyThreadPoolExecutor do
+
+    after(:each) do
+      subject.kill
+      sleep(0.1)
+    end
+
+    subject do
+      RubyThreadPoolExecutor.new(
+        min_threads: 2,
+        max_threads: 5,
+        idletime: 60,
+        max_queue: 10,
+        overflow_policy: :discard
+      )
+    end
+
+    it_should_behave_like :thread_pool_executor
+
+    context '#remaining_capacity' do
+
+      let!(:expected_max){ 100 }
+
+      subject do
+        RubyThreadPoolExecutor.new(
+          min_threads: 10,
+          max_threads: 20,
+          idletime: 60,
+          max_queue: expected_max,
+          overflow_policy: :discard
+        )
+      end
+
+      it 'returns :max_length when no tasks are enqueued' do
+        5.times{ subject.post{ nil } }
+        sleep(0.1)
+        subject.remaining_capacity.should eq expected_max
+      end
+
+      it 'returns the remaining capacity when tasks are enqueued' do
+        100.times{ subject.post{ sleep(0.5) } }
+        sleep(0.1)
+        subject.remaining_capacity.should < expected_max
+      end
+    end
+
+    context '#overload_policy' do
+
+      let!(:min_threads){ 1 }
+      let!(:max_threads){ 1 }
+      let!(:idletime){ 60 }
+      let!(:max_queue){ 1 }
+
+      context ':abort' do
+
+        subject do
+          described_class.new(
+            min_threads: min_threads,
+            max_threads: max_threads,
+            idletime: idletime,
+            max_queue: max_queue,
+            overflow_policy: :abort
+          )
+        end
+
+        specify '#post raises an error when the queue is at capacity' do
+          expect {
+            100.times{ subject.post{ sleep(1) } }
+          }.to raise_error(Concurrent::RejectedExecutionError)
+        end
+
+        specify '#<< raises an error when the queue is at capacity' do
+          expect {
+            100.times{ subject << proc { sleep(1) } }
+          }.to raise_error(Concurrent::RejectedExecutionError)
+        end
+
+        specify 'a #post task is never executed when the queue is at capacity' do
+          executed = Concurrent::AtomicFixnum.new(0)
+          100.times do
+            begin
+              subject.post{ executed.increment }
+            rescue
+            end
+          end
+          sleep(0.1)
+          executed.value.should < 100
+        end
+
+        specify 'a #<< task is never executed when the queue is at capacity' do
+          executed = Concurrent::AtomicFixnum.new(0)
+          100.times do
+            begin
+              subject << proc { executed.increment }
+            rescue
+            end
+          end
+          sleep(0.1)
+          executed.value.should < 100
+        end
+      end
+
+      context ':discard' do
+
+        subject do
+          described_class.new(
+            min_threads: min_threads,
+            max_threads: max_threads,
+            idletime: idletime,
+            max_queue: max_queue,
+            overflow_policy: :discard
+          )
+        end
+
+        specify 'a #post task is never executed when the queue is at capacity' do
+          executed = Concurrent::AtomicFixnum.new(0)
+          100.times do
+            subject.post{ executed.increment }
+          end
+          sleep(0.1)
+          executed.value.should < 100
+        end
+
+        specify 'a #<< task is never executed when the queue is at capacity' do
+          executed = Concurrent::AtomicFixnum.new(0)
+          100.times do
+            subject << proc { executed.increment }
+          end
+          sleep(0.1)
+          executed.value.should < 100
+        end
+      end
+
+      context ':caller_runs' do
+
+        subject do
+          described_class.new(
+            min_threads: 1,
+            max_threads: 1,
+            idletime: idletime,
+            max_queue: 1,
+            overflow_policy: :caller_runs
+          )
+        end
+
+        specify '#post does not create any new threads when the queue is at capacity' do
+          initial = Thread.list.length
+          5.times{ subject.post{ sleep(0.1) } }
+          Thread.list.length.should < initial + 5
+        end
+
+        specify '#post executes the task on the current thread when the queue is at capacity' do
+          subject.should_receive(:handle_overflow).with(any_args).at_least(:once)
+          5.times{ subject.post{ sleep(0.1) } }
+        end
+
+        specify '#post executes the task on the current thread when the queue is at capacity' do
+          bucket = []
+          5.times{|i| subject.post{ bucket.push(i) } }
+          sleep(0.1)
+          bucket.sort.should eq [0, 1, 2, 3, 4]
+        end
+
+        specify '#<< executes the task on the current thread when the queue is at capacity' do
+          subject.should_receive(:handle_overflow).with(any_args).at_least(:once)
+          5.times{ subject << proc { sleep(0.1) } }
+        end
+
+        specify '#post executes the task on the current thread when the queue is at capacity' do
+          bucket = []
+          5.times{|i| subject << proc { bucket.push(i) } }
+          sleep(0.1)
+          bucket.sort.should eq [0, 1, 2, 3, 4]
+        end
+      end
+    end
+  end
+end