RubyGems - bud - Versions diffs - 0.0.4 → 0.0.5 - Mend

bud 0.0.4 → 0.0.5

Files changed (32) hide show

data/README +2 -3
data/bin/budvis +0 -66
data/docs/README.md +27 -15
data/docs/bust.md +1 -1
data/docs/cheat.md +79 -30
data/docs/operational.md +8 -4
data/examples/basics/paths.rb +5 -3
data/lib/bud/aggs.rb +1 -1
data/lib/bud/bud_meta.rb +11 -2
data/lib/bud/bust/bust.rb +1 -1
data/lib/bud/collections.rb +78 -20
data/lib/bud/deploy/threaddeploy.rb +1 -1
data/lib/bud/errors.rb +3 -0
data/lib/bud/graphs.rb +25 -26
data/lib/bud/joins.rb +78 -33
data/lib/bud/metrics.rb +43 -0
data/lib/bud/monkeypatch.rb +1 -1
data/lib/bud/rebl.rb +20 -13
data/lib/bud/rewrite.rb +217 -39
data/lib/bud/server.rb +16 -13
data/lib/bud/state.rb +39 -25
data/lib/bud/storage/dbm.rb +6 -1
data/lib/bud/storage/tokyocabinet.rb +6 -0
data/lib/bud/storage/zookeeper.rb +6 -6
data/lib/bud/viz.rb +5 -1
data/lib/bud/viz_util.rb +70 -0
data/lib/bud.rb +227 -99
metadata +33 -24
data/docs/c.html +0 -251
data/examples/deploy/deploy_ip_port +0 -1
data/examples/deploy/keys.rb +0 -5
data/lib/bud.rb.orig +0 -806

data/lib/bud/viz_util.rb CHANGED Viewed

@@ -14,6 +14,50 @@ module TraceCardinality
   end
 end
+class VizHelper
+  include Bud
+  include TraceCardinality
+  def initialize(tabinf, cycle, depends, rules, dir)
+    @t_tabinf = tabinf
+    @t_cycle = cycle
+    @t_depends = depends
+    @t_rules = rules
+    @dir = dir
+    super()
+  end
+  def summarize(dir, schema)
+    table_io = {}
+    cardinalities.sort{|a, b| a[0] <=> b[0]}.each do |card|
+      table_io["#{card.table}_#{card.bud_time}"] = start_table(dir, card.table, card.bud_time, schema[card.table])
+    end
+    full_info.each do |info|
+      write_table_content(table_io["#{info.table}_#{info.bud_time}"], info.row)
+    end
+    table_io.each_value do |tab|
+      end_table(tab)
+    end
+    # fix: nested loops
+    times.sort.each do |time|
+      card_info = {}
+      cardinalities.each do |card|
+        if card.bud_time == time.bud_time
+          card_info[card.table] = card.cnt
+        end
+      end
+      d = "#{@dir}/tm_#{time.bud_time}"
+      write_graphs(@t_tabinf, @t_cycle, @t_depends, @t_rules, d, @dir, nil, false, nil, time.bud_time, card_info)
+    end
+  end
+end
 module VizUtil #:nodoc: all
   def graph_from_instance(bud_instance, viz_name, output_base, collapse=true, fmt=nil)
     tabinf = {}
@@ -201,4 +245,30 @@ END_JS
     end
     return meta, data
   end
+  def start_table(dir, tab, time, schema)
+    str = "#{dir}/#{tab}_#{time}.html"
+    fout = File.new(str, "w")
+    fout.puts "<html><title>#{tab} @ #{time}</title>"
+    fout.puts "<table border=1>"
+    fout.puts "<tr>" + schema.map{|s| "<th> #{s} </th>"}.join(" ") + "<tr>" unless schema.nil?
+    fout.close
+    return str
+  end
+  def end_table(stream)
+    fp = File.open(stream, "a")
+    fp.puts "</table>"
+    fp.close
+  end
+  def write_table_content(fn, row)
+    stream = File.open(fn, "a")
+    stream.puts "<tr>"
+    stream.puts row.map{|c| "<td>#{c.to_s}</td>"}.join(" ")
+    stream.puts "</tr>"
+    stream.close
+  end
 end

data/lib/bud.rb CHANGED Viewed

@@ -15,6 +15,7 @@ require 'bud/deploy/forkdeploy'
 require 'bud/deploy/threaddeploy'
 require 'bud/errors'
 require 'bud/joins'
+require 'bud/metrics'
 require 'bud/rtrace'
 require 'bud/server'
 require 'bud/state'
@@ -37,10 +38,11 @@ $bud_instances = {}        # Map from instance id => Bud instance
 # three main options:
 #
 # 1. Synchronously. To do this, instantiate your program and then call tick()
-#    one or more times; each call evaluates a single Bud timestep. Note that in
-#    this mode, network communication (channels) and timers cannot be used. This
-#    is mostly intended for "one-shot" programs that compute a single result and
-#    then terminate.
+#    one or more times; each call evaluates a single Bud timestep. In this mode,
+#    any network messages or timer events that occur will be buffered until the
+#    next call to tick(). This is mostly intended for "one-shot" programs that
+#    compute a single result and then terminate, or for interactively
+#    "single-stepping" through the execution of an event-driven system.
 # 2. In a separate thread in the foreground. To do this, instantiate your
 #    program and then call run_fg(). The Bud interpreter will then run, handling
 #    network events and evaluating new timesteps as appropriate. The run_fg()
@@ -49,18 +51,22 @@ $bud_instances = {}        # Map from instance id => Bud instance
 #    program and then call run_bg(). The Bud interpreter will run
 #    asynchronously. To interact with Bud (e.g., insert additional data or
 #    inspect the state of a Bud collection), use the sync_do and async_do
-#    methods. To shutdown the Bud interpreter, use stop_bg().
+#    methods.
 #
-# Most programs should use method #3.
+# Most programs should use method #3. Note that in all three cases, the stop()
+# method should be used to shutdown a Bud instance and release any resources it
+# is using.
 #
 # :main: Bud
 module Bud
   attr_reader :strata, :budtime, :inbound, :options, :meta_parser, :viz, :rtracer
-  attr_reader :dsock, :ip, :port
-  attr_reader :tables, :channels, :tc_tables, :zk_tables, :dbm_tables
+  attr_reader :dsock
+  attr_reader :tables, :channels, :tc_tables, :zk_tables, :dbm_tables, :sources, :sinks
   attr_reader :stratum_first_iter, :joinstate
-  attr_accessor :lazy # This can be changed on-the-fly by REBL
-  attr_accessor :stratum_collection_map
+  attr_reader :this_stratum, :this_rule, :rule_orig_src
+  attr_reader :running_async
+  attr_accessor :stratum_collection_map, :rewritten_strata, :no_attr_rewrite_strata
+  attr_accessor :metrics
   # options to the Bud runtime are passed in a hash, with the following keys
   # * network configuration
@@ -72,14 +78,14 @@ module Bud
   # * operating system interaction
   #   * <tt>:stdin</tt>  if non-nil, reading from the +stdio+ collection results in reading from this +IO+ handle
   #   * <tt>:stdout</tt> writing to the +stdio+ collection results in writing to this +IO+ handle; defaults to <tt>$stdout</tt>
-  #   * <tt>:no_signal_handlers</tt> if true, runtime ignores +SIGINT+ and +SIGTERM+
+  #   * <tt>:signal_handling</tt> how to handle +SIGINT+ and +SIGTERM+.  If :none, these signals are ignored.  If :bloom, they're passed into the built-in scratch called +signals+.  Else shutdown all bud instances.
   # * tracing and output
   #   * <tt>:quiet</tt> if true, suppress certain messages
   #   * <tt>:trace</tt> if true, generate +budvis+ outputs
   #   * <tt>:rtrace</tt>  if true, generate +budplot+ outputs
   #   * <tt>:dump_rewrite</tt> if true, dump results of internal rewriting of Bloom code to a file
+  #   * <tt>:metrics</tt> if true, dumps a hash of internal performance metrics
   # * controlling execution
-  #   * <tt>:lazy</tt>  if true, prevents runtime from ticking except on external calls to +tick+
   #   * <tt>:tag</tt>  a name for this instance, suitable for display during tracing and visualization
   # * storage configuration
   #   * <tt>:dbm_dir</tt> filesystem directory to hold DBM-backed collections
@@ -99,7 +105,8 @@ module Bud
     @zk_tables = {}
     @callbacks = {}
     @callback_id = 0
-    @shutdown_callbacks = []
+    @shutdown_callbacks = {}
+    @shutdown_callback_id = 0
     @post_shutdown_callbacks = []
     @timers = []
     @inside_tick = false
@@ -109,10 +116,15 @@ module Bud
     @done_bootstrap = false
     @joinstate = {}  # joins are stateful, their state needs to be kept inside the Bud instance
     @instance_id = ILLEGAL_INSTANCE_ID # Assigned when we start running
+    @sources = {}
+    @sinks = {}
+    @metrics = {}
+    @endtime = nil
+    @running_async = false
+    @bud_started = false
     # Setup options (named arguments), along with default values
     @options = options.clone
-    @lazy = @options[:lazy] ||= false
     @options[:ip] ||= "127.0.0.1"
     @ip = @options[:ip]
     @options[:port] ||= 0
@@ -177,6 +189,7 @@ module Bud
     u = Unifier.new
     ref_expander = NestedRefRewriter.new(klass.bud_import_table)
     tmp_expander = TempExpander.new
+    with_expander = WithExpander.new
     r2r = Ruby2Ruby.new
     klass.instance_methods(false).each do |m|
@@ -184,24 +197,28 @@ module Bud
       ast = u.process(ast)
       ast = ref_expander.process(ast)
       ast = tmp_expander.process(ast)
+      ast = with_expander.process(ast)
-      if (ref_expander.did_work or tmp_expander.did_work)
+      if ref_expander.did_work or tmp_expander.did_work or with_expander.did_work
         new_source = r2r.process(ast)
         klass.module_eval new_source # Replace previous method def
       end
       ref_expander.did_work = false
       tmp_expander.did_work = false
+      with_expander.did_work = false
     end
     # If we found any temp statements in the klass's rule blocks, add a state
     # block with declarations for the corresponding temp collections.
-    s = tmp_expander.get_state_meth(klass)
-    if s
-      state_src = r2r.process(s)
+    st = tmp_expander.get_state_meth(klass)
+    if st
+      state_src = r2r.process(st)
       klass.module_eval(state_src)
     end
+    ModuleRewriter.ast_mangle_with(with_expander, klass)
     # Always rewrite anonymous classes
     @done_rewrite[klass.name] = true unless klass.name == ""
   end
@@ -275,18 +292,78 @@ module Bud
   # when interacting with it. For example, it is not safe to directly examine
   # Bud collections from the caller's thread (see async_do and sync_do).
   #
-  # This instance of Bud will continue to execute until stop_bg is called.
+  # This instance of Bud will run until stop() is called.
   def run_bg
+    start
+    schedule_and_wait do
+      if @running_async
+        raise BudError, "run_bg called on already-running Bud instance"
+      end
+      @running_async = true
+      # Consume any events received while we weren't running async
+      tick_internal
+    end
+    @rtracer.sleep if options[:rtrace]
+  end
+  # Startup a Bud instance. This starts EventMachine (if needed) and binds to a
+  # UDP server socket. If do_tick is true, we also execute a single Bloom
+  # timestep. Regardless, calling this method does NOT cause Bud to begin
+  # executing timesteps asynchronously (see run_bg).
+  def start(do_tick=false)
     start_reactor
-    # Wait for Bud to start up before returning
     schedule_and_wait do
-      start_bud
+      do_startup unless @bud_started
+      tick_internal if do_tick
+    end
+  end
+  private
+  def do_startup
+    raise BudError, "EventMachine not started" unless EventMachine::reactor_running?
+    raise BudError unless EventMachine::reactor_thread?
+    @instance_id = Bud.init_signal_handlers(self)
+    do_start_server
+    @bud_started = true
+    # Initialize periodics
+    @periodics.each do |p|
+      @timers << make_periodic_timer(p.pername, p.period)
+    end
+    # Arrange for Bud to read from stdin if enabled. Note that we can't do this
+    # earlier because we need to wait for EventMachine startup.
+    @stdio.start_stdin_reader if @options[:stdin]
+    @zk_tables.each_value {|t| t.start_watchers}
+    @halt_cb = register_callback(:halt) do |t|
+      stop
+      if t.first.key == :kill
+        Bud.shutdown_all_instances
+        Bud.stop_em_loop
+      end
+    end
+  end
+  # Pause an instance of Bud that is running asynchronously. That is, this
+  # method allows a Bud instance operating in run_bg or run_fg mode to be
+  # switched to "single-stepped" mode; timesteps can be manually invoked via
+  # tick(). To switch back to running Bud asynchronously, call run_bg().
+  public
+  def pause
+    schedule_and_wait do
+      @running_async = false
     end
   end
   # Run Bud in the "foreground" -- the caller's thread will be used to run the
-  # Bud interpreter. This means this method won't return unless an error
-  # occurs. It is often more useful to run Bud asynchronously -- see run_bg.
+  # Bud interpreter. This means this method won't return unless an error occurs
+  # or Bud is halted. It is often more useful to run Bud in a different thread:
+  # see run_bg.
   def run_fg
     # If we're called from the EventMachine thread (and EM is running), blocking
     # the current thread would imply deadlocking ourselves.
@@ -306,14 +383,15 @@ module Bud
     run_bg
     # Block caller's thread until Bud has shutdown
     q.pop
+    report_metrics if options[:metrics]
   end
-  # Shutdown a Bud instance that is running asynchronously. This method blocks
-  # until Bud has been shutdown. If +stop_em+ is true, the EventMachine event
-  # loop is also shutdown; this will interfere with the execution of any other
-  # Bud instances in the same process (as well as anything else that happens to
-  # use EventMachine).
-  def stop_bg(stop_em=false, do_shutdown_cb=true)
+  # Shutdown a Bud instance and release any resources that it was using. This
+  # method blocks until Bud has been shutdown. If +stop_em+ is true, the
+  # EventMachine event loop is also shutdown; this will interfere with the
+  # execution of any other Bud instances in the same process (as well as
+  # anything else that happens to use EventMachine).
+  def stop(stop_em=false, do_shutdown_cb=true)
     schedule_and_wait do
       do_shutdown(do_shutdown_cb)
     end
@@ -322,15 +400,30 @@ module Bud
       Bud.stop_em_loop
       EventMachine::reactor_thread.join
     end
+    report_metrics if options[:metrics]
   end
+  alias :stop_bg :stop
   # Register a callback that will be invoked when this instance of Bud is
   # shutting down.
+  # XXX: The naming of this method (and cancel_shutdown_cb) is inconsistent
+  # with the naming of register_callback and friends.
   def on_shutdown(&blk)
     # Start EM if not yet started
     start_reactor
+    rv = nil
+    schedule_and_wait do
+      rv = @shutdown_callback_id
+      @shutdown_callbacks[@shutdown_callback_id] = blk
+      @shutdown_callback_id += 1
+    end
+    return rv
+  end
+  def cancel_shutdown_cb(id)
     schedule_and_wait do
-      @shutdown_callbacks << blk
+      raise Bud::BudError unless @shutdown_callbacks.has_key? id
+      @shutdown_callbacks.delete(id)
     end
   end
@@ -345,11 +438,10 @@ module Bud
   end
   # Given a block, evaluate that block inside the background Ruby thread at some
-  # time in the future. Because the block is evaluate inside the background Ruby
-  # thread, the block can safely examine Bud state. Naturally, this method can
-  # only be used when Bud is running in the background. Note that calling
-  # sync_do blocks the caller until the block has been evaluated; for a
-  # non-blocking version, see async_do.
+  # time in the future, and then perform a Bloom tick. Because the block is
+  # evaluate inside the background Ruby thread, the block can safely examine Bud
+  # state. Note that calling sync_do blocks the caller until the block has been
+  # evaluated; for a non-blocking version, see async_do.
   #
   # Note that the block is invoked after one Bud timestep has ended but before
   # the next timestep begins. Hence, synchronous accumulation (<=) into a Bud
@@ -361,7 +453,7 @@ module Bud
     schedule_and_wait do
       yield if block_given?
       # Do another tick, in case the user-supplied block inserted any data
-      tick
+      tick_internal
     end
   end
@@ -372,17 +464,7 @@ module Bud
     EventMachine::schedule do
       yield if block_given?
       # Do another tick, in case the user-supplied block inserted any data
-      tick
-    end
-  end
-  # Shutdown any persistent tables used by the current Bud instance. If you are
-  # running Bud via tick() and using +tctable+ collections, you should call this
-  # after you're finished using Bud. Programs that use Bud via run_fg() or
-  # run_bg() don't need to call this manually.
-  def close_tables
-    @tables.each_value do |t|
-      t.close
+      tick_internal
     end
   end
@@ -394,10 +476,9 @@ module Bud
   # runtime is blocked while the callback is invoked, it can also examine any
   # other Bud state freely.)
   #
-  # Note that registering callbacks on persistent collections (e.g., tables and
-  # tctables) is probably not a wise thing to do: as long as any tuples are
-  # stored in the collection, the callback will be invoked at the end of every
-  # tick.
+  # Note that registering callbacks on persistent collections (e.g., tables,
+  # syncs and stores) is probably not wise: as long as any tuples are stored in
+  # the collection, the callback will be invoked at the end of every tick.
   def register_callback(tbl_name, &block)
     # We allow callbacks to be added before or after EM has been started. To
     # simplify matters, we start EM if it hasn't been started yet.
@@ -419,7 +500,7 @@ module Bud
   # Unregister the callback that has the given ID.
   def unregister_callback(id)
     schedule_and_wait do
-      raise Bud::BudError unless @callbacks.has_key? id
+      raise Bud::BudError, "Missing callback: #{id.inspect}" unless @callbacks.has_key? id
       @callbacks.delete(id)
     end
   end
@@ -433,6 +514,14 @@ module Bud
     cb = register_callback(out_tbl) do |c|
       q.push c.to_a
     end
+    # If the runtime shuts down before we see anything in the output collection,
+    # make sure we hear about it so we can raise an error
+    # XXX: Using two separate callbacks here is ugly.
+    shutdown_cb = on_shutdown do
+      q.push :callback
+    end
     unless in_tbl.nil?
       sync_do {
         t = @tables[in_tbl]
@@ -444,8 +533,13 @@ module Bud
       }
     end
     result = q.pop
+    if result == :callback
+      # Don't try to unregister the callbacks first: runtime is already shutdown
+      raise BudShutdownWithCallbacksError, "Bud instance shutdown before sync_callback completed"
+    end
     unregister_callback(cb)
-    return result
+    cancel_shutdown_cb(shutdown_cb)
+    return (result == :callback) ? nil : result
   end
   # A common special case for sync_callback: block on a delta to a table.
@@ -469,8 +563,14 @@ module Bud
     return if EventMachine::reactor_running?
     EventMachine::error_handler do |e|
-      puts "Unexpected Bud error: #{e.inspect}"
-      puts e.backtrace.join("\n")
+      # Only print a backtrace if a non-BudError is raised (this presumably
+      # indicates an unexpected failure).
+      if e.class <= BudError
+        puts "#{e.class}: #{e}"
+      else
+        puts "Unexpected Bud error: #{e.inspect}"
+        puts e.backtrace.join("\n")
+      end
       Bud.shutdown_all_instances
       raise e
     end
@@ -524,40 +624,22 @@ module Bud
       @instance_id = ILLEGAL_INSTANCE_ID
     }
+    unregister_callback(@halt_cb)
     if do_shutdown_cb
-      @shutdown_callbacks.each {|cb| cb.call}
+      @shutdown_callbacks.each_value {|cb| cb.call}
     end
     @timers.each {|t| t.cancel}
-    close_tables
-    @dsock.close_connection if EventMachine::reactor_running?
+    @tables.each_value {|t| t.close}
+    if EventMachine::reactor_running? and @bud_started
+      @dsock.close_connection
+    end
+    @bud_started = false
+    @running_async = false
     if do_shutdown_cb
       @post_shutdown_callbacks.each {|cb| cb.call}
     end
   end
-  private
-  def start_bud
-    raise BudError unless EventMachine::reactor_thread?
-    @instance_id = Bud.init_signal_handlers(self)
-    do_start_server
-    # Initialize periodics
-    @periodics.each do |p|
-      @timers << set_periodic_timer(p.pername, p.ident, p.period)
-    end
-    # Arrange for Bud to read from stdin if enabled. Note that we can't do this
-    # earlier because we need to wait for EventMachine startup.
-    @stdio.start_stdin_reader if @options[:stdin]
-    @zk_tables.each_value {|t| t.start_watchers}
-    # Compute a fixpoint; this will also invoke any bootstrap blocks.
-    tick unless @lazy
-    @rtracer.sleep if options[:rtrace]
-  end
   def do_start_server
     @dsock = EventMachine::open_datagram_socket(@ip, @options[:port],
                                                 BudServer, self)
@@ -574,12 +656,18 @@ module Bud
   # forwarding, and external_ip:local_port would be if you're in a DMZ, for
   # example.
   def ip_port
-    raise BudError, "ip_port called before port defined" if @port.nil? and @options[:port] == 0 and not @options[:ext_port]
+    raise BudError, "ip_port called before port defined" if port.nil?
+    ip.to_s + ":" + port.to_s
+  end
+  def ip
     ip = options[:ext_ip] ? "#{@options[:ext_ip]}" : "#{@ip}"
-    port = options[:ext_port] ? "#{@options[:ext_port]}" :
+  end
+  def port
+    return nil if @port.nil? and @options[:port] == 0 and not @options[:ext_port]
+    return options[:ext_port] ? "#{@options[:ext_port]}" :
       (@port.nil? ? "#{@options[:port]}" : "#{@port}")
-    ip + ":" + port
   end
   # Returns the internal IP and port.  See ip_port.
@@ -588,9 +676,20 @@ module Bud
     @port.nil? ? "#{@ip}:#{@options[:port]}" : "#{@ip}:#{@port}"
   end
-  # Manually trigger one timestep of Bloom execution.
+  # From client code, manually trigger a timestep of Bloom execution.
   def tick
+    start(true)
+  end
+  # One timestep of Bloom execution. This MUST be invoked from the EventMachine
+  # thread; it is not intended to be called directly by client code.
+  def tick_internal
     begin
+      starttime = Time.now if options[:metrics]
+      if options[:metrics] and not @endtime.nil?
+        @metrics[:betweentickstats] ||= initialize_stats
+        @metrics[:betweentickstats] = running_stats(@metrics[:betweentickstats], starttime - @endtime)
+      end
       @inside_tick = true
       @tables.each_value do |t|
         t.tick
@@ -606,10 +705,17 @@ module Bud
       do_flush
       invoke_callbacks
       @budtime += 1
+      @inbound.clear
     ensure
       @inside_tick = false
       @tick_clock_time = nil
     end
+    if options[:metrics]
+      @endtime = Time.now
+      @metrics[:tickstats] ||= initialize_stats
+      @metrics[:tickstats] = running_stats(@metrics[:tickstats], @endtime - starttime)
+    end
   end
   # Returns the wallclock time associated with the current Bud tick. That is,
@@ -629,9 +735,11 @@ module Bud
   def builtin_state
     loopback  :localtick, [:col1]
     @stdio = terminal :stdio
-    @periodics = table :periodics_tbl, [:pername] => [:ident, :period]
+    readonly :signals, [:key]
+    scratch :halt, [:key]
+    @periodics = table :periodics_tbl, [:pername] => [:period]
-    # for BUD reflection
+    # for Bud reflection
     table :t_rules, [:rule_id] => [:lhs, :op, :src, :orig_src]
     table :t_depends, [:rule_id, :lhs, :op, :body] => [:nm]
     table :t_depends_tc, [:head, :body, :via, :neg, :temporal]
@@ -643,14 +751,13 @@ module Bud
     table :t_table_schema, [:tab_name, :col_name, :ord, :loc]
   end
-  # Handle any inbound tuples off the wire and then clear. Received messages are
-  # placed directly into the storage of the appropriate local channel.
+  # Handle any inbound tuples off the wire. Received messages are placed
+  # directly into the storage of the appropriate local channel. The inbound
+  # queue is cleared at the end of the tick.
   def receive_inbound
     @inbound.each do |msg|
-      #      puts "dequeueing tuple #{msg[1].inspect} into #{msg[0]} @ #{ip_port}"
       tables[msg[0].to_sym] << msg[1]
     end
-    @inbound = []
   end
   # "Flush" any tuples that need to be flushed. This does two things:
@@ -696,13 +803,20 @@ module Bud
     # stratum_first_iter field here distinguishes these cases.
     @stratum_first_iter = true
     begin
+      @this_stratum = strat_num
       strat.each_with_index do |r,i|
+        @this_rule = i
         fixpoint = false
+        rule_src = @rule_orig_src[strat_num][i] unless @rule_orig_src[strat_num].nil?
         begin
+          if options[:metrics]
+            metrics[:rules] ||= {}
+            metrics[:rules][{:strat_num => strat_num, :rule_num => i, :rule_src => rule_src}] ||= 0
+            metrics[:rules][{:strat_num => strat_num, :rule_num => i, :rule_src => rule_src}] += 1
+          end
           r.call
         rescue Exception => e
           # Don't report source text for certain rules (old-style rule blocks)
-          rule_src = @rule_orig_src[strat_num][i] unless @rule_orig_src[strat_num].nil?
           src_msg = ""
           unless rule_src == ""
             src_msg = "\nRule: #{rule_src}"
@@ -741,10 +855,10 @@ module Bud
     Time.new.to_i.to_s << rand.to_s
   end
-  def set_periodic_timer(name, id, period)
+  def make_periodic_timer(name, period)
     EventMachine::PeriodicTimer.new(period) do
-      @tables[name].add_periodic_tuple(id)
-      tick
+      @inbound << [name, [gen_id, Time.now]]
+      tick_internal if @running_async
     end
   end
@@ -791,11 +905,15 @@ module Bud
     $signal_lock.synchronize {
       # If we setup signal handlers and then fork a new process, we want to
       # reinitialize the signal handler in the child process.
-      unless b.options[:no_signal_handlers] or $signal_handler_setup
+      unless b.options[:signal_handling] == :none or $signal_handler_setup
         EventMachine::PeriodicTimer.new(SIGNAL_CHECK_PERIOD) do
           if $got_shutdown_signal
-            Bud.shutdown_all_instances
-            Bud.stop_em_loop
+            if b.options[:signal_handling] == :bloom
+              Bud.tick_all_instances
+            else
+              Bud.shutdown_all_instances
+              Bud.stop_em_loop
+            end
             $got_shutdown_signal = false
           end
         end
@@ -803,6 +921,7 @@ module Bud
         ["INT", "TERM"].each do |signal|
           Signal.trap(signal) {
             $got_shutdown_signal = true
+            b.sync_do{b.signals.pending_merge([[signal]])}
           }
         end
         $setup_signal_handler_pid = true
@@ -814,12 +933,21 @@ module Bud
     }
   end
+  def self.tick_all_instances
+    instances = nil
+    $signal_lock.synchronize {
+      instances = $bud_instances.clone
+    }
+    instances.each_value {|b| b.sync_do }
+  end
   def self.shutdown_all_instances(do_shutdown_cb=true)
     instances = nil
     $signal_lock.synchronize {
       instances = $bud_instances.clone
     }
-    instances.each_value {|b| b.stop_bg(false, do_shutdown_cb) }
+    instances.each_value {|b| b.stop(false, do_shutdown_cb) }
   end
 end