bud 0.0.7 → 0.0.8

data/lib/bud/viz.rb

@@ -1,14 +1,13 @@
 require 'rubygems'
 require 'syntax/convertors/html'
 require 'gchart'
-require 'digest/md5'
 require 'bud/state'
 
 class VizOnline #:nodoc: all
   def initialize(bud_instance)
     @bud_instance = bud_instance
     return if bud_instance.class == Stratification or @bud_instance.class == DepAnalysis
-    @meta_tables = {'t_rules' => 1, 't_depends' => 1, 't_table_info' => 1, 't_cycle' => 1, 't_stratum' => 1, 't_depends_tc' => 1, 't_table_schema' => 1}
+    @meta_tables = {'t_rules' => 1, 't_depends' => 1, 't_table_info' => 1, 't_cycle' => 1, 't_stratum' => 1, 't_depends_tc' => 1, 't_table_schema' => 1, 't_provides' => 1}
     @bud_instance.options[:dbm_dir] = "DBM_#{@bud_instance.class}_#{bud_instance.options[:tag]}_#{bud_instance.object_id}_#{bud_instance.port}"
     @table_info = bud_instance.tables[:t_table_info]
     @table_schema = bud_instance.tables[:t_table_schema]
@@ -57,13 +56,15 @@ class VizOnline #:nodoc: all
       if collection.class == Hash
         row = row[1]
       end
+      if collection.class == Bud::BudPeriodic
+        row = row[0]
+      end
       newrow = [tab, @bud_instance.budtime, row]
       begin
         @logtab << newrow
       rescue
-        raise "ERROR!  #{@logtab} << #{newrow}"
+        raise "ERROR!  #{@logtab} << #{newrow.inspect} (etxt #{$!})"
       end
-
     end
   end
 
@@ -73,7 +74,8 @@ class VizOnline #:nodoc: all
       tab = t[0]
       next if tab == "the_big_log"
       next if @meta_tables[tab.to_s] and @bud_instance.budtime > 0
-      add_rows(t[1], tab) unless t[1].class == Bud::BudPeriodic
+      # PAA: why did we previously exclude periodics?
+      add_rows(t[1], tab) #####unless t[1].class == Bud::BudPeriodic
       if t[1].class == Bud::BudChannel
         add_rows(t[1].pending, "#{tab}_snd")
       end

data/lib/bud/viz_util.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'bud/graphs'
+require 'bud/meta_algebra'
 
 module TraceCardinality
   state do
@@ -18,11 +19,12 @@ class VizHelper
   include Bud
   include TraceCardinality
 
-  def initialize(tabinf, cycle, depends, rules, dir)
+  def initialize(tabinf, cycle, depends, rules, dir, provides)
     @t_tabinf = tabinf
     @t_cycle = cycle
     @t_depends = depends
     @t_rules = rules
+    @t_provides = provides
     @dir = dir
     super()
   end
@@ -59,21 +61,93 @@ end
 
 
 module VizUtil #:nodoc: all
-  def graph_from_instance(bud_instance, viz_name, output_base, collapse=true, fmt=nil)
+  def self.ma_tables
+    # a craven, contemptible hack to grab the metatables.
+    estr = "class Foo\ninclude Bud\ninclude MetaAlgebra\ninclude MetaReports\nend"
+    eval(estr)
+    e = Foo.new
+    e.tables
+  end
+
+  def graph_from_instance(bud_instance, viz_name, output_base, collapse=true, fmt=nil, data=nil)
     tabinf = {}
     bud_instance.tables.each do |t|
       tab = t[0].to_s
       tabinf[tab] = t[1].class.to_s
     end
-    write_graphs(tabinf, bud_instance.builtin_tables, bud_instance.t_cycle,
+
+    begins = get_paths(bud_instance)
+    bit = bud_instance.builtin_tables 
+    VizUtil.ma_tables.each_pair{|k, v| bit[k] = v}
+
+    write_graphs(tabinf, bit, bud_instance.t_cycle,
                  bud_instance.t_depends, bud_instance.t_rules, viz_name,
-                 output_base, fmt, collapse, bud_instance.meta_parser.depanalysis)
+                 output_base, fmt, collapse, bud_instance.meta_parser.depanalysis, -1, nil, 
+                 get_labels(bud_instance), begins)
+    begins
+  end
+
+  def get_paths(bud_instance)
+    return {} unless bud_instance.respond_to? :a_preds 
+    begins = {}
+    bud_instance.a_preds.each do |b|
+      begins[:start] ||= {}
+      begins[:start][b.path.split("|").last] = b.fullpath.split("|").last
+      begins[:finish] = {}
+      begins[:finish][b.fullpath.split("|").last] = true
+    end
+    begins
+  end
+
+  def get_labels(bud_instance)
+    return {} unless bud_instance.respond_to? :lps
+    # sort the paths.  sort the paths to the same destination by length.
+    aps = {}
+    ap_interm = bud_instance.lps.sort do |a, b|
+      if a.to == b.to then
+        a.path.length <=> b.path.length
+      else
+        a <=> b
+      end
+    end
+    ap_interm.each do |a|
+      aps[a.to] ||= []
+      aps[a.to] << a.tag
+    end
+
+    # grab the lattice metadata
+    lub = {}
+    bud_instance.lub.each do |l|
+      lub[l.left] ||= {}
+      lub[l.left][l.right] = l.result
+    end
+
+    # b/c set union isn't working right
+    ap2 = {}
+    aps.each_pair do |k, v|
+      tmp = v.reduce({}) do |memo, i|
+        memo[:val] ||= :M
+        was = memo[:val]
+        if lub[memo[:val]][i]
+          if i == :N
+            memo[:val] = lub[i][memo[:val]]
+          else
+            memo[:val] = lub[memo[:val]][i]
+          end
+        else
+          puts "couldn't find #{memo[:val]} - #{i} in #{lub.inspect}"
+        end
+        memo
+      end
+      ap2[k] = [tmp, v]
+    end
+    ap2
   end
 
   def write_graphs(tabinf, builtin_tables, cycle, depends, rules, viz_name,
-                   output_base, fmt, collapse, depanalysis=nil, budtime=-1, card_info=nil)
+                   output_base, fmt, collapse, depanalysis=nil, budtime=-1, card_info=nil, pathsto={}, begins = {})
     staging = "#{viz_name}.staging"
-    gv = GraphGen.new(tabinf, builtin_tables, cycle, staging, budtime, collapse, card_info)
+    gv = GraphGen.new(tabinf, builtin_tables, cycle, staging, budtime, collapse, card_info, pathsto, begins)
     gv.process(depends)
     dump(rules, output_base, gv)
     gv.finish(depanalysis, fmt)
@@ -116,7 +190,6 @@ module VizUtil #:nodoc: all
       if !code[v[0]]
         code[v[0]] = ""
       end
-      #code[v[0]] = "<br># RULE #{k}<br> " + code[v[0]] + "<br>" + v[1]
       code[v[0]] = "\n# RULE #{k}\n " + code[v[0]] + "\n" + v[1]
     end
     gv_obj.nodes.each_pair do |k, v|
@@ -213,7 +286,7 @@ END_JS
   end
 
   def get_meta2(dir)
-    meta_tabs = {"t_table_info" => :tabinf, "t_table_schema" => :tabscm, "t_cycle" => :cycle, "t_depends" => :depends, "t_rules" => :rules}
+    meta_tabs = {"t_table_info" => :tabinf, "t_table_schema" => :tabscm, "t_cycle" => :cycle, "t_depends" => :depends, "t_rules" => :rules, "t_provides" => :provides}
     meta = {}
     data = []
 
@@ -227,7 +300,7 @@ END_JS
       tup = key[0]
       MessagePack.unpack(v).each {|val| tup << val}
       if meta_tabs[tab]
-        raise "non-zero budtime.  sure this is metadata?" if time != 0 and strict
+        raise "non-zero budtime.(tab=#{tab}, time=#{time})  sure this is metadata?" if time != 0 #and strict
         meta[meta_tabs[tab]] ||= []
         meta[meta_tabs[tab]] << tup
         #ret << tup
@@ -254,10 +327,19 @@ END_JS
   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?
+    # issue with _snd schemas
+    if !schema.nil? and schema[0] == "c_bud_time"
+      fout.puts "<tr>" 
+      if schema[1].length == 2 and schema[1][0].class == Array and schema[1][1].class == Array
+        fout.puts schema[1][0].map{|s| "<th> #{s} </th>"}.join(" ")
+        fout.puts schema[1][1].map{|s| "<th> #{s} </th>"}.join(" ")
+      else
+        fout.puts schema[1].map{|s| "<th> #{s} </th>"}.join(" ")
+      end
+      fout.puts "<tr>"
+    end
     fout.close
     return str
   end

data/lib/bud.rb

@@ -20,6 +20,7 @@ require 'bud/deploy/threaddeploy'
 require 'bud/errors'
 require 'bud/joins'
 require 'bud/metrics'
+require 'bud/meta_algebra'
 require 'bud/rtrace'
 require 'bud/server'
 require 'bud/state'
@@ -92,6 +93,15 @@ module Bud
   #   * <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
+  #   * <tt>:channel_filter</tt> a code block that can be used to filter the
+  #     network messages delivered to this Bud instance. At the start of each
+  #     tick, the code block is invoked for every channel with any incoming
+  #     messages; the code block is passed the name of the channel and an array
+  #     containing the inbound messages. It should return a two-element array
+  #     containing "accepted" and "postponed" messages, respectively. Accepted
+  #     messages are delivered during this tick, and postponed messages are
+  #     buffered and passed to the filter in subsequent ticks. Any messages that
+  #     aren't in either array are dropped.
   # * 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+
@@ -117,7 +127,7 @@ module Bud
     @inside_tick = false
     @tick_clock_time = nil
     @budtime = 0
-    @inbound = []
+    @inbound = {}
     @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
@@ -187,15 +197,15 @@ module Bud
   # 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 directly (since we can be sure
-  # those won't reference Bloom modules).
+  # 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 klass.name == self.name   # Skip methods defined in the Bud module
+    return if [self, DepAnalysis, Stratification].include? klass
 
     u = Unifier.new
-    ref_expander = NestedRefRewriter.new(klass.bud_import_table)
+    ref_expander = NestedRefRewriter.new(klass)
     tmp_expander = TempExpander.new
     with_expander = WithExpander.new
     r2r = Ruby2Ruby.new
@@ -208,8 +218,8 @@ module Bud
       ast = with_expander.process(ast)
 
       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
+        new_src = r2r.process(ast)
+        klass.module_eval new_src # Replace previous method def
       end
 
       ref_expander.did_work = false
@@ -494,7 +504,7 @@ module Bud
     cb_id = nil
     schedule_and_wait do
       unless @tables.has_key? tbl_name
-        raise Bud::Error, "no such table: #{tbl_name}"
+        raise Bud::Error, "no such collection: #{tbl_name}"
       end
 
       raise Bud::Error if @callbacks.has_key? @callback_id
@@ -650,7 +660,8 @@ module Bud
 
   def do_start_server
     @dsock = EventMachine::open_datagram_socket(@ip, @options[:port],
-                                                BudServer, self)
+                                                BudServer, self,
+                                                @options[:channel_filter])
     @port = Socket.unpack_sockaddr_in(@dsock.get_sockname)[0]
   end
 
@@ -669,13 +680,13 @@ module Bud
   end
 
   def ip
-    ip = options[:ext_ip] ? "#{@options[:ext_ip]}" : "#{@ip}"
+    options[:ext_ip] ? "#{@options[:ext_ip]}" : "#{@ip}"
   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}")
+    return @options[:ext_port] ? @options[:ext_port] :
+      (@port.nil? ? @options[:port] : @port)
   end
 
   # Returns the internal IP and port.  See ip_port.
@@ -769,8 +780,10 @@ module Bud
   # 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|
-      tables[msg[0].to_sym] << msg[1]
+    @inbound.each do |tbl_name, msg_buf|
+      msg_buf.each do |b|
+        tables[tbl_name] << b
+      end
     end
   end
 
@@ -840,7 +853,7 @@ module Bud
           unless new_e.class <= Bud::Error
             new_e = Bud::Error
           end
-          raise new_e, "exception during Bud evaluation.\nException: #{e.inspect}.#{src_msg}"
+          raise new_e, "exception during Bud evaluation.\nException: #{e.inspect}\nLocation: #{e.backtrace.first}.#{src_msg}"
         end
       end
       @stratum_first_iter = false
@@ -870,7 +883,8 @@ module Bud
 
   def make_periodic_timer(name, period)
     EventMachine::PeriodicTimer.new(period) do
-      @inbound << [name, [gen_id, Time.now]]
+      @inbound[name.to_sym] ||= []
+      @inbound[name.to_sym] << [gen_id, Time.now]
       tick_internal if @running_async
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bud
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Peter Alvaro
@@ -274,6 +274,7 @@ files:
 - lib/bud/errors.rb
 - lib/bud/graphs.rb
 - lib/bud/joins.rb
+- lib/bud/meta_algebra.rb
 - lib/bud/metrics.rb
 - lib/bud/monkeypatch.rb
 - lib/bud/rebl.rb