contender 0.1.1 → 0.2.0

data/lib/contender/pool/pool_worker.rb

@@ -1,79 +1,38 @@
 module Contender
   module Pool
-    # Encapsulates a single worker thread in a thread pool
     class PoolWorker
-      # @param [ThreadPoolExecutor] pool
-      # @param [TaskQueue] queue
-      # @param [Boolean] non_block
-      # @return [undefined]
-      def initialize(pool, queue, non_block = false)
-        @pool = pool
-        @queue = queue
-        @non_block = non_block
+      extend Forwardable
 
-        # Only changed in the worker thread
-        @state = :inactive
-      end
+      attr_reader :completed_task_count
+      attr_reader :thread
 
-      # @return [undefined]
-      def start
-        return unless inactive?
+      def initialize(thread_factory, first_task)
+        @mutex = Mutex.new
 
-        @thread = Thread.new do
-          start_worker_loop
-        end
+        @thread_factory = thread_factory
+        @first_task = first_task
+        @completed_task_count = 0
       end
 
-      # @return [undefined]
-      def join
-        return unless @thread
-        @thread.join
+      def first_task!
+        @first_task.tap {
+          @first_task = nil
+        }
       end
 
-      # @return [undefined]
-      def interrupt
-        return unless @thread
-        @thread.raise OperationInterrupted
+      def on_task_completion
+        @completed_task_count += 1
       end
 
-      # Returns true if the pool worker is inactive
-      # @return [Boolean]
-      def inactive?
-        :inactive == @state
+      def start(&worker_loop)
+        @thread = @thread_factory.create &worker_loop
       end
 
-      # Returns true if the pool worker is waiting for tasks
-      # @return [Boolean]
-      def waiting?
-        :waiting == @state
-      end
-
-      # Returns true if the pool worker is executing a task
-      # @return [Boolean]
-      def executing?
-        :executing == @state
+      def interrupt
+        @thread.raise Interrupt
       end
 
-    protected
-
-      # Loop that is executed in another thread
-      # @return [undefined]
-      def start_worker_loop
-        @state = :waiting
-
-        loop do
-          break if @pool.shutdown_now?
-
-          task = @queue.dequeue @non_block
-          next unless task
-
-          @state = :executing
-          task.execute
-          @state = :waiting
-        end
-      ensure
-        @state = :inactive
-      end
+      def_delegators :@mutex, :lock, :unlock, :try_lock, :locked?
     end # PoolWorker
   end # Pool
 end

data/lib/contender/pool/rejection_policy.rb

@@ -0,0 +1,61 @@
+module Contender
+  module Pool
+    # Represents the strategy to use when the pool executor rejects a task
+    class RejectionPolicy
+      # @abstract
+      # @param [Object] task
+      # @param [PoolExecutor] executor
+      # @return [undefined]
+      def on_rejection(task, executor)
+        raise NotImplementedError
+      end
+    end
+
+    # Rejection policy that executes the task in the calling thread
+    class ExecutionByCallerPolicy < RejectionPolicy
+      # @param [Object] task
+      # @param [PoolExecutor] executor
+      # @return [undefined]
+      def on_rejection(task, executor)
+        return if executor.shutdown?
+        task.call
+      end
+    end
+
+    # Rejection policy that simply raises an exception
+    class AbortPolicy < RejectionPolicy
+      # @param [Object] task
+      # @param [PoolExecutor] executor
+      # @return [undefined]
+      def on_rejection(task, executor)
+        raise TaskRejectionError, "Task #{task} rejected by thread pool executor"
+      end
+    end
+
+    TaskRejectionError = Class.new RuntimeError
+
+    # Rejection policy that silently discards a task
+    class DiscardPolicy < RejectionPolicy
+      # @param [Object] task
+      # @param [PoolExecutor] executor
+      # @return [undefined]
+      def on_rejection(task, executor)
+        # Just ignore the task
+      end
+    end
+
+    # Rejection policy that discards the first task in the queue and then enqueues the
+    # task
+    class DiscardOldestPolicy < RejectionPolicy
+      # @param [Object] task
+      # @param [PoolExecutor] executor
+      # @return [undefined]
+      def on_rejection(task, executor)
+        return if executor.shutdown?
+
+        executor.queue.poll
+        executor.execute task
+      end
+    end # DiscardOldestPolicy
+  end # Pool
+end

data/lib/contender/queue.rb

@@ -0,0 +1,87 @@
+module Contender
+  # @abstract
+  class Queue
+    include Enumerable
+
+    # @abstract
+    # @param [Object] element
+    # @param [Float] timeout
+    # @return [Boolean]
+    def offer(element, timeout = nil)
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @param [Object] element
+    # @return [undefined]
+    def put(element)
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @param [Float] timeout
+    # @return [Object]
+    def poll(timeout = nil)
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @return [Object]
+    def take
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @return [Object]
+    def peek
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @return [undefined]
+    def clear
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @yield [Object]
+    # @return [undefined]
+    def each
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @param [Object] element
+    # @return [Boolean]
+    def delete(element)
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @param [Array] target
+    # @param [Integer] max_elements
+    # @return [Integer]
+    def drain_to(target, max_elements = FIXNUM_MAX)
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @return [Integer]
+    def capacity_remaining
+      raise NotImplementedError
+    end
+
+    # @abstract
+    # @return [Integer]
+    def size
+      raise NotImplementedError
+    end
+
+    alias_method :length, :size
+
+    # @return [Boolean]
+    def empty?
+      size == 0
+    end
+  end
+end

data/lib/contender/thread_factory.rb

@@ -0,0 +1,37 @@
+module Contender
+  # @abstract
+  class ThreadFactory
+    # @abstract
+    # @yield
+    # @return [Thread]
+    def create(&block)
+      raise NotImplementedError
+    end
+  end
+
+  class SimpleThreadFactory < ThreadFactory
+    # @return [ThreadGroup]
+    attr_reader :group
+
+    # @return [Integer]
+    attr_accessor :priority
+
+    # @return [undefined]
+    def initialize
+      @group = ThreadGroup.new
+      @priority = 0
+    end
+
+    # @api public
+    # @yield
+    # @return [Thread]
+    def create(&block)
+      thread = Thread.new &block
+      thread.priority = @priority
+
+      @group.add thread
+
+      thread
+    end
+  end
+end

data/lib/contender/version.rb

@@ -1,3 +1,3 @@
 module Contender
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/spec/copy_on_write_array_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module Contender
+  describe CopyOnWriteArray do
+    it 'handles concurrent operations without errors' do
+      arr = CopyOnWriteArray.new
+
+      (1..3).map { |i|
+        Thread.new do
+          100.times do |j|
+            arr << i
+            arr.each { |x| x * 2 }
+            arr.shift
+            arr.last
+          end
+        end
+      }.map(&:join)
+    end
+  end
+end

data/spec/copy_on_write_set_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Contender
+  describe CopyOnWriteSet do
+    it 'handles concurrent operations without errors' do
+      set = CopyOnWriteSet.new
+
+      (1..3).map { |i|
+        Thread.new do
+          100.times do |j|
+            n = i * 1000 + j
+
+            set.add n
+            set.each { |e| e }
+
+            set.should include(n)
+
+            set.delete n
+            set.size
+          end
+        end
+      }.map(&:join)
+    end
+  end
+end

data/spec/countdown_latch_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+module Contender
+
+  describe CountdownLatch do
+    it 'requires a positive initial count' do
+      expect {
+        CountdownLatch.new -1
+      }.to raise_error ArgumentError
+    end
+
+    describe 'counting down from 1' do
+      before do
+        @latch = CountdownLatch.new 1
+        @name = :foo
+      end
+
+      it 'blocks until counted down in another thread' do
+        Thread.new do
+          @name = :bar
+          @latch.countdown
+        end
+
+        @latch.await.should == true
+        @latch.count.should == 0
+
+        @name.should == :bar
+      end
+
+      it 'blocks another thread until counted down' do
+        Thread.new do
+          @latch.await.should == true
+          @latch.count.should == 0
+          @name.should == :bar
+        end
+
+        @name = :bar
+        @latch.countdown
+      end
+
+      it 'returns false if timed out' do
+        @latch.await(0).should == false
+      end
+    end
+
+    describe 'counting down from 0' do
+      before do
+        @latch = CountdownLatch.new 0
+      end
+
+      it 'does not block' do
+        @latch.await.should == true
+        @latch.count.should == 0
+      end
+    end
+
+    describe 'counting down from 2' do
+      before do
+        @latch = CountdownLatch.new 2
+        @name = :foo
+      end
+
+      it 'blocks until counted down in 1 parallel thread' do
+        Thread.new do
+          @latch.countdown
+          @name = :bar
+          @latch.countdown
+        end
+
+        @latch.await
+        @latch.count.should == 0
+        @name.should == :bar
+      end
+
+      it 'blocks until counted down in 2 parallel threads' do
+        Thread.new do
+          @latch.countdown
+        end
+
+        Thread.new do
+          @name = :bar
+          @latch.countdown
+        end
+
+        @latch.await
+        @latch.count.should == 0
+        @name.should == :bar
+      end
+
+      it 'blocks until counted down in 2 chained threads' do
+        Thread.new do
+          @latch.countdown
+
+          Thread.new do
+            @name = :bar
+            @latch.countdown
+          end
+        end
+
+        @latch.await
+        @latch.count.should == 0
+        @name.should == :bar
+      end
+    end
+
+    describe 'with interleaved latches' do
+      before do
+        @check_latch = CountdownLatch.new 1
+        @change_latch1 = CountdownLatch.new 1
+        @change_latch2 = CountdownLatch.new 1
+        @name = :foo
+      end
+
+      it 'blocks the correct thread' do
+        Thread.new do
+          @name = :bar
+          @change_latch1.countdown
+
+          @check_latch.await
+
+          @name = :baz
+          @change_latch2.countdown
+        end
+
+        @change_latch1.await
+        @name.should == :bar
+
+        @check_latch.countdown
+
+        @change_latch2.await
+        @name.should == :baz
+      end
+    end
+  end
+
+end