origen 0.0.1 → 0.0.2

data/lib/origen/tester/timing.rb

@@ -0,0 +1,253 @@
+module Origen
+  module Tester
+    module Timing
+      class Timeset
+        attr_accessor :name, :period_in_ns
+
+        def initialize(attrs = {})
+          attrs.each do |name, value|
+            send("#{name}=", value)
+          end
+        end
+      end
+
+      # Set the timeset for the next vectors, this will remain in place until the next
+      # time this is called.
+      #
+      #   $tester.set_timeset("bist_25mhz", 40)
+      #
+      # This method also accepts a block in which case the contained vectors will generate
+      # with the supplied timeset and subsequent vectors will return to the previous timeset
+      # automatically.
+      #
+      #   $tester.set_timeset("bist_25mhz", 40) do
+      #     $tester.cycle
+      #   end
+      #
+      # The arguments can also be supplied as a single array, or not at all. In the latter case
+      # the existing timeset will simply be preserved. This is useful if you have timesets that
+      # can be conditionally set based on the target.
+      #
+      #   # Target 1
+      #   $soc.readout_timeset = ["readout", 120]
+      #   # Target 2
+      #   $soc.readout_timeset = false
+      #
+      #   # This code is compatible with both targets, in the first case the timeset will switch
+      #   # over, in the second case the existing timeset will be preserved.
+      #   $tester.set_timeset($soc.readout_timeset) do
+      #     $tester.cycle
+      #   end
+      def set_timeset(timeset, period_in_ns = nil)
+        if timeset.is_a?(Array)
+          timeset, period_in_ns = timeset[0], timeset[1]
+        end
+        timeset ||= @timeset
+        unless timeset.is_a?(Timeset)
+          fail 'You must supply a period_in_ns argument to set_timeset' unless period_in_ns
+          timeset = Timeset.new(name: timeset.to_s.chomp, period_in_ns: period_in_ns)
+        end
+        called_timesets << timeset unless called_timesets.map(&:name).include?(timeset.name)
+        if block_given?
+          original = @timeset
+          timeset_changed(timeset)
+          @timeset = timeset
+          yield
+          timeset_changed(original)
+          @timeset = original
+        else
+          timeset_changed(timeset)
+          @timeset = timeset
+        end
+      end
+
+      def timeset_changed(timeset)
+        if last_vector && last_vector.timeset != timeset
+          change = { old: last_vector.timeset, new: timeset }
+          # Suppress any duplicate calls
+          if !@_last_timeset_change ||
+             (@_last_timeset_change[:new] != change[:new] &&
+               @_last_timeset_change[:old] != change[:old])
+            before_timeset_change(change)
+          end
+          @_last_timeset_change = change
+        end
+      end
+
+      def before_timeset_change(_options = {})
+      end
+
+      # Cause the pattern to wait.
+      # The following options are available to help you specify the time to wait:
+      # * :cycles - delays specified in raw cycles, the test model is responsible for translating this into a sequence of valid repeat statements
+      # * :time_in_ns - time specified in nano-seconds
+      # * :time_in_us - time specified in micro-seconds
+      # * :time_in_ms - time specified in milli-seconds
+      # * :time_in_s - time specified in seconds
+      # If more than one option is supplied they will get added together to give a final
+      # delay time expressed in cycles.
+      # ==== Examples
+      #   $tester.wait(:cycles => 100, :time_in_ns => 200)   # Wait for 100 cycles + 200ns
+      # This method can also be used to trigger a match loop in which case the supplied time
+      # becomes the time out for the match. See the J750#match method for full details of the
+      # available options.
+      #   $tester.wait(:match => true, :state => :high, :pin => $top.pin(:done), :time_in_ms => 500)
+      def wait(options = {})
+        options = {
+          cycles:         0,
+          time_in_cycles: 0,
+          time_in_us:     0,
+          time_in_ns:     0,
+          time_in_ms:     0,
+          time_in_s:      0,
+          match:          false,   # Set to true to invoke a match loop where the supplied delay
+          # will become the timeout duration
+        }.merge(options)
+
+        cycles = 0
+        cycles += options[:cycles] + options[:time_in_cycles]
+        cycles += s_to_cycles(options[:time_in_s])
+        cycles += ms_to_cycles(options[:time_in_ms])
+        cycles += us_to_cycles(options[:time_in_us])
+        cycles += ns_to_cycles(options[:time_in_ns])
+
+        time = cycles * current_period_in_ns   # Total delay in ns
+        case
+          when time < 1000                      # When less than 1us
+            cc "Wait for #{'a maximum of ' if options[:match]}#{time}ns"
+          when time < 1_000_000                   # When less than 1ms
+            cc "Wait for #{'a maximum of ' if options[:match]}#{(time.to_f / 1000).round(1)}us"        # Display delay in us
+          when time < 1_000_000_000                # When less than 1s
+            cc "Wait for #{'a maximum of ' if options[:match]}#{(time.to_f / 1_000_000).round(1)}ms"
+          else
+            cc "Wait for #{'a maximum of ' if options[:match]}%.2fs" % (time.to_f / 1_000_000_000)
+        end
+
+        if cycles > 0   # Allow this function to be called with 0 in which case it will just return
+          if options[:match]
+            if block_given?
+              match_block(cycles, options) { yield }
+            else
+              match(options[:pin], options[:state], cycles, options)
+            end
+          else
+            delay(cycles)
+          end
+        end
+      end
+
+      # @api private
+      # This should not be called directly, call via tester#wait
+      def delay(cycles, options = {})
+        (cycles / max_repeat_loop).times do
+          if block_given?
+            yield options.merge(repeat: max_repeat_loop)
+          else
+            cycle(options.merge(repeat: max_repeat_loop))
+          end
+        end
+        if block_given?
+          yield options.merge(repeat: (cycles % max_repeat_loop))
+        else
+          cycle(options.merge(repeat: (cycles % max_repeat_loop)))
+        end
+      end
+
+      def max_repeat_loop
+        @max_repeat_loop || 65_535
+      end
+
+      def s_to_cycles(time) # :nodoc:
+        ((time.to_f) * 1000 * 1000 * 1000 / current_period_in_ns).to_int
+      end
+
+      def ms_to_cycles(time) # :nodoc:
+        ((time.to_f) * 1000 * 1000 / current_period_in_ns).to_int
+      end
+
+      def us_to_cycles(time) # :nodoc:
+        ((time.to_f * 1000) / current_period_in_ns).to_int
+      end
+
+      def ns_to_cycles(time) # :nodoc:
+        (time.to_f / current_period_in_ns).to_int
+      end
+
+      def cycles_to_us(cycles) # :nodoc:
+        ((cycles.to_f * current_period_in_ns) / (1000)).ceil
+      end
+
+      def cycles_to_ms(cycles) # :nodoc:
+        ((cycles.to_f * current_period_in_ns) / (1000 * 1000)).ceil
+      end
+
+      # Cycles to tenths of a second
+      def cycles_to_ts(cycles) # :nodoc:
+        ((cycles.to_f * current_period_in_ns) / (1000 * 1000 * 100)).ceil
+      end
+
+      def called_timesets
+        @called_timesets ||= []
+      end
+
+      def current_period_in_ns
+        if @timeset
+          @timeset.period_in_ns
+        else
+          fail 'No timeset has been specified yet!'
+        end
+      end
+      alias_method :current_period, :current_period_in_ns
+      alias_method :period, :current_period_in_ns
+
+      def current_timeset
+        @timeset
+      end
+      alias_method :timeset, :current_timeset
+
+      # Convert the supplied number of cycles to a time, based on the SoC defined cycle period
+      def cycles_to_time(cycles) # :nodoc:
+        (cycles * current_period_in_ns).to_f / 1_000_000_000
+      end
+
+      # This function can be used to generate a clock or some other repeating function
+      # that spans accross a range of vectors.
+      # The period of each cycle and the duration of the sequence are supplied via the following
+      # options:
+      # * :period_in_cycles
+      # * :period_in_ns
+      # * :period_in_us
+      # * :period_in_ms
+      # * :duration_in_cycles
+      # * :duration_in_ns
+      # * :duration_in_us
+      # * :duration_in_ms
+      # If multiple definitions for either option are supplied then they will be added
+      # together.
+      # ==== Example
+      #   # Supply a clock pulse on :pinA for 100ms
+      #   $tester.count(:period_in_cycles => 10, :duration_in_ms => 100) do
+      #       $top.pin(:pinA).drive!(1)
+      #       $top.pin(:pinA).drive!(0)
+      #   end
+      def count(options = {})
+        options = { period_in_cycles: 0, period_in_ms: 0, period_in_us: 0, period_in_ns: 0,
+                    duration_in_cycles: 0, duration_in_ms: 0, duration_in_us: 0, duration_in_ns: 0
+                  }.merge(options)
+
+        period_cycles = options[:period_in_cycles] + ms_to_cycles(options[:period_in_ms]) +
+                        us_to_cycles(options[:period_in_us]) + ns_to_cycles(options[:period_in_ns])
+
+        duration_cycles = options[:duration_in_cycles] + ms_to_cycles(options[:duration_in_ms]) +
+                          us_to_cycles(options[:duration_in_us]) + ns_to_cycles(options[:duration_in_ns])
+
+        total = 0
+        while total < duration_cycles
+          wait(time_in_cycles: period_cycles)
+          yield								# Return control back to caller
+          total += period_cycles
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/files.rb

@@ -0,0 +1,45 @@
+module Origen
+  module Tester
+    class Ultraflex
+      # Methods for handling all Ultraflex file parsing, e.g. datalogs,
+      # test time profiles, etc.
+      module Files
+        # Reads all lines from a Ultraflex detailed execution time file, returning the lines
+        # as an array like this:
+        #
+        #   [
+        #     {:name => "power_cycle", :index => 1, :group => 3, :time => 0.00461},
+        #     {:name => "power_cycle", :index => 2, :group => 3, :time => 0.00481},
+        #     {:name => "power_cycle", :index => 3, :group => 3, :time => 0.00438},
+        #     {:name => "nvm_mass_erase", :index => nil, :group => nil, :time => 0.19863},
+        #   ]
+        def read_test_times(file, _options = {})
+          tests = []
+          File.readlines(file).each do |line|
+            unless line.strip.empty? || line =~ /Entire Job/
+              # http://rubular.com/r/vZOcqovTsf
+              if line =~ /(\w+) ?(\(.*?\))?  \d\d\d\d  (\d+\.\d+).*/
+                t = { name: Regexp.last_match[1], time: Regexp.last_match[3].to_f.round(6) }
+                # If an indexed test
+                if Regexp.last_match[2]
+                  str = Regexp.last_match[2].gsub('(', '').gsub(')', '')
+                  fields = str.split('/')
+                  i = fields[0].to_i
+                  g = fields[1].to_i
+                  t[:index] = i
+                  t[:group] = g
+
+                else
+                  t[:index] = nil
+                  t[:group] = nil
+                end
+                tests << t
+              end
+            end
+          end
+          tests
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/generator/flow.rb

@@ -0,0 +1,119 @@
+module Origen
+  module Tester
+    class Ultraflex
+      module Generator
+        class Flow
+          include Origen::Tester::Generator
+          include Origen::Tester::Generator::FlowControlAPI
+
+          TEMPLATE = "#{Origen.top}/lib/origen/tester/ultraflex/generator/templates/flow.txt.erb"
+          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|
+                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 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 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
+
+          # All tests generated will not run unless the given enable word is asserted.
+          #
+          # This is specially implemented for Ultraflex 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
+end

data/lib/origen/tester/ultraflex/generator/flow_line.rb

@@ -0,0 +1,269 @@
+module Origen
+  module Tester
+    class Ultraflex
+      module Generator
+        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
+
+          # Attributes for each flow line, these must be declared in the order they are to be output
+          ATTRS = %w(label enable job part env opcode parameter tname tnum bin_pass bin_fail
+                     sort_pass sort_fail result flag_pass flag_fail state
+                     group_specifier group_sense group_condition group_name
+                     device_sense device_condition device_name
+                     debug_assume debug_sites comment
+                  )
+
+          # 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,
+            name:           :tname,
+            number:         :tnum,
+            if_enable:      :enable,
+            if_enabled:     :enable,
+            enabled:        :enable,
+            # 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'
+            },
+            enable_flow_word:  {
+              opcode: 'enable-flow-word'
+            },
+            disable_flow_word: {
+              opcode: 'disable-flow-word'
+            },
+            logprint:          {
+              opcode: 'logprint'
+            }
+          }
+
+          # Generate accessors for all attributes and their aliases
+          ATTRS.each do |attr|
+            attr_accessor attr.to_sym
+          end
+
+          ALIASES.each do |_alias, val|
+            if val.is_a? Hash
+              define_method("#{_alias}=") do |v|
+                val.each do |k, _v|
+                  myval = _v == :value ? v : _v
+                  send("#{k}=", myval)
+                end
+              end
+            else
+              define_method("#{_alias}=") do |v|
+                send("#{val}=", v)
+              end
+              define_method("#{_alias}") do
+                send(val)
+              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"
+            ATTRS.each do |attr|
+              if attr == 'parameter'
+                ins = parameter
+                if ins.respond_to?(:name)
+                  l += "#{ins.name}"
+                else
+                  l += "#{ins}"
+                end
+                if 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 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 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
+end