bud 0.0.3 → 0.0.4

data/docs/visualizations.md

@@ -1,55 +1,67 @@
 # Visualizations
 
-Bud programs compile naturally to dataflows, and dataflows have a natural graphical representation.  Plotting a program as a graph can be useful to developers at various stages of program design, implementation and debugging.  Bud predicate dependency graphs (or PDGs) are described on [[PDGs]].
+Bud programs compile naturally to dataflows, and dataflows have a natural
+graphical representation.  Viewing the dataflow graph of a program can be useful
+to developers at various stages of program design, implementation and debugging.
 
-Bud ships with two visualization utilities, __plotter__ and __visualizer__.  Both use _GraphViz_ to draw a directed graph representing the program state and logic.  __plotter__ provides a static analysis of the program, identifying sources and sinks of the dataflow, unconnected components, and points of order corresponding to logically nonmonotonic path edges. __visualizer__ is an offline debugging tool that analyses the trace of a (local) Bud execution and provides an interactive representation of runtime state over time.
+Bud ships with two visualization utilities, __budplot__ and __budvis__.  Both
+use _GraphViz_ to draw a directed graph representing the program state and
+logic.  __budplot__ provides a static analysis of the program, identifying
+sources and sinks of the dataflow, unconnected components, and "points of order"
+that correspond to logically nonmonotonic path edges. __budvis__ is an offline
+debugging tool that analyses the trace of a (local) Bud execution and provides
+an interactive representation of runtime state over time.
 
-## The Plotter 
+## Using budplot
 
-[[https://github.com/bloom-lang/bud/blob/master/util/budplot]]
-
-The __plotter__ is a visual static analysis tool that aids in design and early implementation.  The most common uses of the __plotter__ are:
+__budplot__ is a visual static analysis tool that aids in design and early
+implementation.  The most common uses of __budplot__ are:
 
 1. Visual sanity checking: does the dataflow look like I expected it to look?
 2. Ensuring that a particular set of mixins is fully specified: e.g., did I forget to include a concrete implementation of a protocol required by other modules?
-   The Bloom module system, abstract interfaces and concrete implementations are described in more detail in [[modules]].
-3. Identifying dead code sections
+   The Bloom module system, abstract interfaces and concrete implementations are described in more detail in [modules.md](modules.md).
+3. Identifying dead code
 4. Experimenting with different module compositions
-5. Identifying and iteratively refining a program's points of order
+5. Identifying and iteratively refining a program's "points of order"
 
+To run __budplot__, specify a list of Ruby input files, followed by a list of
+Bud modules to be "mixed in" in the visualization.
 
-    $ ruby budplot 
-    USAGE:
-    ruby budplot LIST_OF_FILES LIST_OF_MODULES
+    $ budplot
+    Usage: budplot LIST_OF_FILES LIST_OF_MODULES
 
-As its usage message indicates, __plotter__ expects a list of ruby input files, followed by a list of Bud modules to mix in.
+For example:
 
-    $ ruby budplot kvs/kvs.rb ReplicatedKVS
+    $ budplot kvs/kvs.rb ReplicatedKVS
     Warning: underspecified dataflow: ["my_id", true]
     Warning: underspecified dataflow: ["add_member", true]
     Warning: underspecified dataflow: ["send_mcast", true]
     Warning: underspecified dataflow: ["mcast_done", false]
     fn is ReplicatedKVS_viz_collapsed.svg
-    $ open -a /Applications/Google\ Chrome.app/ ReplicatedKVS_viz_collapsed.svg
+    $ open bud_doc/index.html
 
-__ReplicatedKVS__ includes the __MulticastProtocol__ and __MembershipProtocol__ protocols, but does not specify which implementation of these abstractions to use.  The program is underspecified, and this is represented in the resulting graph (ReplicatedKVS_viz_collapsed.svg) by a node labeled "??" in the dataflow.
+`ReplicatedKVS` includes the `MulticastProtocol` and `MembershipProtocol`
+protocols, but does not specify which implementation of these abstractions to
+use.  The program is underspecified, and this is represented in the resulting
+graph (`ReplicatedKVS_viz_collapsed.svg`) by a node labeled "??" in the
+dataflow.
 
-    $ ruby budplot kvs/kvs.rb ReplicatedKVS BestEffortMulticast StaticMembership
+    $ budplot kvs/kvs.rb ReplicatedKVS BestEffortMulticast StaticMembership
     fn is ReplicatedKVS_BestEffortMulticast_StaticMembership_viz_collapsed.svg
-    $ open -a /Applications/Google\ Chrome.app/ ReplicatedKVS_BestEffortMulticast_StaticMembership_viz_collapsed.svg
-
-
-## The Visualizer
+    $ open bud_doc/index.html
 
-[[https://github.com/bloom-lang/bud/blob/master/util/budvis]]
+## Using budvis
 
-To enable tracing, we need to set __:trace => true__ in the __Bud__ constructor, and optionally provide a __:tag__ to differentiate between traces by a human-readable name (rather than by object_id).  I modified the unit test `test/tc_kvs.rb` as follows:
+To enable tracing, we need to set `:trace => true` in the `Bud` constructor, and
+optionally provide a `:tag` to differentiate between traces by a human-readable
+name (rather than by `object_id`).  I modified the unit test `test/DBM_kvs.rb` as
+follows:
 
     - v = BestEffortReplicatedKVS.new(@opts.merge(:port => 12345))
     - v2 = BestEffortReplicatedKVS.new(@opts.merge(:port => 12346))
 
-    + v = BestEffortReplicatedKVS.new(@opts.merge(:tag => 'dist_primary', :port => 12345, :trace => true))
-    + v2 = BestEffortReplicatedKVS.new(@opts.merge(:tag => 'dist_backup', :port => 12346, :trace => true))
+    + v = BestEffortReplicatedKVS.new(@opts.merge(:port => 12345, :tag => 'dist_primary', :trace => true))
+    + v2 = BestEffortReplicatedKVS.new(@opts.merge(:port => 12346, :tag => 'dist_backup', :trace => true))
 
 
 Then I ran the unit test:
@@ -57,10 +69,10 @@ Then I ran the unit test:
     $ ruby test/tc_kvs.rb 
     Loaded suite test/tc_kvs
     Started
-    .Created directory: TC_BestEffortReplicatedKVS_dist_primary_2160259460_
-    Created directory: TC_BestEffortReplicatedKVS_dist_primary_2160259460_/bud_
-    Created directory: TC_BestEffortReplicatedKVS_dist_backup_2159579740_
-    Created directory: TC_BestEffortReplicatedKVS_dist_backup_2159579740_/bud_
+    .Created directory: DBM_BestEffortReplicatedKVS_dist_primary_2160259460_
+    Created directory: DBM_BestEffortReplicatedKVS_dist_primary_2160259460_/bud_
+    Created directory: DBM_BestEffortReplicatedKVS_dist_backup_2159579740_
+    Created directory: DBM_BestEffortReplicatedKVS_dist_backup_2159579740_/bud_
     ..
     Finished in 4.366793 seconds.
     
@@ -68,8 +80,8 @@ Then I ran the unit test:
 
 Then I ran the visualization utility:
 
-    $ ruby budvis TC_BestEffortReplicatedKVS_dist_primary_2160259460_/
+    $ budvis DBM_BestEffortReplicatedKVS_dist_primary_2160259460_/
 
 And finally opened the (chronological) first output file:
 
-    $ open -a /Applications/Google\ Chrome.app/ TC_BestEffortReplicatedKVS_dist_primary_2160259460_/tm_0_expanded.svg
+    $ open -a /Applications/Google\ Chrome.app/ DBM_BestEffortReplicatedKVS_dist_primary_2160259460_/tm_0_expanded.svg

data/examples/chat/chat.rb

@@ -24,9 +24,9 @@ class ChatClient
     stdio <~ mcast { |m| [pretty_print(m.val)] }
   end
 
-  # format chat messages with timestamp on the right of the screen
+  # format chat messages with color and timestamp on the right of the screen
   def pretty_print(val)
-    str = val[1].to_s + ": " + (val[3].to_s || '')
+    str = "\033[34m"+val[1].to_s + ": " + "\033[31m" + (val[3].to_s || '') + "\033[0m"
     pad = "(" + val[2].to_s + ")"
     return str + " "*[66 - str.length,2].max + pad
   end
@@ -34,12 +34,7 @@ end
 
 
 
-if ARGV.length == 2
-  server = ARGV[1]
-else
-  server = ChatProtocol::DEFAULT_ADDR
-end
-
+server = (ARGV.length == 2) ? ARGV[1] : ChatProtocol::DEFAULT_ADDR
 puts "Server address: #{server}"
-program = ChatClient.new(ARGV[0], server, :read_stdin => true)
+program = ChatClient.new(ARGV[0], server, :stdin => $stdin)
 program.run_fg

data/examples/chat/chat_server.rb

@@ -14,15 +14,8 @@ class ChatServer
   end
 end
 
-
-
 # ruby command-line wrangling
-if ARGV.first
-  addr = ARGV.first
-else
-  addr = ChatProtocol::DEFAULT_ADDR
-end
-
+addr = ARGV.first ? ARGV.first : ChatProtocol::DEFAULT_ADDR
 ip, port = addr.split(":")
 puts "Server address: #{ip}:#{port}"
 program = ChatServer.new(:ip => ip, :port => port.to_i)

data/examples/deploy/deploy_ip_port

@@ -0,0 +1 @@
+67.188.223.50:5555

data/examples/deploy/keys.rb

@@ -0,0 +1,5 @@
+access_key_id <= [["AKIAJZHUX3MXJLQULOLQ"]]
+secret_access_key <= [['8Udv0/qqHIri7A8HxaIJB0E9h89gu+NsgKMHf/5i']]
+key_name <= [["nrc"]]
+ec2_key_location <= [["/Users/neilc/.ssh/nrc.pem"]]
+

data/examples/deploy/tokenring-ec2.rb

@@ -1,26 +1,26 @@
 require 'rubygems'
 require 'bud'
-require 'tokenring'
 require 'bud/deploy/ec2deploy'
+require 'tokenring'
 
-class RingLocal
+class RingEC2
   include Bud
   include TokenRing
   include EC2Deploy
 
   deploystrap do
+    raise "keys.rb must exist in the current directory" unless File.exists? "keys.rb"
+    eval(IO.read('keys.rb'), binding)
     node_count << [10]
-    eval(IO.read('keys.rb'), binding) if File.exists?('keys.rb')
     ruby_command << ["ruby tokenring-ec2.rb"]
     init_dir << ["."]
   end
-
 end
 
 ip, port = ARGV[0].split(':')
 ext_ip, ext_port = ARGV[1].split(':')
-RingLocal.new(:ip => ip,
-              :ext_ip => ext_ip,
-              :port => port,
-              :ext_port => ext_port,
-              :deploy => ARGV[2]).run_fg
+RingEC2.new(:ip => ip,
+            :port => port,
+            :ext_ip => ext_ip,
+            :ext_port => ext_port,
+            :deploy => ARGV[2]).run_fg

data/examples/deploy/{tokenring-local.rb → tokenring-fork.rb}

@@ -1,17 +1,15 @@
 require 'rubygems'
 require 'bud'
 require 'tokenring'
-require 'bud/deploy/localdeploy'
 
-class RingLocal
+class RingFork
   include Bud
   include TokenRing
-  include LocalDeploy
+  include ForkDeploy
 
   deploystrap do
     node_count << [10]
   end
-
 end
 
-RingLocal.new(:deploy => true).run_fg
+RingFork.new(:deploy => true).run_fg

data/examples/deploy/tokenring-thread.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bud'
+require 'tokenring'
+
+class RingThread
+  include Bud
+  include TokenRing
+  include ThreadDeploy
+
+  deploystrap do
+    node_count << [10]
+  end
+end
+
+RingThread.new(:deploy => true).run_fg

data/examples/deploy/tokenring.rb

@@ -2,38 +2,46 @@ require 'rubygems'
 require 'bud'
 
 module TokenRing
-
   state do
-    table :next_node, [] => [:node]
+    table :next_node, [] => [:addr]
+    channel :next_node_chan, [:@loc] => [:next]
+    scratch :send_next_node, [:node, :next]
+    table :sent_next_node, [:addr]
     channel :token, [:@loc]
     table :token_persist, [:loc]
   end
 
   bloom :make_ring do
-    initial_data <= node.map do |n|
-      # Calculate the successor node (splice deployer into the list)
-      succ_id = (n.uid + 1) % (node_count[[]].num + 1)
-      succ_node = (succ_id == node_count[[]].num) ? [ip_port] :
-        [node[[succ_id]].node]
-      [ n.uid, :next_node, [ succ_node ] ]
+    # Once a node and its successor have both been computed, send a message to
+    # the node with the address of its successor
+    send_next_node <= (node * node * node_ready).combos do |n1, n2, nr|
+      succ_id = (n1.uid + 1) % node_count[[]].num
+      if n2.uid == succ_id and not sent_next_node.has_key? [n1.uid]
+        [n1.addr, n2.addr]
+      end
     end
+    next_node_chan <~ send_next_node
+    sent_next_node <+ send_next_node {|n| [n.node]}
 
-    # Initial data for deployer (not part of "node" set)
-    next_node <= node.map do
-      [node[[0]].node] if @options[:deploy]
-    end
-    token <~ node.map do
-      [node[[0]].node] if @options [:deploy]
+    next_node <= next_node_chan {|n| [n.next]}
+
+    # The deployer sends an initial message to the node with ID 0
+    token <~ (node_ready * node).rights(:uid => :uid) do |n|
+      [n.addr] if (@options[:deploy] and n.uid == 0)
     end
   end
 
   bloom :pass_token do
     # Persist the token for as long as necessary
     token_persist <= token
-    token_persist <- join([token_persist, next_node]).map {|t,_| [t.loc]}
+    token_persist <- (token_persist * next_node).lefts
     # Pass on the token
-    token <~ join([token_persist, next_node]).map {[next_node[[]].node]}
-    stdio <~ token.map {["#{ip_port}: Got token!"]}
+    token <~ (token_persist * next_node).rights do |nn|
+      [nn.addr]
+    end
   end
 
+  bloom :print_token do
+    stdio <~ token {["#{@node_id}: Got token! (@ #{ip_port})"]}
+  end
 end

data/lib/bud/aggs.rb

@@ -4,9 +4,21 @@ module Bud
     def init(val)
       val
     end
+    
+    # In order to support argagg, trans must return a pair:
+    #  1. the running aggregate state
+    #  2. a flag to indicate what the caller should do with the input tuple for argaggs
+    #     a. :ignore tells the caller to ignore this input
+    #     b. :keep tells the caller to save this input
+    #     c. :replace tells the caller to keep this input alone
+    #     d. [:delete, t1, t2, ...] tells the caller to delete the remaining tuples
+    #  For things that do not descend from ArgExemplary, the 2nd part can simply be nil.
+    def trans(the_state, val)
+      return the_state, :ignore
+    end
 
-    def final(state)
-      state
+    def final(the_state)
+      the_state
     end
   end
 
@@ -18,17 +30,21 @@ module Bud
   # is discarded in favor of another, v can never be the final result
 
   class ArgExemplary < Agg #:nodoc: all
-    def tie(state, val)
-      (state == val)
+    def tie(the_state, val)
+      (the_state == val)
     end
-    def final(state)
-      state
+    def final(the_state)
+      the_state
     end
   end
 
   class Min < ArgExemplary #:nodoc: all
-    def trans(state, val)
-      state < val ? state : val
+    def trans(the_state, val)
+      if the_state < val 
+        return the_state, :ignore
+      else 
+        return val, :replace
+      end
     end
   end
   # exemplary aggregate method to be used in Bud::BudCollection.group.  
@@ -38,8 +54,12 @@ module Bud
   end
 
   class Max < ArgExemplary #:nodoc: all
-    def trans(state, val)
-      state > val ? state : val
+    def trans(the_state, val)
+      if the_state > val
+        return the_state, :ignore
+      else
+        return val, :replace
+      end
     end
   end
   # exemplary aggregate method to be used in Bud::BudCollection.group.  
@@ -49,10 +69,14 @@ module Bud
   end
 
   class Choose < ArgExemplary #:nodoc: all
-    def trans(state, val)
-      state.nil? ? val : state
-    end
-    def tie(state, val)
+    def trans(the_state, val)
+      if the_state.nil?
+        return val, :replace
+      else
+        return the_state, :ignore
+      end
+    end
+    def tie(the_state, val)
       false
     end
   end
@@ -62,10 +86,46 @@ module Bud
   def choose(x)
     [Choose.new, x]
   end
+  
+  class ChooseRand < ArgExemplary #:nodoc: all
+    @@reservoir_size = 1 # Vitter's reservoir sampling, k = 1
+    def init(x=nil)
+      the_state = {:cnt => 1, :vals => [x]}
+    end
+    
+    def trans(the_state, val)
+      the_state[:cnt] += 1
+      if the_state[:cnt] < @@reservoir_size
+        the_state[:vals] << val
+        return the_state, :keep
+      else
+        j = rand(the_state[:cnt])
+        if j < @@reservoir_size
+          old_tup = the_state[:vals][j]
+          the_state[:vals][j] = val 
+          return the_state, [:delete, old_tup]
+        else
+          return the_state, :keep
+        end
+      end
+    end
+    def tie(the_state, val)
+      true
+    end
+    def final(the_state)
+      the_state[:vals][rand(the_state[@@reservoir_size])]
+    end
+  end
+
+  # exemplary aggregate method to be used in Bud::BudCollection.group.  
+  # randomly chooses among x entries being aggregated.
+  def choose_rand(x=nil)
+    [ChooseRand.new]
+  end
 
   class Sum < Agg #:nodoc: all
-    def trans(state, val)
-      state + val
+    def trans(the_state, val)
+      return the_state + val, nil
     end
   end
   
@@ -79,8 +139,8 @@ module Bud
     def init(x=nil)
       1
     end
-    def trans(state, x=nil)
-      state + 1
+    def trans(the_state, x=nil)
+      return the_state + 1, nil
     end
   end
   
@@ -94,12 +154,13 @@ module Bud
     def init(val)
       [val, 1]
     end
-    def trans(state, val)
-      retval = [state[0] + val]
-      retval << (state[1] + 1)
+    def trans(the_state, val)
+      retval = [the_state[0] + val]
+      retval << (the_state[1] + 1)
+      return retval, nil
     end
-    def final(state)
-      state[0]*1.0 / state[1]
+    def final(the_state)
+      the_state[0]*1.0 / the_state[1]
     end
   end
   
@@ -113,8 +174,9 @@ module Bud
     def init(x)
       [x]
     end
-    def trans(state, val)
-      state << val
+    def trans(the_state, val)
+      the_state << val
+      return the_state, nil
     end
   end
   

data/lib/bud/bud_meta.rb

@@ -17,16 +17,19 @@ class BudMeta #:nodoc: all
     stratum_map = binaryrel2map(@bud_instance.t_stratum)
 
     rewritten_strata = Array.new(top_stratum + 2) { [] }
+    no_attr_rewrite_strata = Array.new(top_stratum + 2) { [] }
     @bud_instance.t_rules.each do |d|
       if d.op.to_s == '<='
-        # deductive rules are assigned to strata based on
-        # the basic datalog stratification algorithm
+        # Deductive rules are assigned to strata based on the basic Datalog
+        # stratification algorithm
         belongs_in = stratum_map[d.lhs]
         belongs_in ||= 0
         rewritten_strata[belongs_in] << d.src
+        no_attr_rewrite_strata[belongs_in] << d.orig_src
       else
-        # all temporal rules are placed in the last stratum
+        # All temporal rules are placed in the last stratum
         rewritten_strata[top_stratum + 1] << d.src
+        no_attr_rewrite_strata[top_stratum + 1] << d.orig_src
       end
     end
 
@@ -41,7 +44,7 @@ class BudMeta #:nodoc: all
     end
     dump_rewrite(rewritten_strata) if @bud_instance.options[:dump_rewrite]
 
-    return rewritten_strata
+    return rewritten_strata, no_attr_rewrite_strata
   end
 
   def binaryrel2map(rel)
@@ -82,18 +85,25 @@ class BudMeta #:nodoc: all
 
     pt = Unifier.new.process(parse_tree)
     pp pt if @bud_instance.options[:dump_ast]
-    begin
-      check_rule_ast(pt)
-    rescue Exception => e
-      # try to "generate" the source code associated with the problematic
-      # block, so as to generate a more meaningful error message.
-      # if this parse fails, return the original exception (not the new one).
+
+    rv = check_rule_ast(pt)
+    unless rv.nil?
+      if rv.class <= Sexp
+        error_pt = rv
+        error_msg = "Parse error"
+      else
+        error_pt, error_msg = rv
+      end
+
+      # try to "generate" the source code associated with the problematic block,
+      # so as to generate a more meaningful error message.
       begin
-        code = Ruby2Ruby.new.process(pt)
-      rescue Exception => sub_e
-        raise e, "Error parsing rule block #{block_name}.  Could not extract source."
+        code = Ruby2Ruby.new.process(Marshal.load(Marshal.dump(error_pt)))
+        src_msg = "\nCode: #{code}"
+      rescue Exception
+        src_msg = ""
       end
-      raise e, "Error parsing rule block #{block_name}:\n#{code}"
+      raise Bud::CompileError, "#{error_msg} in rule block \"#{block_name}\"#{src_msg}"
     end
 
     rewriter = RuleRewriter.new(seed, @bud_instance)
@@ -103,37 +113,38 @@ class BudMeta #:nodoc: all
 
   # Perform some basic sanity checks on the AST of a rule block. We expect a
   # rule block to consist of a :defn, a nested :scope, and then a sequence of
-  # statements. Each statement is a :call node.
+  # statements. Each statement is a :call node. Returns nil (no error found), a
+  # Sexp (containing an error), or a pair of [Sexp, error message].
   def check_rule_ast(pt)
     # :defn format: node tag, block name, args, nested scope
-    raise Bud::CompileError if pt.sexp_type != :defn
+    return pt if pt.sexp_type != :defn
     scope = pt[3]
-    raise Bud::CompileError if scope.sexp_type != :scope
+    return pt if scope.sexp_type != :scope
     block = scope[1]
 
     block.each_with_index do |n,i|
       if i == 0
-        raise Bud::CompileError if n != :block
+        return pt if n != :block
         next
       end
 
-      raise Bud::CompileError if n.sexp_type != :call
-      raise Bud::CompileError unless n.length == 4
+      # Check for a common case
+      if n.sexp_type == :lasgn
+        return [n, "Illegal operator: '='"]
+      end
+      return pt unless n.sexp_type == :call and n.length == 4
 
       # Rule format: call tag, lhs, op, rhs
       tag, lhs, op, rhs = n
 
       # Check that LHS references a named collection
-      raise Bud::CompileError if lhs.nil? or lhs.sexp_type != :call
+      return n if lhs.nil? or lhs.sexp_type != :call
       lhs_name = lhs[2]
       unless @bud_instance.tables.has_key? lhs_name.to_sym
-        raise Bud::CompileError, "Table does not exist: '#{lhs_name}'"
+        return [n, "Table does not exist: '#{lhs_name}'"]
       end
 
-      # Check that op is a legal Bloom operator
-      unless [:<, :<=].include? op
-        raise Bud::CompileError, "Illegal operator: '#{op}'"
-      end
+      return [n, "Illegal operator: '#{op}'"] unless [:<, :<=].include? op
 
       # Check superator invocation. A superator that begins with "<" is parsed
       # as a call to the binary :< operator. The right operand to :< is a :call
@@ -143,16 +154,17 @@ class BudMeta #:nodoc: all
       # XXX: We don't check for illegal superators (e.g., "<--"). That would be
       # tricky, because they are encoded as a nested unary op in the rule body.
       if op == :<
-        raise Bud::CompileError unless rhs.sexp_type == :arglist
+        return n unless rhs.sexp_type == :arglist
         body = rhs[1]
-        raise Bud::CompileError unless body.sexp_type == :call
+        return n unless body.sexp_type == :call
         op_tail = body[2]
-        raise Bud::CompileError unless [:~, :-@, :+@].include? op_tail
+        return n unless [:~, :-@, :+@].include? op_tail
         rhs_args = body[3]
-        raise Bud::CompileError unless rhs_args.sexp_type == :arglist
-        raise Bud::CompileError if rhs_args.length != 1
+        return n if rhs_args.sexp_type != :arglist or rhs_args.length != 1
       end
     end
+
+    return nil # No errors found
   end
 
   def stratify
@@ -162,6 +174,11 @@ class BudMeta #:nodoc: all
 
     # Copy computed data back into Bud runtime
     strat.stratum.each {|s| @bud_instance.t_stratum << s}
+    @bud_instance.stratum_collection_map = strat.stratum.inject({}) do |memo, t|
+      memo[t[1]] ||= []
+      memo[t[1]] << t[0]
+      memo
+    end
     strat.depends_tc.each {|d| @bud_instance.t_depends_tc << d}
     strat.cycle.each {|c| @bud_instance.t_cycle << c}
     if strat.top_strat.length > 0