bud 0.0.3 → 0.0.4

data/lib/bud/rewrite.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'ruby2ruby'
 
-class RuleRewriter < Ruby2Ruby # :nodoc: all 
+class RuleRewriter < Ruby2Ruby # :nodoc: all
   attr_accessor :rule_indx, :rules, :depends
 
   def initialize(seed, bud_instance)
@@ -9,8 +9,9 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     @ops = {:<< => 1, :< => 1, :<= => 1}
     @monotonic_whitelist = {
           :== => 1, :+ => 1, :<= => 1, :- => 1, :< => 1, :> => 1,
-          :* => 1, :pairs => 1, :matches => 1, :flatten => 1,
-          :lefts => 1, :rights => 1, :map => 1, :pro => 1, :schema => 1
+          :* => 1, :pairs => 1, :matches => 1, :combos => 1, :flatten => 1,
+          :lefts => 1, :rights => 1, :map => 1, :flat_map => 1, :pro => 1,
+          :schema => 1, :keys => 1, :values => 1, :payloads => 1, :~ => 1
       }
     @temp_ops = {:-@ => 1, :~ => 1, :+@ => 1}
     @tables = {}
@@ -22,6 +23,16 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     super()
   end
 
+  def call_is_attr_deref?(recv, op)
+    if recv.first == :call and @bud_instance.tables.has_key? recv[2]
+      schema = @bud_instance.send(recv[2]).schema
+      if schema and schema.include? op
+        return true
+      end
+    end
+    return false
+  end
+
   def process_call(exp)
     recv, op, args = exp
     if recv.nil? and args == s(:arglist) and @collect
@@ -32,10 +43,11 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       do_rule(exp)
     else
       if recv and recv.class == Sexp
-        # ignore accessors of iterator variables
-        unless recv.first == :lvar
-          @nm = true if op == :-@
-          @nm = true unless (@monotonic_whitelist[op] or @bud_instance.tables.has_key? op)
+        # for CALM analysis, mark deletion rules as non-monotonic
+        @nm = true if op == :-@
+        # don't worry about monotone ops, table names, table.attr calls, or accessors of iterator variables
+        unless @monotonic_whitelist[op] or @bud_instance.tables.has_key? op or call_is_attr_deref?(recv, op) or recv.first == :lvar
+          @nm = true
         end
       end
       if @temp_ops[op]
@@ -52,22 +64,27 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     return rhs
   end
 
-  def record_rule(lhs, op, rhs)
-    rule_txt = "#{lhs} #{op} (#{rhs})"
+  def reset_instance_vars
+    @tables = {}
+    @nm = false
+    @temp_op = nil
+  end
+
+  def record_rule(lhs, op, rhs_pos, rhs)
+    rule_txt_orig = "#{lhs} #{op} (#{rhs})"
+    rule_txt = "#{lhs} #{op} (#{rhs_pos})"
     if op == :<
       op = "<#{@temp_op}"
     else
       op = op.to_s
     end
 
-    @rules << [@rule_indx, lhs, op, rule_txt]
+    @rules << [@rule_indx, lhs, op, rule_txt, rule_txt_orig]
     @tables.each_pair do |t, non_monotonic|
       @depends << [@rule_indx, lhs, op, t, non_monotonic]
     end
 
-    @tables = {}
-    @nm = false
-    @temp_op = nil
+    reset_instance_vars
     @rule_indx += 1
   end
 
@@ -83,17 +100,28 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   def do_rule(exp)
     lhs = process exp[0]
     op = exp[1]
-    rhs = collect_rhs(map2pro(exp[2]))
-    record_rule(lhs, op, rhs)
+    pro_rules = map2pro(exp[2])
+    if @bud_instance.options[:no_attr_rewrite]
+      rhs = collect_rhs(pro_rules)
+      rhs_pos = rhs
+    else
+      # need a deep copy of the rules so we can keep a version without AttrName Rewrite
+      pro_rules2 = Marshal.load(Marshal.dump(pro_rules))
+      rhs = collect_rhs(pro_rules)
+      reset_instance_vars
+      rhs_pos = collect_rhs(AttrNameRewriter.new(@bud_instance).process(pro_rules2))
+    end
+    record_rule(lhs, op, rhs_pos, rhs)
     drain(exp)
   end
 
   # Look for top-level map on a base-table on rhs, and rewrite to pro
   def map2pro(exp)
     if exp[1] and exp[1][0] and exp[1][0] == :iter \
-       and exp[1][1] and exp[1][1][1] == :call \
-       and exp[1][1][2] == :map
-      exp[1][1][2] = :pro
+      and exp[1][1] and exp[1][1][1] and exp[1][1][1][0] == :call
+      if exp[1][1][2] == :map
+        exp[1][1][2] = :pro
+      end
     end
     exp
   end
@@ -104,6 +132,77 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   end
 end
 
+# Rewrite named-column refs to positional refs
+class AttrNameRewriter < SexpProcessor # :nodoc: all
+  def initialize(bud_instance)
+    super()
+    self.require_empty = false
+    self.expected = Sexp
+    @iterhash ||= {}
+    @collnames = []
+    @bud_instance = bud_instance
+  end
+
+  # some icky special-case parsing to find mapping between collection names and iter vars
+  def process_iter(exp)
+    if exp[1] and exp[1][0] == :call
+      gather_collection_names(exp[1])
+
+      # now find iter vars and match up
+      if exp[2] and exp[2][0] == :lasgn and @collnames.size == 1 #single-table iter
+        raise Bud::CompileError, "nested redefinition of block variable \"#{exp[2][1]}\" not allowed" if @iterhash[exp[2][1]]
+        @iterhash[exp[2][1]] = @collnames[0]
+      elsif exp[2] and exp[2][0] == :lasgn and @collnames.size > 1 # join iter with lefts/rights
+        if exp[1] and exp[1][2] == :lefts
+          @iterhash[exp[2][1]] = @collnames[0] 
+        elsif exp[1] and exp[1][2] == :rights
+          @iterhash[exp[2][1]] = @collnames[1]
+        else
+          raise Bud::CompileError, "nested redefinition of block variable \"#{exp[2][1]}\" not allowed" if @iterhash[exp[2][1]]
+        end
+      elsif exp[2] and exp[2][0] == :masgn and not @collnames.empty? # join iter
+        next unless exp[2][1] and exp[2][1][0] == :array
+        @collnames.each_with_index do |c, i|
+          next unless exp[2][1][i+1] and exp[2][1][i+1][0] == :lasgn
+          @iterhash[exp[2][1][i+1][1]] = c
+        end
+      end
+    end
+    (1..(exp.length-1)).each {|i| exp[i] = process(exp[i])}
+    exp
+  end
+
+  def gather_collection_names(exp)
+    if exp[0] == :call and exp[1].nil?
+      @collnames << exp[2]
+    else
+      exp.each { |e| gather_collection_names(e) if e and e.class <= Sexp }
+    end
+  end
+
+  def process_call(exp)
+    call, recv, op, args = exp
+
+    if recv and recv.class == Sexp and recv.first == :lvar and recv[1] and @iterhash[recv[1]]
+      if @bud_instance.respond_to?(@iterhash[recv[1]])
+        if @bud_instance.send(@iterhash[recv[1]]).class <= Bud::BudCollection
+          schema = @bud_instance.send(@iterhash[recv[1]]).schema
+          if op != :[] and @bud_instance.send(@iterhash[recv[1]]).respond_to?(op)
+            # if the op is an attribute name in the schema, col is its index
+            col = schema.index(op) unless schema.nil?
+            unless col.nil?
+              op = :[]
+              args = s(:arglist, s(:lit, col))
+            end
+          end
+        end
+        return s(call, recv, op, args)
+      end
+    end
+    return s(call, process(recv), op, process(args))
+  end
+end
+
 # Given a table of renames from x => y, replace all calls to "x" with calls to
 # "y" instead. We don't try to handle shadowing due to block variables: if a
 # block references a block variable that shadows an identifier in the rename
@@ -234,8 +333,8 @@ class TempExpander < SexpProcessor # :nodoc: all
         end
 
         # temp declarations are misparsed if the RHS contains certain constructs
-        # (e.g., old-style join syntax, group, "do |f| ... end" rather than
-        # "{|f| ... }").  Rewrite to correct the misparsing.
+        # (e.g., group, "do |f| ... end" rather than "{|f| ... }").  Rewrite to
+        # correct the misparsing.
         if n.sexp_type == :iter
           iter_body = n.sexp_body
 
@@ -299,13 +398,12 @@ class TempExpander < SexpProcessor # :nodoc: all
 end
 
 class DefnRenamer < SexpProcessor # :nodoc: all
-  def initialize(old_mod_name, new_mod_name, local_name)
+  def initialize(local_name, rename_tbl)
     super()
     self.require_empty = false
     self.expected = Sexp
-    @old_mod_name = old_mod_name
-    @new_mod_name = new_mod_name
     @local_name = local_name
+    @rename_tbl = rename_tbl
   end
 
   def process_defn(exp)
@@ -313,18 +411,21 @@ class DefnRenamer < SexpProcessor # :nodoc: all
     name_s = name.to_s
 
     if name_s =~ /^__bootstrap__.+$/
-      name = name_s.sub(/^(__bootstrap__)(.+)$/, "\\1#{@local_name}__\\2").to_sym
+      new_name = name_s.sub(/^(__bootstrap__)(.+)$/, "\\1#{@local_name}__\\2")
     elsif name_s =~ /^__state\d+__/
-      name = name_s.sub(/^(__state\d+__)(.*)$/, "\\1#{@local_name}__\\2").to_sym
+      new_name = name_s.sub(/^(__state\d+__)(.*)$/, "\\1#{@local_name}__\\2")
     elsif name_s =~ /^__bloom__.+$/
-      name = name_s.sub(/^(__bloom__)(.+)$/, "\\1#{@local_name}__\\2").to_sym
+      new_name = name_s.sub(/^(__bloom__)(.+)$/, "\\1#{@local_name}__\\2")
     else
-      name = "#{@local_name}__#{name_s}".to_sym
+      new_name = "#{@local_name}__#{name_s}"
     end
 
+    new_name = new_name.to_sym
+    @rename_tbl[name] = new_name
+
     # Note that we don't bother to recurse further into the AST: we're only
     # interested in top-level :defn nodes.
-    s(tag, name, args, scope)
+    s(tag, new_name, args, scope)
   end
 end
 
@@ -333,13 +434,13 @@ module ModuleRewriter # :nodoc: all
   # "import_site", bound to "local_name" at the import site. We implement this
   # by converting the imported module into an AST and rewriting the AST like so:
   #
-  #   (a) the module name is mangled to include the local bind name and the
-  #       importer
-  #   (b) instance method names are mangled to include the local bind name
-  #   (c) state defined by the module is mangled to include the local bind name
-  #   (d) statements in the module are rewritten to reference the mangled names
-  #   (e) statements in the module that reference sub-modules are rewritten to
-  #       reference the mangled name of the submodule.
+  #   (a) statements in the module that reference sub-modules are rewritten to
+  #       reference the mangled name of the submodule
+  #   (b) the module name is mangled to include the local bind name and the
+  #       import site
+  #   (c) instance method names are mangled to include the local bind name
+  #   (d) collection names are mangled to include the local bind name
+  #   (e) statements in the module are rewritten to reference the mangled names
   #
   # We then convert the rewritten AST back into Ruby source code using Ruby2Ruby
   # and eval() it to define a new module. We return the name of that newly
@@ -352,7 +453,9 @@ module ModuleRewriter # :nodoc: all
     ast = ast_flatten_nested_refs(ast, mod.bud_import_table)
     ast = ast_process_temps(ast, mod)
     ast, new_mod_name = ast_rename_module(ast, import_site, mod, local_name)
-    rename_tbl = ast_rename_state(ast, local_name)
+    rename_tbl = {}
+    ast = ast_rename_methods(ast, local_name, rename_tbl)
+    ast = ast_rename_state(ast, local_name, rename_tbl)
     ast = ast_update_refs(ast, rename_tbl)
 
     str = Ruby2Ruby.new.process(ast)
@@ -377,9 +480,9 @@ module ModuleRewriter # :nodoc: all
   # the AST is returned in a different format than we expect. In particular, we
   # expect that the methods from any modules included in the target module will
   # be "inlined" into the dumped AST; ParseTree > 3.0.7 adds an "include"
-  # statement to the AST instead. In the long run we should adapt the module
-  # rewrite system to work with ParseTree > 3.0.7 and get rid of this code, but
-  # that will require further changes.
+  # statement to the AST instead. In the long run we should probably adapt the
+  # module rewrite system to work with ParseTree > 3.0.7 and get rid of this
+  # code, but that will require further changes.
   def self.get_raw_parse_tree(klass)
     pt = RawParseTree.new(false)
     klassname = klass.name
@@ -444,9 +547,9 @@ module ModuleRewriter # :nodoc: all
   end
 
   # Rename the given module's name to be a mangle of import site, imported
-  # module, and local bind name. We also need to rename special "state" and
-  # "bootstrap" methods. We also rename "bloom" methods, but we can just mangle
-  # with the local bind name for those.
+  # module, and local bind name. We also rename all the instance methods defined
+  # in the module to include the local bind name (including the special "state",
+  # "bootstrap", and "bloom" methods).
   def self.ast_rename_module(ast, importer, importee, local_name)
     mod_name = ast.sexp_body.first
     raise Bud::BudError if mod_name.to_s != importee.to_s
@@ -458,21 +561,21 @@ module ModuleRewriter # :nodoc: all
     new_name = "#{importer_name}__#{importee_name}__#{local_name}"
     ast[1] = new_name.to_sym
 
-    dr = DefnRenamer.new(mod_name, new_name, local_name)
-    new_ast = dr.process(ast)
-
     # XXX: it would be nice to return a Module, rather than a string containing
     # the Module's name. Unfortunately, I can't see how to do that.
-    return [new_ast, new_name]
+    return [ast, new_name]
+  end
+
+  def self.ast_rename_methods(ast, local_name, rename_tbl)
+    DefnRenamer.new(local_name, rename_tbl).process(ast)
   end
 
   # Mangle the names of all the collections defined in state blocks found in the
   # given module's AST. Returns a table mapping old => new names.
-  def self.ast_rename_state(ast, local_name)
+  def self.ast_rename_state(ast, local_name, rename_tbl)
     # Find all the state blocks in the AST
     raise Bud::BudError unless ast.sexp_type == :module
 
-    rename_tbl = {}
     ast.sexp_body.each do |b|
       next unless b.class <= Sexp
       next if b.sexp_type != :defn
@@ -508,7 +611,7 @@ module ModuleRewriter # :nodoc: all
       end
     end
 
-    return rename_tbl
+    return ast
   end
 
   def self.ast_update_refs(ast, rename_tbl)

data/lib/bud/server.rb

@@ -37,6 +37,7 @@ module Bud
         # other Bud instances in the same process will crash). Ignoring the
         # error isn't best though -- we should do better (#74).
         puts "Exception handling network message (channel '#{obj[0]}'): #{$!}"
+        puts caller.join("\n")
       end
     end
   end

data/lib/bud/state.rb

@@ -32,7 +32,7 @@ module Bud
     false
   end
 
-  # declare a scratch collection to be an input or output interface
+  # declare a transient collection to be an input or output interface
   def interface(mode, name, schema=nil)
     t_provides << [name.to_s, mode]
     scratch(name, schema)
@@ -44,7 +44,7 @@ module Bud
     @tables[name] = Bud::BudTable.new(name, self, schema)
   end
 
-  # declare a transient (1-timestep) collection.  default schema <tt>[:key] => [:val]</tt>
+  # declare a transient collection.  default schema <tt>[:key] => [:val]</tt>
   def scratch(name, schema=nil)
     define_collection(name)
     @tables[name] = Bud::BudScratch.new(name, self, schema)
@@ -58,10 +58,19 @@ module Bud
   end
 
   # declare a transient network collection.  default schema <tt>[:address, :val] => []</tt>
-  def channel(name, schema=nil)
+  def channel(name, schema=nil, loopback=false)
     define_collection(name)
-    @tables[name] = Bud::BudChannel.new(name, self, schema)
-    @channels[name] = @tables[name].locspec_idx
+    @tables[name] = Bud::BudChannel.new(name, self, schema, loopback)
+    @channels[name] = @tables[name]
+  end
+
+  # declare a transient network collection that delivers facts back to the
+  # current Bud instance. This is syntax sugar for a channel that always
+  # delivers to the IP/port of the current Bud instance. Default schema
+  # <tt>[:key] => [:val]</tt>
+  def loopback(name, schema=nil)
+    schema ||= {[:key] => [:val]}
+    channel(name, schema, true)
   end
 
   # declare a collection to be read from +filename+.  rhs of statements only
@@ -74,11 +83,9 @@ module Bud
   # rhs of statements only.
   def periodic(name, period=1)
     define_collection(name)
-    # stick with default schema -- [:key] => [:val]
-    @tables[name] = Bud::BudPeriodic.new(name, self)
     raise BudError if @periodics.has_key? [name]
-    t = [name, gen_id, period]
-    @periodics << t
+    @periodics << [name, gen_id, period]
+    @tables[name] = Bud::BudPeriodic.new(name, self)
   end
 
   def terminal(name) # :nodoc: all
@@ -88,8 +95,8 @@ module Bud
       @terminal = name
     end
     define_collection(name)
-    @channels[name] = nil
     @tables[name] = Bud::BudTerminal.new(name, [:line], self)
+    @channels[name] = @tables[name]
   end
 
   # declare a TokyoCabinet table
@@ -98,6 +105,13 @@ module Bud
     @tables[name] = Bud::BudTcTable.new(name, self, schema)
     @tc_tables[name] = @tables[name]
   end
+  
+  # declare a dbm table
+  def dbm_table(name, schema=nil)
+    define_collection(name)
+    @tables[name] = Bud::BudDbmTable.new(name, self, schema)
+    @dbm_tables[name] = @tables[name]
+  end
 
   # declare an Apache ZooKeeper table
   def zktable(name, path, addr="localhost:2181")

data/lib/bud/storage/dbm.rb

@@ -0,0 +1,170 @@
+require 'dbm'
+
+module Bud
+  # Persistent table implementation based on ndbm.
+  class BudDbmTable < BudCollection # :nodoc: all
+    def initialize(name, bud_instance, given_schema)
+      dbm_dir = bud_instance.options[:dbm_dir]
+      raise BudError, "dbm support must be enabled via 'dbm_dir'" unless dbm_dir
+      unless File.exists?(dbm_dir)
+        Dir.mkdir(dbm_dir)
+        puts "Created directory: #{dbm_dir}" unless bud_instance.options[:quiet]
+      end
+
+      dirname = "#{dbm_dir}/bud_#{bud_instance.port}"
+      unless File.exists?(dirname)
+        Dir.mkdir(dirname)
+        puts "Created directory: #{dirname}" unless bud_instance.options[:quiet]
+      end
+
+      super(name, bud_instance, given_schema)
+      @to_delete = []
+
+      db_fname = "#{dirname}/#{name}.dbm"
+      flags = DBM::WRCREAT
+      if bud_instance.options[:dbm_truncate] == true
+        flags |= DBM::NEWDB
+      end
+      @dbm = DBM.open(db_fname, 0666, flags)
+      if @dbm.nil?
+        raise BudError, "Failed to open dbm database '#{db_fname}': #{@dbm.errmsg}"
+      end
+    end
+
+    def init_storage
+      # XXX: we can't easily use the @storage infrastructure provided by
+      # BudCollection; issue #33
+      @storage = nil
+    end
+
+    def [](key)
+      key_s = MessagePack.pack(key)
+      val_s = @dbm[key_s]
+      if val_s
+        return make_tuple(key, MessagePack.unpack(val_s))
+      else
+        return @delta[key]
+      end
+    end
+
+    def has_key?(k)
+      key_s = MessagePack.pack(k)
+      return true if @dbm.has_key? key_s
+      return @delta.has_key? k
+    end
+
+    def include?(tuple)
+      key = @key_colnums.map{|k| tuple[k]}
+      value = self[key]
+      return (value == tuple)
+    end
+
+    def make_tuple(k_ary, v_ary)
+      t = Array.new(k_ary.length + v_ary.length)
+      @key_colnums.each_with_index do |k,i|
+        t[k] = k_ary[i]
+      end
+      val_cols.each_with_index do |c,i|
+        t[schema.index(c)] = v_ary[i]
+      end
+      tuple_accessors(t)
+    end
+
+    def each(&block)
+      each_from([@delta], &block)
+      each_storage(&block)
+    end
+
+    def each_from(bufs, &block)
+      bufs.each do |b|
+        if b == @storage then
+          each_storage(&block)
+        else
+          b.each_value do |v|
+            yield v
+          end
+        end
+      end
+    end
+
+    def each_storage(&block)
+      @dbm.each do |k,v|
+        k_ary = MessagePack.unpack(k)
+        v_ary = MessagePack.unpack(v)
+        yield make_tuple(k_ary, v_ary)
+      end
+    end
+
+    def flush
+    end
+
+    def close
+      @dbm.close unless @dbm.nil?
+      @dbm = nil
+    end
+
+    def merge_to_db(buf)
+      buf.each do |key,tuple|
+        merge_tuple(key, tuple)
+      end
+    end
+
+    def merge_tuple(key, tuple)
+      val = val_cols.map{|c| tuple[schema.index(c)]}
+      key_s = MessagePack.pack(key)
+      val_s = MessagePack.pack(val)
+      if @dbm.has_key?(key_s)
+        old_tuple = self[key]
+        raise_pk_error(tuple, old_tuple) if tuple != old_tuple
+      else
+        @dbm[key_s] = val_s
+      end
+    end
+
+    # move deltas to on-disk storage, and new_deltas to deltas
+    def tick_deltas
+      merge_to_db(@delta)
+      @delta = @new_delta
+      @new_delta = {}
+    end
+
+    superator "<-" do |o|
+      o.each do |tuple|
+        @to_delete << tuple unless tuple.nil?
+      end
+    end
+
+    def insert(tuple)
+      key = @key_colnums.map{|k| tuple[k]}
+      merge_tuple(key, tuple)
+    end
+
+    alias << insert
+
+    # Remove to_delete and then add pending to db
+    def tick
+      @to_delete.each do |tuple|
+        k = @key_colnums.map{|c| tuple[c]}
+        k_str = MessagePack.pack(k)
+        cols_str = @dbm[k_str]
+        unless cols_str.nil?
+          db_cols = MessagePack.unpack(cols_str)
+          delete_cols = val_cols.map{|c| tuple[schema.index(c)]}
+          if db_cols == delete_cols
+            @dbm.delete k_str
+          end
+        end
+      end
+      @to_delete = []
+
+      merge_to_db(@pending)
+      @pending = {}
+
+      flush
+    end
+
+    def method_missing(sym, *args, &block)
+      @dbm.send sym, *args, &block
+    end
+  end
+end

data/lib/bud/storage/tokyocabinet.rb

@@ -1,4 +1,8 @@
-require 'tokyocabinet'
+begin
+  require 'tokyocabinet'
+  Bud::HAVE_TOKYOCABINET = true
+rescue LoadError
+end
 
 module Bud
   # Persistent table implementation based on TokyoCabinet.

data/lib/bud/stratify.rb

@@ -50,13 +50,12 @@ class Stratification # :nodoc: all
       # classic stratification:
       # if A depends on B, A is >= B.
       # if A depends nonmonotonically on B, A > B.
-      # if A are B are co-dependent, give up. 
+      # if A are B are nonmonotonically co-dependent, give up. 
       #  (don't need to do this, b/c we've ruled out deductive cycles)
-      # stratum choice will represent local evaluation order,
-      # so we need only consider 'synchronous' dependencies (<=)
-
-      # pass 1: assume no deductive cycles
-      # do "vanilla stratification" on deductive rules
+      #
+      # Stratum choice controls local evaluation order, so we need only consider
+      # deductive rules (<=). Temporal rules are placed in an extra "top"
+      # stratum afterward.
       stratum_base <= (depends * stratum_base).pairs(:body => :predicate) do |d, s|
         if d.op.to_s == '<='
           if d.neg
@@ -75,7 +74,7 @@ class Stratification # :nodoc: all
     }
 
     strata[3] = lambda {
-      # there is no good reason that top_strat can't be computed in strata[3] over stratum_base.
+      # there is no good reason that top_strat can't be computed in strata[2] over stratum_base.
       # however, when it is deduced that way, it is empty after a tick
       top_strat <= stratum.group([], max(stratum.stratum))
     }