bud 0.9.7 → 0.9.8

data/docs/operational.md

@@ -58,7 +58,7 @@ Have a look at the following classic "transitive closure" example, which compute
 
     state do
       table :link, [:from, :to, :cost]
-      table :path, [:from, :to, :cost]
+      table :path, [:from, :to,  :cost]
     end
 
     bloom :make_paths do
@@ -67,7 +67,7 @@ Have a look at the following classic "transitive closure" example, which compute
 
       # recurse: path of length n+1 made by a link to a path of length n
       path <= (link*path).pairs(:to => :from) do |l,p|
-        [l.from, p.to, l.cost+p.cost]
+        [l.from, p.to, l.cost + p.cost]
       end
     end
     
@@ -97,4 +97,4 @@ Note that it is possible to write a program in Bloom that is *unstratifiable*: t
 
     glass <= one_item {|t| ['full'] if glass.empty? }
 
-Consider the case where we start out with glass being empty.  Then we know the fact `glass.empty?`, and the bloom statement says that `(glass.empty? => not glass.empty?)` which is equivalent to `(glass.empty? and not glass.empty?)` which is a contradiction.  The Bud runtime detects cycles through non-monotonicity for you automatically when you instantiate your class.
+Consider the case where we start out with glass being empty.  Then we know the fact `glass.empty?`, and the bloom statement says that `(glass.empty? => not glass.empty?)` which is equivalent to `(glass.empty? and not glass.empty?)` which is a contradiction.  The Bud runtime detects cycles through non-monotonicity for you automatically when you instantiate your class.

data/examples/basics/paths.rb

@@ -36,7 +36,7 @@ program = ShortestPaths.new
 
 # populate our little example.  we put two links between 'a' and 'b'
 # to see whether our shortest-paths code does the right thing.
-program.link <= [['a', 'b', 1],
+program.link <+ [['a', 'b', 1],
                  ['a', 'b', 4],
                  ['b', 'c', 1],
                  ['c', 'd', 1],
@@ -48,6 +48,6 @@ program.shortest.to_a.sort.each {|t| puts t.inspect}
 puts "----"
 
 # now lets add an extra link and recompute
-program.link << ['e', 'f', 1]
+program.link <+ [['e', 'f', 1]]
 program.tick
 program.shortest.to_a.sort.each {|t| puts t.inspect}

data/examples/chat/chat_protocol.rb

@@ -4,5 +4,5 @@ module ChatProtocol
     channel :mcast
   end
 
-  DEFAULT_ADDR = "localhost:12345"
+  DEFAULT_ADDR = "127.0.0.1:12345"
 end

data/lib/bud.rb

@@ -70,11 +70,11 @@ module Bud
   attr_reader :budtime, :inbound, :options, :meta_parser, :viz, :rtracer, :dsock
   attr_reader :tables, :builtin_tables, :channels, :zk_tables, :dbm_tables, :app_tables, :lattices
   attr_reader :push_sources, :push_elems, :push_joins, :scanners, :merge_targets
-  attr_reader :this_stratum, :this_rule, :rule_orig_src, :done_bootstrap
+  attr_reader :this_stratum, :this_rule_context, :done_bootstrap
   attr_reader :inside_tick
   attr_accessor :stratified_rules
   attr_accessor :metrics, :periodics
-  attr_accessor :this_rule_context, :qualified_name
+  attr_accessor :qualified_name
   attr_reader :running_async
 
   # options to the Bud runtime are passed in a hash, with the following keys
@@ -109,9 +109,6 @@ module Bud
   #   * <tt>:dbm_dir</tt> filesystem directory to hold DBM-backed collections
   #   * <tt>:dbm_truncate</tt> if true, DBM-backed collections are opened with +OTRUNC+
   def initialize(options={})
-    # 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
@@ -139,7 +136,8 @@ module Bud
     @instance_id = ILLEGAL_INSTANCE_ID # Assigned when we start running
     @metrics = {}
     @endtime = nil
-    @this_stratum = 0
+    @this_stratum = -1
+    @this_rule_id = -1
     @push_sorted_elems = nil
     @running_async = false
     @bud_started = false
@@ -158,8 +156,6 @@ module Bud
     resolve_imports
     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]
 
@@ -500,8 +496,6 @@ module Bud
       rescan_invalidate_tc(stratum, rescan, invalidate)
     end
 
-    prune_rescan_invalidate(rescan, invalidate)
-    # transitive closure
     @default_rescan = rescan.to_a
     @default_invalidate = invalidate.to_a
 
@@ -526,7 +520,7 @@ module Bud
       rescan = dflt_rescan.clone
       invalidate = dflt_invalidate + [scanner.collection]
       rescan_invalidate_tc(stratum, rescan, invalidate)
-      prune_rescan_invalidate(rescan, invalidate)
+      prune_rescan_set(rescan)
 
       # Make sure we reset the rescan/invalidate flag for this scanner at
       # end-of-tick, but we can remove the scanner from its own
@@ -599,7 +593,7 @@ module Bud
     end
   end
 
-  def prune_rescan_invalidate(rescan, invalidate)
+  def prune_rescan_set(rescan)
     rescan.delete_if {|e| e.rescan_at_tick}
   end
 
@@ -616,7 +610,7 @@ module Bud
   end
 
   def do_rewrite
-    @meta_parser = BudMeta.new(self, @declarations)
+    @meta_parser = BudMeta.new(self)
     @stratified_rules = @meta_parser.meta_rewrite
   end
 
@@ -737,16 +731,30 @@ module Bud
   # 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).
+  # anything else that happens to use EventMachine). We always shutdown the EM
+  # loop if there are no more running Bud instances (this does interfere with
+  # other EM-using apps, but it is necessary).
   def stop(stop_em=false, do_shutdown_cb=true)
     schedule_and_wait do
       do_shutdown(do_shutdown_cb)
     end
 
+    # If we're shutting down the last active Bud instance, shutdown the EM event
+    # loop as well. This is probably good practice in general, but it also
+    # prevents weird EM behavior -- it seems as though EM::ConnectionNotBound
+    # exceptions can be raised if the EM event loop is left running and
+    # subsequent events arrive.
+    $signal_lock.synchronize {
+      stop_em = true if $bud_instances.empty? and EventMachine::reactor_running?
+    }
+
     if stop_em
       Bud.stop_em_loop
-      EventMachine::reactor_thread.join
+      unless Thread.current == EventMachine::reactor_thread
+        EventMachine::reactor_thread.join
+      end
     end
+
     report_metrics if options[:metrics]
   end
   alias :stop_bg :stop
@@ -1065,6 +1073,35 @@ module Bud
     @done_bootstrap = true
   end
 
+  def do_invalidate_rescan
+    @default_rescan.each {|elem| elem.rescan = true}
+    @default_invalidate.each {|elem|
+      elem.invalidated = true
+      # Call tick on tables here itself. The rest below
+      elem.invalidate_cache unless elem.class <= PushElement
+    }
+
+    # 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.
+    each_scanner do |scanner, stratum|
+      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
+
+    # Loop a second time to actually call invalidate_cache.  We can't merge this
+    # with the loops above because some versions of invalidate_cache (e.g.,
+    # join) depend on the rescan state of other elements.
+    @num_strata.times do |stratum|
+      @push_sorted_elems[stratum].each {|e| e.invalidate_cache if e.invalidated}
+    end
+  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
@@ -1084,32 +1121,7 @@ module Bud
       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
-          # Call tick on tables here itself. The rest below
-          elem.invalidate_cache unless elem.class <= PushElement
-        }
-
-        # 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.
-        each_scanner do |scanner, stratum|
-          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
-
-        # Loop a second time to actually call invalidate_cache.  We can't merge
-        # this with the loops above because some versions of invalidate_cache
-        # (e.g., join) depend on the rescan state of other elements.
-        @num_strata.times do |stratum|
-          @push_sorted_elems[stratum].each {|e| e.invalidate_cache if e.invalidated}
-        end
+        do_invalidate_rescan
       end
 
       receive_inbound
@@ -1201,6 +1213,7 @@ module Bud
     table :t_cycle, [:predicate, :via, :neg, :temporal]
     table :t_depends, [:bud_obj, :rule_id, :lhs, :op, :body] => [:nm, :in_body]
     table :t_provides, [:interface] => [:input]
+    table :t_rule_stratum, [:bud_obj, :rule_id] => [:stratum]
     table :t_rules, [:bud_obj, :rule_id] => [:lhs, :op, :src, :orig_src, :unsafe_funcs_called]
     table :t_stratum, [:predicate] => [:stratum]
     table :t_table_info, [:tab_name, :tab_type]
@@ -1211,12 +1224,12 @@ module Bud
     @builtin_tables = @tables.clone if toplevel
   end
 
-  # 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.
+  # Handle external inputs: channels, terminals, and periodics. Received
+  # messages are placed directly into the storage of the appropriate local
+  # collection. The inbound 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
+      puts "recv via #{tbl_name}: #{msg_buf}" if $BUD_DEBUG
       msg_buf.each do |b|
         tables[tbl_name] << b
       end
@@ -1241,7 +1254,8 @@ module Bud
     # of PushElements
     @this_stratum = strat_num
     rules.each_with_index do |rule, i|
-      @this_rule_context = rule.bud_obj # user-supplied code blocks will be evaluated in this context at run-time
+      # user-supplied code blocks will be evaluated in this context at run-time
+      @this_rule_context = rule.bud_obj
       begin
         eval_rule(rule.bud_obj, rule.src)
       rescue Exception => e
@@ -1252,6 +1266,8 @@ module Bud
         raise new_e
       end
     end
+    @this_rule_context = nil
+    @this_stratum = -1
   end
 
   ######## ids and timers
@@ -1282,10 +1298,10 @@ module Bud
         EventMachine::release_machine
         EventMachine::instance_variable_set('@reactor_running', false)
       end
+
       # Shutdown all the Bud instances inherited from the parent process, but
       # don't invoke their shutdown callbacks
       Bud.shutdown_all_instances(false)
-
       $got_shutdown_signal = false
       $signal_handler_setup = false
 
@@ -1305,16 +1321,16 @@ module Bud
   end
 
   # Signal handling. If multiple Bud instances are running inside a single
-  # process, we want a SIGINT or SIGTERM signal to cleanly shutdown all of them.
+  # process, we want a SIGINT or SIGTERM signal to cleanly shutdown all of
+  # them. Note that we don't try to do any significant work in the signal
+  # handlers themselves: we just set a flag that is checked by a periodic timer.
   def self.init_signal_handlers(b)
     $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.
+      # Initialize or re-initialize signal handlers if necessary.
       unless b.options[:signal_handling] == :none || $signal_handler_setup
         EventMachine::PeriodicTimer.new(SIGNAL_CHECK_PERIOD) do
           if $got_shutdown_signal
             Bud.shutdown_all_instances
-            Bud.stop_em_loop
             $got_shutdown_signal = false
           end
         end

data/lib/bud/bud_meta.rb

@@ -1,10 +1,14 @@
 require 'bud/rewrite'
 
 class BudMeta #:nodoc: all
-  def initialize(bud_instance, declarations)
-    @bud_instance = bud_instance
-    @declarations = declarations
-    @dependency_analysis = nil # the results of bud_meta are analyzed further using a helper bloom instance. See depanalysis())
+  def initialize(bud_i)
+    @bud_instance = bud_i
+    @declarations = bud_i.methods.select {|m| m =~ /^__bloom__.+$/}.map {|m| m.to_s}
+    @rule_idx = 0
+
+    # The results of bud_meta are analyzed further using a helper Bloom
+    # instance. See depanalysis().
+    @dependency_analysis = nil
   end
 
   def meta_rewrite
@@ -12,20 +16,30 @@ class BudMeta #:nodoc: all
 
     stratified_rules = []
     if @bud_instance.toplevel == @bud_instance
-      nodes, stratum_map, top_stratum = stratify_preds
+      nodes = compute_node_graph
+      analyze_dependencies(nodes)
+
+      stratum_map = stratify_preds(nodes)
+      top_stratum = stratum_map.values.max
+      top_stratum ||= -1
 
       # stratum_map = {fully qualified pred => stratum}. Copy stratum_map data
       # into t_stratum format.
       raise unless @bud_instance.t_stratum.to_a.empty?
       @bud_instance.t_stratum.merge(stratum_map.to_a)
 
-      # slot each rule into the stratum corresponding to its lhs pred (from stratum_map)
       stratified_rules = Array.new(top_stratum + 2) { [] }  # stratum -> [ rules ]
       @bud_instance.t_rules.each do |rule|
         if rule.op == '<='
           # Deductive rules are assigned to strata based on the basic Datalog
-          # stratification algorithm
-          belongs_in = stratum_map[rule.lhs]
+          # stratification algorithm. Note that we don't place all the rules
+          # with a given lhs relation in the same strata; rather, we place a
+          # rule in the lowest strata we can, as determined by the rule's rhs
+          # relations (and whether the rel is used in a non-monotonic context).
+          body_rels = find_body_rels(rule)
+          body_strata = body_rels.map {|r,is_nm| stratum_map[r] + (is_nm ? 1 : 0) || 0}
+          belongs_in = body_strata.max
+
           # If the rule body doesn't reference any collections, it won't be
           # assigned a stratum, so just place it in stratum zero
           belongs_in ||= 0
@@ -35,28 +49,39 @@ class BudMeta #:nodoc: all
           stratified_rules[top_stratum + 1] << rule
         end
       end
-      # stratified_rules[0] may be empty if none of the nodes at stratum 0 are on the lhs
-      # stratified_rules[top_stratum+1] will be empty if there are no temporal rules.
-      # Cleanup
-      stratified_rules = stratified_rules.reject{|r| r.empty?}
+
+      # stratified_rules[0] may be empty if none of the nodes at stratum 0 are
+      # on the lhs stratified_rules[top_stratum+1] will be empty if there are no
+      # temporal rules.
+      stratified_rules.reject! {|r| r.empty?}
+
+      stratified_rules.each_with_index do |strat,strat_num|
+        strat.each do |rule|
+          @bud_instance.t_rule_stratum << [rule.bud_obj, rule.rule_id, strat_num]
+        end
+      end
+
       dump_rewrite(stratified_rules) if @bud_instance.options[:dump_rewrite]
     end
     return stratified_rules
   end
 
+  def find_body_rels(rule)
+    @bud_instance.t_depends.map do |d|
+      [d.body, d.nm] if d.rule_id == rule.rule_id and d.bud_obj == rule.bud_obj
+    end.compact
+  end
+
   def shred_rules
-    # to completely characterize the rules of a bud class we must extract
-    # from all parent classes/modules
-    # after making this pass, we no longer care about the names of methods.
-    # we are shredding down to the granularity of rule heads.
-    seed = 0
+    # After making this pass, we no longer care about the names of methods.  We
+    # are shredding down to the granularity of rule heads.
     rulebag = {}
     @bud_instance.class.ancestors.reverse.each do |anc|
       @declarations.each do |meth_name|
-        rw = rewrite_rule_block(anc, meth_name, seed)
+        rw = rewrite_rule_block(anc, meth_name)
         if rw
-          seed = rw.rule_indx
           rulebag[meth_name] = rw
+          @rule_idx = rw.rule_idx
         end
       end
     end
@@ -67,7 +92,7 @@ class BudMeta #:nodoc: all
     end
   end
 
-  def rewrite_rule_block(klass, block_name, seed)
+  def rewrite_rule_block(klass, block_name)
     return unless klass.respond_to? :__bloom_asts__
 
     pt = klass.__bloom_asts__[block_name]
@@ -103,7 +128,7 @@ class BudMeta #:nodoc: all
       end
       raise Bud::CompileError, "#{error_msg} in rule block \"#{block_name}\"#{src_msg}"
     end
-    rewriter = RuleRewriter.new(seed, @bud_instance)
+    rewriter = RuleRewriter.new(@bud_instance, @rule_idx)
     rewriter.process(pt)
     return rewriter
   end
@@ -176,64 +201,61 @@ class BudMeta #:nodoc: all
   end
 
 
-  Node = Struct.new :name, :status, :stratum, :edges, :in_lhs, :in_body, :in_cycle, :is_neg_head
   # Node.status is one of :init, :in_progress, :done
+  Node = Struct.new :name, :status, :stratum, :edges, :in_lhs, :in_body, :already_neg
   Edge = Struct.new :to, :op, :neg, :temporal
 
-  def stratify_preds
-    bud = @bud_instance.toplevel
+  def compute_node_graph
     nodes = {}
-    bud.t_depends.each do |d|
-      #t_depends [:bud_instance, :rule_id, :lhs, :op, :body] => [:nm, :in_body]
-      lhs = (nodes[d.lhs] ||= Node.new(d.lhs, :init, 0, [], true, false, false, false))
+    @bud_instance.toplevel.t_depends.each do |d|
+      # t_depends [:bud_instance, :rule_id, :lhs, :op, :body] => [:nm, :in_body]
+      lhs = (nodes[d.lhs] ||= Node.new(d.lhs, :init, 0, [], true, false))
       lhs.in_lhs = true
-      body = (nodes[d.body] ||= Node.new(d.body, :init, 0, [], false, true, false, false))
-      temporal = d.op != "<="
-      lhs.edges << Edge.new(body, d.op, d.nm, temporal)
+      body = (nodes[d.body] ||= Node.new(d.body, :init, 0, [], false, true))
       body.in_body = true
+      temporal = (d.op != "<=")
+      lhs.edges << Edge.new(body, d.op, d.nm, temporal)
     end
 
+    return nodes
+  end
+
+  def stratify_preds(nodes)
     nodes.each_value {|n| calc_stratum(n, false, false, [n.name])}
+
     # Normalize stratum numbers because they may not be 0-based or consecutive
     remap = {}
     # if the nodes stratum numbers are [2, 3, 2, 4], remap = {2 => 0, 3 => 1, 4 => 2}
     nodes.values.map {|n| n.stratum}.uniq.sort.each_with_index do |num, i|
       remap[num] = i
     end
+
     stratum_map = {}
-    top_stratum = -1
     nodes.each_pair do |name, n|
       n.stratum = remap[n.stratum]
       stratum_map[n.name] = n.stratum
-      top_stratum = max(top_stratum, n.stratum)
     end
-    analyze_dependencies(nodes)
-    return nodes, stratum_map, top_stratum
+    return stratum_map
   end
 
-  def max(a, b) ; a > b ? a : b ; end
-
   def calc_stratum(node, neg, temporal, path)
     if node.status == :in_process
-      node.in_cycle = true
-      if neg and !temporal and node.is_neg_head
+      if neg and not temporal and not node.already_neg
         raise Bud::CompileError, "unstratifiable program: #{path.uniq.join(',')}"
       end
     elsif node.status == :init
       node.status = :in_process
       node.edges.each do |edge|
-        node.is_neg_head = edge.neg
         next unless edge.op == "<="
+        node.already_neg = neg
         body_stratum = calc_stratum(edge.to, (neg or edge.neg), (edge.temporal or temporal), path + [edge.to.name])
-        node.is_neg_head = false # reset for next edge
-        node.stratum = max(node.stratum, body_stratum + (edge.neg ? 1 : 0))
+        node.stratum = [node.stratum, body_stratum + (edge.neg ? 1 : 0)].max
       end
       node.status = :done
     end
     node.stratum
   end
 
-
   def analyze_dependencies(nodes)  # nodes = {node name => node}
     preds_in_lhs = nodes.select {|_, node| node.in_lhs}.map {|name, _| name}.to_set
     preds_in_body = nodes.select {|_, node| node.in_body}.map {|name, _| name}.to_set