zeevex_concurrency 0.0.1

data/spec/thread_pool_spec.rb

@@ -0,0 +1,281 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'zeevex_concurrency/thread_pool.rb'
+require 'zeevex_concurrency/event_loop.rb'
+require 'timeout'
+require 'thread'
+require 'atomic'
+require 'countdownlatch'
+
+describe ZeevexConcurrency::ThreadPool do
+  let :mutex do
+    Mutex.new
+  end
+
+  let :latch do
+    CountDownLatch.new(1)
+  end
+
+  let :latch_wait_task do
+    Proc.new { latch.wait }
+  end
+
+  let :queue do
+    Queue.new
+  end
+
+  let :pop_task do
+    Proc.new { queue.pop }
+  end
+
+  let :atom do
+    Atomic.new(0)
+  end
+
+  around :each do |ex|
+    Timeout::timeout(30) do
+      ex.run
+    end
+  end
+
+  before do
+    queue
+    pop_task
+    atom
+    latch_wait_task
+    latch
+  end
+
+  def wait_until(timeout = 5, sleep_sec = 0.1)
+    t_start = Time.now
+
+    # go ahead and give up our timeslice as we might as well
+    # let somebody else make the condition true
+    Thread.pass unless yield
+    until yield || (Time.now-t_start) >= timeout
+      sleep sleep_sec
+    end
+    yield
+  end
+
+  shared_examples_for 'thread pool initialization' do
+    context 'basic usage' do
+      it 'should allow enqueue of a proc' do
+        expect { pool.enqueue(Proc.new { true }) }.
+            not_to raise_error
+      end
+
+      it 'should allow enqueue of a block' do
+        expect {
+          pool.enqueue do
+            true
+          end
+        }.not_to raise_error
+      end
+
+      it 'should allow enqueue of a Promise, and return same promise' do
+        promise = ZeevexConcurrency::Promise.new(Proc.new {true})
+        expect { pool.enqueue(promise) }.not_to raise_error
+      end
+
+      it 'should NOT allow both a callable and a block' do
+        expect {
+          pool.enqueue(Proc.new{}) do
+            true
+          end
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  shared_examples_for 'thread pool running tasks' do
+    it 'should execute the task on a different thread' do
+      pool.enqueue { queue << Thread.current.__id__ }
+      queue.pop.should_not == Thread.current.__id__
+    end
+
+    it 'should allow enqueueing from an executed task, and execute both' do
+      pool.enqueue do
+        pool.enqueue { queue << "val2" }
+        queue << "val1"
+      end
+      [queue.pop, queue.pop].sort.should == ["val1", "val2"]
+    end
+
+    it 'should execute a large number of tasks' do
+      atom = Atomic.new(0)
+      300.times do
+        pool.enqueue do
+          atom.update { |x| x+1 }
+        end
+      end
+      Timeout::timeout(20) do
+        while atom.value != 300
+          sleep 0.5
+        end
+      end
+      atom.value.should == 300
+    end
+  end
+
+  shared_examples_for 'thread pool with parallel execution' do
+    after do
+      latch.countdown!
+    end
+
+    # must be an even number
+    let :count do
+      parallelism == -1 ? 32 : parallelism
+    end
+
+    it 'should increase busy_count when tasks start' do
+      count.times { pool.enqueue { queue.pop } }
+      wait_until { pool.busy_count == count }
+      pool.busy_count.should == count
+    end
+
+    it 'should decrease busy_count when tasks finish' do
+      count.times { pool.enqueue { queue.pop } }
+      (count / 2).times { queue << "foo" }
+      pool.enqueue { latch.countdown!; queue.pop }
+      latch.wait
+      # should we need the following?
+      wait_until { pool.busy_count == (count / 2) + 1}
+      pool.busy_count.should == (count / 2) + 1
+    end
+
+    #
+    # TODO: this is pretty iffy - it doesn't really prove the assertion
+    #
+    it 'should return from join only when currently executing tasks finish' do
+      (count / 2).times { pool.enqueue { sleep 1; atom.update {|x| x + 1} } }
+      pool.join
+      atom.value.should == count/2
+    end
+  end
+
+  shared_examples_for 'thread pool with task queue' do
+    it 'should give a total count of backlog in queue' do
+      (parallelism + 1).times { pool.enqueue { queue.pop } }
+      wait_until { pool.backlog == 1 }
+      pool.backlog.should == 1
+    end
+
+    it 'should allow flushing jobs from the queue' do
+      (parallelism + 1).times { pool.enqueue { queue.pop } }
+      wait_until { pool.backlog == 1 }
+      pool.flush
+      pool.backlog.should == 0
+    end
+
+    it 'should not return from join if backlogged tasks have not run' do
+      count = parallelism + 2
+      count.times { pool.enqueue { queue.pop } }
+      expect {
+        Timeout::timeout(2) { pool.join }
+      }.to raise_error(TimeoutError)
+    end
+
+    # TODO: this is another iffy one - how do we accurately meausure
+    #       when join returns and how many tasks are waiting?
+    it 'should return from join when backlogged tasks have' do
+      count = parallelism * 2
+      t_start = Time.now
+      count.times { pool.enqueue { sleep 1; atom.update {|x| x + 1} } }
+      pool.join
+      t_end = Time.now
+      atom.value.should == count
+      # we expect roughly 2 seconds of wall clock time - each thread doing 2 tasks
+      # which sleep for 1 second each
+      (t_end - t_start).round.should == 2
+    end
+  end
+
+  shared_examples_for 'thread pool control' do
+    it 'should allow enqueueing after a stop/start' do
+      pending 'broken on jruby, and really in general'
+      pool.stop
+      pool.start
+      pool.enqueue do
+        queue << "ran"
+      end
+      Timeout::timeout(5) do
+        queue.pop.should == "ran"
+      end
+    end
+  end
+
+  context 'FixedPool' do
+    let :parallelism do
+      32
+    end
+    let :pool do
+      ZeevexConcurrency::ThreadPool::FixedPool.new(parallelism)
+    end
+
+    it_should_behave_like 'thread pool initialization'
+    it_should_behave_like 'thread pool running tasks'
+    it_should_behave_like 'thread pool control'
+    it_should_behave_like 'thread pool with parallel execution'
+    it_should_behave_like 'thread pool with task queue'
+
+    it 'should indicate that the pool is busy when there are tasks in the queue' do
+      (parallelism + 1).times { pool.enqueue { sleep 30 } }
+      wait_until { pool.backlog == 1 }
+      pool.should be_busy
+    end
+
+    it 'should indicate that there are no free workers when there are tasks in the queue' do
+      (parallelism + 1).times { pool.enqueue { sleep 30 } }
+      wait_until { pool.free_count == 0 }
+      pool.free_count.should == 0
+      pool.busy_count.should == parallelism
+    end
+
+  end
+
+  context 'InlineThreadPool' do
+    let :pool do
+      ZeevexConcurrency::ThreadPool::InlineThreadPool.new
+    end
+    let :parallelism do
+      1
+    end
+
+    it_should_behave_like 'thread pool initialization'
+    it_should_behave_like 'thread pool running tasks'
+    it_should_behave_like 'thread pool control'
+  end
+
+  context 'ThreadPerJobPool' do
+    let :pool do
+      ZeevexConcurrency::ThreadPool::ThreadPerJobPool.new
+    end
+    let :parallelism do
+      -1
+    end
+
+    it_should_behave_like 'thread pool initialization'
+    it_should_behave_like 'thread pool running tasks'
+    it_should_behave_like 'thread pool control'
+    it_should_behave_like 'thread pool with parallel execution'
+  end
+
+  context 'EventLoopAdapter' do
+    let :loop do
+      ZeevexConcurrency::EventLoop.new
+    end
+    let :pool do
+      ZeevexConcurrency::ThreadPool::EventLoopAdapter.new loop
+    end
+    let :parallelism do
+      1
+    end
+
+    it_should_behave_like 'thread pool initialization'
+    it_should_behave_like 'thread pool running tasks'
+    it_should_behave_like 'thread pool control'
+    it_should_behave_like 'thread pool with task queue'
+  end
+
+end
+

data/zeevex_concurrency.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zeevex_concurrency/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "zeevex_concurrency"
+  gem.version       = ZeevexConcurrency::VERSION
+  gem.authors       = ["Robert Sanders"]
+  gem.email         = ["robert@zeevex.com"]
+  gem.description   = %q{Concurrency utilities including Delays, Promises, Futures, Event Loops, Thread Pools, and Synchronizing wrappers}
+  gem.summary       = %q{Some concurrency utilities for Ruby}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'zeevex_proxy'
+  gem.add_dependency 'countdownlatch', '~> 1.0.0'
+  gem.add_dependency 'atomic', '~> 1.0.0'
+
+  ## other headius utils
+  # s.add_dependency 'thread_safe'
+
+  gem.add_development_dependency 'rspec', '~> 2.9.0'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'pry'
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification 
+name: zeevex_concurrency
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Robert Sanders
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-01-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :runtime
+  name: zeevex_proxy
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  prerelease: false
+  type: :runtime
+  name: countdownlatch
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  prerelease: false
+  type: :runtime
+  name: atomic
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 2
+        - 9
+        - 0
+        version: 2.9.0
+  prerelease: false
+  type: :development
+  name: rspec
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  name: rake
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  name: pry
+  requirement: *id006
+description: Concurrency utilities including Delays, Promises, Futures, Event Loops, Thread Pools, and Synchronizing wrappers
+email: 
+- robert@zeevex.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/zeevex_concurrency.rb
+- lib/zeevex_concurrency/delay.rb
+- lib/zeevex_concurrency/delayed.rb
+- lib/zeevex_concurrency/event_loop.rb
+- lib/zeevex_concurrency/future.rb
+- lib/zeevex_concurrency/logging.rb
+- lib/zeevex_concurrency/nil_logger.rb
+- lib/zeevex_concurrency/promise.rb
+- lib/zeevex_concurrency/synchronized.rb
+- lib/zeevex_concurrency/thread_pool.rb
+- lib/zeevex_concurrency/version.rb
+- script/repl
+- script/testall
+- spec/delay_spec.rb
+- spec/delayed_spec.rb
+- spec/event_loop_spec.rb
+- spec/future_spec.rb
+- spec/promise_spec.rb
+- spec/spec_helper.rb
+- spec/thread_pool_spec.rb
+- zeevex_concurrency.gemspec
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Some concurrency utilities for Ruby
+test_files: 
+- spec/delay_spec.rb
+- spec/delayed_spec.rb
+- spec/event_loop_spec.rb
+- spec/future_spec.rb
+- spec/promise_spec.rb
+- spec/spec_helper.rb
+- spec/thread_pool_spec.rb
+has_rdoc: