origen 0.2.6 → 0.3.0

data/lib/origen/tester/parser/searchable_array.rb

@@ -1,32 +0,0 @@
-module Origen
-  module Tester
-    module Parser
-      class SearchableArray < ::Array
-        def where(conditions)
-          exact = conditions.delete(:exact)
-          results = SearchableArray.new
-          each do |item|
-            if conditions.all? do |attr, val|
-                 if val.is_a?(Array)
-                   if exact
-                     val.any? { |v| item.send(attr).to_s == v.to_s }
-                   else
-                     val.any? { |v| item.send(attr).to_s =~ /#{v.to_s}/ }
-                   end
-                 else
-                   if exact
-                     item.send(attr).to_s == val.to_s
-                   else
-                     item.send(attr).to_s =~ /#{val.to_s}/
-                   end
-                 end
-               end
-              results << item
-            end
-          end
-          results
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/parser/searchable_hash.rb

@@ -1,32 +0,0 @@
-module Origen
-  module Tester
-    module Parser
-      class SearchableHash < ::Hash
-        def where(conditions)
-          exact = conditions.delete(:exact)
-          results = SearchableArray.new
-          each do |_key, item|
-            if conditions.all? do |attr, val|
-                 if val.is_a?(Array)
-                   if exact
-                     val.any? { |v| item.send(attr).to_s == v.to_s }
-                   else
-                     val.any? { |v| item.send(attr).to_s =~ /#{v.to_s}/ }
-                   end
-                 else
-                   if exact
-                     item.send(attr).to_s == val.to_s
-                   else
-                     item.send(attr).to_s =~ /#{val.to_s}/
-                   end
-                 end
-               end
-              results << item
-            end
-          end
-          results
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/time.rb

@@ -1,338 +0,0 @@
-module Origen
-  module Tester
-    # Class for handling test time analysis - implements the functionality
-    # exposed via the 'origen time' command
-    class Time
-      require 'yaml'
-
-      TT_LIB_DIR  = "#{Origen.root}/config/test_time/lib"
-      TT_FLOW_DIR = "#{Origen.root}/config/test_time/flow"
-      DEFAULT_LIBRARY = "#{TT_LIB_DIR}/default.yaml"
-      DEFAULT_FLOW    = "#{TT_FLOW_DIR}/default.yaml"
-
-      # If any new embedded hashes are added to this a default of {} must also be added
-      # to the sanitize method
-      TEST_META_DATA = { 'rule'      => nil,
-                         'reference' => { 'rule_result' => nil,
-                                          'time'        => nil,
-                                          'target'      => nil
-                                        }
-                       }
-
-      def stats
-        @stats ||= { imported: 0, rules_assigned: 0, reference_rules_evaluated: 0 }
-      end
-
-      def clear_stats
-        @stats = nil
-      end
-
-      # Import a flow, this can be from either a datalog or an execution time
-      def import_test_flow(file, options = {})
-        clear_stats
-        @options = options
-        if Origen.tester.respond_to?('read_test_times')
-          tests = Origen.tester.read_test_times(file, options)
-          flow = []
-          merge_indexed_tests(tests) do |name, _attrs|
-            if import?(name)
-              Origen.log.info "imported... #{name}"
-              flow << name
-            end
-          end
-          puts ''
-          puts 'Import complete!'
-          puts ''
-          export_flow(flow, options)
-        else
-          error 'Sorry, no test time import method is defined for the current tester'
-        end
-      end
-
-      def import_test_time(file, options = {})
-        clear_stats
-        @options = options
-        if Origen.tester.respond_to?('read_test_times')
-          tests = Origen.tester.read_test_times(file, options)
-          total = extract_total_time(tests)
-          flow = []
-          library = {}
-          imported = 0.0
-          merge_indexed_tests(tests) do |name, attrs|
-            attrs = sanitize(attrs)
-
-            if import?(name)
-              Origen.log.info "importing... #{name}"
-              flow << name
-              if library[name]
-                library[name] = merge(library[name], attrs)
-              else
-                library[name] = populate(name, attrs)
-                stats[:imported] += 1
-              end
-              imported += attrs['reference']['time']
-              # puts name
-            end
-          end
-          puts ''
-          puts 'Import complete!'
-          puts ''
-          puts 'Some stats...'
-          puts ''
-          puts "Tests imported:        #{stats[:imported]}"
-          puts "Rules assigned:        #{stats[:rules_assigned]}"
-          puts "Ref rules calculated:  #{stats[:reference_rules_evaluated]}"
-          puts ''
-          puts 'Total time:            ' + total.round(6).to_s + 's'
-          puts 'Total filtered time:   ' + imported.round(6).to_s + 's'
-          if stats[:imported] == stats[:rules_assigned]
-            puts 'Forecasted:            ' + calculate_time(flow, library, options.merge(silent: true)).to_s + 's'
-          else
-            puts 'Forecasted:            SOME TESTS HAVE NO RULES ASSIGNED!'
-          end
-          puts ''
-          export_library(library, options)
-        else
-          error 'Sorry, no test time import method is defined for the current tester'
-        end
-      end
-
-      def forecast_test_time(options = {})
-        clear_stats
-        @options = options
-        time = 0.0
-        flow = import_flow(input_flow_file(options))
-        library = import_library(input_library_file(options))['tests']
-        calculate_time(flow, library, options)
-      end
-
-      def output_library_file(options = {})
-        if options[:ref_name]
-          "#{TT_LIB_DIR}/#{options[:ref_name]}.yaml"
-        else
-          DEFAULT_LIBRARY
-        end
-      end
-
-      def input_library_file(options = {})
-        output_library_file(options)
-      end
-
-      def output_flow_file(options = {})
-        if options[:ref_name]
-          "#{TT_FLOW_DIR}/#{options[:ref_name]}.yaml"
-        else
-          DEFAULT_FLOW
-        end
-      end
-
-      def input_flow_file(options = {})
-        output_flow_file(options)
-      end
-
-      # Force the imported test data from the tester into a YAML compliant form
-      def sanitize(attrs)
-        # Force all keys to strings...
-        attrs.keys.each do |key|
-          begin
-            attrs[key.to_s] = attrs.delete(key)
-          rescue
-            # No problem
-          end
-        end
-        attrs['reference'] ||= {}
-        # attrs["opportunity"] ||= {}
-        if attrs['time']
-          attrs['reference']['time'] = attrs.delete('time')
-        end
-        deep_merge(TEST_META_DATA, attrs)
-      end
-
-      # Populate the attributes based on user specified rules
-      def populate(name, attrs, options = {})
-        if rules
-          r = rules.assign(name, attrs, options)
-          if r
-            stats[:rules_assigned] += 1
-            attrs['rule'] = r
-          else
-            warn "No rule assigned to: #{name}"
-            attrs.delete('rule')
-          end
-          r = rules.evaluate(name, attrs, options)
-          if r
-            stats[:reference_rules_evaluated] += 1
-            attrs['reference']['rule_result'] = r
-          else
-            warn "No reference rule result assigned to: #{name}"
-            attrs['reference'].delete('rule_result')
-          end
-        end
-        attrs['reference']['target'] = Origen.target.name
-        attrs
-      end
-
-      def export_library(lib, options = {})
-        tests = {}
-        lib.each do |name, attrs|
-          tests[name] = attrs
-        end
-        Origen.file_handler.open_for_write(output_library_file(options)) do |f|
-          f.puts YAML.dump('tests' => tests)
-        end
-        puts "Test library exported to: #{Origen.file_handler.relative_path_to(output_library_file(options))}"
-      end
-
-      def import_library(lib, _options = {})
-        YAML.load(File.open(lib))
-      end
-
-      def export_flow(flow, options = {})
-        Origen.file_handler.open_for_write(output_flow_file(options)) do |f|
-          f.puts YAML.dump(flow)
-        end
-        puts "Test flow exported to: #{Origen.file_handler.relative_path_to(output_flow_file(options))}"
-      end
-
-      def import_flow(flow, _options = {})
-        YAML.load(File.open(flow))
-      end
-
-      # Deep merge two hashes, the first one should be the defaults, the second one will override any
-      # items from the defaults
-      def deep_merge(hash1, hash2)
-        hash1.merge(hash2) do |_key, oldval, newval|
-          oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
-          newval = newval.to_hash if newval.respond_to?(:to_hash)
-          oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? deep_merge(oldval, newval) : newval
-        end
-      end
-
-      # Merge two sets of attributes for the same test, generally this means that the time will
-      # be averaged and all other attributes will remain the same
-      def merge(t1, t2)
-        t1['reference']['time'] = (t1['reference']['time'] + t2['reference']['time']) / 2
-        t1
-      end
-
-      # Calculate the time for the given flow, using times from the given library
-      def calculate_time(flow, library, options = {})
-        options = {
-          silent:  false,
-          summary: false
-        }.merge(options)
-        unless options[:silent] || options[:summary]
-          Origen.log.info 'Test'.ljust(60) + 'Rule'.ljust(40) +
-            library.first[1]['reference']['target'].ljust(30) + Origen.target.name
-          orig = 0
-        end
-        forecasted = flow.reduce(0.0) do  |sum, test|
-          if library[test]['include'] == false || library[test]['exclude'] == true
-            sum
-          else
-            orig += library[test]['reference']['time'] unless options[:silent] || options[:summary]
-            forecast = rules.forecast(test, library[test], options)
-            unless options[:silent] || options[:summary]
-              Origen.log.info test.ljust(60) + library[test]['rule'].to_s.ljust(40) +
-                              "#{library[test]['reference']['time'].round(6)}".ljust(30) +
-                              "#{forecast.round(6)}"
-            end
-            sum + forecast
-          end
-        end
-        if options[:silent]
-          forecasted.round(6)
-        elsif options[:summary]
-          Origen.log.info Origen.target.name.ljust(50) + "#{forecasted.round(6)}"
-        else
-          Origen.log.info ''
-          Origen.log.info ''.ljust(100) + '---------------'.ljust(30) + '---------------'
-          Origen.log.info ''.ljust(100) + "#{orig.round(6)}".ljust(30) + "#{forecasted.round(6)}"
-          Origen.log.info ''.ljust(100) + '---------------'.ljust(30) + '==============='
-          Origen.log.info ''
-        end
-      end
-
-      def extract_total_time(tests)
-        tests.reduce(0.0) { |sum, test| sum + test[:time] }
-      end
-
-      # This combines the test time from indexed tests and removes the :index and :group keys from all tests.
-      #
-      # If it is an indexed test then a single hash will be returned containing the total time and the key:
-      # {:indexed => true}.
-      def merge_indexed_tests(tests)
-        ix_counter = false
-        ix_group = false
-        ix_test = false
-        ix_total = false
-
-        tests.each do |t|
-          i = t.delete(:index)
-          g = t.delete(:group)
-          process = true
-          if ix_counter
-            if ix_test == t[:name]
-              process = false
-              warning "Incomplete index data from test: #{ix_test}" if i != ix_counter + 1
-              ix_counter = i
-              ix_total += t[:time]
-              # If the last test in the index
-              if i == ix_group
-                yield(ix_test, { time: ix_total, indexed: true })
-                ix_counter = false
-              end
-            else
-              warning "Incomplete index data from test: #{ix_test}"
-              yield(ix_test, { time: ix_total, indexed: true })
-              ix_counter = false
-            end
-          end
-          # Don't combine this with the above via an else, it is required to be separate to generate the
-          # next entry in the case where an index group was incomplete
-          if process
-            if i
-              # Ignore tests with an invalid index and a very short time, these occur from tests which
-              # are in the flow, but have not been executed in this run
-              unless i != 1 && t[:time] < 0.0001
-                ix_counter = i
-                ix_group = g
-                ix_test = t[:name]
-                ix_total = t[:time]
-                warning "Incomplete index data from test: #{t[:name]}" if ix_counter != 1
-              end
-            else
-              yield t.delete(:name), t
-            end
-          end
-        end
-      end
-
-      def import?(test)
-        if filter
-          filter.import?(test)
-        else
-          true
-        end
-      end
-
-      def filter
-        return @filter if defined?(@filter)
-        if defined?(TestTimeFilter)
-          @filter = TestTimeFilter.new
-        else
-          @filter = false
-        end
-      end
-
-      def rules
-        return @rules if defined?(@rules)
-        if defined?(TestTimeRules)
-          @rules = TestTimeRules.new
-        else
-          @rules = false
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/timing.rb

@@ -1,253 +0,0 @@
-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