origen 0.0.1 → 0.0.2

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

@@ -0,0 +1,207 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class FlowLine
+          attr_accessor :parser, :flow, :line
+
+          TYPES = %w(
+            Test characterize defaults enable-flow-word disable-flow-word error-print goto
+            goto-on-all-done goto-on-all-lastfail goto-on-all-lastfaildoall logprint modify
+            nop print reset set-device set-device-new set-error-bin set-retest-bin skip
+            stop assign-integer create-integer delete-integer create-site-var assign-site-var
+            flag-clear flag-clear-all flag-false flag-false-all flag-true flag-true-all
+            state-clear-all state-false-all state-true-all
+          )
+
+          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
+          )
+
+          ALIASES = {
+            bin:         :bin_fail,
+            softbin:     :sort_fail,
+            soft_bin:    :sort_fail,
+            name:        :tname,
+            number:      :tnum,
+            test_number: :tnum,
+            test_num:    :tnum,
+            type:        :opcode
+          }
+
+          # Make readers for each low level attribute
+          ATTRS.each do |attr|
+            attr_reader attr
+          end
+
+          # And the aliases
+          ALIASES.each do |_alias, attr|
+            define_method("#{_alias}") do
+              send(attr)
+            end
+          end
+
+          # Returns the test instance called by the given line or nil
+          def self.extract_test(line)
+            l = new(line)
+            if l.valid? && l.test?
+              l.test_instance_name
+            end
+          end
+
+          def initialize(line, options = {})
+            @parser = options[:parser]
+            @flow = options[:flow]
+            @line = line
+            parse
+            if valid?
+              ATTRS.each_with_index do |attr, i|
+                instance_variable_set("@#{attr}", components[i + 1])
+              end
+            end
+          end
+
+          def inspect  # :nodoc:
+            "<FlowLine: #{type}, Parameter: #{parameter}>"
+          end
+
+          def description
+            from_instance = test_instance ? test_instance.description : ''
+            from_flow = parser.descriptions.flow_line(name: test_instance_name, flow: flow.file)
+            if !from_instance.empty? && !from_flow.empty?
+              [from_instance, "\n", from_flow].flatten
+            elsif from_instance.empty?
+              from_flow
+            else
+              from_instance
+            end
+          end
+
+          def parse
+            @components = @line.split("\t") unless @line.strip.empty?
+          end
+
+          def valid?
+            components[6] && TYPES.include?(components[6])
+          end
+
+          def components
+            @components ||= []
+          end
+
+          def test?
+            %w(Test characterize).include? opcode
+          end
+
+          def executes_under_context?(context)
+            enable_conditions_met?(context) &&
+              job_conditions_met?(context) &&
+              part_conditions_met?(context) &&
+              env_conditions_met?(context)
+          end
+
+          def enable_conditions_met?(context)
+            conditions_met?(enable, context[:enable])
+          end
+
+          def job_conditions_met?(context)
+            conditions_met?(job, context[:job])
+          end
+
+          def part_conditions_met?(context)
+            conditions_met?(part, context[:part])
+          end
+
+          def env_conditions_met?(context)
+            conditions_met?(env, context[:env])
+          end
+
+          def conditions_met?(conditions, values)
+            if conditions.empty?
+              true
+            else
+              values = [values].flatten
+              conditions = conditions.split(',').map(&:strip)
+              not_conditions = conditions.select { |c| c =~ /^!/ }
+              conditions = conditions - not_conditions
+              # Make sure all -ve conditions are not met
+              if not_conditions.all? do |c|
+                   c =~ /^!(.*)/
+                   c = Regexp.last_match[1]
+                   !values.include?(c)
+                 end
+                # And then any +ve conditions
+                if conditions.empty?
+                  true
+                else
+                  values.any? { |v| conditions.include?(v) }
+                end
+              else
+                false
+              end
+            end
+          end
+
+          def test_instance_name
+            parameter
+          end
+          alias_method :instance_name, :test_instance_name
+
+          def test_instance
+            instances = parser.test_instances.where(name: parameter, exact: true)
+            if instances.size > 1
+              puts "Warning multiple instances of #{name} found, using the first one"
+            end
+            if instances.size == 0
+              nil
+            else
+              instances.first
+            end
+          end
+          alias_method :instance, :test_instance
+
+          # Returns an array of patterns used by the given test, if there are none
+          # an empty array is returned.
+          # Optionally supply patterns to exclude if you want to ignore common subroutine
+          # patterns for example.
+          def patterns(options = {})
+            i = test_instance
+            if i
+              pats = i.patterns
+              if options[:ignore] && pats
+                pats.reject { |p| [options[:ignore]].flatten.include?(p) }
+              else
+                []
+              end
+            else
+              []
+            end
+          end
+          alias_method :pattern, :patterns
+
+          # Returns a string summarizing any conditions (enable words, jobs, etc.) that
+          # gate the execution of this line
+          def conditions
+            c = []
+            c << "Enable: #{enable}" unless enable.empty?
+            c << "Job: #{job}" unless job.empty?
+            c << "Part: #{part}" unless part.empty?
+            c << "Env: #{env}" unless env.empty?
+            c.join('; ')
+          end
+
+          def vdd
+            i = test_instance
+            if i
+              i.vdd
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class Flows < Origen::Tester::Parser::SearchableArray
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+
+          def import(file)
+            self << Flow.new(file, parser: parser)
+          end
+
+          def inspect
+            "<TestFlows: #{size}>"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class PatternSet
+          class Pattern
+            attr_accessor :parser
+
+            ATTRS = %w(pattern_set file_name start_label stop_label comment)
+
+            ALIASES = {
+              pattern: :file_name,
+              file:    :file_name,
+              name:    :file_name
+            }
+
+            # Generate readers for all attributes and their aliases
+            ATTRS.each do |attr|
+              attr_reader attr.to_sym
+            end
+
+            ALIASES.each do |_alias, attr|
+              define_method("#{_alias}") do
+                send(attr)
+              end
+            end
+
+            def initialize(line)
+              @line = line
+              parse
+              if valid?
+                ATTRS.each_with_index do |attr, i|
+                  instance_variable_set("@#{attr}", components[i + 1])
+                end
+              end
+            end
+
+            def parse
+              @components = @line.split("\t") unless @line.strip.empty?
+            end
+
+            def valid?
+              components[1] && !components[1].empty? && components[1] != 'Pattern Set' &&
+                components[2] && !components[2].empty?
+            end
+
+            def components
+              @components ||= []
+            end
+          end
+
+          def initialize(line, options = {})
+            @parser = options[:parser]
+            p = add_pattern_line(line)
+            @name = p.pattern_set if p.valid?
+          end
+
+          def inspect  # :nodoc:
+            "<PatternSet: #{name}>"
+          end
+
+          def name
+            @name
+          end
+
+          def patterns
+            @patterns ||= []
+          end
+
+          def self.extract_name(line)
+            new(line).name
+          end
+
+          def add_pattern_line(line)
+            p = Pattern.new(line)
+            patterns << Pattern.new(line) if p.valid?
+            p
+          end
+
+          def valid?
+            patterns.all?(&:valid?)
+          end
+
+          # Returns an array containing all pattern names contained in this
+          # pattern set
+          def pattern_names
+            # This removes the path and extensions
+            patterns.map { |pat| pat.name.gsub(/.*[\\\/]/, '').gsub(/\..*/, '') }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class PatternSets < Origen::Tester::Parser::SearchableHash
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+
+          def import(file)
+            File.readlines(file).each do |line|
+              name = PatternSet.extract_name(line)
+              if name
+                if self[name]
+                  self[name].add_pattern_line(line)
+                else
+                  l = PatternSet.new(line, parser: parser)
+                  self[l.name] = l if l.valid?
+                end
+              end
+            end
+          end
+
+          def inspect
+            "<Patsets: #{size}>"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,322 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class TestInstance
+          attr_accessor :parser
+
+          TYPES = %w(
+            functional board_pmu empty pin_pmu power_supply mto_memory
+          )
+
+          TYPE_ALIASES = {
+            functional_t:         :functional,
+            boardpmu_t:           :board_pmu,
+            nvmboardpmucal_t:     :board_pmu,
+            nvmboardpmumeasure_t: :board_pmu,
+            empty_t:              :empty,
+            pinpmu_t:             :pin_pmu,
+            nvmpinpmucal_t:       :pin_pmu,
+            nvmpinpmumeas_t:      :pin_pmu,
+            powersupply_t:        :power_supply,
+            mtomemory_t:          :mto_memory
+          }
+
+          attributes = %w(
+            test_name proc_type proc_name proc_called_as dc_category dc_selector ac_category ac_selector
+            time_sets edge_sets pin_levels overlay
+          )
+          80.times do |i|
+            attributes << "arg#{i}"
+          end
+          attributes << 'comment'
+
+          ATTRS = attributes
+
+          ALIASES = {
+            name:       :test_name,
+
+            functional: {
+              pattern:             :arg0,
+              start_func:          :arg1,
+              pre_pat_func:        :arg2,
+              pre_test_func:       :arg3,
+              post_test_func:      :arg4,
+              post_pat_func:       :arg5,
+              end_func:            :arg6,
+              set_pass_fail:       :arg7,
+              start_func_args:     :arg13,
+              pre_pat_func_args:   :arg14,
+              pre_test_func_args:  :arg15,
+              post_test_func_args: :arg16,
+              post_pat_func_args:  :arg17,
+              end_func_args:       :arg18,
+              wait_flags:          :arg21,
+              wait_time:           :arg22,
+              pat_flag_func:       :arg23,
+              pat_flag_func_args:  :arg24,
+              relay_mode:          :arg25,
+              threading:           :arg26,
+              match_all_sites:     :arg27,
+              capture_mode:        :arg30,
+              capture_what:        :arg31,
+              capture_memory:      :arg32,
+              capture_size:        :arg33,
+              datalog_mode:        :arg34,
+              data_type:           :arg35
+            },
+
+            board_pmu:  {
+              hsp_start:           :arg0,
+              start_func:          :arg1,
+              pre_pat_func:        :arg2,
+              pre_test_func:       :arg3,
+              post_test_func:      :arg4,
+              post_pat_func:       :arg5,
+              end_func:            :arg6,
+              precond_pat:         :arg7,
+              hold_state_pat:      :arg8,
+              holdstate_pat:       :arg8,
+              pattern:             :arg8,
+              pcp_stop:            :arg9,
+              wait_flags:          :arg10,
+              start_lo:            :arg11,
+              init_lo:             :arg11,
+              start_hi:            :arg12,
+              init_hi:             :arg12,
+              start_hiz:           :arg13,
+              init_hiz:            :arg13,
+              float_pins:          :arg14,
+              pinlist:             :arg15,
+              measure_mode:        :arg16,
+              irange:              :arg17,
+              clamp:               :arg18,
+              vrange:              :arg19,
+              sampling_time:       :arg20,
+              samples:             :arg21,
+              setting_time:        :arg22,
+              hi_lo_lim_valid:     :arg23,
+              hi_limit:            :arg24,
+              lo_limit:            :arg25,
+              force_cond_1:        :arg26,
+              force_cond_2:        :arg27,
+              gang_pins_tested:    :arg28,
+              relay_mode:          :arg29,
+              wait_time_out:       :arg30,
+              start_func_args:     :arg31,
+              pre_pat_func_args:   :arg32,
+              pre_test_func_args:  :arg33,
+              post_test_func_args: :arg34,
+              post_pat_func_args:  :arg35,
+              end_func_args:       :arg36,
+              pcp_start:           :arg37,
+              pcp_check_pg:        :arg38,
+              hsp_stop:            :arg39,
+              hsp_check_pg:        :arg40,
+              resume_pat:          :arg41,
+              utility_pins_1:      :arg42,
+              utility_pins_0:      :arg43,
+              pre_charge_enable:   :arg44,
+              pre_charge:          :arg45,
+              threading:           :arg46
+            },
+
+            pin_pmu:    {
+              hsp_start:           :arg0,
+              start_func:          :arg1,
+              pre_pat_func:        :arg2,
+              pre_test_func:       :arg3,
+              post_test_func:      :arg4,
+              post_pat_func:       :arg5,
+              end_func:            :arg6,
+              precond_pat:         :arg7,
+              hold_state_pat:      :arg8,
+              holdstate_pat:       :arg8,
+              pattern:             :arg8,
+              pcp_stop:            :arg9,
+              wait_flags:          :arg10,
+              start_lo:            :arg11,
+              init_lo:             :arg11,
+              start_hi:            :arg12,
+              init_hi:             :arg12,
+              start_hiz:           :arg13,
+              init_hiz:            :arg13,
+              float_pins:          :arg14,
+              pinlist:             :arg15,
+              measure_mode:        :arg16,
+              irange:              :arg17,
+              setting_time:        :arg18,
+              hi_lo_lim_valid:     :arg19,
+              hi_limit:            :arg20,
+              lo_limit:            :arg21,
+              force_cond_1:        :arg22,
+              force_cond_2:        :arg23,
+              fload:               :arg24,
+              f_load:              :arg24,
+              relay_mode:          :arg25,
+              wait_time_out:       :arg26,
+              start_func_args:     :arg27,
+              pre_pat_func_args:   :arg28,
+              pre_test_func_args:  :arg29,
+              post_test_func_args: :arg30,
+              post_pat_func_args:  :arg31,
+              end_func_args:       :arg32,
+              pcp_start:           :arg33,
+              pcp_check_pg:        :arg34,
+              hsp_stop:            :arg35,
+              hsp_check_pg:        :arg36,
+              sampling_time:       :arg37,
+              samples:             :arg38,
+              resume_pat:          :arg39,
+              vcl:                 :arg40,
+              vch:                 :arg41,
+              utility_pins_1:      :arg42,
+              utility_pins_0:      :arg43,
+              pre_charge_enable:   :arg44,
+              pre_charge:          :arg45,
+              threading:           :arg46
+            },
+            mto_memory: {
+              pattern:                   :arg0,
+              start_func:                :arg1,
+              pre_pat_func:              :arg2,
+              pre_test_func:             :arg3,
+              post_test_func:            :arg4,
+              post_pat_func:             :arg5,
+              end_of_body_func:          :arg6,
+              set_pass_fail:             :arg7,
+              float_pins:                :arg11,
+              start_of_body_func_args:   :arg12,
+              pre_pat_func_args:         :arg13,
+              pre_test_func_args:        :arg14,
+              post_test_func_args:       :arg15,
+              post_pat_func_args:        :arg16,
+              end_of_body_func_args:     :arg17,
+              utility_pins_1:            :arg18,
+              utility_pins_0:            :arg19,
+              wait_flags:                :arg20,
+              wait_time_out:             :arg21,
+              pat_flag_f:                :arg22,
+              pat_flag_func_args:        :arg23,
+              relay_mode:                :arg24,
+              x_enable_mask:             :arg29,
+              x_shift_direction:         :arg30,
+              x_shift_input:             :arg31,
+              y_enable_mask:             :arg36,
+              y_shift_direction:         :arg37,
+              y_shift_input:             :arg38,
+              dga:                       :arg39,
+              dgb:                       :arg40,
+              dgc:                       :arg41,
+              dgd:                       :arg42,
+              dg_enable_mask:            :arg43,
+              dg_shift_direction:        :arg44,
+              dg_shift_input:            :arg45,
+              x_coincidence_enable_mask: :arg46,
+              y_coincidence_enable_mask: :arg47,
+              two_bit_dg_setup:          :arg48,
+              x_scramble_algorithm:      :arg49,
+              y_scramble_algorithm:      :arg50,
+              topo_inversion_algorithm:  :arg51,
+              utility_counter_a:         :arg52,
+              utility_counter_b:         :arg53,
+              utility_counter_c:         :arg54,
+              dut_data_source:           :arg55,
+              scramble_addr:             :arg56,
+              speed_mode:                :arg57,
+              resource_map:              :arg58,
+              receive_data:              :arg59,
+              data_to_capture:           :arg60,
+              capture_marker:            :arg61,
+              enable_wrapping:           :arg62,
+              capture_scrambled_address: :arg63,
+              mapmem_0_input_set:        :arg64,
+              mapmem_1_input_set:        :arg65,
+              threading:                 :arg69,
+              match_all_sites:           :arg70
+            }
+          }
+
+          # Make readers for each low level attribute
+          ATTRS.each do |attr|
+            attr_reader attr
+          end
+
+          # And the aliases
+          ALIASES.each do |_alias, attr|
+            define_method("#{_alias}") do
+              send(attr)
+            end
+          end
+
+          def initialize(line, options = {})
+            @parser = options[:parser]
+            @line = line
+            parse
+            if valid?
+              ATTRS.each_with_index do |attr, i|
+                instance_variable_set("@#{attr}", components[i + 1])
+              end
+              if ALIASES[type]
+                ALIASES[type].each do |_alias, attr|
+                  define_singleton_method("#{_alias}") do
+                    send(attr)
+                  end
+                end
+              end
+            end
+          end
+
+          def inspect  # :nodoc:
+            "<TestInstance: #{name}, Type: #{type}>"
+          end
+
+          def description
+            parser.descriptions.test_instance(name: name)
+          end
+
+          def type
+            TYPE_ALIASES[proc_name.downcase.to_sym] || :unsupported
+          end
+
+          def parse
+            @components = @line.split("\t") unless @line.strip.empty?
+          end
+
+          def valid?
+            components[4] && ['Excel Macro', 'VB DLL'].include?(components[4])
+          end
+
+          def components
+            @components ||= []
+          end
+
+          # Returns an array of all pattern names referenced in this test instance
+          def patterns
+            if self.respond_to?(:pattern)
+              pattern.split(',').map do |pat|
+                extract_pattern_from_patset(pat)
+              end.flatten.map { |pat| pat.gsub(/.*[\\\/]/, '').gsub(/\..*/, '') }
+            end
+          end
+
+          def extract_pattern_from_patset(patset)
+            pset = parser.pattern_sets.where(name: patset, exact: true)
+            if pset.size > 1
+              puts "Warning multiple pattern sets called #{patset} found, using the first one"
+            end
+            if pset.size == 0
+              patset
+            else
+              pset.first.pattern_names
+            end
+          end
+
+          def vdd
+            parser.dc_specs.where(name: 'VDD', exact: true).first.lookup(dc_category, dc_selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Origen
+  module Tester
+    class J750
+      class Parser
+        class TestInstances < Origen::Tester::Parser::SearchableHash
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+
+          def import(file)
+            File.readlines(file).each do |line|
+              l = TestInstance.new(line, parser: parser)
+              self[l.name] = l if l.valid?
+            end
+          end
+
+          def inspect
+            "<TestInstances: #{size}>"
+          end
+        end
+      end
+    end
+  end
+end