origen_testers 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed6eed4f43211577112670d75be50cd8c5af22d1
-  data.tar.gz: 44239f70ea1b03d86784cfbaf0dffd91694b0535
+  metadata.gz: 112e2af4457169ff2ba79641610c0722d565f1fb
+  data.tar.gz: 8833d9bcc8538cb5e5a32f934222e90360957d0d
 SHA512:
-  metadata.gz: b1dbc83b631cc269e949a36a9473cfc0935601478adacf5216293db841fc7fce6fdafe88125db77c3ba0d897237858e3aee651d9167b987f0f35f35d0c8535b3
-  data.tar.gz: 2c2f1b09187a88366d9169d531a41465a997e09c321858babf28c5f2f20dc4eead6665fb946f6de91d630ad79693b753a189c01b89fc115b4dc57490c3ca54b8
+  metadata.gz: c28c0d2cba87e54110b23a77a7f4cf4eb6adc54f93daca4531a9168e98bd0915481d1bc7d4eefae082fbdfb648c7bb31f93a4e8dc7f2b12abcc164ede3b2b039
+  data.tar.gz: ca63134cf7ac29bb74ece0bd9487251ad16ba4b59c6901ebc34288f471591138ad72a433d84d7490586daaee38722189b9d1b088d780b611164cde7aff7758df

data/config/version.rb

@@ -1,6 +1,6 @@
 module OrigenTesters
   MAJOR = 0
-  MINOR = 12
+  MINOR = 13
   BUGFIX = 0
   DEV = nil
 

data/lib/origen_testers/flow.rb

@@ -130,13 +130,13 @@ module OrigenTesters
     end
 
     # @api private
-    # This fires between target loads
+    # This fires between target loads (unless overridden by the ATE specific flow class)
     def at_run_start
       @@program = nil
     end
 
     # @api private
-    # This fires between flows
+    # This fires between flows (unless overridden by the ATE specific flow class)
     def at_flow_start
       @labels = {}
     end

data/lib/origen_testers/smartest_based_tester/base/flow.rb

@@ -36,6 +36,7 @@ module OrigenTesters
         end
 
         def at_flow_start
+          model # Call to ensure the signature gets populated
         end
 
         def at_flow_end
@@ -45,7 +46,7 @@ module OrigenTesters
           h = ['{']
           if add_flow_enable
             var = filename.sub(/\..*/, '').upcase
-            var = "#{var}_ENABLE"
+            var = generate_flag_name("#{var}_ENABLE")
             if add_flow_enable == :enabled
               flow_control_variables << [var, 1]
             else
@@ -84,9 +85,11 @@ module OrigenTesters
           @indent = add_flow_enable ? 2 : 1
           @lines = []
           @stack = { on_fail: [], on_pass: [] }
-          m = Processors::IfRanCleaner.new.process(model.ast)
+          m = Processors::ContinueImplementer.new.process(model.ast)
+          m = Processors::IfRanCleaner.new.process(m)
+          m = Processors::FlagOptimizer.new.run(m)
+          m = Processors::AdjacentIfCombiner.new.process(m)
           m = Processors::EmptyBranchCleaner.new.process(m)
-          m = Processors::FlagOptimizer.new.process(m)
           @set_runtime_variables = Processors::ExtractSetVariables.new.run(m)
           process(m)
         end
@@ -122,10 +125,8 @@ module OrigenTesters
             line '{'
             @indent += 1
             on_fail = node.children.find { |n| n.try(:type) == :on_fail }
-            with_continue(on_fail ? on_fail.children.any? { |n| n.try(:type) == :continue } : false) do
-              process_all(on_fail) if on_fail
-              stack[:on_fail].each { |n| process_all(n) }
-            end
+            process_all(on_fail) if on_fail
+            stack[:on_fail].each { |n| process_all(n) }
             @indent -= 1
             line '}'
           else
@@ -160,6 +161,8 @@ module OrigenTesters
 
         def on_condition_flag(node)
           flag, state, *nodes = *node
+          flag_true = node.find(:flag_true)
+          flag_false = node.find(:flag_false)
           if flag.is_a?(Array)
             condition = flag.map { |f| "@#{generate_flag_name(f)} == 1" }.join(' or ')
           else
@@ -168,13 +171,21 @@ module OrigenTesters
           line "if #{condition} then"
           line '{'
           @indent += 1
-          process_all(nodes) if state
+          if flag_true
+            process_all(flag_true.children)
+          else
+            process_all(nodes) if state
+          end
           @indent -= 1
           line '}'
           line 'else'
           line '{'
           @indent += 1
-          process_all(nodes) unless state
+          if flag_false
+            process_all(flag_false.children)
+          else
+            process_all(nodes) unless state
+          end
           @indent -= 1
           line '}'
         end
@@ -182,7 +193,7 @@ module OrigenTesters
         def on_flow_flag(node)
           flag, state, *nodes = *node
           [flag].flatten.each do |f|
-            flow_control_variables << f
+            flow_control_variables << generate_flag_name(f)
           end
           on_condition_flag(node)
         end
@@ -190,7 +201,7 @@ module OrigenTesters
         def on_run_flag(node)
           flag, state, *nodes = *node
           [flag].flatten.each do |f|
-            runtime_control_variables << f
+            runtime_control_variables << generate_flag_name(f)
           end
           on_condition_flag(node)
         end
@@ -208,42 +219,38 @@ module OrigenTesters
         end
 
         def on_set_run_flag(node)
-          flag = node.value
+          flag = generate_flag_name(node.value)
           runtime_control_variables << flag
-          line "@#{generate_flag_name(flag)} = 1;"
+          line "@#{flag} = 1;"
         end
 
         def on_group(node)
           on_fail = node.children.find { |n| n.try(:type) == :on_fail }
           on_pass = node.children.find { |n| n.try(:type) == :on_pass }
-          with_continue(on_fail && on_fail.children.any? { |n| n.try(:type) == :continue }) do
-            line '{'
-            @indent += 1
-            stack[:on_fail] << on_fail if on_fail
-            stack[:on_pass] << on_pass if on_pass
-            process_all(node.children - [on_fail, on_pass])
-            stack[:on_fail].pop if on_fail
-            stack[:on_pass].pop if on_pass
-            @indent -= 1
-            line "}, open,\"#{unique_group_name(node.find(:name).value)}\", \"\""
-          end
+          line '{'
+          @indent += 1
+          stack[:on_fail] << on_fail if on_fail
+          stack[:on_pass] << on_pass if on_pass
+          process_all(node.children - [on_fail, on_pass])
+          stack[:on_fail].pop if on_fail
+          stack[:on_pass].pop if on_pass
+          @indent -= 1
+          line "}, open,\"#{unique_group_name(node.find(:name).value)}\", \"\""
         end
 
         def on_set_result(node)
-          unless @continue
-            bin = node.find(:bin).try(:value)
-            desc = node.find(:bin).to_a[1]
-            sbin = node.find(:softbin).try(:value)
-            sdesc = node.find(:softbin).to_a[1] || 'fail'
-            if bin && desc
-              hardware_bin_descriptions[bin] ||= desc
-            end
+          bin = node.find(:bin).try(:value)
+          desc = node.find(:bin).to_a[1]
+          sbin = node.find(:softbin).try(:value)
+          sdesc = node.find(:softbin).to_a[1] || 'fail'
+          if bin && desc
+            hardware_bin_descriptions[bin] ||= desc
+          end
 
-            if node.to_a[0] == 'pass'
-              line "stop_bin \"#{sbin}\", \"\", , good, noreprobe, green, #{bin}, over_on;"
-            else
-              line "stop_bin \"#{sbin}\", \"#{sdesc}\", , bad, noreprobe, red, #{bin}, over_on;"
-            end
+          if node.to_a[0] == 'pass'
+            line "stop_bin \"#{sbin}\", \"\", , good, noreprobe, green, #{bin}, over_on;"
+          else
+            line "stop_bin \"#{sbin}\", \"#{sdesc}\", , bad, noreprobe, red, #{bin}, over_on;"
           end
         end
 
@@ -266,13 +273,6 @@ module OrigenTesters
           [job].flatten.map { |j| "@JOB == \"#{j.to_s.upcase}\"" }
         end
 
-        def with_continue(value)
-          orig = @continue
-          @continue = true if value
-          yield
-          @continue = orig
-        end
-
         private
 
         def generate_flag_name(flag)

data/lib/origen_testers/smartest_based_tester/base/generator.rb

@@ -26,7 +26,8 @@ module OrigenTesters
 
         # @api private
         def at_flow_start
-          flow.at_flow_start
+          f = flow
+          f.at_flow_start
           # Initialize this to the value currently set on the tester, any further setting of
           # this by the interface will override
           flow.add_flow_enable = tester.add_flow_enable

data/lib/origen_testers/smartest_based_tester/base/processors.rb

@@ -7,6 +7,9 @@ module OrigenTesters
         autoload :EmptyBranchCleaner, 'origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner'
         autoload :FlagOptimizer, 'origen_testers/smartest_based_tester/base/processors/flag_optimizer'
         autoload :ExtractSetVariables, 'origen_testers/smartest_based_tester/base/processors/extract_set_variables'
+        autoload :AdjacentIfCombiner, 'origen_testers/smartest_based_tester/base/processors/adjacent_if_combiner'
+        autoload :ContinueImplementer, 'origen_testers/smartest_based_tester/base/processors/continue_implementer'
+        autoload :ExtractRunFlagTable, 'origen_testers/smartest_based_tester/base/processors/extract_run_flag_table'
       end
     end
   end

data/lib/origen_testers/smartest_based_tester/base/processors/adjacent_if_combiner.rb

@@ -0,0 +1,106 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # This combines adjacent if flag nodes where the flag is in the opposite state
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:run_flag, "SOME_FLAG", true,
+        #       s(:test,
+        #         s(:name, "test1"))),
+        #     s(:run_flag, "SOME_FLAG", false,
+        #       s(:test,
+        #         s(:name, "test2"))))
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:run_flag, "SOME_FLAG",
+        #       s(:flag_true,
+        #         s(:test,
+        #           s(:name, "test1"))),
+        #       s(:flag_false,
+        #         s(:test,
+        #           s(:name, "test2")))))
+        #
+        # See here for an example of the kind of flow level effect it has:
+        # https://github.com/Origen-SDK/origen_testers/issues/43
+        class AdjacentIfCombiner < ATP::Processor
+          class SetRunFlagFinder < ATP::Processor
+            def contains?(node, flag_name)
+              @result = false
+              @flag_name = flag_name
+              process_all(node)
+              @result
+            end
+
+            def on_set_run_flag(node)
+              if node.to_a[0] == @flag_name
+                @result = true
+              end
+            end
+            alias_method :on_set_flow_flag, :on_set_run_flag
+          end
+
+          def on_unnamed_collection(node)
+            node.updated(nil, optimize(process_all(node.children)))
+          end
+          alias_method :on_on_fail, :on_unnamed_collection
+          alias_method :on_on_pass, :on_unnamed_collection
+
+          def on_named_collection(node)
+            name, *nodes = *node
+            node.updated(nil, [name] + optimize(process_all(nodes)))
+          end
+          alias_method :on_flow, :on_named_collection
+          alias_method :on_group, :on_named_collection
+
+          def on_group(node)
+            name, *nodes = *node
+            node.updated(nil, [name] + optimize(process_all(nodes)))
+          end
+
+          def optimize(nodes)
+            results = []
+            node1 = nil
+            nodes.each do |node2|
+              if node1
+                if opposite_flag_states?(node1, node2) && safe_to_combine?(node1, node2)
+                  results << combine(node1, node2)
+                  node1 = nil
+                else
+                  results << node1
+                  node1 = node2
+                end
+              else
+                node1 = node2
+              end
+            end
+            results << node1 if node1
+            results
+          end
+
+          def combine(node1, node2)
+            true_node = node1.to_a[1] ? node1 : node2
+            false_node = node1.to_a[1] ? node2 : node1
+            true_node = n(:flag_true, process_all(true_node.to_a[2..-1]))
+            false_node = n(:flag_false, process_all(false_node.to_a[2..-1]))
+
+            n(node1.type, [node1.to_a[0], true_node, false_node])
+          end
+
+          def opposite_flag_states?(node1, node2)
+            ((node1.type == :run_flag && node2.type == :run_flag) || (node1.type == :flow_flag && node2.type == :flow_flag)) &&
+              node1.to_a[0] == node2.to_a[0] && node1.to_a[1] != node2.to_a[1]
+          end
+
+          def safe_to_combine?(node1, node2)
+            # Nodes won't be collapsed if node1 touches the shared run flag, i.e. if there is any chance
+            # that by the time it would naturally execute node2, the flag could have been changed by node1
+            !SetRunFlagFinder.new.contains?(node1, node1.to_a[0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/continue_implementer.rb

@@ -0,0 +1,39 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Implements continue on a fail branch for V93K by removing any bin nodes that are
+        # siblings of continue nodes. The continue nodes are also removed in the process since
+        # they have now served their function.
+        class ContinueImplementer < ATP::Processor
+          # Delete any on-fail child if it's 'empty'
+          def on_on_fail(node)
+            if cont = node.find(:continue) || @continue
+              node = node.updated(nil, node.children - [cont] - node.find_all(:set_result))
+            end
+            node.updated(nil, process_all(node.children))
+          end
+
+          def on_group(node)
+            f = node.find(:on_fail)
+            if f && f.find(:continue)
+              with_continue do
+                node = node.updated(nil, process_all(node.children))
+              end
+              node
+            else
+              node.updated(nil, process_all(node.children))
+            end
+          end
+
+          def with_continue
+            orig = @continue
+            @continue = true
+            yield
+            @continue = orig
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner.rb

@@ -2,45 +2,17 @@ module OrigenTesters
   module SmartestBasedTester
     class Base
       module Processors
+        # Removes any empty on_pass and on_fail branches
         class EmptyBranchCleaner < ATP::Processor
           # Delete any on-fail child if it's 'empty'
           def on_test(node)
-            on_pass = node.find(:on_pass)
-            on_fail = node.find(:on_fail)
-            unless on_fail.nil?
-              n = node.remove(on_fail) if branch_is_empty?(on_fail)
-              return n
+            if on_pass = node.find(:on_pass)
+              node = node.remove(on_pass) if on_pass.children.empty?
             end
-            node
-          end
-
-          # Returns true if:
-          #   - node is completely empty
-          #   - only child is (continue) node
-          #   - only two children, one continue and one set-result
-          def branch_is_empty?(node)
-            children = node.children.dup
-            return true if children.nil?
-
-            # test for only-child situation
-            first_born = children.shift
-            if children.empty?
-              if first_born == n0(:continue)
-                return true
-              else
-                return false
-              end
-            end
-
-            # if only 2 children, check qualificataions, else done and return false
-            next_born = children.shift
-            if children.empty?
-              if (first_born.type == :continue && next_born.type == :set_result) ||
-                 (first_born.type == :set_result && next_born.type == :continue)
-                return true
-              end
+            if on_fail = node.find(:on_fail)
+              node = node.remove(on_fail) if on_fail.children.empty?
             end
-            false
+            node = node.updated(nil, process_all(node.children))
           end
         end
       end

data/lib/origen_testers/smartest_based_tester/base/processors/extract_run_flag_table.rb

@@ -0,0 +1,33 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      module Processors
+        # Processes the AST and tabulates occurrences of unique set_run_flag nodes
+        class ExtractRunFlagTable < ATP::Processor
+          # Hash table of run_flag name with number of times used
+          attr_reader :run_flag_table
+
+          # Reset hash table
+          def initialize
+            @run_flag_table = {}.with_indifferent_access
+          end
+
+          # For run_flag nodes, increment # of occurrences for specified flag
+          def on_run_flag(node)
+            children = node.children.dup
+            names = children.shift
+            state = children.shift
+            Array(names).each do |name|
+              if @run_flag_table[name.to_sym].nil?
+                @run_flag_table[name.to_sym] = 1
+              else
+                @run_flag_table[name.to_sym] += 1
+              end
+            end
+            process_all(node.children)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/processors/flag_optimizer.rb

@@ -2,139 +2,184 @@ module OrigenTesters
   module SmartestBasedTester
     class Base
       module Processors
+        # This processor eliminates the use of run flags between adjacent tests:
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:test,
+        #       s(:name, "test1"),
+        #       s(:id, "t1"),
+        #       s(:on_fail,
+        #         s(:set_run_flag, "t1_FAILED", "auto_generated"),
+        #         s(:continue))),
+        #     s(:run_flag, "t1_FAILED", true,
+        #       s(:test,
+        #         s(:name, "test2"))))
+        #
+        #
+        #   s(:flow,
+        #     s(:name, "prb1"),
+        #     s(:test,
+        #       s(:name, "test1"),
+        #       s(:id, "t1"),
+        #       s(:on_fail,
+        #         s(:test,
+        #           s(:name, "test2")))))
+        #
         class FlagOptimizer < ATP::Processor
           attr_reader :run_flag_table
-          # This optimizes the AST such that any adjacent flow noes that
-          #
-          # For example this AST:
-          #   (flow
-          #     (test
-          #       (name "test1")
-          #       (on-fail
-          #         (set-run-flag "t1_FAILED")))
-          #     (run-flag "t1_FAILED" true
-          #       (test
-          #         (name "test2"))
-          #       (test
-          #         (name "test3")))
-          #     (test
-          #       (name "test4")
-          #       (on-pass
-          #         (set-run-flag "t4_PASSED"))
-          #       (on-fail
-          #         (continue)))
-          #     (run-flag "t4_PASSED" true
-          #       (test
-          #         (name "test5"))
-          #       (test
-          #         (name "test6"))))
-          #
-          # Will be optimized to this:
-          #   (flow
-          #     (test
-          #       (name "test1")
-          #       (on-fail
-          #         (test
-          #           (name "test2"))
-          #         (test
-          #           (name "test3"))))
-          #     (test
-          #       (name "test4")
-          #       (on-pass
-          #         (test
-          #           (name "test5"))
-          #         (test
-          #           (name "test6")))
-          #       (on-fail
-          #         (continue))))
 
-          # Processes the AST and tabulates occurences of unique set_run_flag nodes
-          class ExtractRunFlagTable < ATP::Processor
-            # Hash table of run_flag name with number of times used
-            attr_reader :run_flag_table
+          def run(node)
+            # Pre-process the AST for # of occurrences of each run-flag used
+            t = ExtractRunFlagTable.new
+            t.process(node)
+            @run_flag_table = t.run_flag_table
+            process(node)
+          end
 
-            # Reset hash table
-            def initialize
-              @run_flag_table = {}
+          def on_named_collection(node)
+            name, *nodes = *node
+            node.updated(nil, [name] + optimize(process_all(nodes)))
+          end
+          alias_method :on_flow, :on_named_collection
+          alias_method :on_group, :on_named_collection
+
+          def on_run_flag(node)
+            name, state, *nodes = *node
+            if run_flag_to_remove.last && run_flag_to_remove.last == node.to_a[0..1]
+              node.to_a.last
+            else
+              node.updated(nil, [name, state] + optimize(process_all(nodes)))
             end
+          end
 
-            # For run_flag nodes, increment # of occurences for specified flag
-            def on_run_flag(node)
-              children = node.children.dup
-              name = children.shift
-              state = children.shift
-              unless name.is_a?(Array)
-                if @run_flag_table[name.to_sym].nil?
-                  @run_flag_table[name.to_sym] = 1
-                else
-                  @run_flag_table[name.to_sym] += 1
+          def on_on_fail(node)
+            if to_inline = nodes_to_inline_on_pass_or_fail.last
+              # If this node sets the flag that gates the node to be inlined
+              set_run_flag = node.find(:set_run_flag)
+              if set_run_flag && gated_by_set?(set_run_flag.to_a[0], to_inline)
+                # Remove the sub-node that sets the flag if there are no further references to it
+
+                if @run_flag_table[set_run_flag.to_a[0]] == 1 || !@run_flag_table[set_run_flag.to_a[0]]
+                  node = node.updated(nil, node.children - [set_run_flag])
                 end
+
+                # And append the content of the node to be in_lined at the end of this on pass/fail node
+                append = reorder_nested_run_flags(set_run_flag.to_a[0], to_inline).to_a[2..-1]
+
+                # Belt and braces approach to make sure this node to be inlined does
+                # not get picked up anywhere else
+                nodes_to_inline_on_pass_or_fail.pop
+                nodes_to_inline_on_pass_or_fail << nil
               end
             end
+            node.updated(nil, optimize(process_all(node.children + Array(append))))
           end
+          alias_method :on_on_pass, :on_on_fail
 
-          # Only run this on top level flow and consider adjacent nodes, no need for
-          # looking at nested conditions.
-          def on_flow(node)
-            # Pre-process the AST for # of occurences of each run-flag used
-            t = ExtractRunFlagTable.new
-            t.process(node)
-            @run_flag_table = t.run_flag_table
-
-            name, *nodes = *node
+          def optimize(nodes)
             results = []
-            node_a = nil
-            nodes.each do |node_b|
-              if node_a && node_a.type == :test && node_b.type == :run_flag
-                result, node_a = remove_run_flag(node_a, node_b)
-                results << result
+            node1 = nil
+            nodes.each do |node2|
+              if node1
+                if can_be_combined?(node1, node2)
+                  node1 = combine(node1, node2)
+                else
+                  results << node1
+                  node1 = node2
+                end
               else
-                results << node_a unless node_a.nil?
-                node_a = node_b
+                node1 = node2
               end
             end
-            results << node_a unless node_a.nil?
-            node.updated(nil, [name] + results)
+            results << node1 if node1
+            results
           end
 
-          # Given two adjacent nodes, where the first (a) is a test and the second (b)
-          # is a run_flag, determine if (a) conditionally sets the same flag that (b)
-          # uses.  If it does, do a logical replacement, if not, move on quietly.
-          def remove_run_flag(node_a, node_b)
-            on_pass = node_a.find(:on_pass)
-            on_fail = node_a.find(:on_fail)
-
-            unless on_pass.nil? && on_fail.nil?
-              if on_pass.nil?
-                flag_node = on_fail.find(:set_run_flag)
-                conditional = [flag_node, on_fail]
-              else
-                flag_node = on_pass.find(:set_run_flag)
-                conditional = [flag_node, on_pass]
+          def can_be_combined?(node1, node2)
+            if node1.type == :test && node2.type == :run_flag
+              if node1.find_all(:on_fail, :on_pass).any? do |node|
+                if n = node.find(:set_run_flag)
+                  # Inline instead of setting a flag if...
+                  gated_by_set?(n.to_a[0], node2) && # The flag set by node1 is gating node2
+                  n.to_a[1] == 'auto_generated' && # The flag has been generated and not specified by the user
+                  n.to_a[0] !~ /_RAN$/ # And don't compress RAN flags because they can be set by both on_fail and on_pass
+                end
+              end
+                return true
               end
             end
-            unless conditional.nil?
-              children = node_b.children.dup
-              name = children.shift
-              # remove the '_RAN' here so it won't match and if_ran cases are ignored
-              name = name.gsub(/_RAN$/, '') unless name.is_a?(Array)
-              state = children.shift
-              *nodes = *children
-              flag_node_b = n2(:set_run_flag, name, 'auto_generated') if state == true
+            false
+          end
 
-              if conditional.first == flag_node_b
-                n = conditional.last.dup
-                result = node_a.remove(n)
-                n = n.remove(conditional.first) if @run_flag_table[name.to_sym] == 1
-                n = n.remove(n0(:continue)) if n.type == :on_fail
-                s = n.find(:set_result) if n.type == :on_fail
-                n = n.remove(s) if s
-                n = n.updated(nil, n.children + (nodes.is_a?(Array) ? nodes : [nodes]))
-                result = result.updated(nil, result.children + (n.is_a?(Array) ? n : [n]))
-                return result, nil
-              end
+          def combine(node1, node2)
+            nodes_to_inline_on_pass_or_fail << node2
+            node1 = node1.updated(nil, process_all(node1.children))
+            nodes_to_inline_on_pass_or_fail.pop
+            node1
+          end
+
+          # node will always be a run_flag type node, guaranteed by the caller
+          #
+          # Returns true if flag matches the one supplied and it is required to be set(true), like this:
+          #
+          #   s(:run_flag, flag, true,
+          #     s(:test, ...
+          #
+          # Also returns true if flag matches the one supplied, but it is nested within other flag conditions:
+          #
+          #   s(:run_flag, other_flag, false,
+          #     s(:run_flag, other_flag2, true,
+          #       s(:run_flag, flag, true,
+          #         s(:test, ...
+          def gated_by_set?(flag, node)
+            (flag == node.to_a[0] && node.to_a[1]) ||
+              (node.to_a.size == 3 && node.to_a.last.type == :run_flag && gated_by_set?(flag, node.to_a.last))
+          end
+
+          # Returns the node with the run_flag clauses re-ordered to have the given flag of interest at the top.
+          #
+          # The caller guarantees the run_flag clause containing the given flag is present.
+          #
+          # For example, given this node:
+          #
+          #   s(:run_flag, "flag1", false,
+          #     s(:run_flag, "ot_BEA7F3B_FAILED", true,
+          #       s(:test,
+          #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+          #         s(:name, "inner_test1_BEA7F3B"),
+          #         s(:number, 0),
+          #         s(:id, "it1_BEA7F3B"),
+          #         s(:on_fail,
+          #           s(:render, "multi_bin;")))))
+          #
+          # Then this node would be returned when the flag of interest is ot_BEA7F3B_FAILED:
+          #
+          #   s(:run_flag, "ot_BEA7F3B_FAILED", true,
+          #     s(:run_flag, "flag1", false,
+          #       s(:test,
+          #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+          #         s(:name, "inner_test1_BEA7F3B"),
+          #         s(:number, 0),
+          #         s(:id, "it1_BEA7F3B"),
+          #         s(:on_fail,
+          #           s(:render, "multi_bin;")))))
+          def reorder_nested_run_flags(flag, node)
+            # If the run_flag we care about is already at the top, just return node
+            unless node.to_a[0] == flag && node.to_a[1]
+              run_flag_to_remove << [flag, true]
+              node = n(:run_flag, [flag, true, process(node)])
+              run_flag_to_remove.pop
             end
-            [node_a, node_b]
+            node
+          end
+
+          def run_flag_to_remove
+            @run_flag_to_remove ||= []
+          end
+
+          def nodes_to_inline_on_pass_or_fail
+            @nodes_to_inline_on_pass_or_fail ||= []
           end
         end
       end

data/lib/origen_testers/smartest_based_tester/v93k/templates/vars.tf.erb

@@ -5,9 +5,9 @@ declarations
 
 % clean_runtime_control_variables.each do |var|
 %   if var.is_a?(Array)
-@<%= var[0].to_s.upcase %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
+@<%= var[0].to_s %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
 %   else
-@<%= var.to_s.upcase %> = 0;
+@<%= var.to_s %> = 0;
 %   end
 % end
 
@@ -17,9 +17,9 @@ flags
 
 % clean_flow_control_variables.each do |var|
 %   if var.is_a?(Array)
-user <%= var[0].to_s.upcase %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
+user <%= var[0].to_s %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
 %   else
-user <%= var.to_s.upcase %> = 0;
+user <%= var.to_s %> = 0;
 %   end
 % end
 

data/lib/origen_testers/timing.rb

@@ -146,12 +146,18 @@ module OrigenTesters
         original = @timeset
         timeset_changed(timeset)
         @timeset = timeset
+        dut.timeset = timeset.name if dut.timesets[timeset.name]
+        dut.current_timeset_period = timeset.period_in_ns
         yield
         timeset_changed(original)
         @timeset = original
+        dut.timeset = original.name if dut.timesets[original.name]
+        dut.current_timeset_period = original.period_in_ns
       else
         timeset_changed(timeset)
         @timeset = timeset
+        dut.timeset = timeset.name if dut.timesets[timeset.name]
+        dut.current_timeset_period = timeset.period_in_ns
       end
     end
 

data/program/components/_prb1_main.rb

@@ -208,5 +208,15 @@ Flow.create do |options|
 
   pass 2, if_ran: :g100
 
+  log 'Test node optimization within an if_failed branch'
+  func :some_func_test, id: :sft1
+
+  if_failed :sft1 do
+    bin 10, if_flag: "Alarm"
+    bin 11, unless_flag: "Alarm"
+    bin 12, if_enable: "AlarmEnabled"
+    bin 13, unless_enable: "AlarmEnabled"
+  end
+
   pass 1, description: "Good die!", softbin: 1
 end

data/program/flow_control.rb

@@ -338,4 +338,85 @@ Flow.create interface: 'OrigenTesters::Test::Interface' do
 
     func :test36, on_fail: { render: 'multi_bin;' }, if_flag: :my_flag
   end
+
+  log 'An optimization test case, this should not generate a flag on V93K'
+  func :test1, id: :t1a
+
+  if_passed :t1a do
+    func :test2
+  end
+
+  if_failed :t1a do
+    func :test3
+    bin 10
+  end
+
+  log 'The reverse optimization test case, this should not generate a flag on V93K'
+  func :test1, id: :t1b
+
+  if_failed :t1b do
+    func :test3
+    bin 10
+  end
+
+  if_passed :t1b do
+    func :test2
+  end
+
+  if tester.v93k?
+    log 'Nested optimization test case'
+    func :outer_test, id: :ot
+    if_failed :ot do
+      unless_flag :flag1 do
+        func :inner_test1, id: :it1
+        render 'multi_bin;', if_failed: :it1
+      end
+    end
+
+    log 'Nested flag optimization test case'
+    if_flag :flag1 do
+      func :test4, id: :nf_t4
+      if_failed :nf_t4 do
+        render 'multi_bin;', if_flag: :flag1
+      end
+    end
+
+    log 'The setting of flags used in later OR conditions should be preserved'
+    func :test2, id: :of1
+    func :test3, if_failed: :of1
+    func :test2, id: :of2
+    func :test3, if_failed: :of2
+    func :test4
+    func :test4, if_any_failed: [:of1, :of2]
+
+    log 'The setting of flags used in later AND conditions should be preserved'
+    func :test2, id: :af1
+    func :test3, if_failed: :af1
+    func :test2, id: :af2
+    func :test3, if_failed: :af2
+    func :test4
+    func :test4, if_all_failed: [:af1, :af2]
+    
+    log 'Adjacent tests that set a flag and then use it in an OR condition should be valid'
+    func :test2, id: :of11
+    func :test2, id: :of12
+    func :test4, if_any_failed: [:of11, :of12]
+
+    log 'Adjacent tests that set a flag and then use it in an AND condition should be valid'
+    func :test2, id: :af11
+    func :test2, id: :af12
+    func :test4, if_all_failed: [:af11, :af12]
+
+    log 'Adjacent if combiner test case 1'
+    func :test1, if_enable: :my_enable_word
+    func :test2, unless_enable: :my_enable_word
+    func :test1, if_flag: :my_flag
+    func :test2, unless_flag: :my_flag
+
+    log 'Adjacent if combiner test case 2'
+    func :test2, unless_enable: :my_enable_word
+    func :test1, if_enable: :my_enable_word
+    func :test2, unless_flag: :my_flag
+    func :test1, if_flag: :my_flag
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-19 00:00:00.000000000 Z
+date: 2017-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -241,7 +241,10 @@ files:
 - lib/origen_testers/smartest_based_tester/base/pattern_compiler.rb
 - lib/origen_testers/smartest_based_tester/base/pattern_master.rb
 - lib/origen_testers/smartest_based_tester/base/processors.rb
+- lib/origen_testers/smartest_based_tester/base/processors/adjacent_if_combiner.rb
+- lib/origen_testers/smartest_based_tester/base/processors/continue_implementer.rb
 - lib/origen_testers/smartest_based_tester/base/processors/empty_branch_cleaner.rb
+- lib/origen_testers/smartest_based_tester/base/processors/extract_run_flag_table.rb
 - lib/origen_testers/smartest_based_tester/base/processors/extract_set_variables.rb
 - lib/origen_testers/smartest_based_tester/base/processors/flag_optimizer.rb
 - lib/origen_testers/smartest_based_tester/base/processors/if_ran_cleaner.rb