dispatch_queue_rb 1.0.0

data/test/test_dispatch.rb

@@ -0,0 +1,91 @@
+# =============================================================================
+#
+# MODULE      : test/test_dispatch.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+
+module DispatchQueue
+  describe Dispatch do
+    describe "default_queue" do
+      it "is a ThreadPoolQueue" do
+        Dispatch.default_queue.must_be_instance_of ThreadPoolQueue
+      end
+
+      it "must remain the same" do
+        q1 = Dispatch.default_queue
+        q2 = Dispatch.default_queue
+
+        q1.wont_be_nil
+        q2.wont_be_nil
+        q2.must_be_same_as q1
+      end
+    end
+
+    describe "main_queue" do
+      it "is a ThreadQueue" do
+        Dispatch.main_queue.must_be_instance_of ThreadQueue
+      end
+
+      it "must remain the same" do
+        q1 = Dispatch.main_queue
+        q2 = Dispatch.main_queue
+
+        q1.wont_be_nil
+        q2.wont_be_nil
+        q2.must_be_same_as q1
+      end
+    end
+
+    describe "ncpu" do
+      it "returns the number of cpu cores available" do
+        Dispatch.ncpu.must_be_kind_of Integer
+        Dispatch.ncpu.must_be :>, 1
+      end
+    end
+
+    describe "synchronize" do
+      it "synchronizes an asynchronous operation with the calling thread" do
+        done = false
+        assert_wont_timeout do
+          Dispatch.synchronize do |completion_handler|
+            Dispatch.default_queue.dispatch_async do
+              done = true
+              completion_handler.call()
+            end
+          end
+        end
+        done.must_equal true
+      end
+
+      it "return its result to the calling thread" do
+        assert_wont_timeout do
+          Dispatch.synchronize do |completion_handler|
+            Dispatch.default_queue.dispatch_async do
+              completion_handler.call( :result )
+            end
+          end.must_equal :result
+        end
+      end
+    end
+
+    describe "concurrent_map" do
+      it "returns reslt of concurrently executed block" do
+        start_time = Time.now()
+        result = Dispatch.concurrent_map( 1..10 ) do |i|
+          sleep( 0.001 )
+          i
+        end.must_equal (1..10).to_a
+
+        elapsed_time = Time.now - start_time
+        elapsed_time.must_be :<, 0.005
+      end
+    end
+
+  end
+end

data/test/test_dispatch_group.rb

@@ -0,0 +1,59 @@
+# =============================================================================
+#
+# MODULE      : test/test_dispatch_group.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+require 'timeout'
+
+module DispatchQueue
+  describe DispatchGroup do
+
+    subject { DispatchGroup.new }
+
+    it "can create a new group" do
+      subject.must_be_instance_of DispatchGroup
+    end
+
+
+    describe "wait()" do
+      it "returns true immediatly when no work is pending in the group" do
+        subject.wait().must_equal true
+      end
+
+      it "waits forever if group enters and never leaves" do
+        subject.enter()
+
+        assert_must_timeout do
+          subject.wait()
+        end
+      end
+
+      it "waits until timeout expires and returns false if enter never leaves " do
+        subject.enter()
+
+        assert_wont_timeout(0.002) do
+          subject.wait( timeout:0.001 ).must_equal false
+        end
+      end
+
+      it "returns true when leave() is called" do
+        subject.enter()
+        Dispatch.default_queue.dispatch_async do
+          sleep( 0.001 )
+          subject.leave()
+        end
+
+        assert_wont_timeout(0.002) do
+          subject.wait().must_equal true
+        end
+      end
+    end # describe "wait()"
+
+  end # describe DispatchGroup do
+end # module DispatchQueue

data/test/test_group_concurrent_queue.rb

@@ -0,0 +1,75 @@
+# =============================================================================
+#
+# MODULE      : test/test_group_concurrent_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+require 'timeout'
+
+module DispatchQueue
+  describe "DispatchGroup with ConcurrentQueue" do
+    let( :target_queue ) { ConcurrentQueue.new }
+    let( :group ) { DispatchGroup.new }
+
+    it "leaves group when task completes, with single task on idle queue " do
+      target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.002 ) { group.wait() }
+    end
+
+    it "leaves group when task completes, with enquened tasks" do
+      (1..10).each do
+        target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      end
+
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.020 ) { group.wait() }
+    end
+
+    it "leaves group when task completes, with barrier tasks only" do
+      (1..4).each do
+        target_queue.dispatch_barrier_async( group:group ) { sleep( 0.002 ) }
+      end
+
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.010 ) { group.wait() }
+    end
+
+    it "leaves group when task completes, with mix of barrier and non-barrier tasks" do
+      target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      (1..10).each do
+        target_queue.dispatch_async( group:group ) { sleep( 0.001 ) }
+      end
+
+      target_queue.dispatch_barrier_async( group:group ) { sleep( 0.001 ) }
+      (1..10).each do
+        target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      end
+      target_queue.dispatch_barrier_async( group:group ) { sleep( 0.001 ) }
+
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.030 ) { group.wait() }
+    end
+
+    it "completes immediatly after a last synchronous barrier" do
+      target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      (1..10).each do
+        target_queue.dispatch_async( group:group ) { sleep( 0.001 ) }
+      end
+
+      target_queue.dispatch_barrier_async( group:group ) { sleep( 0.001 ) }
+      (1..10).each do
+        target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      end
+
+      assert_must_timeout( 0.001 ) { group.wait() }
+      target_queue.dispatch_barrier_sync( group:group ) { sleep( 0.001 ) }
+      assert_wont_timeout( 0.001 ) { group.wait() }
+    end
+  end # DispatchGroup with ConcurrentQueue
+end # module DispatchQueue

data/test/test_group_serial_queue.rb

@@ -0,0 +1,33 @@
+# =============================================================================
+#
+# MODULE      : test/test_group_serial_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+require 'timeout'
+
+module DispatchQueue
+  describe "DispatchGroup with SerialQueue" do
+
+    let( :target_queue ) { SerialQueue.new }
+    let( :group ) { DispatchGroup.new }
+
+    it "leaves group when task completes, with single task on idle queue " do
+      target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.002 ) { group.wait() }
+    end
+
+    it "leaves group when task completes, with enquened tasks" do
+      target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.005 ) { group.wait() }
+    end
+  end # DispatchGroup with SerialQueue
+end # module DispatchQueue

data/test/test_group_thread_pool_queue.rb

@@ -0,0 +1,34 @@
+# =============================================================================
+#
+# MODULE      : test/test_group_thread_pool_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+require 'timeout'
+
+module DispatchQueue
+  describe "DispatchGroup with ThreadPoolQueue" do
+    let( :target_queue ) { Dispatch.default_queue }
+    let( :group ) { DispatchGroup.new }
+
+    it "leaves group when task completes, with single task on idle queue " do
+      target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.002 ) { group.wait() }
+    end
+
+    it "leaves group when task completes, with enquened tasks" do
+      (1..10).each do
+        target_queue.dispatch_async( group:group ) { sleep( 0.002 ) }
+      end
+
+      assert_must_timeout( 0.001 ) { group.wait() }
+      assert_wont_timeout( 0.020 ) { group.wait() }
+    end
+  end # DispatchGroup with ThreadPoolQueue
+end # module DispatchQueue

data/test/test_heap.rb

@@ -0,0 +1,58 @@
+# =============================================================================
+#
+# MODULE      : test/test_heap.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+
+module DispatchQueue
+  describe Heap do
+
+    subject { Heap.new }
+
+    def push( heap, *elements )
+      elements.each { |e| heap.push( e ) }
+    end
+
+    def drain( heap )
+      elements = []
+      elements.push( heap.pop() ) while !heap.empty?
+      elements
+    end
+
+    it "can be initialized with no argument" do
+      subject.must_be_instance_of Heap
+    end
+
+    it "is empty when newly created" do
+      subject.size.must_equal 0
+      subject.count.must_equal 0
+      subject.length.must_equal 0
+      subject.empty?.must_equal true
+    end
+
+    it "stores pushed elements in an order that preserves heap property" do
+      push( subject, 7, 1, 6, 2, 5, 3, 4 )
+      subject.size.must_equal 7
+      subject.empty?.must_equal false
+      subject.elements.must_equal( [1, 2, 3, 7, 5, 6, 4] )
+    end
+
+    it "pops elements in sorted order" do
+      push( subject, 7, 1, 6, 2, 5, 3, 4 )
+      drain( subject ).must_equal [1, 2, 3, 4, 5, 6, 7]
+    end
+
+    it "pops elements in sorted order" do
+      count = 100
+      push( subject, *(1..count).to_a.shuffle )
+      drain( subject ).must_equal (1..count).to_a
+    end
+
+  end
+end

data/test/test_serial_queue.rb

@@ -0,0 +1,77 @@
+# =============================================================================
+#
+# MODULE      : test/test_serial_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+
+module DispatchQueue
+  describe SerialQueue do
+
+    let( :task_count )    { 4 }
+    let( :log )           { [] }
+    let( :lock )          { Mutex.new }
+    let( :logger )        { Proc.new { |e, d| lock.synchronize { log << [e, d] } } }
+    subject               { SerialQueue.new }
+
+    it "can initialize a serial queue" do
+      subject.must_be_instance_of SerialQueue
+    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 serial queues" do
+      let( :subject2 )    { SerialQueue.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_thread_pool_queue.rb

@@ -0,0 +1,63 @@
+# =============================================================================
+#
+# MODULE      : test/test_thread_pool_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+
+require '_test_env.rb'
+
+module DispatchQueue
+  describe ThreadPoolQueue do
+
+    let( :log )     { [] }
+    let( :lock )    { Mutex.new }
+    let( :logger )  { Proc.new { |e, d| lock.synchronize { log << [e, d] } } }
+    let( :max_threads ) { 2 }
+    subject { ThreadPoolQueue.new( max_threads: max_threads,
+                                   debug_trace: logger,
+                                   thread_termination_delay: 0.001 ) }
+
+    it "can initialize a thread ppol" do
+      subject.must_be_instance_of ThreadPoolQueue
+    end
+
+    it "can execute work in the thread pool" do
+      (1..10).each do |i|
+        subject.dispatch_async do
+          sleep(0.001)
+          logger.call( :task, { task_id:i, thread:Thread.current } )
+        end
+      end
+      subject.wait_for_all_threads_termination()
+
+      completed_tasks = Set.new( log.select { |e, d| e == :task }.map { |e, d| d[:task_id] } )
+      completed_tasks.must_equal( Set.new( 1..10 ) )
+    end
+
+    it "spawns and terminates threads as needed" do
+      (1..200).each do |i|
+        subject.dispatch_async do
+          sleep(0.001)
+          logger.call( :task, { task_id:i, thread:Thread.current } )
+        end
+      end
+
+      sleep(0.02)
+      subject.max_threads = 8
+      sleep(0.01)
+      subject.max_threads = 2
+
+      subject.wait_for_all_threads_termination()
+
+      thread_count = 0
+      thread_count_list = log.map { |e, d| thread_count = d[:thread_count] || thread_count }
+      major_thread_counts = thread_count_list.chunk { |n| n }.map { |cnt, e| [cnt, e.count] }.select { |t,e| e > 10 }.map { |t,e| t }
+      major_thread_counts.must_equal( [2, 8, 2] )
+    end
+
+  end
+end