ori-rb 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 982c11168837e41b1cb170b200732867a648c00546ef530b5f390da2436f4c63
-  data.tar.gz: 42a74eeba76762d3ec9ed5f3dd5e379be15d941a7a04a4ee7431da732e03b3bf
+  metadata.gz: 03b2c0bd50b0d212d915829d9aab2bac8931cf15610fe450618911a06e6ba34c
+  data.tar.gz: 87e21b3dc2b88cd1b58de05c9f28a956e5a2488191eac190ae9c4fe8972466a0
 SHA512:
-  metadata.gz: 200f9cb47a64c132688613fffb42b5a642c288f47004821e60ee451758c4fb241e9a2136e26ac23053db33e474bb9aad082949d03f7e04f1197fdc2fe09ead11
-  data.tar.gz: 38817593a3040a762ad3fff44e18352dfa7c0367e47a3e8aa7434222ce059cedc58c113b249df39a0f93cecf4fe87189dccd25820a5d2a870b6448cebf791e17
+  metadata.gz: e4735eb0c3bb0850ce368358e152b7f442c4405cb8fe15f6168a3be4e92508697583cde21da979262dd0b848dd8fffb71a47ef4a62e25d9f3021140f74a23616
+  data.tar.gz: 22b75abdb0b5abd387f823aafcbb0e954ed5f791026d1d9c6dacfeb5a558cf9f31df9c320027d68f0887520ea3e006b5c135c9ca6fb50f763102ffac3b5c1f3a

data/README.md

@@ -25,7 +25,7 @@ Ori provides a set of primitives that allow you to build concurrent applications
 ## Installation
 
 ```ruby
-gem "ori-rb", "~> 0.2"
+gem "ori-rb", "~> 0.4.6"
 ```
 
 Then execute:

data/lib/ori/scope.rb

@@ -9,7 +9,6 @@ require "English"
 
 module Ori
   class Scope
-    # Add thread-local state management
     class ThreadLocalState
       attr_reader :fiber_ids,
         :tasks,
@@ -54,16 +53,14 @@ module Ori
       @cancelled = false
       @closed = false
 
-      # Cross-thread wakeup mechanism for unblock and fiber_interrupt
       @wakeup_mutex = ::Mutex.new
       @wakeup_queue = [] #: Array[Fiber]
       @pending_interrupts = {} #: Hash[Fiber, Exception]
       @wakeup_reader, @wakeup_writer = IO.pipe
 
-      # Instead, use thread-local storage
       thread_local_state[object_id] = ThreadLocalState.new
 
-      inherit_or_set_deadline(deadline)
+      inherit_or_register_deadline(deadline)
 
       if @tracer
         @scope_id = Random.uuid_v7(extra_timestamp_bits: 12)
@@ -80,15 +77,14 @@ module Ori
         process_available_work
         Fiber.yield if parent_scope && pending_work?
       end
-    rescue Interrupt => error
-      puts "Scope interrupted! Shutting down..."
-      shutdown!(error)
     ensure
       close_scope
       @parent_scope&.deregister_child_scope(self)
     end
 
-    # Public API
+    # -------------------
+    # --- Public API ---
+    # -------------------
 
     def fork(&block)
       task = create_task(&block)
@@ -137,19 +133,9 @@ module Ori
       raise(cause || exn)
     end
 
-    def tag(name)
-      @tracer&.record_scope(@scope_id, :tag, name)
-    end
-
-    def print_ascii_trace
-      @tracer&.visualize
-    end
-
-    def write_html_trace(directory)
-      @tracer&.write_timeline_data(directory)
-    end
-
-    # Ruby FiberScheduler interface implementation
+    # ----------------------------------------------------
+    # --- Ruby FiberScheduler interface implementation ---
+    # ----------------------------------------------------
 
     def fiber(&block)
       task = fork(&block)
@@ -236,6 +222,9 @@ module Ori
         return @parent_scope.block(...) if @parent_scope
       end
 
+      # TODO: Track blocked fibers separately so we don't
+      # try to resume them indefinitely prior to unblock
+
       Fiber.yield
     end
 
@@ -309,9 +298,6 @@ module Ori
       (total || 0) > 0 ? total : -(e.errno || 0)
     end
 
-    # def io_pread(...) = ()
-    # def io_pwrite(...) = ()
-
     def process_wait(pid, flags)
       return @parent_scope.process_wait(pid, flags) unless fiber_ids.key?(Fiber.current)
 
@@ -344,6 +330,8 @@ module Ori
     end
 
     # TODO: Implement these
+    # def io_pread(...) = ()
+    # def io_pwrite(...) = ()
     # def timeout_after(...) = ()
     # def address_resolve(...) = ()
 
@@ -376,6 +364,24 @@ module Ori
       false
     end
 
+    def root_scope
+      @parent_scope ? @parent_scope.root_scope : self
+    end
+
+    # Purposefully excludes blocked fibers from checks
+    def has_active_work?
+      return false if closed?
+
+      return true if @wakeup_mutex.synchronize { @wakeup_queue.any? }
+      return true if pending.any?(&:alive?)
+      return true if waiting.any? { |fiber, _| fiber.alive? }
+      return true if readable.any? { |_, fibers| fibers.any?(&:alive?) }
+      return true if writable.any? { |_, fibers| fibers.any?(&:alive?) }
+      return true if child_scopes? && child_scopes.any? { |scope| scope.has_active_work? }
+
+      false
+    end
+
     def register_child_scope(scope)
       child_scopes.add(scope)
     end
@@ -404,20 +410,9 @@ module Ori
       state.child_scopes?
     end
 
-    # Scope lifecycle
-
-    def inherit_or_set_deadline(duration)
-      parent_deadline = parent_scope&.remaining_deadline
-
-      if parent_deadline && (duration.nil? || parent_deadline < duration)
-        # Inherit parent's deadline
-        @deadline_at = current_time + parent_deadline
-        @deadline_owner = parent_scope.deadline_owner
-      elsif duration
-        @deadline_at = current_time + duration
-        @deadline_owner = self
-      end
-    end
+    # -----------------------
+    # --- Scope lifecycle ---
+    # -----------------------
 
     def process_available_work
       now = current_time
@@ -456,8 +451,7 @@ module Ori
         end
       end
 
-      # TODO: This doesn't work because it only looks in the current scope, not the parents
-      # check_stalled_fibers! if fibers_to_resume.empty?
+      check_stalled_fibers! if fibers_to_resume.empty?
 
       fibers_to_resume.each do |fiber|
         blocked.delete(fiber)
@@ -498,7 +492,7 @@ module Ori
     end
 
     def drain_wakeup_queue
-      interrupts = nil
+      interrupts = nil #: Hash[Fiber, Exception]?
       fibers = @wakeup_mutex.synchronize do
         unless @pending_interrupts.empty?
           interrupts = @pending_interrupts.dup
@@ -518,21 +512,6 @@ module Ori
       end
     end
 
-    def interrupt_fiber(fiber, exception)
-      id = fiber_ids[fiber]
-      @tracer&.record(id, :interrupted, exception.message)
-
-      # Remove from wait states before cancelling
-      waiting.delete(fiber)
-      blocked.delete(fiber)
-
-      if (task = task_queue[fiber])
-        task.cancel(exception)
-      else
-        fiber.kill
-      end
-    end
-
     def close_scope
       @closed = true
       @tracer&.record_scope(@scope_id, :closed)
@@ -541,7 +520,9 @@ module Ori
       @wakeup_writer&.close unless @wakeup_writer&.closed?
     end
 
-    # Timeouts and deadlines
+    # ------------------------------
+    # --- Timeouts and deadlines ---
+    # ------------------------------
 
     def current_time
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -576,12 +557,11 @@ module Ori
 
     def check_stalled_fibers!
       return false if blocked.none?
+      return false if root_scope.has_active_work?
 
-      if pending.empty? && waiting.empty? && readable.empty? && writable.empty?
-        error = CancellationError.new(self, "All fibers are blocked, impossible to proceed")
-        shutdown!(error)
-        raise(error)
-      end
+      error = DeadlockError.new(self)
+      shutdown!(error)
+      raise(error)
     end
 
     def next_timeout(now = nil)
@@ -599,7 +579,9 @@ module Ori
       [0, delay].max
     end
 
-    # Fiber management
+    # ------------------------
+    # --- Fiber management ---
+    # ------------------------
 
     def create_task(&block)
       return false if @cancelled
@@ -610,16 +592,6 @@ module Ori
       task
     end
 
-    def register_task(task)
-      fiber_ids[task.fiber] = task.id
-      task_queue[task.fiber] = task
-
-      if @tracer
-        @tracer.register_fiber(task.id, @scope_id)
-        @tracer.record(task.id, :created)
-      end
-    end
-
     def resume_fiber(fiber)
       resume_task_or_fiber(task_queue.fetch(fiber, fiber))
     end
@@ -655,6 +627,13 @@ module Ori
       @tracer&.record(id, :completed) unless fiber.alive?
     end
 
+    def interrupt_fiber(fiber, exception)
+      waiting.delete(fiber)
+      blocked.delete(fiber)
+
+      cancel_fiber!(fiber, exception)
+    end
+
     def cancel_fiber!(fiber, error)
       return unless fiber.alive?
 
@@ -664,15 +643,38 @@ module Ori
       if (task = task_queue[fiber])
         task.cancel(error)
       else
-        # For raw fibers, we still need to resume them one last time
-        # to give them a chance to cleanup
         fiber.raise(error)
       end
 
       @tracer&.record(id, :cancelled, error.message)
     end
 
-    # Registration
+    # --------------------
+    # --- Registration ---
+    # --------------------
+
+    def inherit_or_register_deadline(duration)
+      parent_deadline = parent_scope&.remaining_deadline
+
+      if parent_deadline && (duration.nil? || parent_deadline < duration)
+        # Inherit parent's deadline
+        @deadline_at = current_time + parent_deadline
+        @deadline_owner = parent_scope.deadline_owner
+      elsif duration
+        @deadline_at = current_time + duration
+        @deadline_owner = self
+      end
+    end
+
+    def register_task(task)
+      fiber_ids[task.fiber] = task.id
+      task_queue[task.fiber] = task
+
+      if @tracer
+        @tracer.register_fiber(task.id, @scope_id)
+        @tracer.record(task.id, :created)
+      end
+    end
 
     def register_timeout(fiber, deadline)
       return unless deadline
@@ -699,7 +701,9 @@ module Ori
       added
     end
 
-    # Cleanup
+    # ---------------
+    # --- Cleanup ---
+    # ---------------
 
     def cleanup_dead_fibers
       dead_fibers = fiber_ids.reject { |fiber, _| fiber.alive? }.to_set
@@ -749,14 +753,15 @@ module Ori
       state&.waiting&.delete(fiber)
     end
 
-    # Add helper method to access thread-local state
+    # -------------
+    # --- State ---
+    # -------------
+
     def state
       thread_local_state&.[](object_id) or
         raise "Scope accessed from wrong thread"
     end
 
-    # Update all instance variable references to use state
-
     #: () -> LazyHash
     def task_queue = state.tasks
 
@@ -777,5 +782,21 @@ module Ori
 
     #: () -> Set[Scope]
     def child_scopes = state.child_scopes
+
+    # -----------------
+    # --- Debugging ---
+    # -----------------
+
+    def tag(name)
+      @tracer&.record_scope(@scope_id, :tag, name)
+    end
+
+    def print_ascii_trace
+      @tracer&.visualize
+    end
+
+    def write_html_trace(directory)
+      @tracer&.write_timeline_data(directory)
+    end
   end
 end

data/lib/ori/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module Ori
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

data/lib/ori.rb

@@ -6,7 +6,6 @@ loader.setup
 
 module Ori
   class CancellationError < StandardError
-
     #: Scope
     attr_reader :scope
 
@@ -17,6 +16,13 @@ module Ori
     end
   end
 
+  class DeadlockError < CancellationError
+    #: (Scope scope, ?String? message) -> void
+    def initialize(scope, message = "All fibers are blocked, impossible to proceed")
+      super(scope, message)
+    end
+  end
+
   class << self
     #: (?name: String?, ?cancel_after: Numeric?, ?raise_after: Numeric?, ?trace: bool) { (Scope) -> void } -> Scope
     def sync(name: nil, cancel_after: nil, raise_after: nil, trace: false, &block)
@@ -41,6 +47,8 @@ module Ori
 
         scope.await
         scope
+      rescue DeadlockError
+        raise
       rescue CancellationError => error
         # Re-raise if:
         # 1. The error is from a different scope, or

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ori-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors:
 - Jahfer Husain