bud 0.9.5 → 0.9.6

data/lib/bud/executor/elements.rb

@@ -12,7 +12,7 @@ module Bud
   class PushElement < BudCollection
     attr_accessor :rescan, :invalidated
     attr_accessor :elem_name
-    attr_reader :found_delta, :wired_by, :outputs
+    attr_reader :found_delta, :wired_by, :outputs, :pendings
 
     def initialize(name_in, bud_instance, collection_name=nil, given_schema=nil, defer_schema=false, &blk)
       super(name_in, bud_instance, given_schema, defer_schema)
@@ -130,7 +130,7 @@ module Bud
         elsif ou.class <= Bud::LatticeWrapper
           ou.insert(item, self)
         else
-          raise Bud::Error, "expected output target: #{ou.class}"
+          raise Bud::Error, "unexpected output target: #{ou.class}"
         end
       end
 

data/lib/bud/executor/join.rb

@@ -526,7 +526,8 @@ module Bud
       @rhs_rcvd = false
       @hash_tables = [{},{}]
       if @lhs_keycols.nil? and blk.nil?
-        # pointwise comparison. Could use zip, but it creates an array for each field pair
+        # Pointwise comparison. Could use zip, but it creates an array for each
+        # field pair.
         blk = lambda {|lhs, rhs|
           lhs.to_a == rhs.to_a
         }
@@ -536,7 +537,7 @@ module Bud
 
     def setup_preds(preds)
       # This is simpler than PushSHJoin's setup_preds, because notin is a binary
-      # operator where both lhs and rhs are collections.  preds an array of
+      # operator where both lhs and rhs are collections. preds is an array of
       # hash_pairs. For now assume that the attributes are in the same order as
       # the tables.
       @lhs_keycols, @rhs_keycols = preds.reduce([[], []]) do |memo, item|
@@ -548,10 +549,13 @@ module Bud
         memo
       end
     end
+
     def find_col(colspec, rel)
       if colspec.is_a? Symbol
+        unless rel.respond_to? colspec
+          raise Bud::Error, "attribute :#{colspec} not found in #{rel.tabname}"
+        end
         col_desc = rel.send(colspec)
-        raise Bud::Error, "unknown column #{colspec} in #{@rel.tabname}" if col_desc.nil?
       elsif colspec.is_a? Array
         col_desc = colspec
       else
@@ -562,7 +566,7 @@ module Bud
 
     def get_key(item, offset)
       keycols = offset == 0 ? @lhs_keycols : @rhs_keycols
-      keycols.nil? ? $EMPTY : keycols.map{|col| item[col]}
+      keycols.nil? ? $EMPTY : item.values_at(*keycols)
     end
 
     public
@@ -571,7 +575,16 @@ module Bud
     end
 
     def insert(item, source)
-      offset = source == @lhs ? 0 : 1
+      if source == @lhs && source == @rhs       # Self join
+        do_insert(item, 0)
+        do_insert(item, 1)
+      else
+        offset = source == @lhs ? 0 : 1
+        do_insert(item, offset)
+      end
+    end
+
+    def do_insert(item, offset)
       key = get_key(item, offset)
       (@hash_tables[offset][key] ||= Set.new).add item
       if @rhs_rcvd and offset == 0
@@ -597,7 +610,6 @@ module Bud
     end
 
     def process_match(lhs_item, rhs_values)
-      exclude = true
       if rhs_values.nil?
         # no corresponding rhs. Include in output
         exclude = false
@@ -605,33 +617,24 @@ module Bud
         # for any lhs * rhs pair, if block returns true, do not push lhs. lhs is pushed
         # only if there is no match (anti-join)
         exclude = rhs_values.any?{|rhs_item| @blk.call(lhs_item, rhs_item)}
+      else
+        exclude = true
       end
-      unless exclude
-        push_out(lhs_item)
-      end
-    end
 
-    public
-    def push_out(item)
-      @outputs.each do |ou|
-        if ou.class <= Bud::PushElement
-          ou.insert(item, self)
-        elsif ou.class <= Bud::BudCollection
-          ou.do_insert(item, ou.new_delta)
-        else
-          raise Bud::Error, "expected either a PushElement or a BudCollection"
-        end
-      end
-      # for all the following, o is a BudCollection
-      @deletes.each{|o| o.pending_delete([item])}
-      @delete_keys.each{|o| o.pending_delete_keys([item])}
-      @pendings.each{|o| o.pending_merge([item])}
+      push_out(lhs_item, false) unless exclude
     end
 
     def invalidate_cache
-      puts "#{self.class}/#{self.tabname} invalidated" if $BUD_DEBUG
-      @hash_tables = [{},{}]
-      @rhs_rcvd = false
+      raise Bud::Error if @rhs_rcvd     # sanity check; should already be reset
+
+      if @lhs.rescan
+        puts "#{tabname} rel:#{@lhs.tabname} invalidated" if $BUD_DEBUG
+        @hash_tables[0] = {}
+      end
+      if @rhs.rescan
+        puts "#{tabname} rel:#{@rhs.tabname} invalidated" if $BUD_DEBUG
+        @hash_tables[1] = {}
+      end
     end
 
     def stratum_end

data/lib/bud/graphs.rb

@@ -167,7 +167,7 @@ class GraphGen #:nodoc: all
       @edges[ekey].arrowsize = 2
 
       @edges[ekey].color = (@nodes[body]["color"].source || "")
-      @edges[ekey].URL = "#{rule_id}.html" unless rule_id.nil?
+      @edges[ekey].URL = "#{rule_id}-#{head}.html" unless rule_id.nil?
       if head =~ /_msg\z/
         @edges[ekey].minlen = 2
       else
@@ -303,7 +303,7 @@ class SpaceTime
           params[:URL] = "DBM_#{k}/tm_#{item}.svg"
         end
         snd = @subs[k].add_nodes(label, params)
-        unless @head[k].id == snd.id
+        unless @head[k].object_id == snd.object_id
           @subs[k].add_edges(@head[k], snd, :weight => 2)
           @head[k] = snd
         end

data/lib/bud/lattice-core.rb

@@ -1,6 +1,8 @@
 require 'bud/executor/elements'
 
 class Bud::Lattice
+  include Comparable
+
   @@lattice_kinds = {}
   @@global_morphs = Set.new
   @@global_mfuncs = Set.new
@@ -76,7 +78,7 @@ class Bud::Lattice
   end
 
   def eql?(o)
-    return self == o
+    self == o
   end
 
   # Ensure hashing and equality semantics are consistent.
@@ -84,6 +86,11 @@ class Bud::Lattice
     reveal.hash
   end
 
+  # Similarly, use reveal'ed value to implement Comparable.
+  def <=>(o)
+    reveal <=> o.reveal
+  end
+
   # Return the state valued associated with a lattice instance. Note that this
   # is non-monotonic when invoked from user code; it should be used with care by
   # framework code.
@@ -107,8 +114,6 @@ end
 
 # TODO:
 # * merge logic for set-oriented collections
-# * invalidation/rescan/non-monotonic stuff?
-# * expressions on RHS ("CollExpr")
 class Bud::LatticePushElement
   attr_reader :wired_by, :outputs
   attr_accessor :invalidated, :rescan
@@ -381,15 +386,15 @@ class Bud::PushApplyMethod < Bud::LatticePushElement
 end
 
 class Bud::LatticeWrapper
-  attr_reader :tabname, :wired_by, :rescan_on_merge
-  attr_accessor :accumulate_tick_deltas
+  attr_reader :tabname, :wired_by, :rescan_on_delta
+  attr_accessor :accumulate_tick_deltas, :bud_instance
 
   def initialize(tabname, klass, bud_i)
     @tabname = tabname
     @klass = klass
     @bud_instance = bud_i
     @wired_by = []
-    @rescan_on_merge = Set.new
+    @rescan_on_delta = Set.new
   end
 
   def qualified_tabname
@@ -400,6 +405,35 @@ class Bud::LatticeWrapper
     false
   end
 
+  def setup_wiring(input, kind)
+    if input.class <= Bud::LatticeWrapper
+      input.to_push_elem.wire_to(self, kind)
+    elsif (input.class <= Bud::LatticePushElement || input.class <= Bud::PushElement)
+      input.wire_to(self, kind)
+    elsif input.class <= Bud::BudCollection
+      input.pro.wire_to(self, kind)
+    elsif input.class <= Proc
+      tbl = register_coll_expr(input)
+      tbl.pro.wire_to(self, kind)
+    else
+      raise Bud::Error, "unrecognized wiring input: #{input}"
+    end
+
+    add_merge_target
+  end
+
+  def positive_predecessors
+    @wired_by.select {|e| e.outputs.include?(self) || e.pendings.include?(self)}
+  end
+
+  private
+  def register_coll_expr(expr)
+    name = "expr_#{expr.object_id}".to_sym
+    @bud_instance.coll_expr(name, expr, nil)
+    @bud_instance.send(name)
+  end
+
+  public
   def current_value
     @storage ||= @klass.new
     @storage
@@ -436,30 +470,6 @@ class Bud::LatticeWrapper
     rv
   end
 
-  def setup_wiring(input, kind)
-    if input.class <= Bud::LatticeWrapper
-      input.to_push_elem.wire_to(self, kind)
-    elsif (input.class <= Bud::LatticePushElement || input.class <= Bud::PushElement)
-      input.wire_to(self, kind)
-    elsif input.class <= Bud::BudCollection
-      input.pro.wire_to(self, kind)
-    elsif input.class <= Proc
-      tbl = register_coll_expr(input)
-      tbl.pro.wire_to(self, kind)
-    else
-      raise Bud::Error, "unrecognized wiring input: #{input}"
-    end
-
-    add_merge_target
-  end
-
-  private
-  def register_coll_expr(expr)
-    name = "expr_#{expr.object_id}".to_sym
-    @bud_instance.coll_expr(name, expr, nil)
-    @bud_instance.send(name)
-  end
-
   # Merge "i" into @new_delta
   public
   def insert(i, source)
@@ -520,8 +530,17 @@ class Bud::LatticeWrapper
   end
 
   def bootstrap
-    @storage = do_merge(current_value, @pending)
-    @pending = nil
+    # Bootstrap blocks might install lattice values via either <= (@new_delta)
+    # or <+ (@pending).
+    if @new_delta
+      merge_to_storage(@new_delta)
+      @new_delta = nil
+    end
+
+    if @pending
+      merge_to_storage(@pending)
+      @pending = nil
+    end
   end
 
   def tick
@@ -537,7 +556,7 @@ class Bud::LatticeWrapper
     m = do_merge(current_value, v)
     if m != current_value
       @storage = m
-      @rescan_on_merge.each do |e|
+      @rescan_on_delta.each do |e|
         if e.kind_of? Bud::ScannerElement
           e.force_rescan = true
         else

data/lib/bud/lattice-lib.rb

@@ -1,69 +1,66 @@
 require 'bud/lattice-core'
 
+# Float::INFINITY only defined in MRI 1.9.2+
+unless defined? Float::INFINITY
+  Float::INFINITY = 1.0/0.0
+end
+
 class Bud::MaxLattice < Bud::Lattice
   wrapper_name :lmax
 
-  def initialize(i=nil)
-    unless i.nil? || i.class <= Comparable
-      reject_input(i)
-    end
+  def initialize(i=-Float::INFINITY)
+    reject_input(i) unless i.class <= Comparable
     @v = i
   end
 
   def merge(i)
-    i_val = i.reveal
-    (@v.nil? || (i_val != nil && i_val > @v)) ? i : self
+    i.reveal > @v ? i : self
   end
 
   morph :gt do |k|
-    Bud::BoolLattice.new(!!(@v && @v > k))
+    Bud::BoolLattice.new(!!(@v > k))
   end
 
   morph :gt_eq do |k|
-    Bud::BoolLattice.new(!!(@v && @v >= k))
+    Bud::BoolLattice.new(!!(@v >= k))
   end
 
   # XXX: support MaxLattice input?
   morph :+ do |i|
-    # Since bottom of lmax is negative infinity, + is a no-op
-    return self if @v.nil?
+    # NB: since bottom of lmax is negative infinity, + is a no-op
     reject_input(i, "+") unless i.class <= Numeric
     self.class.new(@v + i)
   end
 
   morph :min_of do |i|
     reject_input(i, "min_of") unless i.class <= Numeric
-    (@v.nil? || i < @v) ? self.class.new(i) : self
+    i < @v ? self.class.new(i) : self
   end
 
   def lt_eq(k)
-    Bud::BoolLattice.new(!!(@v && @v <= k))
+    Bud::BoolLattice.new(!!(@v <= k))
   end
 end
 
 class Bud::MinLattice < Bud::Lattice
   wrapper_name :lmin
 
-  def initialize(i=nil)
-    unless i.nil? || i.class <= Comparable
-      reject_input(i)
-    end
+  def initialize(i=Float::INFINITY)
+    reject_input(i) unless i.class <= Comparable
     @v = i
   end
 
   def merge(i)
-    i_val = i.reveal
-    (@v.nil? || (i_val != nil && i_val < @v)) ? i : self
+    i.reveal < @v ? i : self
   end
 
   morph :lt do |k|
-    Bud::BoolLattice.new(!!(@v && @v < k))
+    Bud::BoolLattice.new(!!(@v < k))
   end
 
   # XXX: support MinLattice input
   morph :+ do |i|
     # Since bottom of lmin is infinity, + is a no-op
-    return self if @v.nil?
     reject_input(i, "+") unless i.class <= Numeric
     self.class.new(@v + i)
   end
@@ -205,7 +202,8 @@ end
 class Bud::SetLattice < Bud::Lattice
   wrapper_name :lset
 
-  def initialize(i=[])
+  def initialize(i=Set.new)
+    reject_input(i) unless i.kind_of? Enumerable
     reject_input(i) if i.any? {|e| e.kind_of? Bud::Lattice}
 
     i = Set.new(i) unless i.kind_of? Set
@@ -216,6 +214,11 @@ class Bud::SetLattice < Bud::Lattice
     wrap_unsafe(@v | i.reveal)
   end
 
+  # Override default "inspect" implementation to produce slightly nicer output
+  def inspect
+    "<#{self.class.wrapper}: #{reveal.to_a.sort.inspect}>"
+  end
+
   morph :intersect do |i|
     wrap_unsafe(@v & i.reveal)
   end
@@ -304,8 +307,8 @@ class Bud::PositiveSetLattice < Bud::SetLattice
   end
 
   monotone :pos_sum do
-    @sum = @v.reduce(:+) if @sum.nil?
-    Bud::MaxLattice.new(@sum)
+    @sum = @v.reduce(Bud::MaxLattice.new(0), :+) if @sum.nil?
+    @sum
   end
 end
 
@@ -361,7 +364,7 @@ class Bud::BagLattice < Bud::Lattice
   end
 
   monotone :size do
-    @size = @v.values.reduce(:+) if @size.nil?
-    Bud::MaxLattice.new(@size)
+    @size = @v.values.reduce(Bud::MaxLattice.new(0), :+) if @size.nil?
+    @size
   end
 end

data/lib/bud/monkeypatch.rb

@@ -46,7 +46,7 @@ class Struct
     false
   end
 
-  def to_msgpack(out='')
+  def to_msgpack(out=nil)
     self.to_a.to_msgpack(out)
   end
 

data/lib/bud/rebl.rb

@@ -4,7 +4,9 @@ require 'rubygems'
 require 'bud'
 require 'abbrev'
 require 'tempfile'
-TABLE_TYPES = ["table", "scratch", "channel", "loopback", "periodic", "sync", "store"]
+
+TABLE_TYPES = ["table", "scratch", "channel", "loopback", "periodic",
+               "sync", "store", "interface", "interfaces"]
 
 # The class to which rebl adds user-specified rules and declarations.
 class ReblBase
@@ -93,10 +95,13 @@ class ReblShell
 
   # One step of the rebl shell loop: processes one rebl shell line from stdin
   # and returns.  May raise an Exception.
-  def self.rebl_loop(lib,noreadline=false)
+  def self.rebl_loop(lib, noreadline=false)
     begin
-      line = Readline::readline('rebl> ') unless noreadline
-      line = gets if noreadline
+      if noreadline
+        line = gets
+      else
+        line = Readline::readline('rebl> ')
+      end
       do_exit if line.nil?
       line.strip!
       return if line.empty?
@@ -110,7 +115,7 @@ class ReblShell
         else
           puts "invalid command or ambiguous command prefix"
         end
-      elsif TABLE_TYPES.include? split_line[0]
+      elsif is_collection? split_line[0]
         # Collection
         lib.add_collection(line)
       else
@@ -186,6 +191,12 @@ class ReblShell
     puts "\n" + @@exit_message
     exit!
   end
+
+  # Checks if a given string refers to a collection type (one of the builtin
+  # collection types or a wrapper_name for a lattice).
+  def self.is_collection?(c)
+    TABLE_TYPES.include?(c) || Bud::Lattice.lattice_kinds.has_key?(c.to_sym)
+  end
 end
 
 
@@ -233,11 +244,14 @@ class LibRebl
   def dump(c)
     if c.nil?
       puts "Error: dump must be passed a collection name"
-    elsif not @rebl_class_inst.tables.has_key? c.to_sym
-      puts "Error: non-existent collection \"#{c}\""
-    else
+    elsif @rebl_class_inst.tables.has_key? c.to_sym
       tups = @rebl_class_inst.tables[c.to_sym].to_a.sort
       puts(tups.empty? ? "(empty)" : tups.sort.map{|t| "#{t}"}.join("\n"))
+    elsif @rebl_class_inst.lattices.has_key? c.to_sym
+      val = @rebl_class_inst.lattices[c.to_sym].current_value
+      puts val.inspect
+    else
+      puts "Error: non-existent collection \"#{c}\""
     end
   end
 
@@ -334,11 +348,15 @@ class LibRebl
                                        end)
       @rebl_class_inst.dbm_tables.merge! @old_inst.dbm_tables
       @rebl_class_inst.zk_tables.merge! @old_inst.zk_tables
+      @rebl_class_inst.lattices.merge! @old_inst.lattices
 
       # Fix the bud instance pointers from copied tables.
       @rebl_class_inst.tables.each_value do |v|
         v.bud_instance = @rebl_class_inst
       end
+      @rebl_class_inst.lattices.each_value do |v|
+        v.bud_instance = @rebl_class_inst
+      end
     end
 
     # Run lazily in background, shutting down old instance.