bud 0.0.8 → 0.1.0.pre1

data/lib/bud.rb

@@ -2,37 +2,35 @@ require 'rubygems'
 require 'eventmachine'
 require 'msgpack'
 require 'socket'
-require 'superators'
+require 'superators19'
 require 'thread'
-
-# Ruby2Ruby 1.3.1 is buggy (see issue #250)
-gem 'ruby2ruby', '< 1.3.1'
-require 'ruby2ruby'
+require 'bud/errors'
 
 require 'bud/monkeypatch'
 
 require 'bud/aggs'
 require 'bud/bud_meta'
 require 'bud/collections'
-require 'bud/depanalysis'
-require 'bud/deploy/forkdeploy'
-require 'bud/deploy/threaddeploy'
-require 'bud/errors'
 require 'bud/joins'
 require 'bud/metrics'
-require 'bud/meta_algebra'
+#require 'bud/meta_algebra'
 require 'bud/rtrace'
 require 'bud/server'
 require 'bud/state'
 require 'bud/storage/dbm'
-require 'bud/storage/tokyocabinet'
 require 'bud/storage/zookeeper'
-require 'bud/stratify'
 require 'bud/viz'
 
+require 'bud/executor/elements.rb'
+require 'bud/executor/group.rb'
+require 'bud/executor/join.rb'
+
 ILLEGAL_INSTANCE_ID = -1
 SIGNAL_CHECK_PERIOD = 0.2
 
+$BUD_DEBUG = ENV["BUD_DEBUG"].to_i > 0
+$BUD_SAFE = ENV["BUD_SAFE"].to_i > 0
+
 $signal_lock = Mutex.new
 $got_shutdown_signal = false
 $signal_handler_setup = false
@@ -66,13 +64,13 @@ $bud_instances = {}        # Map from instance id => Bud instance
 module Bud
   attr_reader :strata, :budtime, :inbound, :options, :meta_parser, :viz, :rtracer
   attr_reader :dsock
-  attr_reader :builtin_tables, :tables
-  attr_reader :channels, :tc_tables, :zk_tables, :dbm_tables, :sources, :sinks
-  attr_reader :stratum_first_iter, :joinstate
-  attr_reader :this_stratum, :this_rule, :rule_orig_src
+  attr_reader :tables, :builtin_tables, :channels, :zk_tables, :dbm_tables, :sources, :sinks, :app_tables
+  attr_reader :push_sources, :push_elems, :push_joins, :scanners, :merge_targets, :done_wiring
+  attr_reader :this_stratum, :this_rule, :rule_orig_src, :done_bootstrap, :done_wiring
+  attr_accessor :stratum_collection_map, :stratified_rules
+  attr_accessor :metrics, :periodics
+  attr_accessor :this_rule_context, :qualified_name
   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
@@ -90,6 +88,7 @@ module Bud
   #   * <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>:print_wiring</tt> if true, print the wiring diagram of the program to stdout
   #   * <tt>:metrics</tt> if true, dumps a hash of internal performance metrics
   # * controlling execution
   #   * <tt>:tag</tt>  a name for this instance, suitable for display during tracing and visualization
@@ -105,17 +104,19 @@ module Bud
   # * storage configuration
   #   * <tt>:dbm_dir</tt> filesystem directory to hold DBM-backed collections
   #   * <tt>:dbm_truncate</tt> if true, DBM-backed collections are opened with +OTRUNC+
-  #   * <tt>:tc_dir</tt>  filesystem directory to hold TokyoCabinet-backed collections
-  #   * <tt>:tc_truncate</tt> if true, TokyoCabinet-backed collections are opened with +OTRUNC+
-  # * deployment
-  #   * <tt>:deploy</tt>  enable deployment
-  #   * <tt>:deploy_child_opts</tt> option hash to pass to deployed instances
   def initialize(options={})
-    @builtin_tables = {}
+    # capture the binding for a subsequent 'eval'. This ensures that local
+    # variable names introduced later in this method don't interfere with 
+    # table names used in the eval block.
+    options[:dump_rewrite] ||= ENV["BUD_DUMP_REWRITE"].to_i > 0
+    options[:dump_ast]     ||= ENV["BUD_DUMP_AST"].to_i > 0
+    options[:print_wiring] ||= ENV["BUD_PRINT_WIRING"].to_i > 0
+    @qualified_name = ""
     @tables = {}
-    @rewritten_strata = []
+    @table_meta = []
+    @stratified_rules = []
     @channels = {}
-    @tc_tables = {}
+    @push_elems = {}
     @dbm_tables = {}
     @zk_tables = {}
     @callbacks = {}
@@ -124,17 +125,23 @@ module Bud
     @shutdown_callback_id = 0
     @post_shutdown_callbacks = []
     @timers = []
+    @app_tables = []
     @inside_tick = false
     @tick_clock_time = nil
     @budtime = 0
     @inbound = {}
     @done_bootstrap = false
-    @joinstate = {}  # joins are stateful, their state needs to be kept inside the Bud instance
+    @done_wiring = false
     @instance_id = ILLEGAL_INSTANCE_ID # Assigned when we start running
     @sources = {}
     @sinks = {}
     @metrics = {}
     @endtime = nil
+    @this_stratum = 0
+    @push_sorted_elems = nil
+
+    # XXX This variable is unused in the Push executor
+    @stratum_first_iter = false
     @running_async = false
     @bud_started = false
 
@@ -147,104 +154,133 @@ module Bud
     # NB: If using an ephemeral port (specified by port = 0), the actual port
     # number won't be known until we start EM
 
-    relatives = self.class.modules + [self.class]
-    relatives.each do |r|
-      Bud.rewrite_local_methods(r)
-    end
+    builtin_state
 
-    @declarations = ModuleRewriter.get_rule_defs(self.class)
+    resolve_imports
 
-    init_state
+    # Invoke all the user-defined state blocks and initialize builtin state.
+    call_state_methods
+
+    @declarations = self.class.instance_methods.select {|m| m =~ /^__bloom__.+$/}.map {|m| m.to_s}
 
     @viz = VizOnline.new(self) if @options[:trace]
     @rtracer = RTrace.new(self) if @options[:rtrace]
 
-    # Get dependency info and determine stratification order.
-    unless self.class <= Stratification or self.class <= DepAnalysis
-      do_rewrite
-    end
-
-    # Load the rules as a closure. Each element of @strata is an array of
-    # lambdas, one for each rewritten rule in that strata. Note that legacy Bud
-    # code (with user-specified stratification) assumes that @strata is a simple
-    # array, so we need to convert it before loading the rewritten strata.
-    @strata = []
-    @rule_src = []
-    @rule_orig_src = []
-    declaration
-    @strata.each_with_index do |s,i|
-      raise Bud::Error if s.class <= Array
-      @strata[i] = [s]
-      # Don't try to record source text for old-style rule blocks
-      @rule_src[i] = [""]
+    do_rewrite
+    if toplevel == self
+      # initialize per-stratum state
+      num_strata = @stratified_rules.length
+      @scanners = num_strata.times.map{{}}
+      @push_sources = num_strata.times.map{{}}
+      @push_joins = num_strata.times.map{[]}
+      @merge_targets = num_strata.times.map{{}}
     end
+  end
 
-    @rewritten_strata.each_with_index do |src_ary,i|
-      @strata[i] ||= []
-      @rule_src[i] ||= []
-      @rule_orig_src[i] ||= []
-      src_ary.each_with_index do |src, j|
-        @strata[i] << eval("lambda { #{src} }")
-        @rule_src[i] << src
-        @rule_orig_src[i] << @no_attr_rewrite_strata[i][j]
+  def module_wrapper_class(mod)
+    class_name = "#{mod}__wrap"
+    begin
+      klass = Module.const_get(class_name.to_sym)
+      unless klass.is_a? Class
+        raise Bud::Error, "Internal error: #{class_name} is in use"
       end
+    rescue NameError # exception if class class_name doesn't exist
     end
+    klass ||= eval "class #{class_name}; include Bud; include #{mod}; end"
+    klass
   end
 
-  private
+  def toplevel
+     @toplevel = (@options[:toplevel] || self)
+  end
 
-  # Rewrite methods defined in the given klass to expand module references and
-  # temp collections. Imported modules are rewritten during the import process;
-  # we rewrite the main class associated with this Bud instance and any included
-  # modules here. Note that we only rewrite each distinct Class once, and we
-  # skip methods defined by the Bud (Ruby) module or the builtin Bloom programs
-  # (since we can be sure those won't need rewriting).
-  def self.rewrite_local_methods(klass)
-    @done_rewrite ||= {}
-    return if @done_rewrite.has_key? klass.name
-    return if [self, DepAnalysis, Stratification].include? klass
+  def qualified_name
+    toplevel? ? "" : @options[:qualified_name]
+  end
 
-    u = Unifier.new
-    ref_expander = NestedRefRewriter.new(klass)
-    tmp_expander = TempExpander.new
-    with_expander = WithExpander.new
-    r2r = Ruby2Ruby.new
+  def toplevel?
+    toplevel.object_id == self.object_id
+  end
 
-    klass.instance_methods(false).each do |m|
-      ast = ParseTree.translate(klass, m)
-      ast = u.process(ast)
-      ast = ref_expander.process(ast)
-      ast = tmp_expander.process(ast)
-      ast = with_expander.process(ast)
+  def import_instance(name)
+    name = "@" + name.to_s
+    instance_variable_get(name) if instance_variable_defined? name
+  end
 
-      if ref_expander.did_work or tmp_expander.did_work or with_expander.did_work
-        new_src = r2r.process(ast)
-        klass.module_eval new_src # Replace previous method def
+  def import_defs
+    @imported_defs = {} # mod name -> Module map
+    self.class.ancestors.each do |anc|
+      if anc.respond_to? :bud_import_table
+        anc_imp_tbl = anc.bud_import_table
+        anc_imp_tbl.each do |nm, mod|
+          # Ensure that two modules have not been imported under one alias.
+          if @imported_defs.member? nm and not @imported_defs[nm] == anc_imp_tbl[nm]
+              raise Bud::CompileError, "Conflicting imports: modules #{@imported_defs[nm]} and #{anc_imp_tbl[nm]} both are imported as '#{nm}'"
+          end
+          @imported_defs[nm] = mod
+        end
       end
-
-      ref_expander.did_work = false
-      tmp_expander.did_work = false
-      with_expander.did_work = false
     end
+    @imported_defs ||= self.class.ancestors.inject({}) {|tbl, e| tbl.merge(e.bud_import_table)}
+  end
 
-    # If we found any temp statements in the klass's rule blocks, add a state
-    # block with declarations for the corresponding temp collections.
-    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 == ""
+  def budtime
+    toplevel? ?  @budtime : toplevel.budtime
   end
 
-  # Invoke all the user-defined state blocks and initialize builtin state.
-  def init_state
-    builtin_state
-    call_state_methods
+  # absorb rules and dependencies from imported modules. The corresponding module instantiations
+  # would themselves have resolved their own imports.
+  def resolve_imports
+    import_tbl = import_defs
+
+    import_tbl.each_pair do |local_name, mod_name|
+      # corresponding to "import <mod_name> => :<local_name>"
+      mod_inst = send(local_name)
+      qlocal_name = toplevel? ? local_name.to_s : self.qualified_name + "." + local_name.to_s
+      if mod_inst.nil?
+        # create wrapper instances
+        #puts "=== resolving #{self}.#{mod_name} => #{local_name}"
+        klass = module_wrapper_class(mod_name)
+        mod_inst = klass.new(:toplevel => toplevel, :qualified_name => qlocal_name) # this instantiation will resolve the imported module's own imports
+        instance_variable_set("@#{local_name}", mod_inst)
+      end
+      mod_inst.tables.each_pair do |name, t|
+        # Absorb the module wrapper's user-defined state.
+        unless @tables.has_key? t.tabname
+          qname = (local_name.to_s + "." + name.to_s).to_sym  # access path to table.
+          tables[qname] = t
+        end
+      end
+      mod_inst.t_rules.each do |imp_rule|
+        qname = local_name.to_s + "." + imp_rule.lhs.to_s  #qualify name by prepending with local_name
+        self.t_rules << [imp_rule.bud_obj, imp_rule.rule_id, qname, imp_rule.op,
+                     imp_rule.src, imp_rule.orig_src]
+      end
+      mod_inst.t_depends.each do |imp_dep|
+        qlname = local_name.to_s + "." + imp_dep.lhs.to_s  #qualify names by prepending with local_name
+        qrname = local_name.to_s + "." + imp_dep.body.to_s
+        self.t_depends << [imp_dep.bud_obj, imp_dep.rule_id, qlname, imp_dep.op, qrname, imp_dep.nm]
+      end
+      mod_inst.t_provides.each do |imp_pro|
+        qintname = local_name.to_s + "." + imp_pro.interface.to_s  #qualify names by prepending with local_name
+        self.t_provides << [qintname, imp_pro.input]
+      end
+      mod_inst.channels.each do |name, ch|
+        qname = (local_name.to_s + "." + name.to_s)
+        @channels[qname.to_sym] = ch
+      end
+      mod_inst.dbm_tables.each do |name, t|
+        qname = (local_name.to_s + "." + name.to_s)
+        @dbm_tables[qname.to_sym] = t
+      end
+      mod_inst.periodics.each do |p|
+        qname = (local_name.to_s + "." + p.pername.to_s)
+        p.pername = qname.to_sym
+        @periodics << [p.pername, p.period]
+      end
+    end
+
+    nil
   end
 
   # If module Y is a parent module of X, X's state block might reference state
@@ -270,8 +306,15 @@ module Bud
     end
   end
 
-  # Evaluate all bootstrap blocks
+  # Evaluate all bootstrap blocks and tick deltas
   def do_bootstrap
+    # evaluate bootstrap for imported modules
+    @this_rule_context = self
+    imported = import_defs.keys
+    imported.each do |mod_alias|
+      wrapper = import_instance mod_alias
+      wrapper.do_bootstrap
+    end
     self.class.ancestors.reverse.each do |anc|
       anc.instance_methods(false).each do |m|
         if /^__bootstrap__/.match m
@@ -281,19 +324,182 @@ module Bud
     end
     bootstrap
 
+    @tables.each_value {|t| t.bootstrap} if toplevel == self
     @done_bootstrap = true
   end
 
+  def do_wiring
+    @stratified_rules.each_with_index { |rules, stratum| eval_rules(rules, stratum) }
+
+    # prepare list of tables that will be actively used at run time. First, all the user defined ones.
+    # We start @app_tables off as a set, then convert to an array later.
+    @app_tables = (@tables.keys - @builtin_tables.keys).reduce(Set.new) {|tabset, nm| tabset << @tables[nm]; tabset}
+    # Check scan and merge_targets to see if any builtin_tables need to be added as well.
+    @scanners.each do |scs|
+      scs.each_value {|s| @app_tables << s.collection}
+    end
+    @merge_targets.each{|mts| #mts == merge_targets at stratum
+      mts.each_key {|t| @app_tables << t}
+    }
+    @app_tables = @app_tables.nil? ? [] : @app_tables.to_a
+
+    # for each stratum create a sorted list of push elements in topological order
+    @push_sorted_elems = []
+    @scanners.each do |scs|  # scs's values constitute scanners at a stratum
+      # start with scanners and transitively add all reachable elements in a breadth-first order
+      working = scs.values
+      seen = Set.new(working)
+      sorted_elems = [] # sorted elements in this stratum
+      while not working.empty?
+        sorted_elems += working
+        wired_to = []
+        working.each do |e|
+          e.wirings.each do |out|
+            if (out.class <= PushElement and not seen.member?(out))
+              seen << out
+              wired_to << out
+            end
+          end
+        end
+        working = wired_to
+      end
+      @push_sorted_elems << sorted_elems
+    end
+
+    @merge_targets.each_with_index do |stratum_tables, stratum|
+      @scanners[stratum].each_value do |s|
+        stratum_tables[s.collection] = true
+      end
+    end
+
+    # sanity check
+    @push_sorted_elems.each do |stratum_elems|
+      stratum_elems.each do |se|
+        se.check_wiring
+      end
+    end
+
+    prepare_invalidation_scheme
+
+    @done_wiring = true
+    if @options[:print_wiring]
+      @push_sources.each do |strat| 
+        strat.each_value{|src| src.print_wiring}
+      end
+    end
+  end
+
+  # All collections (elements included) are semantically required to erase any cached information at the start of a tick
+  # and start from a clean slate. prepare_invalidation_scheme prepares a just-in-time invalidation scheme that
+  # permits us to preserve data from one tick to the next, and to keep things in incremental mode unless there's a
+  # negation.
+  # This scheme solves the following constraints.
+  # 1. A full scan of an elements contents results in downstream elements getting full scans themselves (i.e no \
+  #    deltas). This effect is transitive.
+  # 2. Invalidation of an element's cache results in rebuilding of the cache and a consequent fullscan
+  # 3. Invalidation of an element requires upstream elements to rescan their contents, or to transitively pass the
+  #    request on further upstream. Any element that has a cache can rescan without passing on the request to higher
+  #    levels.
+  #
+  # This set of constraints is solved once during wiring, resulting in four data structures
+  # @default_invalidate = set of elements and tables to always invalidate at every tick. Organized by stratum
+  # @default_rescan = set of elements and tables to always scan fully in the first iteration of every tick.
+  # scanner[stratum].invalidate = Set of elements to additionally invalidate if the scanner's table is invalidated at
+  #  run-time
+  # scanner[stratum].rescan = Similar to above.
+
+
+  def prepare_invalidation_scheme
+    num_strata =  @push_sorted_elems.size
+    if $BUD_SAFE
+      @app_tables = @tables.values # No tables excluded
+
+      invalidate = Set.new
+      rescan = Set.new
+      @app_tables.each {|t| invalidate << t if (t.class <= BudScratch)}
+      num_strata.times do |stratum|
+        @push_sorted_elems[stratum].each do |elem|
+          invalidate << elem
+          rescan << elem
+        end
+      end
+      #prune_rescan_invalidate(rescan, invalidate)
+      @default_rescan = rescan.to_a
+      @default_invalidate = invalidate.to_a
+      @reset_list = [] # Nothing to reset at end of tick. It'll be overwritten anyway
+      return
+    end
+
+
+    # Any table that occurs on the lhs of rule is not considered a source (by default it is).
+    # In addition, we only consider non-temporal rules because invalidation is only about this tick.
+    t_rules.each {|rule| @tables[rule.lhs.to_sym].is_source = false if rule.op == "<="}
+
+    invalidate = Set.new
+    rescan = Set.new
+    # Compute a set of tables and elements that should be explicitly told to invalidate or rescan.
+    # Start with a set of tables that always invalidate, and elements that always rescan
+    @app_tables.each {|t| invalidate << t if t.invalidate_at_tick}
+    num_strata.times do |stratum|
+      @push_sorted_elems[stratum].each do |elem|
+        rescan << elem if elem.rescan_at_tick
+      end
+      rescan_invalidate_tc(stratum, rescan, invalidate)
+    end
+    prune_rescan_invalidate(rescan, invalidate)
+    # transitive closure
+    @default_rescan = rescan.to_a
+    @default_invalidate = invalidate.to_a
+
+    # Now compute for each table that is to be scanned, the set of dependent tables and elements that will be invalidated
+    # if that table were to be invalidated at run time.
+    dflt_rescan = rescan
+    dflt_invalidate = invalidate
+    to_reset = rescan + invalidate
+    num_strata.times do |stratum|
+      @scanners[stratum].each_value do |scanner|
+        # If it is going to be always invalidated, it doesn't need further examination.
+        next if dflt_rescan.member? scanner
+
+        rescan = dflt_rescan + [scanner]  # add scanner to scan set
+        invalidate = dflt_invalidate.clone
+        rescan_invalidate_tc(stratum, rescan, invalidate)
+        prune_rescan_invalidate(rescan, invalidate)
+        to_reset += rescan + invalidate
+        # Give the diffs (from default) to scanner; these are elements that are dependent on this scanner
+        diffscan = (rescan - dflt_rescan).find_all {|elem| elem.class <= PushElement}
+        scanner.invalidate_at_tick(diffscan, (invalidate - dflt_invalidate).to_a)
+      end
+    end
+    @reset_list = to_reset.to_a
+  end
+
+
+  #given rescan, invalidate sets, compute transitive closure
+  def rescan_invalidate_tc(stratum, rescan, invalidate)
+    rescan_len = rescan.size
+    invalidate_len = invalidate.size
+    while true
+      # Ask each element if it wants to add itself to either set, depending on who else is in those sets already.
+      @push_sorted_elems[stratum].each {|t| t.add_rescan_invalidate(rescan, invalidate)}
+      break if rescan_len == rescan.size and invalidate_len == invalidate.size
+      rescan_len = rescan.size
+      invalidate_len = invalidate.size
+    end
+  end
+
+  def prune_rescan_invalidate(rescan, invalidate)
+    rescan.delete_if {|e| e.rescan_at_tick}
+  end
+
   def do_rewrite
     @meta_parser = BudMeta.new(self, @declarations)
-    @rewritten_strata, @no_attr_rewrite_strata = @meta_parser.meta_rewrite
+    @stratified_rules = @meta_parser.meta_rewrite
   end
 
   public
 
   ########### give empty defaults for these
-  def declaration # :nodoc: all
-  end
   def bootstrap # :nodoc: all
   end
 
@@ -357,7 +563,7 @@ module Bud
     # 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
@@ -529,6 +735,7 @@ module Bud
   # inserted into the output collection: these are returned to the caller.
   def sync_callback(in_tbl, tupleset, out_tbl)
     q = Queue.new
+    # XXXX Why two separate entrances into the event loop? Why is the callback not registered in the sync_do below?
     cb = register_callback(out_tbl) do |c|
       q.push c.to_a
     end
@@ -565,6 +772,11 @@ module Bud
     sync_callback(nil, nil, out_tbl)
   end
 
+  # XXX make tag specific
+  def inspect
+    "#{self.class}:#{self.object_id.to_s(16)}"
+  end
+
   private
 
   def invoke_callbacks
@@ -635,7 +847,6 @@ module Bud
     # Silently ignore duplicate shutdown requests or attempts to shutdown an
     # instance that hasn't been started yet.
     return if @instance_id == ILLEGAL_INSTANCE_ID
-
     $signal_lock.synchronize {
       raise unless $bud_instances.has_key? @instance_id
       $bud_instances.delete @instance_id
@@ -691,7 +902,7 @@ module Bud
 
   # Returns the internal IP and port.  See ip_port.
   def int_ip_port
-    raise Bud::Error, "ip_port called before port defined" if @port.nil? and @options[:port] == 0
+    raise Bud::Error, "int_ip_port called before port defined" if @port.nil? and @options[:port] == 0
     @port.nil? ? "#{@ip}:#{@options[:port]}" : "#{@ip}:#{@port}"
   end
 
@@ -703,6 +914,7 @@ module Bud
   # 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
+    puts "#{object_id}/#{port} : =============================================" if $BUD_DEBUG
     begin
       starttime = Time.now if options[:metrics]
       if options[:metrics] and not @endtime.nil?
@@ -710,21 +922,80 @@ module Bud
         @metrics[:betweentickstats] = running_stats(@metrics[:betweentickstats], starttime - @endtime)
       end
       @inside_tick = true
-      @tables.each_value do |t|
-        t.tick
+      
+      unless @done_bootstrap
+        do_bootstrap
+        do_wiring
+      else
+        # inform tables and elements about beginning of tick.
+        @app_tables.each {|t| t.tick}
+        @default_rescan.each {|elem| elem.rescan = true}
+        @default_invalidate.each {|elem|
+          elem.invalidated = true
+          elem.invalidate_cache unless elem.class <= PushElement # call tick on tables here itself. The rest below.
+        }
+
+        num_strata = @push_sorted_elems.size
+        # The following loop invalidates additional (non-default) elements and tables that depend on the run-time
+        # invalidation state of a table.
+        # Loop once to set the flags
+        num_strata.times do |stratum|
+          @scanners[stratum].each_value do |scanner|
+            if scanner.rescan
+              scanner.rescan_set.each {|e| e.rescan = true}
+              scanner.invalidate_set.each {|e|
+                e.invalidated = true;
+                e.invalidate_cache unless e.class <= PushElement
+            }
+            end
+          end
+        end
+        #Loop a second time to actually call invalidate_cache
+        num_strata.times do |stratum|
+          @push_sorted_elems[stratum].each { |elem|  elem.invalidate_cache if elem.invalidated}
+        end
       end
 
-      @joinstate = {}
-
-      do_bootstrap unless @done_bootstrap
       receive_inbound
-
-      @strata.each_with_index { |s,i| stratum_fixpoint(s, i) }
+      # compute fixpoint for each stratum in order
+      @stratified_rules.each_with_index do |rules,stratum|
+        fixpoint = false
+        first_iter = true
+        until fixpoint
+          fixpoint = true
+          @scanners[stratum].each_value {|s| s.scan(first_iter)}
+          first_iter = false
+          # flush any tuples in the pipes
+          @push_sorted_elems[stratum].each {|p| p.flush}
+          # tick deltas on any merge targets and look for more deltas
+          # check to see if any joins saw a delta
+          push_joins[stratum].each do |p|
+            if p.found_delta==true
+              fixpoint = false 
+              p.tick_deltas
+            end
+          end
+          merge_targets[stratum].each_key do |t|
+            fixpoint = false if t.tick_deltas
+          end
+        end
+        # push end-of-fixpoint
+        @push_sorted_elems[stratum].each {|p|
+          p.stratum_end
+        }
+        merge_targets[stratum].each_key do |t|
+          t.flush_deltas
+        end
+      end
       @viz.do_cards if @options[:trace]
       do_flush
+
       invoke_callbacks
       @budtime += 1
       @inbound.clear
+
+      @reset_list.each {|e| e.invalidated = false; e.rescan = false}
+
     ensure
       @inside_tick = false
       @tick_clock_time = nil
@@ -757,14 +1028,13 @@ module Bud
 
     loopback  :localtick, [:col1]
     @stdio = terminal :stdio
-    readonly :signals, [:key]
+    signal :signals, [:name]
     scratch :halt, [:key]
     @periodics = table :periodics_tbl, [:pername] => [:period]
 
-    # 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]
+    # for BUD reflection
+    table :t_rules, [:bud_obj, :rule_id] => [:lhs, :op, :src, :orig_src]
+    table :t_depends, [:bud_obj, :rule_id, :lhs, :op, :body] => [:nm]
     table :t_provides, [:interface] => [:input]
     table :t_underspecified, t_provides.schema
     table :t_stratum, [:predicate] => [:stratum]
@@ -773,7 +1043,7 @@ module Bud
     table :t_table_schema, [:tab_name, :col_name, :ord, :loc]
 
     # Identify builtin tables as such
-    @builtin_tables = @tables.clone
+    @builtin_tables = @tables.clone if toplevel
   end
 
   # Handle any inbound tuples off the wire. Received messages are placed
@@ -781,6 +1051,7 @@ module Bud
   # queue is cleared at the end of the tick.
   def receive_inbound
     @inbound.each do |tbl_name, msg_buf|
+      puts "channel #{tbl_name} rcv:  #{msg_buf}" if $BUD_DEBUG
       msg_buf.each do |b|
         tables[tbl_name] << b
       end
@@ -793,89 +1064,32 @@ module Bud
   def do_flush
     @channels.each_value { |c| c.flush }
     @zk_tables.each_value { |t| t.flush }
-    @tc_tables.each_value { |t| t.flush }
     @dbm_tables.each_value { |t| t.flush }
   end
 
-  def stratum_fixpoint(strat, strat_num)
-    # This routine uses semi-naive evaluation to compute a fixpoint of the rules
-    # in strat.
-    #
-    # As described in lib/collections.rb, each collection has three
-    # sub-collections of note here:
-    #   @storage: the "main" storage of tuples
-    #   @delta: tuples that should be used to drive derivation of new facts
-    #   @new_delta: a place to store newly-derived facts
-    #
-    # The first time through this loop we mark @stratum_first_iter=true, which
-    # tells the Join::each code to join up all its @storage subcollections to
-    # start. In subsequent iterations the join code uses some table's @delta to
-    # ensure that only new tuples are derived.
-    #
-    # Note that calling "each" on a non-Join collection will iterate through
-    # both storage and delta.
-    #
-    # At the end of each iteration of this loop we transition:
-    # - @delta tuples are merged into @storage
-    # - @new_delta tuples are moved into @delta
-    # - @new_delta is set to empty
-    #
-    # XXX as a performance optimization, it would be nice to bypass the delta
-    # tables for any preds that don't participate in a rhs Join -- in that case
-    # there's pointless extra tuple movement letting tuples "graduate" through
-    # @new_delta and @delta.
-
-    # In semi-naive, the first iteration should join up tables on their storage
-    # fields; subsequent iterations do the delta-joins only.  The
-    # 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)
-          src_msg = ""
-          unless rule_src == ""
-            src_msg = "\nRule: #{rule_src}"
-          end
+  def eval_rule(__obj__, __src__)
+    __obj__.instance_eval __src__  # ensure that the only local variables are __obj__ and __src__
+  end
 
-          new_e = e
-          unless new_e.class <= Bud::Error
-            new_e = Bud::Error
-          end
-          raise new_e, "exception during Bud evaluation.\nException: #{e.inspect}\nLocation: #{e.backtrace.first}.#{src_msg}"
-        end
-      end
-      @stratum_first_iter = false
-      fixpoint = true
-      # tick collections in this stratum; if we don't have info on that, tick all collections
-      colls = @stratum_collection_map[strat_num] if @stratum_collection_map
-      colls ||= @tables.keys
-      colls.each do |name|
-        coll = @tables[name]
-        # ignore missing tables; rebl for example deletes them mid-stream
-        next if coll.nil?
-
-        unless coll.delta.empty? and coll.new_delta.empty?
-          fixpoint = false unless coll.new_delta.empty?
-          coll.tick_deltas
-        end
+  def eval_rules(rules, strat_num)
+    # This routine evals the rules in a given stratum, which results in a wiring of PushElements
+    @this_stratum = strat_num  
+    rules.each_with_index do |rule, i|
+      @this_rule = i
+      @this_rule_context = rule.bud_obj # user-supplied code blocks will be evaluated in this context at run-time
+      begin
+        eval_rule(rule.bud_obj, rule.src)
+      rescue Exception => e
+        err_msg = "** Exception while wiring rule: #{rule.src}\n ****** #{e}"
+        # Create a new exception for accomodating err_msg, but reuse original backtrace
+        new_e = (e.class <= Bud::Error) ? e.class.new(err_msg) : Bud::Error.new(err_msg)
+        new_e.set_backtrace(e.backtrace)
+        raise new_e
       end
-    end while not fixpoint
+    end
   end
 
   private
-
   ######## ids and timers
   def gen_id
     Time.new.to_i.to_s << rand.to_s