dispatch_queue_rb 1.0.0

data/lib/dispatch_queue_rb/internal/condition_variable_pool.rb

@@ -0,0 +1,33 @@
+# =============================================================================
+#
+# MODULE      : lib/dispatch_queue_rb/internal/condition_variable_pool.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+module DispatchQueue
+  module ConditionVariablePool
+    class << self
+
+      @@mutex = Mutex.new
+      @@pool = []
+
+      def acquire()
+        @@mutex.synchronize do
+          return @@pool.shift if !@@pool.empty?
+        end
+
+        return Mutex.new, ConditionVariable.new
+      end
+
+      def release( mutex, condition )
+        @@mutex.synchronize do
+          @@pool << [mutex, condition]
+        end
+      end
+
+    end
+  end # class ConditionVariablePool
+end # module DispatchQueue

data/lib/dispatch_queue_rb/internal/continuation.rb

@@ -0,0 +1,41 @@
+# =============================================================================
+#
+# MODULE      : lib/dispatch_queue_rb/internal/continuation.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+module DispatchQueue
+  class Continuation
+    attr_reader :barrier
+    attr_reader :eta
+
+    def initialize( target_queue:nil, group:nil, barrier:false, eta:nil, &task )
+      @task = task
+      @target_queue = target_queue
+      @group = group
+      @barrier = barrier
+      @eta = eta
+    end
+
+    def run( default_target_queue:nil, override_target_queue:nil )
+      queue = override_target_queue || @target_queue || default_target_queue
+      if queue
+        if @barrier
+          queue.dispatch_barrier_async( group:@group, &@task )
+        else
+          queue.dispatch_async( group:@group, &@task )
+        end
+        @group.leave() if @group
+      else
+        begin
+          @task.call() if @task
+        ensure
+          @group.leave() if @group
+        end
+      end
+    end
+  end # class Continuation
+end # module DispatchQueue

data/lib/dispatch_queue_rb/internal/heap.rb

@@ -0,0 +1,88 @@
+# =============================================================================
+#
+# MODULE      : lib/dispatch_queue_rb/internal/heap.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+module DispatchQueue
+  class Heap
+
+    def initialize( &compare )
+      @heap = []
+      @compare = compare
+    end
+
+    def push( elt )
+      @heap.push( elt )
+      _sift_up( @heap.count - 1 )
+    end
+
+    def pop()
+      head = @heap.first
+      tail =  @heap.pop()
+      @heap[0] = tail if !@heap.empty?
+      _sift_down( 0 )
+      head
+    end
+
+    def head()
+      @heap.first
+    end
+
+    def count
+      @heap.count
+    end
+
+    alias_method :size, :count
+    alias_method :length, :count
+
+    def empty?
+      @heap.empty?
+    end
+
+    def elements
+      @heap
+    end
+
+  private
+    def _ordered?( i, j )
+      a = @heap[i]
+      b = @heap[j]
+      return @compare.call( a, b ) if @compare
+      return a < b
+    end
+
+    def _swap( i, j )
+      @heap[i], @heap[j] = @heap[j], @heap[i]
+    end
+
+    def _sift_up( i )
+      loop do
+        parent = (i-1) / 2
+        break if parent < 0
+        break if _ordered?( parent, i )
+        _swap( parent, i )
+        i = parent
+      end
+    end
+
+    def _sift_down( i )
+      size = @heap.size
+      loop do
+        left = i*2 + 1
+        right = left + 1
+        largest = i
+
+        largest = left if left < size && _ordered?( left, largest )
+        largest = right if right < size && _ordered?( right, largest )
+        break if largest == i
+        _swap( i, largest )
+        i = largest
+      end
+    end
+
+  end # class Heap
+end # module DispatchQueue

data/lib/dispatch_queue_rb/internal/thread_pool_queue.rb

@@ -0,0 +1,127 @@
+# =============================================================================
+#
+# MODULE      : lib/dispatch_queue_rb/internal/thread_pool_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+module DispatchQueue
+  class ThreadPoolQueue
+
+    def initialize( max_threads:nil, debug_trace:nil, thread_termination_delay:0.01 )
+      @max_threads = max_threads || Dispatch.ncpu()
+      @debug_trace = debug_trace
+      @thread_termination_delay = thread_termination_delay
+
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @tasks = []
+      @worker_threads = Set.new
+      @idle_count = 0
+    end
+
+    def dispatch_async( group:nil, &task )
+      group.enter() if group
+      @mutex.synchronize do
+        @tasks << Continuation.new( group:group, &task )
+        @condition.signal()
+        _sync_try_spwan_more_threads()
+      end
+      self
+    end
+
+    alias_method :dispatch_barrier_async, :dispatch_async
+
+    include DispatchSyncImpl
+    include DispatchAfterImpl
+
+
+
+    def max_threads
+      @mutex.synchronize do
+        @max_threads
+      end
+    end
+
+    def max_threads=( new_value )
+      @mutex.synchronize do
+        @max_threads = new_value
+        _sync_try_spwan_more_threads()
+      end
+    end
+
+    def wait_for_all_threads_termination
+      loop do
+        sleep 0.001
+        break if @tasks.empty? && @worker_threads.empty?
+      end
+    end
+
+
+  private
+    def _worker_main()
+      Thread.current[:current_queue] = self
+
+      begin
+        loop do
+          task = _pop_task()
+          break if task.nil?
+          task.run()
+        end
+      ensure
+        @mutex.synchronize do
+          @worker_threads.delete( Thread.current )
+          @debug_trace.call( :terminated, { thread:       Thread.current,
+                                            thread_count: @worker_threads.count,
+                                            idle_count:   @idle_count,
+                                            task_count:   @tasks.count } ) if @debug_trace
+        end
+      end
+    end
+
+    def _pop_task()
+      @mutex.synchronize do
+        return nil if @worker_threads.count > @max_threads
+        _sync_wait_for_item()
+        task = @tasks.shift();
+        _sync_try_spwan_more_threads() if task
+        task
+      end
+    end
+
+
+    #
+    # _sync_xxx() methods assume that the mutex is already owned
+    #
+
+    def _sync_try_spwan_more_threads()
+      return if @worker_threads.count >= @max_threads
+      return if @idle_count > 0
+      return if @tasks.empty?
+
+      thread = _sync_spawn_worker_thread()
+      @debug_trace.call( :spawned, {  thread:       thread,
+                                      from_thread:  Thread.current,
+                                      thread_count: @worker_threads.count,
+                                      idle_count:   @idle_count,
+                                      task_count:   @tasks.count } ) if @debug_trace
+    end
+
+    def _sync_spawn_worker_thread()
+      thread = Thread.new { _worker_main() }
+      @worker_threads.add( thread )
+      thread
+    end
+
+    def _sync_wait_for_item()
+      if @tasks.empty?
+        @idle_count += 1
+        @condition.wait( @mutex, @thread_termination_delay )
+        @idle_count -= 1
+      end
+    end
+
+  end # class ThreadPoolQueue
+end # module DispatchQueue

data/lib/dispatch_queue_rb/internal/thread_queue.rb

@@ -0,0 +1,62 @@
+# =============================================================================
+#
+# MODULE      : lib/dispatch_queue_rb/internal/thread_queue.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+module DispatchQueue
+  class ThreadQueue
+    def initialize( thread_termination_delay:0.01 )
+      @thread_termination_delay = thread_termination_delay
+
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @tasks = []
+      @thread = nil
+    end
+
+    def dispatch_async( group:nil, &task )
+      group.enter() if group
+      @mutex.synchronize do
+        resume = @tasks.empty?
+        @tasks << Continuation.new( group:group, &task )
+        _sync_spawn_or_wakeup_thread() if resume
+      end
+      self
+    end
+
+    alias_method :dispatch_barrier_async, :dispatch_async
+
+    include DispatchSyncImpl
+    include DispatchAfterImpl
+
+
+  private
+    def _thread_main
+      Thread.current[:current_queue] = self
+
+      @mutex.synchronize do
+        loop do
+          @tasks.shift.run() if !@tasks.empty?
+
+          next if !@tasks.empty?
+          @condition.wait( @mutex, @thread_termination_delay )
+
+          if @tasks.empty?
+            @thread = nil
+            break
+          end
+        end # loop
+      end
+    end
+
+    def _sync_spawn_or_wakeup_thread()
+      @thread = Thread.new { _thread_main() } if @thread.nil?
+      @condition.signal()
+    end
+
+  end # class ThreadQueue
+end # module DispatchQueue

data/lib/dispatch_queue_rb/internal/timer_pool.rb

@@ -0,0 +1,71 @@
+# =============================================================================
+#
+# MODULE      : lib/dispatch_queue_rb/internal/timer_pool.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+module DispatchQueue
+  class TimerPool
+
+    def self.default_pool
+      @@default_pool
+    end
+
+    def initialize()
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @heap = Heap.new { |a,b| a.eta < b.eta }
+      @scheduled_eta = nil
+      @thread = nil
+    end
+
+    def dispatch_after( eta, group:nil, target_queue:nil, &task )
+      group.enter() if group
+      target_queue ||= Dispatch.default_queue
+      eta = Time.now + eta if !(Time === eta)
+      continuation = Continuation.new( target_queue:target_queue, group:group, eta:eta, &task )
+
+      @mutex.synchronize do
+        @heap.push( continuation )
+        if @scheduled_eta.nil? || eta < @scheduled_eta
+          @thread = Thread.new { _thread_main() } if @thread.nil?
+          @condition.signal()
+        end
+      end
+      target_queue
+    end
+
+
+
+  private
+    def _thread_main
+      @mutex.synchronize do
+        loop do
+          _fire_expired_timers()
+          wait_time = @heap.head.eta - Time.now if !@heap.empty?
+          next if wait_time && wait_time < 0
+
+          idle = @heap.empty?
+          @condition.wait( @mutex, wait_time || 0.01 )
+          if idle && @heap.empty?
+            @thread = nil
+            break
+          end
+        end # loop
+      end
+    end
+
+    def _fire_expired_timers
+      while !@heap.empty? && @heap.head.eta < Time.now do
+        continuation = @heap.pop
+        continuation.run()
+      end
+    end
+
+    @@default_pool = self.new
+
+  end # class TimerPool
+end # module DispatchQueue

data/lib/dispatch_queue_rb/mixins/dispatch_after_impl.rb

@@ -0,0 +1,18 @@
+# =============================================================================
+#
+# MODULE      : lib/dispatch_queue_rb/mixins/dispatch_after_impl.rb
+# PROJECT     : DispatchQueue
+# DESCRIPTION :
+#
+# Copyright (c) 2016, Marc-Antoine Argenton.  All rights reserved.
+# =============================================================================
+
+module DispatchQueue
+  module DispatchAfterImpl
+
+    def dispatch_after( eta, group:nil, &task )
+      TimerPool.default_pool.dispatch_after( eta, group:group, target_queue:self, &task )
+    end
+
+  end # class DispatchAfterImpl
+end # module DispatchQueue