dispatch_queue_rb 1.0.0

data/test/test_thread_queue.rb

@@ -0,0 +1,77 @@
+# =============================================================================
+#
+# MODULE      : test/test_thread_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+
+module DispatchQueue
+  describe ThreadQueue do
+
+    let( :task_count )    { 4 }
+    let( :log )           { [] }
+    let( :lock )          { Mutex.new }
+    let( :logger )        { Proc.new { |e, d| lock.synchronize { log << [e, d] } } }
+    subject               { ThreadQueue.new }
+
+    it "can initialize a thread queue" do
+      subject.must_be_instance_of ThreadQueue
+    end
+
+    def task( task_id )
+      logger.call( :begin_task, { task_id:task_id, thread:Thread.current } )
+      sleep(0.001)
+      logger.call( :end_task, { task_id:task_id, thread:Thread.current } )
+    end
+
+    describe "dispatch_async" do
+      it "executes tasks serially" do
+        (1..task_count).each { |i| subject.dispatch_async { task( i ) } }
+        subject.dispatch_barrier_sync {} # wait for all previous tasks to complete
+
+        log.map { |e,d| e }.must_equal [:begin_task, :end_task] * task_count
+      end
+
+      it "executes tasks in enqueue order" do
+        (1..task_count).each { |i| subject.dispatch_async { task( i ) } }
+        subject.dispatch_barrier_sync {} # wait for all previous tasks to complete
+
+        task_id_list = log.select { |e,d| e == :begin_task }.map { |e,d| d[:task_id] }
+        task_id_list.must_equal (1..task_count).to_a
+      end
+
+      it "resumes execution when new tasks are enqueues" do
+        (1..task_count).each { |i| subject.dispatch_async { task( "a#{i}".to_sym ) } }
+        subject.dispatch_barrier_sync {} # wait for all previous tasks to complete
+        sleep( 0.01 )
+
+        (1..task_count).each { |i| subject.dispatch_async { task( "b#{i}".to_sym ) } }
+        subject.dispatch_barrier_sync {} # wait for all previous tasks to complete
+
+        task_id_list = log.select { |e,d| e == :begin_task }.map { |e,d| d[:task_id] }
+        task_id_list.count.must_equal task_count*2, task_id_list
+      end
+    end
+
+    describe "with multiple thread queues" do
+      let( :subject2 )    { ThreadQueue.new }
+
+      it "interleaves tasks from different queues" do
+        (1..task_count).each { |i| subject.dispatch_async { task( "a#{i}".to_sym ) } }
+        (1..task_count).each { |i| subject2.dispatch_async { task( "b#{i}".to_sym ) } }
+        subject.dispatch_barrier_sync {} # wait for all previous tasks to complete
+        subject2.dispatch_barrier_sync {} # wait for all previous tasks to complete
+
+        task_id_list = log.select { |e,d| e == :begin_task }.map { |e,d| d[:task_id] }
+        task_chunks = task_id_list.chunk { |e| e.to_s[0] }.map { |c, l| l }
+        task_chunks.count.must_be :>, 3, task_chunks
+      end
+    end
+
+  end
+end

data/test/test_timer_pool.rb

@@ -0,0 +1,124 @@
+# =============================================================================
+#
+# MODULE      : test/test_timer_pool.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+
+module DispatchQueue
+  describe TimerPool do
+    let( :group )           { DispatchGroup.new }
+    let( :queue )           { SerialQueue.new }
+    let( :reference_time )  { Time.now + 0.005 }
+    let( :result )          { [] }
+
+    describe "default_pool" do
+      subject { TimerPool.default_pool }
+
+      it "is a valid TimerPool" do
+        subject.must_be_instance_of TimerPool
+      end
+
+      it "execute tasks after specified time" do
+        done = false
+        subject.dispatch_after( Time.now() + 0.001 ) { done = true }
+        done.must_equal false
+        sleep( 0.002 )
+        done.must_equal true
+      end
+
+      it "execute tasks after specified delay" do
+        done = false
+        subject.dispatch_after( 0.001 ) { done = true }
+        done.must_equal false
+        sleep( 0.002 )
+        done.must_equal true
+      end
+
+      it "execute tasks in eta order" do
+        subject.dispatch_after( reference_time + 0.001, target_queue:queue, group:group ) { result << 1 }
+        subject.dispatch_after( reference_time + 0.003, target_queue:queue, group:group ) { result << 3 }
+        subject.dispatch_after( reference_time + 0.004, target_queue:queue, group:group ) { result << 4 }
+        subject.dispatch_after( reference_time + 0.002, target_queue:queue, group:group ) { result << 2 }
+        group.wait()
+        result.must_equal [1,2,3,4]
+      end
+    end # describe "default_pool"
+
+    describe "SerialQueue.dispatch_after" do
+      subject { SerialQueue.new }
+
+      it "execute tasks in eta order" do
+        subject.dispatch_after( reference_time + 0.001, group:group ) { result << 1 }
+        subject.dispatch_after( reference_time + 0.003, group:group ) { result << 3 }
+        subject.dispatch_after( reference_time + 0.004, group:group ) { result << 4 }
+        subject.dispatch_after( reference_time + 0.002, group:group ) { result << 2 }
+        group.wait()
+        result.must_equal [1,2,3,4]
+      end
+
+      it "execute more tasks in eta order" do
+        count = 100
+        (1..count).to_a.shuffle.each do |i|
+          subject.dispatch_after( reference_time + i * 0.001, group:group ) { result << i }
+        end
+        group.wait()
+        result.must_equal (1..count).to_a
+      end
+    end
+
+    describe "ThreadQueue.dispatch_after" do
+      subject { ThreadQueue.new }
+
+      it "execute tasks in eta order" do
+        subject.dispatch_after( reference_time + 0.001, group:group ) { result << 1 }
+        subject.dispatch_after( reference_time + 0.003, group:group ) { result << 3 }
+        subject.dispatch_after( reference_time + 0.004, group:group ) { result << 4 }
+        subject.dispatch_after( reference_time + 0.002, group:group ) { result << 2 }
+        group.wait()
+        result.must_equal [1,2,3,4]
+      end
+    end
+
+
+    # NOTE: these test may fail occasionally since the target queues uses are
+    # concurrent and only guaranty that work will be scheduled in order.
+    # Execution might be out of order by the time the result is enqueued.
+    # Ordering relies exclusively on the delays introduced by dispatch_after(),
+    # which might not be nough.
+    # Also note that there is no synchronization on writing to result, so this
+    # will result in a race condition in multi-threaded ruby interpretter.
+
+    describe "ConcurrentQueue.dispatch_after" do
+      subject { ConcurrentQueue.new }
+
+      it "execute tasks in eta order" do
+        subject.dispatch_after( reference_time + 0.001, group:group ) { result << 1 }
+        subject.dispatch_after( reference_time + 0.003, group:group ) { result << 3 }
+        subject.dispatch_after( reference_time + 0.004, group:group ) { result << 4 }
+        subject.dispatch_after( reference_time + 0.002, group:group ) { result << 2 }
+        group.wait()
+        result.must_equal [1,2,3,4]
+      end
+    end
+
+    describe "ThreadPoolQueue.dispatch_after" do
+      subject { ThreadPoolQueue.new }
+
+      it "execute tasks in eta order" do
+        subject.dispatch_after( reference_time + 0.001, group:group ) { result << 1 }
+        subject.dispatch_after( reference_time + 0.003, group:group ) { result << 3 }
+        subject.dispatch_after( reference_time + 0.004, group:group ) { result << 4 }
+        subject.dispatch_after( reference_time + 0.002, group:group ) { result << 2 }
+        group.wait()
+        result.must_equal [1,2,3,4]
+      end
+    end
+
+  end # describe TimerPool
+end # module DispatchQueue

data/test/test_version.rb

@@ -0,0 +1,155 @@
+# =============================================================================
+#
+# MODULE      : test/test_version.rb
+# PROJECT     : DispatchQueueRb
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+
+module DispatchQueue
+  describe VERSION do
+
+    subject { VERSION }
+
+    it "is definied as a string" do
+      subject.must_be_instance_of String
+    end
+
+  end
+
+
+  class Expectation
+    def initialize( target, action=nil, *args, **opts, &block )
+      @target = target
+      @action = action
+      @args = args
+      @opts = opts
+      @block = block
+    end
+
+    def to
+      self
+    end
+
+    def to_be
+      self
+    end
+
+    def method_missing( name, *args, **opts, &block )
+      # puts "method_missing( #{name.inspect} )"
+      Expectation.new( self, name, *args, **opts, &block )
+    end
+
+    def inspect
+      "#{@target.inspect}#{_inspect_action()}"
+    end
+
+    def ==( arg )
+      Expectation.new( self, :==, arg )
+    end
+
+    def !=( arg )
+      Expectation.new( self, :!=, arg )
+    end
+
+    def =~( arg, within:nil )
+      Expectation.new( self, :=~, arg, within:within )
+    end
+
+
+  private
+    def _inspect_action()
+      return "" if @action.nil?
+      return " #{@action} #{@args[0]}" if _is_operator_action()
+      return ".#{@action}" if @args.empty? && @opts.empty?
+      return ".#{@action}(#{_inspect_action_args()})"
+    end
+
+    def _is_operator_action()
+      @args.count == 1 && [:==, :!=, :=~, :<=>, :<, :>, :<=, :>=, :<<, :>>].include?( @action )
+    end
+
+
+    def _inspect_action_args()
+      return "" if @args.empty? && @opts.empty?
+      return " " + ( @args.map { |a| a.inspect } +
+                     @opts.map { |k,v| "#{k}: #{v.inspect}" } ).join( ', ' ) + " "
+    end
+  end
+
+
+  # expect( subject ) < 10
+  # expect( subject ).start_with?( "aaa" )
+  # expect( subject ).to.start_with?( "aaa" )
+  # expect( subject ).to.include?( "aaa" )
+  # expect( subject ).count < 10
+  # expect( subject ).count.to_equal( 10 ).within( 20 )
+  # expect( subject ).count.to_equal( 10 ).within( 20 )
+
+  describe Expectation do
+
+    def expect( value )
+      Expectation.new( value )
+    end
+
+    it "can create a new expectation" do
+      expectation = expect( :value )
+      expectation.must_be_instance_of Expectation
+    end
+
+    it "inspects to the wrapped value" do
+      expectation = expect( :value )
+      expectation.inspect.must_equal ":value"
+    end
+
+    it "inspects with method call" do
+      expectation = expect( :value ).something()
+      expectation.inspect.must_equal ":value.something"
+    end
+
+    it "inspects with method call and arguments" do
+      expectation = expect( :value ).something(:aaa, :bbb)
+      expectation.inspect.must_equal ":value.something( :aaa, :bbb )"
+    end
+
+    it "inspects with method call and optional arguments" do
+      expectation = expect( :value ).something(:aaa, bbb:1)
+      expectation.inspect.must_equal ":value.something( :aaa, bbb: 1 )"
+    end
+
+    it "inspects with chained method calls" do
+      expectation = expect( :value ).something(:aaa, :bbb).something_else( aaa:1, bbb:2 )
+      expectation.inspect.must_equal ":value.something( :aaa, :bbb ).something_else( aaa: 1, bbb: 2 )"
+    end
+
+    it "inspects with chained method calls and binary operators" do
+      expectation = expect( :value ).something(:aaa, :bbb) < 10
+      expectation.inspect.must_equal ":value.something( :aaa, :bbb ) < 10"
+    end
+
+    it "inspects with chained method calls and binary operators 2" do
+      expectation = expect( :value ).something(:aaa, :bbb).to_be << 10
+      expectation.inspect.must_equal ":value.something( :aaa, :bbb ) << 10"
+    end
+
+    it "inspects with chained method calls and binary operators 3" do
+      expectation = expect( [1,2,3] ).size ==  10
+      expectation.inspect.must_equal "[1, 2, 3].size == 10"
+    end
+
+    it "inspects with chained method calls and binary operators 4" do
+      expectation = expect( [1,2,3] ).size !=  10
+      expectation.inspect.must_equal "[1, 2, 3].size != 10"
+    end
+
+    it "inspects with chained method calls and binary operators 4" do
+      expectation = expect( [1,2,3] ).size.=~( 10, within:1 )
+      expectation.inspect.must_equal "[1, 2, 3].size =~ 10"
+    end
+
+  end
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: dispatch_queue_rb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Marc-Antoine Argenton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: watch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.3'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: DispatchQueueRb is a pure ruby implementation of Grand Central Dispatch
+  concurrency primitives. It implements serial and concurrent queues, with synchronous,
+  asynchronous, barrier and delayed dispatch methods. All queues dispatch methods
+  support an optional dispatch groups to synchronize on completion of a group of tasks.
+  It also provides a thread pool based concurrent queue, scaled to the number of available
+  cpu cores, and used by default to schedule the actual work.
+email:
+- maargenton.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- dispatch_queue_rb.gemspec
+- lib/dispatch_queue_rb.rb
+- lib/dispatch_queue_rb/concurrent_queue.rb
+- lib/dispatch_queue_rb/dispatch.rb
+- lib/dispatch_queue_rb/dispatch_group.rb
+- lib/dispatch_queue_rb/internal/condition_variable_pool.rb
+- lib/dispatch_queue_rb/internal/continuation.rb
+- lib/dispatch_queue_rb/internal/heap.rb
+- lib/dispatch_queue_rb/internal/thread_pool_queue.rb
+- lib/dispatch_queue_rb/internal/thread_queue.rb
+- lib/dispatch_queue_rb/internal/timer_pool.rb
+- lib/dispatch_queue_rb/mixins/dispatch_after_impl.rb
+- lib/dispatch_queue_rb/mixins/dispatch_sync_impl.rb
+- lib/dispatch_queue_rb/serial_queue.rb
+- lib/dispatch_queue_rb/version.rb
+- rakefile.rb
+- test/_test_env.rb
+- test/test_concurrent_queue.rb
+- test/test_condition_variable_pool.rb
+- test/test_continuation.rb
+- test/test_dispatch.rb
+- test/test_dispatch_group.rb
+- test/test_group_concurrent_queue.rb
+- test/test_group_serial_queue.rb
+- test/test_group_thread_pool_queue.rb
+- test/test_heap.rb
+- test/test_serial_queue.rb
+- test/test_thread_pool_queue.rb
+- test/test_thread_queue.rb
+- test/test_timer_pool.rb
+- test/test_version.rb
+homepage: https://github.com/marcus999/dispatch_queue_rb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Pure ruby implementation of Grand Central Dispatch concurrency primitives.
+test_files:
+- test/_test_env.rb
+- test/test_concurrent_queue.rb
+- test/test_condition_variable_pool.rb
+- test/test_continuation.rb
+- test/test_dispatch.rb
+- test/test_dispatch_group.rb
+- test/test_group_concurrent_queue.rb
+- test/test_group_serial_queue.rb
+- test/test_group_thread_pool_queue.rb
+- test/test_heap.rb
+- test/test_serial_queue.rb
+- test/test_thread_pool_queue.rb
+- test/test_thread_queue.rb
+- test/test_timer_pool.rb
+- test/test_version.rb