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

bud 0.0.4 → 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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