origen_testers 0.45.4 → 0.48.1

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/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/flow.rb

@@ -18,7 +18,7 @@ module OrigenTesters
         # Returns an array containing all runtime variables which get set by the flow
         attr_reader :set_runtime_variables
 
-        attr_accessor :add_flow_enable, :flow_name, :flow_bypass, :flow_description
+        attr_accessor :add_flow_enable, :flow_name, :flow_bypass, :flow_description, :subdirectory
 
         def self.generate_flag_name(flag)
           case flag[0]

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/pattern_master.rb

@@ -6,7 +6,7 @@ module OrigenTesters
         include OrigenTesters::Generator
 
         attr_reader :flow, :paths
-        attr_accessor :filename, :id
+        attr_accessor :filename, :id, :subdirectory
 
         def initialize(flow = nil)
           @flow = flow
@@ -18,7 +18,7 @@ module OrigenTesters
         end
 
         def subdirectory
-          'vectors'
+          @subdirectory ||= 'vectors'
         end
 
         def paths

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

@@ -85,7 +85,13 @@ module OrigenTesters
           end
           # Finally set any initial values that have been supplied
           options[:attrs].each do |k, v|
-            send("#{k}=", v) if respond_to?("#{k}=")
+            accessor = "#{k}="
+            if respond_to?(accessor)
+              send(accessor, v)
+            else
+              accessor = "#{k.to_s.underscore}="
+              send(accessor, v) if respond_to?(accessor)
+            end
           end
         end
 

data/lib/origen_testers/smartest_based_tester/base/test_methods/base_tml.rb

@@ -13,14 +13,14 @@ module OrigenTesters
 
           def method_missing(method, *args, &block)
             if definitions[method]
-              m = platform::TestMethod.new methods: definitions[method].dup,
-                                           attrs:   (args.first || {}),
-                                           type:    method,
-                                           library: self
-              test_methods.add(m)
-              m
+              instantiate_test_method(method, args)
             else
-              super
+              method = method.to_s.underscore.to_sym
+              if definitions[method]
+                instantiate_test_method(method, args)
+              else
+                super
+              end
             end
           end
 
@@ -31,6 +31,17 @@ module OrigenTesters
           def definitions
             @definitions || self.class::TEST_METHODS
           end
+
+          private
+
+          def instantiate_test_method(method, args)
+            m = platform::TestMethod.new methods: definitions[method].dup,
+                                         attrs:   (args.first || {}),
+                                         type:    method,
+                                         library: self
+            test_methods.add(m)
+            m
+          end
         end
       end
     end