origen_testers 0.4.0

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

@@ -0,0 +1,171 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Flow
+        include OrigenTesters::Generator
+        include OrigenTesters::Generator::FlowControlAPI
+
+        OUTPUT_POSTFIX = 'flow'
+
+        def add(type, options = {})
+          ins = false
+          options = save_context(options) if [:test, :cz].include?(type)
+          branch_unless_enabled(options) do |options|
+            ins = track_relationships(options) do |options|
+              platform::FlowLine.new(type, options)
+            end
+            collection << ins unless Origen.interface.resources_mode?
+            if ins.test?
+              c = Origen.interface.consume_comments
+              unless Origen.interface.resources_mode?
+                Origen.interface.descriptions.add_for_test_usage(ins.parameter, Origen.interface.top_level_flow, c)
+              end
+            else
+              Origen.interface.discard_comments
+            end
+          end
+          ins
+        end
+
+        def logprint(message, options = {})
+          message.gsub!(/\s/, '_')
+          add(:logprint, options.merge(parameter: message))
+        end
+
+        def test(instance, options = {})
+          add(:test, options.merge(parameter: instance))
+        end
+
+        def cz(instance, cz_setup, options = {})
+          add(:cz, options.merge(parameter: instance, cz_setup: cz_setup))
+        end
+
+        def use_limit(name, options = {})
+          add(:use_limit, options)
+        end
+
+        def goto(label, options = {})
+          add(:goto, options.merge(parameter: label))
+        end
+
+        def nop(options = {})
+          add(:nop, options.merge(parameter: nil))
+        end
+
+        def set_device(options = {})
+          add(:set_device, options)
+        end
+
+        def set_error_bin(options = {})
+          add(:set_error_bin, options)
+        end
+
+        def enable_flow_word(word, options = {})
+          add(:enable_flow_word, options.merge(parameter: word))
+        end
+
+        def disable_flow_word(word, options = {})
+          add(:disable_flow_word, options.merge(parameter: word))
+        end
+
+        def flag_false(name, options = {})
+          add(:flag_false, options.merge(parameter: name))
+        end
+
+        def flag_false_all(name, options = {})
+          add(:flag_false_all, options.merge(parameter: name))
+        end
+
+        #        def flag_true(name, options = {})
+        def flag_true(options = {})
+          add(:flag_true, options)
+        end
+
+        def flag_true_all(name, options = {})
+          add(:flag_true_all, options.merge(parameter: name))
+        end
+
+        # Generates 2 flow lines of flag-true to help set a single flag based on OR of 2 other flags
+        def or_flags(name1, name2, options = {})
+          options = {
+            condition: :fail, # condition to check for
+            flowname:  false,  # if flowname provided
+          }.merge(options)
+
+          case options[:condition]
+            when :fail
+              options[:condition] = 'FAILED'
+            when :pass
+              options[:condition] = 'PASSED'
+            else
+              options[:condition] = 'RAN'
+          end
+          id = options.delete(:id)  # get original ID
+
+          # set parameter names
+          parameter = "#{id}"
+          parameter += "_#{options[:flowname]}" if options[:flowname]
+          parameter += "_#{options[:condition]}"
+
+          options[:id] = id
+          add(:flag_true_all, options.merge(parameter: parameter))
+          options.delete(:id)
+          add(:flag_false, options.merge(parameter: parameter, if_passed: name1, result: '', flag_pass: '', flag_fail: '')) # No ID
+          add(:flag_false, options.merge(parameter: parameter, if_passed: name2)) # No ID
+          nop
+        end
+
+        # All tests generated will not run unless the given enable word is asserted.
+        #
+        # This is specially implemented for J750 since it does not have a native
+        # support for flow word not enabled.
+        # It will generate a goto branch around the tests contained with the block
+        # if the given flow word is enabled.
+        def unless_enable(word, options = {})
+          if options[:or]
+            yield
+          else
+            @unless_enable_block = word
+            options = options.merge(unless_enable: word)
+            branch_unless_enabled(options.merge(_force_unless_enable: true)) do
+              yield
+            end
+            @unless_enable_block = nil
+          end
+        end
+        alias_method :unless_enabled, :unless_enable
+
+        def start_flow_branch(identifier, options = {})
+          goto(identifier, options)
+        end
+
+        def skip(identifier = nil, options = {})
+          identifier, options = nil, identifier if identifier.is_a?(Hash)
+          identifier = generate_unique_label(identifier)
+          goto(identifier, options)
+          yield
+          nop(label: identifier)
+        end
+
+        private
+
+        # If the test has an unless_enable then branch around it
+        def branch_unless_enabled(options)
+          word = options.delete(:unless_enable) || options.delete(:unless_enabled)
+          if word && (word != @unless_enable_block || options.delete(:_force_unless_enable))
+            # Not sure if this is really required, but duplicating these hashes here to ensure
+            # that all other flow context keys are preserved and applied to the branch lines
+            orig_options = options.merge({})
+            close_options = options.merge({})
+            label = generate_unique_label
+            goto(label, options.merge(if_enable: word))
+            yield orig_options
+            nop(close_options.merge(label: label))
+          else
+            yield options
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,322 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class FlowLine
+        attr_accessor :type, :id, :cz_setup # cz_setup is a virtual attrib since it is not part of the regular flow line
+        # cz_setup combine with instance name when characterize opcode is used
+
+        # Map any aliases to the official names here, multiple aliases for a given attribute
+        # are allowed
+        ALIASES = {
+          bin:            :bin_fail,
+          softbin:        :sort_fail,
+          soft_bin:       :sort_fail,
+          sbin:           :sort_fail,
+          name:           :tname,
+          number:         :tnum,
+          if_enable:      :enable,
+          if_enabled:     :enable,
+          enabled:        :enable,
+          hi_limit:       :hilim,
+          hi:             :hilim,
+          lo_limit:       :lolim,
+          lo:             :lolim,
+          # Aliases can also be used to set defaults on multiple attributes like this,
+          # use :value to refer to the value passed in to the given alias
+          flag_false:     { device_condition: 'flag-false',
+                            device_name:      :value
+                         },
+          flag_true:      { device_condition: 'flag-true',
+                            device_name:      :value
+                         },
+          flag_false_any: { group_specifier: 'any-active',
+                            group_condition: 'flag-false',
+                            group_name:      :value
+                             },
+          flag_false_all: { group_specifier: 'all-active',
+                            group_condition: 'flag-false',
+                            group_name:      :value
+                             },
+          flag_true_any:  { group_specifier: 'any-active',
+                            group_condition: 'flag-true',
+                            group_name:      :value
+                            },
+          flag_true_all:  { group_specifier: 'all-active',
+                            group_condition: 'flag-true',
+                            group_name:      :value
+                            },
+          flag_clear:     { device_condition: 'flag-clear',
+                            device_name:      :value
+                         }
+        }
+
+        # Assign attribute defaults here, generally this should match whatever defaults
+        # Teradyne has set whenever you create a new test instance, etc.
+        DEFAULTS = {
+          test:              {
+            opcode: 'Test',
+            result: 'Fail'
+          },
+          cz:                {
+            opcode: 'characterize',
+            result: 'None'
+          },
+          goto:              {
+            opcode: 'goto'
+          },
+          nop:               {
+            opcode: 'nop'
+          },
+          set_device:        {
+            opcode: 'set-device'
+          },
+          set_error_bin:     {
+            opcode: 'set-error-bin'
+          },
+          enable_flow_word:  {
+            opcode: 'enable-flow-word'
+          },
+          disable_flow_word: {
+            opcode: 'disable-flow-word'
+          },
+          logprint:          {
+            opcode: 'logprint'
+          },
+          use_limit:         {
+            opcode: 'Use-Limit',
+            result: 'Fail'
+          },
+          flag_false:        {
+            opcode: 'flag-false'
+          },
+          flag_false_all:    {
+            opcode: 'flag-false-all'
+          },
+          flag_true:         {
+            opcode: 'flag-true'
+          },
+          flag_true_all:     {
+            opcode: 'flag-true-all'
+          }
+        }
+
+        def self.define
+          # Generate accessors for all attributes and their aliases
+          self::TESTER_FLOWLINE_ATTRS.each do |attr|
+            writer = "#{attr}=".to_sym
+            reader = attr.to_sym
+            attr_reader attr.to_sym unless method_defined? reader
+            attr_writer attr.to_sym unless method_defined? writer
+          end
+
+          ALIASES.each do |_alias, val|
+            if val.is_a? Hash
+              if ((self::TESTER_FLOWLINE_ATTRS.map(&:to_sym)) & val.keys) == val.keys
+                writer = "#{_alias}=".to_sym
+                unless method_defined? writer
+                  define_method("#{_alias}=") do |v|
+                    val.each do |k, _v|
+                      myval = _v == :value ? v : _v
+                      send("#{k}=", myval)
+                    end
+                  end
+                end
+              end
+            else
+
+              if self::TESTER_FLOWLINE_ATTRS.include? "#{val}"
+                writer = "#{_alias}=".to_sym
+                reader = _alias.to_sym
+                unless method_defined? writer
+                  define_method("#{_alias}=") do |v|
+                    send("#{val}=", v)
+                  end
+                end
+                unless method_defined? reader
+                  define_method("#{_alias}") do
+                    send(val)
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def initialize(type, attrs = {})
+          @ignore_missing_instance = attrs.delete(:instance_not_available)
+          self.cz_setup = attrs.delete(:cz_setup)
+          @type = type
+          # Set the defaults
+          DEFAULTS[@type.to_sym].each do |k, v|
+            send("#{k}=", v) if self.respond_to?("#{k}=")
+          end
+          # Then the values that have been supplied
+          attrs.each do |k, v|
+            send("#{k}=", v) if self.respond_to?("#{k}=")
+          end
+        end
+
+        def parameter=(value)
+          if (@type == :test || @test == :cz) && !@ignore_missing_instance
+            if value.is_a?(String) || value.is_a?(Symbol)
+              fail "You must supply the actual test instance object for #{value} when adding it to the flow"
+            end
+          end
+          @parameter = value
+        end
+
+        def parameter
+          # When referring to the test instance take the opportunity to refresh the current
+          # version of the test instance
+          @parameter = Origen.interface.identity_map.current_version_of(@parameter)
+        end
+
+        # Returns the fully formatted flow line for insertion into a flow sheet
+        def to_s
+          l = "\t"
+          self.class::TESTER_FLOWLINE_ATTRS.each do |attr|
+            if attr == 'parameter'
+              ins = parameter
+              if ins.respond_to?(:name)
+                l += "#{ins.name}"
+              else
+                l += "#{ins}"
+              end
+              if type == :cz && cz_setup
+                l += " #{cz_setup}\t"
+              else
+                l += "\t"
+              end
+            else
+              l += "#{send(attr)}\t"
+            end
+          end
+          "#{l}"
+        end
+
+        def job
+          if !if_jobs.empty? && !unless_jobs.empty?
+            fail "Both if and unless jobs have been defined for test: #{parameter}"
+          elsif !if_jobs.empty?
+            if_jobs.join(',')
+          elsif !unless_jobs.empty?
+            unless_jobs.map { |j| "!#{j}" }.join(',')
+          else
+            ''
+          end
+        end
+        alias_method :jobs, :job
+
+        def unless_enable=(*args)
+        end
+        alias_method :unless_enabled=, :unless_enable=
+
+        def if_jobs
+          @if_jobs ||= []
+        end
+
+        def unless_jobs
+          @unless_jobs ||= []
+        end
+
+        def if_job=(jobs)
+          [jobs].flatten.compact.each do |job|
+            job = job.to_s.upcase
+            if job =~ /!/
+              self.unless_job = job
+            else
+              if_jobs << job unless if_jobs.include?(job)
+            end
+          end
+        end
+        alias_method :if_jobs=, :if_job=
+        alias_method :add_if_jobs, :if_job=
+        alias_method :add_if_job, :if_job=
+
+        def unless_job=(jobs)
+          [jobs].flatten.compact.each do |job|
+            job = job.to_s.upcase
+            job.gsub!('!', '')
+            unless_jobs << job unless unless_jobs.include?(job)
+          end
+        end
+        alias_method :unless_jobs=, :unless_job=
+        alias_method :add_unless_jobs, :unless_job=
+        alias_method :add_unless_job, :unless_job=
+
+        def continue_on_fail
+          self.result = 'None'
+        end
+
+        def continue_pass
+          self.result = 'Pass'
+        end
+
+        def debug_assume_pass
+          self.debug_assume = 'Pass'
+        end
+
+        def debug_assume_fail
+          self.debug_assume = 'Fail'
+        end
+
+        #          def debug_sites
+        #            self.debug_sites = "All"
+        #          end
+
+        def set_flag_on_fail
+          self.flag_fail = "#{id}_FAILED"
+        end
+
+        def set_flag_on_pass
+          self.flag_pass = "#{id}_PASSED"
+        end
+
+        def set_flag_on_ran
+          self.flag_pass = "#{id}_RAN"
+        end
+
+        def run_if_any_passed(parent)
+          parent.continue_on_fail
+          self.flag_true_any = parent.set_flag_on_pass
+        end
+
+        def run_if_all_passed(parent)
+          parent.continue_on_fail
+          self.flag_true_all = parent.set_flag_on_pass
+        end
+
+        def run_if_any_failed(parent)
+          parent.continue_on_fail
+          self.flag_true_any = parent.set_flag_on_fail
+        end
+
+        def run_if_all_failed(parent)
+          parent.continue_on_fail
+          self.flag_true_all = parent.set_flag_on_fail
+        end
+
+        def run_if_all_(args)
+          # code
+        end
+
+        def id
+          @id || "#{parameter}_#{unique_counter}"
+        end
+
+        def unique_counter
+          @unique_counter ||= self.class.unique_counter
+        end
+
+        def self.unique_counter
+          @ix ||= -1
+          @ix += 1
+        end
+
+        def test?
+          @type == :test
+        end
+      end
+    end
+  end
+end