origen 0.0.1 → 0.0.2

data/lib/origen/tester/j750/parser/timeset.rb

@@ -0,0 +1,15 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class Timeset
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        autoload :Flows,   'origen/tester/j750/parser/flows'
+        autoload :Flow,   'origen/tester/j750/parser/flow'
+        autoload :FlowLine,   'origen/tester/j750/parser/flow_line'
+        autoload :TestInstances,   'origen/tester/j750/parser/test_instances'
+        autoload :TestInstance,   'origen/tester/j750/parser/test_instance'
+        autoload :PatternSets,   'origen/tester/j750/parser/pattern_sets'
+        autoload :PatternSet,   'origen/tester/j750/parser/pattern_set'
+        autoload :DCSpecs,   'origen/tester/j750/parser/dc_specs'
+        autoload :DCSpec,   'origen/tester/j750/parser/dc_spec'
+        autoload :ACSpecs,   'origen/tester/j750/parser/ac_specs'
+        autoload :ACSpec,   'origen/tester/j750/parser/ac_spec'
+        autoload :Descriptions,   'origen/tester/j750/parser/descriptions'
+
+        def reset
+          @flows = nil
+          @test_instances = nil
+          @pattern_sets = nil
+          @dc_specs = nil
+          @ac_specs = nil
+        end
+
+        def descriptions
+          @descriptions ||= Descriptions.new(parser: self)
+        end
+
+        # Returns an array of test flows
+        def flows
+          @flows ||= Flows.new(parser: self)
+        end
+
+        def test_instances
+          @test_instances ||= TestInstances.new(parser: self)
+        end
+        alias_method :instances, :test_instances
+
+        def pattern_sets
+          @pattern_sets ||= PatternSets.new(parser: self)
+        end
+        alias_method :patsets, :pattern_sets
+        alias_method :pat_sets, :pattern_sets
+
+        def dc_specs
+          @dc_specs ||= DCSpecs.new(parser: self)
+        end
+
+        def ac_specs
+          @ac_specs ||= ACSpecs.new(parser: self)
+        end
+
+        def inspect
+          "<Parsed Program: Flows: #{flows.size}>"
+        end
+
+        # Parse a file, array of files, or a directory.
+        #
+        # This can be called multiple times to add new files to the
+        # program model.
+        def parse(file)
+          Origen.log.info ''
+          Origen.log.info "Parsing J750 test program from: #{file}"
+          Origen.log.info ''
+          reset
+          # Note use of local file handler here, this should be how it is
+          # done globally, otherwise we can run into hard to debug problems
+          # due to state/reference dir changes in the single Origen.file_handler
+          Origen::FileHandler.new.resolve_files(file) do |f|
+            parse_file(f)
+          end
+          Origen.log.info ''
+          self
+        end
+
+        def parse_file(file)
+          line = File.readlines(file).first
+          begin
+            if line =~ /Flow Table/
+              flows.import(file)
+            elsif line =~ /Instances/
+              test_instances.import(file)
+            elsif line =~ /Pattern Sets/
+              patsets.import(file)
+            elsif line =~ /DC Spec/
+              dc_specs.import(file)
+            else
+              puts "Skipped (un-supported file type): #{file}"
+            end
+          rescue Exception => e
+            if e.is_a?(ArgumentError) && e.message =~ /invalid byte sequence/
+              puts "Skipped (not ASCII): #{file}"
+            else
+              puts e.message
+              puts e.backtrace
+              exit 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/jlink/jlink.rb

@@ -0,0 +1,33 @@
+module Origen
+  module Tester
+    class JLink < CommandBasedTester
+      def initialize
+        super
+        # The minimum time unit is 1ms
+        set_timeset('default', 1_000_000)
+        @pat_extension = 'jlk'
+        @comment_char = '//'
+      end
+
+      def delay(cycles)
+        microcode "Sleep #{cycles_to_ms(cycles)}"
+      end
+
+      def write_byte(address, data)
+        microcode "w1 0x#{address.to_s(16).upcase}, 0x#{data.to_s(16).upcase}"
+      end
+
+      def write_word(address, data)
+        microcode "w2 0x#{address.to_s(16).upcase}, 0x#{data.to_s(16).upcase}"
+      end
+
+      def write_longword(address, data)
+        microcode "w4 0x#{address.to_s(16).upcase}, 0x#{data.to_s(16).upcase}"
+      end
+
+      def read(address, number_of_regs = 1)
+        microcode "mem 0x#{address.to_s(16)}, #{number_of_regs}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Origen
+  module Tester
+    module Parser
+      class DescriptionLookup
+        def initialize
+          @store = { flow: {}, test: {}, usage: {} }
+        end
+
+        def for_flow(name, _options = {})
+          k = flow_key(name)
+          @store[:flow][k] || []
+        end
+
+        def for_test_definition(name, _options = {})
+          n = name_key(name)
+          @store[:test][n] || []
+        end
+
+        def for_test_usage(name, flow, _options = {})
+          k = flow_key(flow)
+          n = name_key(name)
+          @store[:usage][k] ||= {}
+          @store[:usage][k][n] || []
+        end
+
+        def add_for_flow(flow, description, _options = {})
+          k = flow_key(flow)
+          @store[:flow][k] ||= []
+          [description].flatten.each do |d|
+            @store[:flow][k] << d
+          end
+        end
+
+        def add_for_test_definition(test, description, _option = {})
+          n = name_key(test)
+          @store[:test][n] ||= []
+          [description].flatten.each do |d|
+            @store[:test][n] << d
+          end
+        end
+
+        def add_for_test_usage(test, flow, description, _option = {})
+          k = flow_key(flow)
+          n = name_key(test)
+          @store[:usage][k] ||= {}
+          @store[:usage][k][n] ||= []
+          [description].flatten.each do |d|
+            @store[:usage][k][n] << d
+          end
+        end
+
+        private
+
+        def flow_key(flow)
+          Pathname.new(flow).basename('.*').to_s
+        end
+
+        def name_key(name)
+          name.to_s.downcase
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,32 @@
+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/parser.rb

@@ -0,0 +1,24 @@
+module Origen
+  module Tester
+    module Parser
+      autoload :SearchableArray, 'origen/tester/parser/searchable_array'
+      autoload :SearchableHash,  'origen/tester/parser/searchable_hash'
+      autoload :DescriptionLookup,  'origen/tester/parser/description_lookup'
+
+      def parse(*args, &block)
+        parser.parse(*args, &block)
+      end
+
+      # Returns a SearchableArray containing all tests parsed from flows, this is intended to
+      # be the main API for accessing parsed test program attributes and should be a consistent
+      # method that is implemented accross all tester models.
+      #
+      # Direct access to the underlying structure (which will be specific to the tester model)
+      # can be achieved through the parser method, which returns an instance of J750::Parser
+      #   $tester.parser.test_instances
+      def tests
+        parser.flow_items
+      end
+    end
+  end
+end

data/lib/origen/tester/time.rb

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