origen_testers 0.31.0 → 0.40.0

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

@@ -4,6 +4,38 @@ module OrigenTesters
       require 'origen_testers/smartest_based_tester/base/flow'
       class Flow < Base::Flow
         TEMPLATE = "#{Origen.root!}/lib/origen_testers/smartest_based_tester/v93k/templates/template.tf.erb"
+
+        def flow_header
+          h = ['  {']
+          if add_flow_enable
+            h << "    if @#{flow_enable_var_name} == 1 then"
+            h << '    {'
+            i = '   '
+          else
+            i = ''
+          end
+          if set_runtime_variables.size > 0
+            h << i + '    {'
+            set_runtime_variables.each do |var|
+              h << i + "       @#{generate_flag_name(var.to_s)} = -1;"
+            end
+            h << i + '    }, open,"Init Flow Control Vars", ""'
+          end
+          h
+        end
+
+        def flow_footer
+          f = []
+          if add_flow_enable
+            f << '    }'
+            f << '    else'
+            f << '    {'
+            f << '    }'
+          end
+          f << ''
+          f << "  }, open,\"#{flow_name}\",\"#{flow_description}\""
+          f
+        end
       end
     end
   end

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

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

data/lib/origen_testers/smartest_based_tester/v93k/test_suite.rb

@@ -3,6 +3,115 @@ module OrigenTesters
     class V93K
       require 'origen_testers/smartest_based_tester/base/test_suite'
       class TestSuite < Base::TestSuite
+        ATTRS =
+          %w(name
+             comment
+
+             timing_equation timing_spec timing_set
+             level_equation level_spec level_set
+             analog_set
+             pattern
+             context
+             test_type
+             test_method
+
+             test_number
+             test_level
+
+             bypass
+             set_pass
+             set_fail
+             hold
+             hold_on_fail
+             output_on_pass
+             output_on_fail
+             pass_value
+             fail_value
+             per_pin_on_pass
+             per_pin_on_fail
+             log_mixed_signal_waveform
+             fail_per_label
+             ffc_enable
+             log_first
+             ffv_enable
+             frg_enable
+             hardware_dsp_disable
+          )
+
+        ALIASES = {
+          tim_equ_set:     :timing_equation,
+          tim_spec_set:    :timing_spec,
+          timset:          :timing_set,
+          timeset:         :timing_set,
+          time_set:        :timing_set,
+          lev_equ_set:     :level_equation,
+          lev_spec_set:    :level_spec,
+          levset:          :level_set,
+          levels:          :level_set,
+          pin_levels:      :level_set,
+          anaset:          :analog_set,
+          test_num:        :test_number,
+          test_function:   :test_method,
+          value_on_pass:   :pass_value,
+          value_on_fail:   :fail_value,
+          seqlbl:          :pattern,
+          mx_waves_enable: :log_mixed_signal_waveform,
+          hw_dsp_disable:  :hardware_dsp_disable,
+          ffc_on_fail:     :log_first
+        }
+
+        DEFAULTS = {
+          output_on_pass:  true,
+          output_on_fail:  true,
+          pass_value:      true,
+          fail_value:      true,
+          per_pin_on_pass: true,
+          per_pin_on_fail: true
+        }
+
+        # Generate accessors for all attributes and their aliases
+        ATTRS.each do |attr|
+          if attr == 'name' || attr == 'pattern'
+            attr_reader attr.to_sym
+          else
+            attr_accessor attr.to_sym
+          end
+        end
+
+        # Define the aliases
+        ALIASES.each do |_alias, val|
+          define_method("#{_alias}=") do |v|
+            send("#{val}=", v)
+          end
+          define_method("#{_alias}") do
+            send(val)
+          end
+        end
+
+        def lines
+          if pattern
+            burst = $tester.multiport ? "#{$tester.multiport_name(pattern)}" : "#{pattern}"
+          end
+          l = []
+          l << "  comment = \"#{comment}\";" if comment
+          l << "  ffc_on_fail = #{wrap_if_string(log_first)};" if log_first
+          l << "  local_flags = #{flags};"
+          l << '  override = 1;'
+          l << "  override_anaset = #{wrap_if_string(analog_set)};" if analog_set
+          l << "  override_lev_equ_set = #{wrap_if_string(level_equation)};" if level_equation
+          l << "  override_lev_spec_set = #{wrap_if_string(level_spec)};" if level_spec
+          l << "  override_levset = #{wrap_if_string(level_set)};" if level_set
+          l << "  override_seqlbl = #{wrap_if_string(burst)};" if pattern
+          l << "  override_test_number = #{test_number};" if test_number
+          l << "  override_testf = #{test_method.id};" if test_method
+          l << "  override_tim_equ_set = #{wrap_if_string(timing_equation)};" if timing_equation
+          l << "  override_tim_spec_set = #{wrap_if_string(timing_spec)};" if timing_spec
+          l << "  override_timset = #{wrap_if_string(timing_set)};" if timing_set
+          l << '  site_control = "parallel:";'
+          l << '  site_match = 2;'
+          l << "  test_level = #{test_level};" if test_level
+          l
+        end
       end
     end
   end

data/lib/origen_testers/smartest_based_tester/v93k_smt8.rb

@@ -0,0 +1,8 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K_SMT8 < Base
+      require 'origen_testers/smartest_based_tester/v93k_smt8/generator.rb'
+    end
+  end
+  V93K_SMT8 = SmartestBasedTester::V93K_SMT8
+end

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

@@ -0,0 +1,234 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K_SMT8
+      require 'origen_testers/smartest_based_tester/base/flow'
+      class Flow < Base::Flow
+        TEMPLATE = "#{Origen.root!}/lib/origen_testers/smartest_based_tester/v93k_smt8/templates/template.flow.erb"
+
+        def on_test(node)
+          test_suite = node.find(:object).to_a[0]
+          if test_suite.is_a?(String)
+            name = test_suite
+          else
+            name = test_suite.name
+            test_method = test_suite.test_method
+            if test_method.respond_to?(:test_name) && test_method.test_name == '' &&
+               n = node.find(:name)
+              test_method.test_name = n.value
+            end
+          end
+
+          if node.children.any? { |n| t = n.try(:type); t == :on_fail || t == :on_pass } ||
+             !stack[:on_pass].empty? || !stack[:on_fail].empty?
+            line "#{name}.execute();"
+            @open_test_names << name
+            @post_test_lines << []
+            process_all(node.to_a.reject { |n| t = n.try(:type); t == :on_fail || t == :on_pass })
+            on_pass = node.find(:on_pass)
+            on_fail = node.find(:on_fail)
+
+            if on_fail && on_fail.find(:continue) && tester.force_pass_on_continue
+              if test_method.respond_to?(:force_pass)
+                test_method.force_pass = 1
+              else
+                Origen.log.error 'Force pass on continue has been enabled, but the test method does not have a force_pass attribute!'
+                Origen.log.error "  #{node.source}"
+                exit 1
+              end
+              @open_test_methods << test_method
+            else
+              if test_method.respond_to?(:force_pass)
+                test_method.force_pass = 0
+              end
+              @open_test_methods << nil
+            end
+
+            pass_lines = capture_lines do
+              @indent += 1
+              pass_branch do
+                process_all(on_pass) if on_pass
+                stack[:on_pass].each { |n| process_all(n) }
+              end
+              @indent -= 1
+            end
+
+            fail_lines = capture_lines do
+              @indent += 1
+              fail_branch do
+                process_all(on_fail) if on_fail
+                stack[:on_fail].each { |n| process_all(n) }
+              end
+              @indent -= 1
+            end
+
+            if !pass_lines.empty? && fail_lines.empty?
+              line "if (#{name}.pass) {"
+              pass_lines.each { |l| line l, already_indented: true }
+              line '}'
+
+            elsif pass_lines.empty? && !fail_lines.empty?
+              line "if (!#{name}.pass) {"
+              fail_lines.each { |l| line l, already_indented: true }
+              line '}'
+
+            elsif !pass_lines.empty? && !fail_lines.empty?
+              line "if (#{name}.pass) {"
+              pass_lines.each { |l| line l, already_indented: true }
+              line '} else {'
+              fail_lines.each { |l| line l, already_indented: true }
+              line '}'
+
+            end
+
+            @open_test_methods.pop
+            @open_test_names.pop
+            @post_test_lines.pop.each { |l| line(l) }
+          else
+            line "#{name}.execute();"
+          end
+        end
+
+        def on_sub_flow(node)
+          sub_flow = sub_flow_from(node)
+          @sub_flows ||= {}
+          path = Pathname.new(node.find(:path).value)
+          name = path.basename('.*').to_s
+          @sub_flows[name] = "#{path.dirname}.#{name}".gsub(/(\/|\\)/, '.')
+          # Pass down all input variables before executing
+          sub_flow.input_variables.each do |var|
+            var = var[0] if var.is_a?(Array)
+            line "#{name}.#{var} = #{var};"
+          end
+          line "#{name}.execute();"
+          # And then retrieve all common output variables
+          (output_variables & sub_flow.output_variables).sort.each do |var|
+            var = var[0] if var.is_a?(Array)
+            line "#{var} = #{name}.#{var};"
+          end
+          if on_pass = node.find(:on_pass)
+            pass_lines = capture_lines do
+              @indent += 1
+              pass_branch do
+                process_all(on_pass) if on_pass
+              end
+              @indent -= 1
+            end
+            on_pass = nil if pass_lines.empty?
+          end
+
+          if on_fail = node.find(:on_fail)
+            fail_lines = capture_lines do
+              @indent += 1
+              fail_branch do
+                process_all(on_fail) if on_fail
+              end
+              @indent -= 1
+            end
+            on_fail = nil if fail_lines.empty?
+          end
+
+          if on_pass && !on_fail
+            line "if (#{name}.pass) {"
+            pass_lines.each { |l| line l, already_indented: true }
+            line '}'
+
+          elsif !on_pass && on_fail
+            line "if (!#{name}.pass) {"
+            fail_lines.each { |l| line l, already_indented: true }
+            line '}'
+
+          elsif on_pass && on_fail
+            line "if (#{name}.pass) {"
+            pass_lines.each { |l| line l, already_indented: true }
+            line '} else {'
+            fail_lines.each { |l| line l, already_indented: true }
+            line '}'
+          end
+        end
+
+        def sub_flows
+          @sub_flows || {}
+        end
+
+        # Variables which should be defined as an input to the current flow
+        def input_variables
+          vars = flow_variables
+          # Jobs and enables flow into a sub-flow
+          (vars[:all][:jobs] + vars[:all][:referenced_enables] + vars[:all][:set_enables] +
+            # As do any flags which are referenced by it but which are not set within it
+            (vars[:all][:referenced_flags] - vars[:all][:set_flags])).uniq.sort do |x, y|
+            x = x[0] if x.is_a?(Array)
+            y = y[0] if y.is_a?(Array)
+            x <=> y
+          end
+        end
+
+        # Variables which should be defined as an output of the current flow
+        def output_variables
+          vars = flow_variables
+          # Flags that are set by this flow flow out of it
+          (vars[:this_flow][:set_flags] +
+           # As do any flags set by its children which are marked as external
+           vars[:all][:set_flags_extern] +
+           # And any flags which are set by a child and referenced in this flow
+           (vars[:this_flow][:referenced_flags] & vars[:sub_flows][:set_flags]) +
+           # And also intermediate flags, those are flags which are set by a child and referenced
+           # by a parent of the current flow
+           intermediate_variables).uniq.sort do |x, y|
+            x = x[0] if x.is_a?(Array)
+            y = y[0] if y.is_a?(Array)
+            x <=> y
+          end
+        end
+
+        # Output variables which are not directly referenced by this flow, but which are referenced by a parent
+        # flow and set by the given child flow and therefore must pass through the current flow.
+        # By calling this method with no argument it will consider variables set by any child flow, alternatively
+        # pass in the variables for the child flow in question and only that will be considered.
+        def intermediate_variables(*sub_flows)
+          set_flags = []
+          all_sub_flows.each { |f| set_flags += f.flow_variables[:all][:set_flags] }
+          if set_flags.empty?
+            []
+          else
+            upstream_referenced_flags = []
+            p = parent
+            while p
+              upstream_referenced_flags += p.flow_variables[:this_flow][:referenced_flags]
+              p = p.parent
+            end
+            upstream_referenced_flags.uniq
+            set_flags & upstream_referenced_flags
+          end
+        end
+
+        def flow_header
+          h = []
+          if add_flow_enable && top_level?
+            h << "        if (#{flow_enable_var_name} == 1) {"
+            i = '            '
+          else
+            i = '        '
+          end
+          flow_variables[:this_flow][:set_flags].each do |var|
+            if var.is_a?(Array)
+              h << i + "#{var[0]} = #{var[1].is_a?(String) || var[1].is_a?(Symbol) ? '"' + var[1].to_s + '"' : var[1]};"
+            else
+              h << i + "#{var} = -1;"
+            end
+          end
+          h << '' unless flow_variables[:this_flow][:set_flags].empty?
+          h
+        end
+
+        def flow_footer
+          f = []
+          if add_flow_enable && top_level?
+            f << '        }'
+          end
+          f
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K_SMT8
+      # Include this module in an interface class to make it a V93K interface and to give
+      # access to the V93K SMT8 program generator API
+      module Generator
+        extend ActiveSupport::Concern
+
+        require_all "#{Origen.root!}/lib/origen_testers/smartest_based_tester/v93k_smt8"
+        require 'origen_testers/smartest_based_tester/base/generator'
+
+        included do
+          include Base::Generator
+          PLATFORM = V93K_SMT8
+        end
+
+        # Sub flows are generated in a forked process for SMT8, however any updates made to interface
+        # instance variables by the sub-flow will be applied to the interface of the master process.
+        # This is what the user would expect to happen and keeps them largely unaware of the fact that
+        # the sub-flow is actually being generated by a forked process.
+        # However, to do this it is necessary to marshal the value of the instance variables and
+        # some (rich) Ruby objects cannot be marshaled. This parameter allows applications to selectively
+        # mark such variables as not to be returned from the forked process, skipping the marshal
+        # operation but also meaning that any changes made to the variable by the sub-flow will not
+        # be visible to the top-level flow.
+        #
+        # If the application actually needs updates to that variable made during a sub-flow to
+        # be available to the top-level flow, then they will need to work around it in another
+        # way on a case by case basis.
+        #
+        #   # In the application's interface
+        #   sub_flow_no_return_vars << :@my_problem_var
+        def sub_flow_no_return_vars
+          @sub_flow_no_return_vars ||= []
+        end
+
+        # See sub_flow_no_return_vars
+        def sub_flow_no_return_vars=(val)
+          @sub_flow_no_return_vars = val
+        end
+
+        def limits_workbook
+          @@limits_workbook ||= LimitsWorkbook.new(manually_register: true)
+        end
+      end
+    end
+  end
+end