wires 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dadfbad6be58d85473f3742baef26fe8dc4ef70d
-  data.tar.gz: 5e3f4739b620686a558f8c4265557d71cf819176
+  metadata.gz: 2db21e3f9e121e59a5bb749f91bfc99671408c69
+  data.tar.gz: e05678e737f152a47a9ccd3e7b14214d2ac61f4b
 SHA512:
-  metadata.gz: a3c1d8fffaf16e1672cc8b6d16818300f8bf22104463647530d931f167373f8ca0de6abb2f7db8227b7549643e41ab9080a6f2ca2320d52eb64d053674a6832b
-  data.tar.gz: 325e54850fe5774c5b1ba1d70e257790b1dd50a2229ee69eafedbbbd7407cf15972750770de991a7ea33b795dc8366fd1fb86275d270dad3333add5a2ae84bfa
+  metadata.gz: fb026f33a976e5c66d0da73e28bf5ac47deae08b8c1589df176bf70c471c4ea63b8d281777a4416b883258a91e820aeda776db7df0b167441b09b1a5f180c3cf
+  data.tar.gz: 03fbb2d4b977391eecfc75d4f3dfb259dd57b9345bd6c96e050020af2917dac2ad6ced83c89b6ddbb4b12b06b4e720ad611a9e61865c5f00d3b581e975169ce5

data/lib/wires/hub.rb

@@ -10,6 +10,8 @@ module Wires
       # Allow user to get/set limit to number of child threads
       attr_accessor :max_child_threads
       
+    private
+    
       # Make subclasses call class_init
       def inherited(subcls); subcls.class_init end
       
@@ -31,15 +33,20 @@ module Wires
         
         @please_finish_all = false
         
-        @at_exit = Proc.new{nil}
-        at_exit do self.at_exit_proc end
+        @on_neglect = Proc.new do |args|
+          $stderr.puts "#{self} neglected to spawn task: #{args.inspect}"
+        end
+        @on_neglect_done = Proc.new do |args|
+          $stderr.puts "#{self} finally spawned neglected task: #{args.inspect}"
+        end
+        
+        at_exit { (sleep 0.05 until dead?) unless $! }
         
         state_machine_init
         
       nil end
       
-      def at_exit_proc;  @at_exit.call;  end
-      
+    public
       
       def dead?;  state==:dead  end
       def alive?; state==:alive end
@@ -68,10 +75,8 @@ module Wires
       #   until all child threads are done
       def kill(*flags)
         sleep 0 until @spawning_count <= 0
-        # @spawning_count_lock.synchronize do
-          @please_finish_all = (not flags.include? :purge_tasks)
-          sleep 0 until request_state :dead unless (flags.include? :nonblocking)
-        # end
+        @please_finish_all = (not flags.include? :purge_tasks)
+        sleep 0 until request_state :dead unless (flags.include? :nonblocking)
       nil end
       
       # Register hook to execute before run - can call multiple times
@@ -94,6 +99,13 @@ module Wires
         @after_kills << [block, retain]
       nil end
       
+      def on_neglect(&block)
+        @on_neglect=block
+      end
+      def on_neglect_done(&block)
+        @on_neglect_done=block
+      end
+      
       # Spawn a task
       def spawn(*args) # :args: event, ch_string, proc, blocking
         @spawning_count_lock.synchronize { @spawning_count += 1 }
@@ -136,38 +148,59 @@ module Wires
       
       def purge_neglected
         @neglected_lock.synchronize do
-          @neglected = Array.new
+          @neglected.clear
+        end
+      nil end
+      
+      def number_neglected
+        @neglected_lock.synchronize do
+          @neglected.size
         end
       end
       
+      # Join child threads, one by one, allowing more children to appear
+      def join_children
+        a_thread = Thread.new{nil}
+        while a_thread
+          @child_threads_lock.synchronize do
+            a_thread = @child_threads.shift
+          end
+          a_thread.join if ((a_thread) and (a_thread!=Thread.current))
+          sleep 0 # Yield to other threads
+        end
+      nil end
+      
     private
       
       # Temporarily neglect a task until resources are available to run it
       def neglect(*args)
-        $stderr.puts "#{self} neglected to spawn #{args.inspect}"
         @neglected_lock.synchronize do
+          @on_neglect.call(args)
           @neglected << args
         end
       false end
       
       # Run a chain of @neglected tasks in place until no more are waiting
       def spawn_neglected_task_chain
-        neglected_one = nil
-        @neglected_lock.synchronize do
+        args = @neglected_lock.synchronize do
           return nil if @neglected.empty?
-          neglected_one = @neglected.shift
+          ((@neglected.shift)[0...-1]<<true) # Call with blocking
         end
-        spawn(*((neglected_one)[0...-1]<<true)) # Call with blocking
+        spawn(*args)
+        @on_neglect_done.call(args)
         spawn_neglected_task_chain
       nil end
       
       # Flush @neglected task queue, each in a new thread
       def spawn_neglected_task_threads
         until (cease||=false)
-          @neglected_lock.synchronize do
+          args = @neglected_lock.synchronize do
             break if (cease = @neglected.empty?)
-            spawn(*((@neglected.shift)[0...-1]<<false)) # Call without blocking
+            ((@neglected.shift)[0...-1]<<false) # Call without blocking
           end
+          break if cease
+          spawn(*args)
+          @on_neglect_done.call(args)
         end
       nil end
       
@@ -185,19 +218,6 @@ module Wires
         end
       nil end
       
-      # Join child threads, one by one, allowing more children to appear
-      def join_children
-        a_thread = Thread.new{nil}
-        while a_thread
-          @child_threads_lock.synchronize do
-            # flush_queue
-            a_thread = @child_threads.shift
-          end
-          a_thread.join if a_thread
-          sleep 0 # Yield to other threads
-        end
-      nil end
-      
     end
     
     

data/lib/wires/time.rb

@@ -37,7 +37,9 @@ module Wires
     
     def active?;        @active                                      end
     def inactive?;      not @active                                  end
-    def ready?;         @active and (Time.now >= @time)              end
+    
+    def ready?(at_time=Time.now);  @active and (at_time >= @time)    end
+    
     def time_until;    (@active ? [(Time.now - @time), 0].max : nil) end
     
     def cancel;         @active = false                         ;nil end
@@ -83,6 +85,8 @@ module Wires
     @schedule_lock  = Monitor.new
     @dont_sleep     = false
     
+    @grain = 1.seconds
+    
     # Operate on the metaclass as a type of singleton pattern
     class << self
       
@@ -90,7 +94,6 @@ module Wires
       def add(new_item)
         expect_type new_item, TimeSchedulerItem
         schedule_add(new_item)
-        wakeup
       nil end
       # Add an event to the schedule using << operator
       alias_method :<<, :add
@@ -98,18 +101,26 @@ module Wires
       # Get a copy of the event schedule from outside the class
       def list;  @schedule.clone end
       # Clear the event schedule from outside the class
-      def clear; @schedule.clear end
+      def clear; schedule_clear end
       
     private
     
+      def schedule_clear
+        @schedule.clear
+      end
+    
       def schedule_reshuffle
         @schedule.select! {|x| x.active?}
         @schedule.sort! {|a,b| a.time <=> b.time}
       nil end
       
       def schedule_add(new_item)
-        @schedule << new_item
-        schedule_reshuffle
+        if new_item.ready?(@next_pass)
+          Thread.new{ new_item.fire_when_ready(blocking:true) }
+        else
+          @schedule << new_item
+          schedule_reshuffle
+        end
       nil end
       
       def schedule_concat(other_list)
@@ -118,72 +129,69 @@ module Wires
       nil end
       
       def schedule_pull
-        pending = Array.new
+        pending_now  = Array.new
+        pending_soon = Array.new
         while ((not @schedule.empty?) and @schedule[0].ready?)
-          pending << @schedule.shift
+          pending_now << @schedule.shift
+        end
+        while ((not @schedule.empty?) and @schedule[0].ready?(@next_pass))
+          pending_soon << @schedule.shift
         end
-        [pending, @schedule[0]]
+        return [pending_now, pending_soon]
+      end
+      
+      def schedule_next_pass
+        @next_pass = Time.now+@grain
       end
       
       # Put all functions dealing with @schedule under @schedule_lock
       threadlock :list,
-                 :clear,
+                 :schedule_clear,
                  :schedule_reshuffle,
                  :schedule_add,
                  :schedule_concat,
                  :schedule_pull,
+                 :schedule_next_pass,
            lock: :@schedule_lock
       
       def main_loop
         
-        @keepgoing = true
+        # @keepgoing = true
         pending = Array.new
         on_deck = nil
         
         while @keepgoing
           
+          schedule_next_pass
+          
           # Pull, fire, and requeue relevant events
-          pending, on_deck = schedule_pull
-          pending.each { |x| x.fire }
-          schedule_concat pending
+          pending_now, pending_soon = schedule_pull
+          pending_now.each { |x| x.fire }
+          pending_soon.each{ |x| Thread.new{ x.fire_when_ready(blocking:true) }}
+          # schedule_concat pending_now
           
-          @sleepzone = true
-          # Calculate the time to sleep based on next event's time
-          if on_deck
-            sleep on_deck.time_until
-          else # sleep until wakeup if no event is on deck
-            sleep
-          end
-          @sleepzone = false
+          sleep [@next_pass-Time.now, 0].max
         end
         
       nil end
       
-      def wakeup
-        sleep 0 until @sleepzone==true
-        sleep 0 until @thread.status=='sleep'
-        @thread.wakeup
-      nil end
-      
     end
     
-    # Use fired event to only start scheduler when Hub is running
-    # This also gets the scheduler loop its own thread within the Hub's threads
-    # on :time_scheduler_start, self do; main_loop; end;
-    # Channel.new(self).fire(:time_scheduler_start)
-    
-    # Refire the start event after Hub dies in case it restarts
+    # Start the main loop upon run of Hub
     Hub.after_run(retain:true) do 
+      @keepgoing = true
       @thread = Thread.new { main_loop }
     end
     
     # Stop the main loop upon death of Hub
-    Hub.before_kill(retain:true) do 
-      sleep 0 until @sleepzone==true
-      sleep 0 until @thread.status=='sleep'
-      @keepgoing=false
-      wakeup
+    Hub.before_kill(retain:true) do
+      Thread.exclusive do
+        @keepgoing=false
+        @next_pass=Time.now
+        @thread.wakeup
+      end
       @thread.join
+      schedule_clear
     end
     
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2013-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport