bud 0.0.2

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2011, Regents of the University of California
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+o  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+o  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+o  Neither the name of the University of California, Berkeley nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,30 @@
+# Bud
+
+This is Bud, a.k.a. "Bloom Under Development".  It is an initial cut at a Bloom DSL, using Ruby as a setting.
+
+Please see LICENSE for licensing information.
+
+Language cheatsheet in doc/cheat.md
+
+Main deficiencies at this point are:
+- Inefficient evaluation: Programs are run using semi-naive evaluation strategies, but no further
+  query optimization has been implemented, and little effort has been spent in
+  tuning.
+
+- No Ruby constraints: Within Bloom programs the full power of Ruby is also available, including mutable state.
+  This allows programmers to get outside the Bloom framework and lose cleanliness.
+
+- Compatibility: Bud only works with Ruby (MRI) 1.8. MRI 1.9, JRuby and other Ruby
+  implementations are currently not supported.
+
+To install:
+    % gem install bud
+
+Simple example programs can be found in examples. A much larger set
+of example programs and libraries can be found in the bud-sandbox repo.
+
+## Optional Dependencies
+
+The bud gem has a handful of mandatory dependencies. It also has one optional
+dependency: if you wish to use the Bud collections backed by Zookeeper (the
+"zktable" collection type), the "zookeeper" gem must be installed.

data/bin/budplot

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'bud'
+require 'bud/bud_meta'
+require 'bud/graphs'
+require 'bud/depanalysis'
+
+# args: N, files_n, classes_m
+
+def process(mods)
+  classdef = "class FooBar\ninclude Bud\n" + mods.map{|m| "include #{m}"}.join("\n")  +  "\nend\n FooBar.new"
+  puts "classdef #{classdef}"
+  d = eval(classdef)
+
+  d.t_rules.each {|s| puts "RULE: #{s.inspect}" }
+  #d.t_depends.each {|s| puts "DEP: #{s.inspect}" }
+
+  da = d.meta_parser.depanalysis
+
+  #puts "MP info src=#{da.source.length}, snk=#{da.sink.length}, under=#{da.underspecified.length}"
+
+  #d.meta_parser.depanalysis.source.each do |s|
+  #  puts "SRC: #{s}"
+  #end
+
+  interfaces = {}
+  d.t_provides.each do |name, is_input|
+    interfaces[name] = is_input
+  end
+
+  tabinf = {}
+  inp = []
+  outp = []
+  priv = []
+  d.tables.each do |t|
+    tab = t[0].to_s
+    tabinf[tab] = t[1].class.to_s
+    if interfaces[tab].nil?
+      unless tab =~ /^t_/ or tab == "stdio" or tab == "localtick"
+        priv << t
+      end
+    else
+      if interfaces[tab]
+        inp << t
+      else
+        outp << t
+      end
+    end
+  end
+
+  svg = "bud_doc/" + mods.join("_") + "_viz" 
+  write_index(inp, outp, priv, svg)
+  gv = GraphGen.new(d.t_stratum, tabinf, d.t_cycle, svg, -1, 1, ".", true, d.meta_parser.depanalysis)
+  gv.process(d.t_depends)
+  gv.dump(d.t_rules)
+  gv.finish
+
+  gv2 = GraphGen.new(d.t_stratum, tabinf, d.t_cycle, svg, -1, 1, ".", false, d.meta_parser.depanalysis)
+  gv2.process(d.t_depends)
+  gv2.dump(d.t_rules)
+  gv2.finish
+end
+
+def write_index(inp, outp, priv, svg)
+  f = File.open("bud_doc/index.html", "w")
+  f.puts "<html>"
+  f.puts "<embed src=\"#{ENV['PWD']}/#{svg}_collapsed.svg\" width=\"100%\" height=\"60%\" type=\"image/svg+xml\" pluginspage=\"http://www.adobe.com/svg/viewer/install/\" />"
+
+  f.puts "<table border='1' valign='top' width = '100%'><tr valign='top'>"
+  f.puts "<td valign='top'>"
+  f.puts "<h2> Input Interfaces </h2>"
+  do_table(f, inp)
+  f.puts "</td><td>"
+  f.puts "<h2> Output Interfaces </h2>"
+  do_table(f, outp)
+  f.puts "</td><td>"
+  f.puts "<h2> Private State </h2>"
+  do_table(f, priv, true)
+  f.puts "</td>"
+  f.puts "</tr></table>"
+  f.puts "</html>"
+  f.close
+end
+
+def do_table(f, info, type=false)
+  next if info.nil?
+  f.puts "<table border='1'>"
+  info.sort{|a, b| a[0].to_s <=> b[0].to_s}.each do |inf|
+    #f.puts "<h3>#{inf[0]}</h3>"
+    #f.puts  "&nbsp; (#{inf[1].class.to_s.gsub('Bud::Bud', '')})<br>" if type
+    unless inf[1].schema.nil?
+      f.puts "<tr><td><b>#{inf[0]}</b></td>" + inf[1].schema.map{|i| "<td>#{i}</td>"}.join(" ") + "</tr>"
+    end
+  end
+  f.puts "</table>"
+end
+
+@shreddies = []
+@provides = []
+@demands = []
+@tabinf = {}
+@port = 12345
+files = []
+classes = []
+
+if ARGV.length < 2
+  puts "len #{ARGV.length} USAGE:\nruby plotter.rb LIST_OF_FILES LIST_OF_MODULES"
+  exit
+end
+
+`mkdir bud_doc`
+
+modules = []
+(0..ARGV.length-1).each do |i|
+  begin
+    f = File.open(ARGV[i])
+    mods = false
+  rescue
+    mods = true
+  end
+
+  unless mods
+    puts "DO #{ARGV[i]}"
+    eval ( "require \"#{ARGV[i]}\"")
+  else
+    puts "Work on #{ARGV[i]}"
+    #instant(ARGV[i])
+    modules << ARGV[i]
+    puts "OK"
+  end
+end
+
+process(modules)
+

data/bin/budvis

@@ -0,0 +1,201 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'tokyocabinet'
+require 'bud'
+require 'bud/graphs'
+include TokyoCabinet
+
+# prototype offline viz
+
+BUD_TC_DIR = "#{ARGV[0]}/bud_"
+
+
+class VizHelper
+  include Bud
+
+  state do
+    table :full_info, [:bud_time, :table, :row]
+    scratch :cardinalities, [:bud_time, :table] => [:cnt]
+    scratch :times, [:bud_time]
+  end
+
+  def initialize(strata, tabinf, cycle, depends, rules, dir)
+    @t_strata = strata
+    @t_tabinf = tabinf
+    @t_cycle = cycle
+    @t_depends = depends
+    @dir = dir
+    @t_rules = rules
+    super()
+  end
+
+  bloom :counting do
+    cardinalities <= full_info.group([full_info.bud_time, full_info.table], count)
+    times <= full_info.map{|f| [f.bud_time]}
+  end
+
+  def summarize(dir, schema)
+    table_io = {}
+    timeseries = {}
+    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])
+      unless timeseries[card.table]
+        timeseries[card.table] = []
+      end
+      timeseries[card.table] << card.cnt
+    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
+
+    ts2 = {}
+    timeseries.each_pair do |k, v|
+      fn = v
+      puts "GOT #{fn}"
+      #ts2[k] = "#{ENV['PWD']}/#{fn}"
+      ts2[k] = v
+    end
+
+    sum = GraphGen.new(@t_strata, @t_tabinf, @t_cycle, "#{@dir}/summary", -1, 3, @dir, false, nil, ts2)
+    sum.process(@t_depends)
+    sum.dump(@t_rules)
+    sum.finish
+
+    # 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
+
+      gv = GraphGen.new(@t_strata, @t_tabinf, @t_cycle, "#{@dir}/tm_#{time.bud_time}", time.bud_time, 3, @dir, false, nil, card_info)
+      gv.process(@t_depends)
+      gv.dump(@t_rules)
+      gv.finish
+
+    end
+
+  end
+
+  def start_table(dir, tab, time, schema)
+    str = "#{dir}/#{tab}_#{time}.html"
+    #fout = File.new("#{dir}/#{tab}_#{time}.html", "w")
+    fout = File.new(str, "w")
+
+    #fout.puts "<h1>#{tab} #{time_node_header()}</h1>"
+    fout.puts "<html><title>#{tab} @ #{time}</title>"
+    fout.puts "<table border=1>"
+    fout.puts "<tr>" + schema.map{|s| "<th> #{s} </th>"}.join(" ") + "<tr>"
+    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
+
+def deserialize_table(tab, strict)
+  # oy.  meta only
+  ret = []
+  tab.each_pair do |k, v|
+    #key = Marshal.load(k)
+    key = MessagePack.unpack(k)
+    time = key.shift
+    raise "non-zero budtime.  sure this is metadata?" if time != 0 and strict
+    tup = key
+    #Marshal.load(v).each{|v| tup << v }
+    MessagePack.unpack(v).each{|val| tup << val }
+    ret << tup
+  end
+  tab.close
+  return ret
+end
+
+def usage
+  puts "Usage:"
+  puts "Running a Bud program with option :visualize => 3 will cause a TC directory TC_dir to be created (Class_ObjectId_Port)"
+  puts "> ruby visualize.rb TC_dir"
+  puts "This will create a series of svg files in TC_dir, the root of which will be named tm_0_expanded.svg.  Open in a browser.\n"
+  puts "e.g."
+  puts "> ruby test/tc_carts.rb"
+  puts "> ruby visualize.rb BCS_2159661360_"
+  puts "> open -a /Applications/Google\ Chrome.app/ BCS_2159661360_/tm_0_expanded.svg"
+  exit
+end
+
+# begin "main"
+
+usage unless ARGV[0]
+
+@tables = {}
+
+Dir.new(BUD_TC_DIR).entries.each do |file|
+  next if file =~ /^\./
+  puts "FILE is #{file}"
+  hdb = TokyoCabinet::HDB.new
+  ret = hdb.open("#{BUD_TC_DIR}/#{file}", HDB::OREADER)
+  raise "db not found" unless ret
+  @tables[file] = hdb
+end
+
+
+# let's try to do a visualization
+strata = deserialize_table(@tables['t_stratum_vizlog.tch'], true)
+tabinf = deserialize_table(@tables['t_table_info_vizlog.tch'], true)
+tabscm = deserialize_table(@tables['t_table_schema_vizlog.tch'], true)
+cycle = deserialize_table(@tables['t_cycle_vizlog.tch'], true)
+depends = deserialize_table(@tables['t_depends_vizlog.tch'], true)
+rules = deserialize_table(@tables['t_rules_vizlog.tch'], true)
+
+
+schminf = {}
+tabscm.each do |ts|
+  puts "TABSCM: #{ts.inspect}"
+  tab = ts[0].to_s
+  unless schminf[tab]
+    schminf[tab] = []
+  end
+  schminf[tab][ts[2]] = ts[1]
+end
+
+gv = GraphGen.new(strata, tabinf, cycle, "OUTPUT", -1, 1, "plotter_out")
+gv.process(depends)
+gv.finish
+
+
+vh = VizHelper.new(strata, tabinf, cycle, depends, rules, ARGV[0])
+
+@tables.each_pair do |name, contents|
+  name = name.gsub("_vizlog.tch", "")
+  contents.each_pair do |k, v|
+    key = MessagePack.unpack(k)
+    time = key[0]
+    row = key
+    MessagePack.unpack(v).each{ |val| row << val }
+    if name == "t_table_info.tch" or name == "t_table_schema.tch"
+      #vh.full_info << [0, name, row]
+    else
+      vh.full_info << [time, name, row]
+    end
+  end
+end
+
+vh.tick
+vh.summarize(ARGV[0], schminf)

data/bin/rebl

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'bud/rebl'
+
+ReblShell::run

data/docs/README.md

@@ -0,0 +1,13 @@
+#Bud: Bloom under development#
+Welcome to the documentation for *Bud*, a prototype of Bloom under development.
+
+The documents here are organized to be read in any order, but you might like to try the following:
+
+* [intro.md](intro.md): A brief introduction to Bud and Bloom
+* [getstarted.md](getstarted.md): A quickstart to teach you basic Bloom concepts, the use of `rebl` interactive terminal, and the embedding of Bloom code in Ruby via the `Bud` module.
+* [operational.md](operational.md): an operational view of Bloom, to provide a more detailed  model of how Bloom code is evaluated by Bud.
+* [Bud RubyDoc](http://rubydoc.info/github/bloom-lang/bud/): RubyDoc on the language constructs and runtime hooks provided by the Bud module
+* [cheat.md](cheat.md): A concise "cheat sheet" to remind you about Bloom syntax.
+* [ruby_hooks.md](ruby_hooks.md): Bud module methods that allow you to interact with the Bud evaluator from other Ruby threads.
+* [bud-sandbox](http://github.com/bloom-lang/bud-sandbox): a github repository including lots of useful libraries and examples.
+* [bfs.md](bfs.md):  A walkthrough of the Bloom distributed filesystem.