origen_testers 0.31.0 → 0.40.0

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

@@ -17,13 +17,17 @@ module OrigenTesters
         attr_accessor :abs_class_name
         attr_reader :limits
         attr_accessor :limits_id
+        alias_method :limit_id, :limits_id
+        alias_method :limit_id=, :limits_id=
+        # Used to store the name of the primary test logged in SMT8
+        attr_accessor :sub_test_name
 
         def initialize(options)
           @type = options[:type]
           @library = options[:library]
           @class_name = options[:methods].delete(:class_name)
           @parameters = {}
-          @limits_id = options[:methods].delete(:limits_id)
+          @limits_id = options[:methods].delete(:limits_id) || options[:methods].delete(:limit_id)
           @limits = TestMethods::Limits.new(self)
           # Add any methods
           if options[:methods][:methods]
@@ -116,10 +120,11 @@ module OrigenTesters
           when :boolean
             # Check for valid values
             if [0, 1, true, false].include?(val)
+              # Use true/false for smt8 and 0/1 for smt7
               if [1, true].include?(val)
-                1
+                tester.smt8? ? true : 1
               else
-                0
+                tester.smt8? ? false : 0
               end
             else
               fail "Unknown boolean value for attribute #{attr}: #{val}"

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

@@ -4,87 +4,6 @@ module OrigenTesters
       class TestSuite
         attr_accessor :meta
 
-        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|
-          attr_accessor attr.to_sym
-        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 initialize(name, attrs = {})
           @name = name
           if interface.unique_test_names == :signature
@@ -106,7 +25,7 @@ module OrigenTesters
             end
           end
           # Set the defaults
-          DEFAULTS.each do |k, v|
+          self.class::DEFAULTS.each do |k, v|
             send("#{k}=", v)
           end
           # Then the values that have been supplied
@@ -115,6 +34,10 @@ module OrigenTesters
           end
         end
 
+        def smt8?
+          tester.smt8?
+        end
+
         def pattern=(name)
           Origen.interface.record_pattern_reference(name) if name
           @pattern = name
@@ -129,31 +52,6 @@ module OrigenTesters
           fail 'Once assigned the name of a test suite cannot be changed!'
         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
-
         def method_missing(method, *args, &block)
           if test_method && test_method.respond_to?(method)
             test_method.send(method, *args, &block)
@@ -171,7 +69,10 @@ module OrigenTesters
         end
 
         def to_meta
-          meta || {}
+          m = meta || {}
+          m['Test'] = name
+          m['Test Name'] ||= try(:test_name)
+          m
         end
 
         def extract_atp_attributes(options)

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

@@ -10,6 +10,11 @@ module OrigenTesters
         def initialize(flow)
           @flow = flow
           @collection = []
+          @existing_names = {}
+          # Test names also have to be unique vs. the current flow name
+          if tester.smt8?
+            @existing_names[flow.filename.sub('.flow', '').to_s] = true
+          end
         end
 
         def filename
@@ -17,7 +22,11 @@ module OrigenTesters
         end
 
         def add(name, options = {})
+          symbol = name.is_a?(Symbol)
           name = make_unique(name)
+          # Ensure names given as a symbol stay as a symbol, this is more for
+          # alignment to existing test cases than anything else
+          name = name.to_sym if symbol
           suite = platform::TestSuite.new(name, options)
           @collection << suite
           # c = Origen.interface.consume_comments
@@ -43,14 +52,15 @@ module OrigenTesters
         private
 
         def make_unique(name)
-          @existing_names ||= {}
-          if @existing_names[name.to_sym]
-            @existing_names[name.to_sym] += 1
-            "#{name}_#{@existing_names[name.to_sym]}"
-          else
-            @existing_names[name.to_sym] = 0
-            name
+          name = name.to_s
+          tempname = name
+          i = 0
+          while @existing_names[tempname]
+            i += 1
+            tempname = "#{name}_#{i}"
           end
+          @existing_names[tempname] = true
+          tempname
         end
       end
     end

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

@@ -5,33 +5,55 @@ module OrigenTesters
       class VariablesFile
         include OrigenTesters::Generator
 
-        attr_reader :flow_control_variables, :runtime_control_variables
+        attr_reader :variables
         attr_accessor :filename, :id
 
         def initialize(options = {})
-          @flow_control_variables = []
-          @runtime_control_variables = []
         end
 
         def subdirectory
           'testflow/mfh.testflow.setup'
         end
 
-        def clean_flow_control_variables
-          flow_control_variables.uniq.sort do |x, y|
+        def add_variables(vars)
+          if @variables
+            vars.each do |k, v|
+              if k == :empty?
+                @variables[:empty?] ||= v
+              else
+                v.each do |k2, v2|
+                  unless v2.empty?
+                    @variables[k][k2] |= v2
+                  end
+                end
+              end
+            end
+          else
+            @variables = vars
+          end
+        end
+
+        # What SMT7 calls a flag
+        def flags
+          (variables[:all][:referenced_enables] + variables[:all][:set_enables]).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
 
-        def clean_runtime_control_variables
-          runtime_control_variables.uniq.sort do |x, y|
+        # What SMT7 calls a declaration
+        def declarations
+          (variables[:all][:jobs] + variables[:all][:referenced_flags] + variables[: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
+
+        def to_be_written?
+          tester.smt7?
+        end
       end
     end
   end

data/lib/origen_testers/smartest_based_tester/smt7.rb

@@ -0,0 +1,59 @@
+module OrigenTesters
+  module SmartestBasedTester
+    module SMT7
+      # This is an internal method use by Origen which returns a fully formatted vector
+      # You can override this if you wish to change the output formatting at vector level
+      def format_vector(vec)
+        timeset = vec.timeset ? "#{vec.timeset.name}" : ''
+        pin_vals = vec.pin_vals ? "#{vec.pin_vals} " : ''
+        if vec.repeat # > 1
+          microcode = "R#{vec.repeat}"
+        else
+          microcode = vec.microcode ? vec.microcode : ''
+        end
+
+        if Origen.mode.simulation? || !inline_comments || $_testers_no_inline_comments
+          comment = ''
+        else
+
+          header_comments = []
+          repeat_comment = ''
+          vec.comments.each_with_index do |comment, i|
+            if comment =~ /^#/
+              if comment =~ /^#(R\d+)$/
+                repeat_comment = Regexp.last_match(1) + ' '
+              # Throw away the ############# headers and footers
+              elsif comment !~ /^# ####################/
+                comment = comment.strip.sub(/^# (## )?/, '')
+                if comment == ''
+                  # Throw away empty lines at the start/end, but preserve them in the middle
+                  unless header_comments.empty? || i == vec.comments.size - 1
+                    header_comments << comment
+                  end
+                else
+                  header_comments << comment
+                end
+              end
+            end
+          end
+
+          if vec.pin_vals && ($_testers_enable_vector_comments || vector_comments)
+            comment = "#{vec.number}:#{vec.cycle}"
+            comment += ': ' if !header_comments.empty? || !vec.inline_comment.empty?
+          else
+            comment = ''
+          end
+          comment += header_comments.join("\cm") unless header_comments.empty?
+          unless vec.inline_comment.empty?
+            comment += "\cm" unless header_comments.empty?
+            comment += "(#{vec.inline_comment})"
+          end
+          comment = "#{repeat_comment}#{comment}"
+        end
+
+        # Max comment length 250 at the end
+        "#{microcode.ljust(25)}#{timeset.ljust(27)}#{pin_vals}# #{comment[0, 247]};"
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/smt8.rb

@@ -0,0 +1,218 @@
+module OrigenTesters
+  module SmartestBasedTester
+    module SMT8
+      # This currently defines what subdirectory of the pattern output directory that
+      # patterns will be output to
+      def subdirectory
+        File.join(package_namespace, 'patterns')
+      end
+
+      # An internal method called by Origen to create the pattern header
+      def pattern_header(options = {})
+        options = {
+        }.merge(options)
+        @program_lines = []
+        @program_action_lines = []
+        if zip_patterns
+          @program_lines << '<?xml version="1.0" encoding="UTF-8"?>'
+          @program_lines << '<Program xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Program.xsd">'
+        end
+        @program_lines << '  <Assignment id="memory" value="SM"/>'
+        pin_list = ordered_pins.map do |p|
+          if Origen.app.pin_pattern_order.include?(p.id)
+            # specified name overrides pin name
+            if (p.is_a?(Origen::Pins::PinCollection)) || p.id != p.name
+              p.id.to_s # groups or aliases can be lower case
+            else
+              p.id.to_s.upcase # pins must be uppercase
+            end
+          else
+            if (p.is_a?(Origen::Pins::PinCollection)) || p.id != p.name
+              p.name.to_s # groups or aliases can be lower case
+            else
+              p.name.to_s.upcase # pins must be uppercase
+            end
+          end
+        end.join(',')
+        @program_lines << "  <Instrument id=\"#{pin_list}\">"
+      end
+
+      # An internal method called by Origen to generate the pattern footer
+      def pattern_footer(options = {})
+        options = {
+          end_in_ka:      false
+        }.merge(options)
+        if options[:end_in_ka]
+          Origen.log.warning '93K keep alive not yet implemented!'
+          ss 'WARNING: 93K keep alive not yet implemented!'
+        end
+        @program_footer_lines = []
+        @program_footer_lines << '</Program>' if zip_patterns
+      end
+
+      # @api private
+      def open_and_write_pattern(filename)
+        pat_name = Pathname.new(filename).basename.to_s
+
+        @gen_vec = 0
+        @vector_number = 0
+        @vector_lines = []
+        @comment_lines = []
+        # @program_lines was already created with the pattern_header
+
+        yield
+
+        write_gen_vec
+        @program_lines << '  </Instrument>'
+
+        if zip_patterns
+          tmp_dir = filename.gsub('.', '_')
+          FileUtils.mkdir_p(tmp_dir)
+          program_file = File.join(tmp_dir, 'Program.sprg')
+          vector_file = File.join(tmp_dir, 'Vectors.vec')
+          comments_file = File.join(tmp_dir, 'Comments.cmt')
+
+          File.open(program_file, 'w') do |f|
+            (@program_lines + @program_action_lines + @program_footer_lines).each do |line|
+              f.puts line
+            end
+          end
+
+          File.open(vector_file, 'w') { |f| @vector_lines.each { |l| f.puts l } }
+          File.open(comments_file, 'w') { |f| @comment_lines.each { |l| f.puts l } }
+
+          Dir.chdir tmp_dir do
+            `zip #{pat_name} Program.sprg Vectors.vec Comments.cmt`
+            FileUtils.mv pat_name, filename
+          end
+        else
+          File.open filename, 'w' do |f|
+            f.puts '<Pattern>'
+            f.puts '  <Program>'
+            (@program_lines + @program_action_lines + @program_footer_lines).each do |line|
+              f.puts '  ' + line
+            end
+            f.puts '  </Program>'
+            f.puts '  <Vector>'
+            @vector_lines.each { |l| f.puts '    ' + l }
+            f.puts '  </Vector>'
+            f.puts '  <Comment>'
+            @comment_lines.each { |l| f.puts '    ' + l }
+            f.puts '  </Comment>'
+            f.puts '</Pattern>'
+          end
+        end
+      ensure
+        FileUtils.rm_rf(tmp_dir) if zip_patterns && File.exist?(tmp_dir)
+      end
+
+      # @api private
+      #
+      # The SMT8 microcode is implemented as a post conversion of the SMT7 microcode, rather than
+      # generating SMT8 microcode originally.
+      # This is generally an easier implementation and since they both run on the same h/ware there
+      # should always be a 1:1 feature mapping between the 2 systems.
+      def track_and_format_comment(comment)
+        if comment =~ /^SQPG/
+          if comment =~ /^SQPG PADDING/
+            # A gen vec should not be used for MRPT vectors, the padding instruction marks the end of them
+            @gen_vec = 0
+          else
+            write_gen_vec
+            if comment =~ /^SQPG JSUB ([^;]+);/
+              @program_lines << "    <Instruction id=\"patternCall\" value=\"#{tester.package_namespace}.patterns.#{Regexp.last_match(1)}\"/>"
+            elsif comment =~ /^SQPG MACT (\d+);/
+              @program_lines << "    <Instruction id=\"match\" value=\"#{Regexp.last_match(1)}\"/>"
+            elsif comment =~ /^SQPG MRPT (\d+);/
+              @program_lines << "    <Instruction id=\"matchRepeat\" value=\"#{Regexp.last_match(1)}\"/>"
+            elsif comment =~ /^SQPG LBGN (\d+);/
+              @program_lines << "    <Instruction id=\"loop\" value=\"#{Regexp.last_match(1)}\"/>"
+            elsif comment =~ /^SQPG LEND;/
+              @program_lines << "    <Instruction id=\"loopEnd\"/>"
+            elsif comment =~ /^SQPG RETC (\d) (\d);/
+              @program_lines << "    <Instruction id=\"returnConditional\">"
+              @program_lines << "      <Assignment id=\"onFail\" value=\"#{Regexp.last_match(1) == '0' ? 'false' : 'true'}\"/>"
+              @program_lines << "      <Assignment id=\"resetFail\" value=\"#{Regexp.last_match(2) == '0' ? 'false' : 'true'}\"/>"
+              @program_lines << '    </Instruction>'
+            else
+              Origen.log.warning "This SMT7 microcode was not converted to SMT8: #{comment}"
+            end
+          end
+        end
+      end
+
+      # This is an internal method use by Origen which returns a fully formatted vector
+      # You can override this if you wish to change the output formatting at vector level
+      def format_vector(vec)
+        has_microcode = vec.microcode && !vec.microcode.empty?
+        has_repeat = vec.repeat && vec.repeat > 1
+        if has_microcode || has_repeat
+          # Close out current gen_vec group
+          write_gen_vec
+          if has_repeat
+            @program_lines << "    <Instruction id=\"genVec\" value=\"1\">"
+            @program_lines << "      <Assignment id=\"repeat\" value=\"#{vec.repeat}\"/>"
+            @program_lines << '    </Instruction>'
+            @gen_vec -= 1
+          end
+          if has_microcode
+            puts vec.microcode
+          end
+        end
+
+        unless Origen.mode.simulation? || !inline_comments || $_testers_no_inline_comments
+          header_comments = []
+          repeat_comment = ''
+          vec.comments.each_with_index do |comment, i|
+            if comment =~ /^#/
+              if comment =~ /^#(R\d+)$/
+                repeat_comment = Regexp.last_match(1) + ' '
+              # Throw away the ############# headers and footers
+              elsif comment !~ /^# ####################/
+                comment = comment.strip.sub(/^# (## )?/, '')
+                if comment == ''
+                  # Throw away empty lines at the start/end, but preserve them in the middle
+                  unless header_comments.empty? || i == vec.comments.size - 1
+                    header_comments << comment
+                  end
+                else
+                  header_comments << comment
+                end
+              end
+            end
+          end
+
+          if vec.pin_vals && ($_testers_enable_vector_comments || vector_comments)
+            comment = "#{vec.number}:#{vec.cycle}"
+            comment += ': ' if !header_comments.empty? || !vec.inline_comment.empty?
+          else
+            comment = ''
+          end
+          # comment += header_comments.join("\cm") unless header_comments.empty?
+          # Seems that SMT8 does not support the above newline char, so identify split lines with something else
+          comment += header_comments.join('----') unless header_comments.empty?
+          unless vec.inline_comment.empty?
+            comment += "\cm" unless header_comments.empty?
+            comment += "(#{vec.inline_comment})"
+          end
+          c = "#{repeat_comment}#{comment}"
+          @comment_lines << "#{@vector_number} #{c}"[0, 3000] unless c.empty?
+        end
+
+        if vec.pin_vals
+          @vector_lines << vec.pin_vals.gsub(' ', '')
+          @vector_number += 1
+          @gen_vec += 1
+        end
+      end
+
+      # @api private
+      def write_gen_vec
+        if @gen_vec > 0
+          @program_lines << "    <Instruction id=\"genVec\" value=\"#{@gen_vec}\"/>"
+          @gen_vec = 0
+        end
+      end
+    end
+  end
+end