origen_testers 0.46.1 → 0.48.3

data/lib/origen_testers/charz/profile.rb

@@ -0,0 +1,120 @@
+module OrigenTesters
+  module Charz
+    # A Charz Profile
+    # Used to store characterization routines as well as flow control, conditional execution, and test placement meta data
+    class Profile
+      # @!attribute id
+      #   @return [Symbol] the id of the current profile, used as a key in OrigenTesters::Charz#charz_profiles hash
+      # @!attribute name
+      #   @return [Symbol] the value used (if the user decides) to generate the name of the created charz test. defaults to the value of @id
+      # @!attribute placement
+      #   @return [Symbol] placement of the to be created charz tests, defaults to inline, accepts :eof as well. Other placements can be used as well if @valid_placements is altered
+      # @!attribute on_result
+      #   @return [Symbol] indicates if the resulting charz tests are depending on the point tests result, valid values include :on_fail, and :on_pass
+      # @!attribute enables
+      #   @return [Symbol, String, Array, Hash] enable gates to be wrapped around the resulting charz tests
+      # @!attribute flags
+      #   @return [Symbol, String, Array, Hash] flag gates to be wrapped around the resulting charz tests
+      # @!attribute routines
+      #   @return [Array] list of charz routines to be called under this profile
+      # @!attribute charz_only
+      #   @return [Boolean] indicates if the point tests should or shouldn't be added to the flow
+      attr_accessor :id, :name, :placement, :on_result, :enables, :flags, :routines, :charz_only
+
+      def initialize(id, options, &block)
+        @id = id
+        @id = @id.symbolize unless id.is_a? Symbol
+        options.each { |k, v| instance_variable_set("@#{k}", v) }
+        (block.arity < 1 ? (instance_eval(&block)) : block.call(self)) if block_given?
+        @name ||= id
+        @placement ||= :inline
+        @defined_routines = options.delete(:defined_routines)
+        attrs_ok?
+      end
+
+      def attrs_ok?
+        return if @quality_check == false
+
+        unknown_routines = @routines - @defined_routines
+        unless unknown_routines.empty?
+          Origen.log.error "Profile #{id}: unknown routines: #{unknown_routines}"
+          fail
+        end
+
+        @valid_placements ||= [:inline, :eof]
+        unless @valid_placements.include? @placement
+          Origen.log.error "Profile #{id}: invalid placement value, must be one of: #{@valid_placements}"
+          fail
+        end
+
+        if @on_result
+          @valid_on_results ||= [:on_fail, :fail, :failed, :on_pass, :pass, :passed]
+          unless @valid_on_results.include?(@on_result)
+            Origen.log.error "Profile #{id}: invalid on_result value, must be one of: #{@valid_on_results}"
+            fail
+          end
+        end
+
+        if @charz_only && @on_result
+          Origen.log.error "Profile #{id}: @charz_only is set, but @on_result (#{@on_result}) requires the parent test to exist in the flow"
+          fail
+        end
+
+        unless @gate_checks == false
+          gate_check(@enables, :enables) if @enables
+          gate_check(@flags, :flags) if @flags
+        end
+      end
+
+      def gate_check(gates, gate_type)
+        case gates
+        when Symbol, String
+          return
+        when Array
+          unknown_gates = gates.reject { |gate| [String, Symbol].include? gate.class }
+          if unknown_gates.empty?
+            return
+          else
+            Origen.log.error "Profile #{id}: Unknown #{gate_type} type(s) in #{gate_type} array."
+            Origen.log.error "Arrays must contain Strings and/or Symbols, but #{unknown_gates.map(&:class).uniq } were found in #{gates}"
+            fail
+          end
+        when Hash
+          gates.each do |gate, gated_routines|
+            if gate.is_a? Hash
+              Origen.log.error "Profile #{id}: #{gate_type} Hash keys cannot be of type Hash, but only Symbol, String, or Array"
+              fail
+            end
+            gate_check(gate, gate_type)
+            gated_routines = [gated_routines] unless gated_routines.is_a? Array
+            unknown_routines = gated_routines - @defined_routines
+            unless unknown_routines.empty?
+              Origen.log.error "Profile #{id}: unknown routines found in @#{gate_type}[#{gate.is_a?(Symbol) ? ':' : ''}#{gate}]: #{unknown_routines}"
+              fail
+            end
+          end
+        else
+          Origen.log.error "Profile #{id}: Unknown #{gate_type} type: #{gates.class}. #{gate_type} must be of type Symbol, String, Array, or Hash"
+          fail
+        end
+      end
+
+      def method_missing(m, *args, &block)
+        ivar = "@#{m.to_s.gsub('=', '')}"
+        ivar_sym = ":#{ivar}"
+        if m.to_s =~ /=$/
+          define_singleton_method(m) do |val|
+            instance_variable_set(ivar, val)
+          end
+        elsif instance_variables.include? ivar_sym
+          instance_variable_get(ivar)
+        else
+          define_singleton_method(m) do
+            instance_variable_get(ivar)
+          end
+        end
+        send(m, *args, &block)
+      end
+    end
+  end
+end

data/lib/origen_testers/charz/routine.rb

@@ -0,0 +1,38 @@
+module OrigenTesters
+  module Charz
+    # A Generic charz routine
+    # Used to store characterization test specific meta data, values of which are used by the user to determine test parameter values
+    class Routine
+      # @!attribute id
+      #   @return [Symbol] charz routine symbol, used as a key in OrigenTesters::Charz#charz_routines
+      # @!attribute name
+      #   @return [Symbol] the value used (if the user decides) to generate the name of the created charz test. defaults to the value of @id
+      attr_accessor :id, :name
+
+      def initialize(id, options = {}, &block)
+        @id = id
+        @id = @id.symbolize unless id.is_a? Symbol
+        options.each { |k, v| instance_variable_set("@#{k}", v) }
+        (block.arity < 1 ? (instance_eval(&block)) : block.call(self)) if block_given?
+        @name ||= @id
+      end
+
+      def method_missing(m, *args, &block)
+        ivar = "@#{m.to_s.gsub('=', '')}"
+        ivar_sym = ":#{ivar}"
+        if m.to_s =~ /=$/
+          define_singleton_method(m) do |val|
+            instance_variable_set(ivar, val)
+          end
+        elsif instance_variables.include? ivar_sym
+          instance_variable_get(ivar)
+        else
+          define_singleton_method(m) do
+            instance_variable_get(ivar)
+          end
+        end
+        send(m, *args, &block)
+      end
+    end
+  end
+end

data/lib/origen_testers/charz/routines/search_routine.rb

@@ -0,0 +1,42 @@
+module OrigenTesters
+  module Charz
+    # a 1D search routine
+    class SearchRoutine < Routine
+      # @!attribute start
+      #   @return [Numeric] search start value
+      # @!attribute stop
+      #   @return [Numeric] search stop value
+      # @!attribute res
+      #   @return [Numeric] search resolution
+      # @!attribute spec
+      #   @return [Numeric] spec parameter to be searched
+      attr_accessor :start, :stop, :res, :spec
+
+      # Runs the same initialization as Routine
+      # performs some rudimentary quality checks, which can be disabled by setting @quality_check = false
+      def initialize(id, options = {}, &block)
+        super
+        attrs_ok?
+      end
+
+      def attrs_ok?
+        return if @quality_check == false
+
+        @required_attrs ||= [:start, :stop, :res, :spec]
+        attrs = @required_attrs.map { |attr| instance_variable_get("@#{attr}") }
+        if attrs.compact.size != @required_attrs.size
+          Origen.log.error "SearchRoutine #{@id}: unspecified attributes, each of #{@required_attrs} must have a value"
+          fail
+        end
+
+        return if @attr_value_check == false
+        if [@start, @stop, @res].all? { |attr| attr.is_a? Numeric }
+          unless @res <= (@start - @stop).abs
+            Origen.log.error "SearchRoutine #{@id}: Search resolution (#{@res}) is larger than the search range: #{(@start - @stop).abs}"
+            fail
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/charz/routines/shmoo_routine.rb

@@ -0,0 +1,62 @@
+module OrigenTesters
+  module Charz
+    # A 2D search or "Shmoo" routine
+    class ShmooRoutine < Routine
+      # @!attribute x_start
+      #   @return [Numeric] the starting search value for the x dimension's spec search
+      # @!attribute x_stop
+      #   @return [Numeric] the stopping search value for the x dimension's spec search
+      # @!attribute x_res
+      #   @return the search resolution value for the x dimension's spec search
+      # @!attribute x_spec
+      #   @return [Symbol, String] the spec parameter of interest for the x dimension
+      attr_accessor :x_start, :x_stop, :x_res, :x_spec
+      # @!attribute y_start
+      #   @return [Numeric] the starting search value for the x dimension's spec search
+      # @!attribute y_stop
+      #   @return [Numeric] the stopping search value for the x dimension's spec search
+      # @!attribute y_res
+      #   @return the search resolution value for the x dimension's spec search
+      # @!attribute y_spec
+      #   @return [Symbol, String] the spec parameter of interest for the x dimension
+      attr_accessor :y_start, :y_stop, :y_res, :y_spec
+
+      def initialize(id, options = {}, &block)
+        super
+        attrs_ok?
+      end
+
+      def attrs_ok?
+        return if @quality_check == false
+
+        @required_attrs ||= [:x_start, :x_stop, :x_res, :x_spec, :y_start, :y_stop, :y_res, :y_spec]
+        attrs = @required_attrs.map { |attr| instance_variable_get("@#{attr}") }
+        if attrs.compact.size != @required_attrs.size
+          Origen.log.error "ShmooRoutine #{@id}: unspecified attributes, each of #{@required_attrs} must have a value"
+          fail
+        end
+
+        return if @attr_value_check == false
+
+        # not sure if I want this check, if so need to scope out if step count is common
+
+        # if [@x_start, @x_stop, @x_res].all? { |attr| attr.is_a? Numeric }
+        #   unless @x_res <= (@x_start - @x_stop).abs
+        #     Origen.log.error "ShmooRoutine #{@id}: Search x_resolution (#{@x_res} is larger than the search x_range (#{@x_start - @x_stop).abs})"
+        #     fail
+        #   end
+        # end
+        # if [@y_start, @y_stop, @y_res].all? { |attr| attr.is_a? Numeric }
+        #   unless @y_res <= (@y_start - @y_stop).abs
+        #     Origen.log.error "ShmooRoutine #{@id}: Search y_resolution (#{@y_res} is larger than the search y_range (#{@y_start - @y_stop).abs})"
+        #     fail
+        #   end
+        # end
+        unless @x_spec != @y_spec
+          Origen.log.error "ShmooRoutine #{@id}: Search x_spec is identical to y_spec"
+          fail
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/charz/session.rb

@@ -0,0 +1,100 @@
+module OrigenTesters
+  module Charz
+    # A charz session
+    # contains the final combination of charz object (routines/profiles) and user options to determine how and what charz tests should be created
+    # the session should be checked in your interface to determine the current status and can be queried to make charz generation decisions
+    class Session < Profile
+      # @!attribute defaults
+      #   @return [Hash] list of values to instantiate the inherited attributes from Profile with if not altered by the session update
+      attr_accessor :defaults
+
+      def initialize(options = {})
+        @id = :current_charz_session
+        @active = false
+        @valid = false
+        if options[:defaults]
+          @defaults = options[:defaults]
+        else
+          @defaults = {
+            placement:  :inline,
+            on_result:  nil,
+            enables:    nil,
+            flags:      nil,
+            name:       'charz',
+            charz_only: false
+          }
+        end
+      end
+
+      # Pauses the current session's activity while maintaining everthing else about the sessions state
+      def pause
+        @active = false
+      end
+
+      # Resume activity, if the session is valid
+      def resume
+        if @valid
+          @active = true
+        end
+      end
+
+      # Takes a Routine or Profile, and queries it to setup the session's attributes
+      # the attributes values can be set from 3 different sources, in order of priority (first is most important):
+      #   - options
+      #   - charz object
+      #   - defaults
+      #
+      # If the resulting session is invalid, @valid will turn false. Otherwise, the session becomes active
+      def update(charz_obj, options)
+        @valid = false
+        if charz_obj.nil?
+          @active = false
+          @valid = false
+          return @valid
+        end
+        @defined_routines = options.delete(:defined_routines)
+        assign_by_priority(:placement, charz_obj, options)
+        assign_by_priority(:on_result, charz_obj, options)
+        assign_by_priority(:enables, charz_obj, options)
+        assign_by_priority(:flags, charz_obj, options)
+        assign_by_priority(:routines, charz_obj, options)
+        assign_by_priority(:name, charz_obj, options)
+        assign_by_priority(:charz_only, charz_obj, options)
+        attrs_ok?
+        massage_gates
+        @active = true
+        @valid = true
+      end
+
+      private
+
+      # convert hash gates to set convert their routines to type array if not already
+      def massage_gates
+        if @enables.is_a?(Hash)
+          @enables = {}.tap do |new_h|
+            @enables.each { |gates, routines| new_h[gates] = [routines].flatten }
+          end
+        end
+        if @flags.is_a?(Hash)
+          @flags = {}.tap do |new_h|
+            @flags.each { |gates, routines| new_h[gates] = [routines].flatten }
+          end
+        end
+      end
+
+      # see initialize
+      def assign_by_priority(ivar, charz_obj, options)
+        if options.keys.include?(ivar)
+          instance_variable_set("@#{ivar}", options[ivar])
+        elsif charz_obj.send(ivar)
+          instance_variable_set("@#{ivar}", charz_obj.send(ivar))
+        elsif @defaults.keys.include?(ivar)
+          instance_variable_set("@#{ivar}", @defaults[ivar])
+        else
+          Origen.log.error "Charz Session: No value could be determined for #{ivar}"
+          fail
+        end
+      end
+    end
+  end
+end

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

@@ -430,7 +430,8 @@ module OrigenTesters
         end
 
         def clean_flag(flag)
-          flag = flag.to_s
+          # Added .dup to below line to get an unfrozen copy of the string, corrects a run time error
+          flag = flag.to_s.dup
           if flag[0] == '$'
             flag[0] = ''
           end

data/lib/origen_testers/igxl_based_tester/ultraflex/flow.rb

@@ -10,14 +10,20 @@ module OrigenTesters
         def on_test(node)
           super
           ins = node.find(:object).value
-          if ins.respond_to?(:lo_limit) && (ins.lo_limit || ins.hi_limit) || ins.respond_to?(:lo) && (ins.lo || ins.hi)
+
+          # allow defer limits when limits are only given in sub tests
+          if ins.respond_to?(:defer_limits)
             if ins.defer_limits
               completed_lines.last.opcode = 'Test-defer-limits'
             end
+          end
+
+          if ins.respond_to?(:lo_limit) && (ins.lo_limit || ins.hi_limit) || ins.respond_to?(:lo) && (ins.lo || ins.hi)
             limit = completed_lines.last.dup
             limit.type = :use_limit
             limit.opcode = 'Use-Limit'
             limit.parameter = nil
+            limit.tnum = nil                            # Don't duplate test numbers, allow auto-increment by leaving blank
             if ins.respond_to?(:lo_limit)
               lo = ins.lo_limit
               hi = ins.hi_limit

data/lib/origen_testers/labview_based_tester/pxie6570.rb

@@ -36,7 +36,7 @@ module OrigenTesters
         unless options[:subroutine_pat]
           stage.with_bank(:body) do
             # find the first vector
-            stage.bank.delete_at(0) until stage.bank[0].is_a?(OrigenTesters::Vector)
+            stage.bank.delete_at(0) until stage.bank[0].is_a?(OrigenTesters::Vector) || stage.bank.empty?
           end
         end
       end

data/lib/origen_testers/origen_ext/generator/flow.rb

@@ -138,6 +138,7 @@ module Origen
           end
           Origen.interface.startup(options) if Origen.interface.respond_to?(:startup)
           interface.instance_eval(&block)
+          Origen.interface.generate_eof_charz_tests if Origen.interface.respond_to?(:generate_eof_charz_tests)
           Origen.interface.shutdown(options) if Origen.interface.respond_to?(:shutdown)
           interface.at_flow_end if interface.respond_to?(:at_flow_end)
           Origen.app.listeners_for(:on_flow_end).each do |listener|

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

@@ -119,6 +119,7 @@ module OrigenTesters
           o[:test_name] = extract_test_name(node, o)
           o[:test_number] = extract_test_number(node, o)
           o[:limits] = extract_limits(node, o)
+          o[:test_text] = node.find(:test_text).try(:value)
           if on_fail = node.find(:on_fail)
             if set_result = on_fail.find(:set_result)
               if bin = set_result.find(:bin)
@@ -252,9 +253,12 @@ module OrigenTesters
             # "Test Number"
             l << f(options[:test_number])
             # "Test Text"
-            # l << f(options[:bin_s_name] || options[:bin_h_name])
-            names = ["#{options[:suite_name]}", "#{options[:test_name]}"]
-            l << f(names.uniq.join('.'))
+            if options[:test_text]
+              l << f(options[:test_text])
+            else
+              names = ["#{options[:suite_name]}", "#{options[:test_name]}"]
+              l << f(names.uniq.join('.'))
+            end
             if test_modes.empty?
               # "Low Limit"
               l << f((options[:limits][nil] || {})[:lsl])

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

@@ -35,21 +35,25 @@ module OrigenTesters
 
         # 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)
-            # Need to use strings for the comparison as some flags can be a string and some a symbol
-            x.to_s <=> y.to_s
+          if variables
+            (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)
+              # Need to use strings for the comparison as some flags can be a string and some a symbol
+              x.to_s <=> y.to_s
+            end
           end
         end
 
         # 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)
-            # Need to use strings for the comparison as some declarations can be a string and some a symbol
-            x.to_s <=> y.to_s
+          if variables
+            (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)
+              # Need to use strings for the comparison as some declarations can be a string and some a symbol
+              x.to_s <=> y.to_s
+            end
           end
         end