origen 0.0.1 → 0.0.2

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

@@ -0,0 +1,174 @@
+module Origen
+  module Tester
+    class Ultraflex
+      module Generator
+        class TestInstances
+          include Origen::Tester::Generator
+
+          TEMPLATE = "#{Origen.top}/lib/origen/tester/ultraflex/generator/templates/instances.txt.erb"
+          OUTPUT_POSTFIX = 'instances'
+
+          class IndexedString < ::String
+            attr_accessor :index
+
+            def name
+              self
+            end
+          end
+
+          def add(name, type, options = {})
+            options = {
+              test_instance_class: TestInstance
+            }.merge(options)
+            ins = options.delete(:test_instance_class).new(name, type, options)
+            if @current_group
+              @current_group << ins
+            else
+              collection << ins
+            end
+            c = Origen.interface.consume_comments
+            Origen.interface.descriptions.add_for_test_definition(name, c)
+            ins
+          end
+
+          # IG-XL doesn't have a formal instance group type and instead declares them anonymously
+          # whenever test instances of the same name appear consecutively in the test instance sheet.
+          # However when it comes to generating a test program life becomes much easier if we have
+          # a way to explicitly declare instances as part of a group - this makes duplicate tracking
+          # and sorting of the test instance sheet much easier.
+          #
+          # Use this method to generate instance groups via a block. Within the the block you should
+          # generate instances as normal and they will automatically be assigned to the current group.
+          # Note that the name of the instances generated within the group is discarded and replaced
+          # with the name of the group. Origen automatically appends "grp" to this name to highlight
+          # instances that were generated as part of the group.
+          #
+          #   test_instances.group("erase_all_blocks") do |group|
+          #     # Generate instances here as normal
+          #     test_instances.functional("erase_blk0")
+          #     test_instances.functional("erase_blk1")
+          #   end
+          #
+          # The group object is passed into the block but usually you should not need to interact
+          # with this directly except maybe to set the name if it is not yet established at the point
+          # where the group is initiated:
+          #
+          #   test_instances.group do |group|
+          #     # Generate instances here as normal
+          #     group.name = "group_blah"
+          #   end
+          #
+          # A common way to generate groups is to create a helper method in your application which
+          # is responsible for creating groups as required:
+          #
+          #   def group_wrapper(name, options)
+          #     if options[:by_block]
+          #       test_instances.group(name) do |group|
+          #         yield group
+          #       end
+          #     else
+          #       yield
+          #     end
+          #   end
+          #
+          # In that case the group argument becomes quite useful for branching based on whether you
+          # are generating a group or standalone instances:
+          #
+          #  group_wrapper(name, options) do |group|
+          #    if group
+          #      # Generate group instances
+          #    else
+          #      # Generate standalone instances
+          #    end
+          #  end
+          def group(name = nil, options = {})
+            name, options = nil, name if name.is_a?(Hash)
+            @current_group = TestInstanceGroup.new(name, options)
+            collection << @current_group
+            yield @current_group
+            @current_group = nil
+          end
+          alias_method :add_group, :group
+
+          def finalize(_options = {}) # :nodoc:
+            uniq!
+            sort!
+          end
+
+          def uniq! # :nodoc:
+            uniques = []
+            versions = {}
+            multi_version_tests = {}
+            collection.each do |instance|
+              # If a uniquely named instance is found add it, otherwise update the version
+              # of the current instance to match that of the existing instance that it duplicates
+              unless uniques.any? do |i|
+                if i == instance
+                  instance.version = i.version
+                  true
+                else
+                  false
+                end
+              end
+                if instance.respond_to?(:version=)
+                  versions[instance.unversioned_name] ||= 0
+                  versions[instance.unversioned_name] += 1
+                  if versions[instance.unversioned_name] > 1
+                    multi_version_tests[instance.unversioned_name] = true
+                  end
+                  instance.version = versions[instance.unversioned_name]
+                end
+                uniques << instance
+              end
+            end
+            # This final loop disables the version identifier for tests that have only a single version,
+            # this makes it clearer when multiple versions exist - whenever you see a v1 you know there
+            # is at least a v2 also.
+            collection.map! do |instance|
+              if instance.respond_to?(:version=)
+                unless multi_version_tests[instance.unversioned_name]
+                  instance.append_version = false
+                end
+              end
+              instance
+            end
+            self.collection = uniques
+          end
+
+          def sort! # :nodoc:
+            # Present the instances in the final sheet in alphabetical order
+            collection.map!.with_index do |ins, _i|
+              if ins.is_a?(String)   # Can happen if content has been rendered in from a template
+                ins = IndexedString.new(ins)
+              end
+              ins
+            end
+            collection.sort! { |a, b| [a.name.to_s] <=> [b.name.to_s] }
+          end
+
+          def bpmu(name, options = {})
+            add(name, :board_pmu, options)
+          end
+          alias_method :board_pmu, :bpmu
+
+          def ppmu(name, options = {})
+            add(name, :pin_pmu, options)
+          end
+          alias_method :pin_pmu, :ppmu
+
+          def functional(name, options = {})
+            add(name, :functional, options)
+          end
+
+          def empty(name, options = {})
+            add(name, :empty, options)
+          end
+
+          def other(name, options = {})
+            add(name, :other, options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+require 'active_support/concern'
+
+module Origen
+  module Tester
+    class Ultraflex
+      module Generator
+        extend ActiveSupport::Concern
+
+        autoload :TestInstance,  'origen/tester/ultraflex/generator/test_instance'
+        autoload :TestInstanceGroup,  'origen/tester/ultraflex/generator/test_instance_group'
+        autoload :TestInstances, 'origen/tester/ultraflex/generator/test_instances'
+        autoload :Patset,  'origen/tester/ultraflex/generator/patset'
+        autoload :Patsets, 'origen/tester/ultraflex/generator/patsets'
+        autoload :Patgroup,  'origen/tester/ultraflex/generator/patgroup'
+        autoload :Patgroups, 'origen/tester/ultraflex/generator/patgroups'
+        autoload :Flow,  'origen/tester/ultraflex/generator/flow'
+        autoload :FlowLine,  'origen/tester/ultraflex/generator/flow_line'
+        autoload :Placeholder, 'origen/tester/generator/placeholder'
+
+        included do
+          include Origen::Tester::Interface  # adds the interface helpers/Origen hook-up
+          include Origen::Tester::Generator::FlowControlAPI::Interface
+          PLATFORM = Origen::Tester::Ultraflex
+        end
+
+        def reset_globals
+          flow.reset_globals
+          @@test_instances_filename = nil
+          @@patsets_filename = nil
+          @@patgroups_filename = nil
+          @@test_instances_filename = nil
+          @@patsets_filename = nil
+          @@patgroups_filename = nil
+          @@test_instance_sheets = nil
+          @@patset_sheets = nil
+          @@flow_sheets = nil
+          @@patgroup_sheets = nil
+        end
+
+        # Convenience method to allow the current name for the test instance,
+        # patsets and patgroups sheets to be set to the same value.
+        #
+        #   # my ultraflex interface
+        #
+        #   resources_filename = "common"
+        #
+        #   # The above is equivalent to:
+        #
+        #   test_instances_filename = "common"
+        #   patsets_filename = "common"
+        #   patgroups_filename = "common"
+        def resources_filename=(name)
+          self.test_instances_filename = name
+          self.patsets_filename = name
+          self.patgroups_filename = name
+        end
+
+        # Set the name of the current test instances sheet. This does not change
+        # the name of the current sheet, but rather sets the name of the sheet that
+        # will be generated the next time you access test_instances.
+        def test_instances_filename=(name)
+          @@test_instances_filename = name
+        end
+
+        # Set the name of the current pattern sets sheet. This does not change
+        # the name of the current sheet, but rather sets the name of the sheet that
+        # will be generated the next time you access patsets.
+        def patsets_filename=(name)
+          @@patsets_filename = name
+        end
+
+        # Set the name of the current pattern groups sheet. This does not change
+        # the name of the current sheet, but rather sets the name of the sheet that
+        # will be generated the next time you access patgroups.
+        def patgroups_filename=(name)
+          @@patgroups_filename = name
+        end
+
+        # Returns the name of the current test instances sheet
+        def test_instances_filename
+          @@test_instances_filename ||= 'global'
+        end
+
+        # Returns the name of the current pat sets sheet
+        def patsets_filename
+          @@patsets_filename ||= 'global'
+        end
+
+        # Returns the name of the current pat groups sheet
+        def patgroups_filename
+          @@patgroups_filename ||= 'global'
+        end
+
+        # Returns a hash containing all test instance sheets
+        def test_instance_sheets
+          @@test_instance_sheets ||= {}
+        end
+
+        # Returns a hash containing all pat set sheets
+        def patset_sheets
+          @@patset_sheets ||= {}
+        end
+
+        # Returns a hash containing all flow sheets
+        def flow_sheets
+          @@flow_sheets ||= {}
+        end
+
+        # Returns a hash containing all pat group sheets
+        def patgroup_sheets
+          @@patgroup_sheets ||= {}
+        end
+
+        # Returns an array containing all sheet generators where a sheet generator is a flow,
+        # test instance, patset or pat group sheet.
+        # All Origen program generators must implement this method
+        def sheet_generators # :nodoc:
+          g = []
+          [flow_sheets, test_instance_sheets, patset_sheets, patgroup_sheets].each do |sheets|
+            sheets.each do |_name, sheet|
+              g << sheet
+            end
+          end
+          g
+        end
+
+        # Returns an array containing all flow sheet generators.
+        # All Origen program generators must implement this method
+        def flow_generators
+          g = []
+          flow_sheets.each do |_name, sheet|
+            g << sheet
+          end
+          g
+        end
+
+        # Returns the current test instances sheet (as defined by the current value of
+        # test_instances_filename).
+        #
+        # Pass in a filename argument to have a specific sheet returned instead.
+        #
+        # If the sheet does not exist yet it will be created.
+        def test_instances(filename = test_instances_filename)
+          f = filename.to_sym
+          return test_instance_sheets[f] if test_instance_sheets[f]
+          t = TestInstances.new
+          t.filename = f
+          test_instance_sheets[f] = t
+        end
+
+        # Returns the current pattern sets sheet (as defined by the current value of
+        # patsets_filename).
+        #
+        # Pass in a filename argument to have a specific sheet returned instead.
+        #
+        # If the sheet does not exist yet it will be created.
+        def patsets(filename = patsets_filename)
+          f = filename.to_sym
+          return patset_sheets[f] if patset_sheets[f]
+          p = Patsets.new
+          p.filename = f
+          patset_sheets[f] = p
+        end
+        alias_method :pat_sets, :patsets
+        alias_method :pattern_sets, :patsets
+
+        # Returns the current flow sheet (as defined by the name of the current top
+        # level flow source file).
+        #
+        # Pass in a filename argument to have a specific sheet returned instead.
+        #
+        # If the sheet does not exist yet it will be created.
+        def flow(filename = Origen.file_handler.current_file.basename('.rb').to_s)
+          f = filename.to_sym
+          return flow_sheets[f] if flow_sheets[f]
+          p = Flow.new
+          p.inhibit_output if Origen.interface.resources_mode?
+          p.filename = f
+          flow_sheets[f] = p
+        end
+
+        # Returns the current pattern groups sheet (as defined by the current value of
+        # patgroups_filename).
+        #
+        # Pass in a filename argument to have a specific sheet returned instead.
+        #
+        # If the sheet does not exist yet it will be created.
+        def patgroups(filename = patgroups_filename)
+          f = filename.to_sym
+          return patgroup_sheets[f] if patgroup_sheets[f]
+          p = Patgroups.new
+          p.filename = f
+          patgroup_sheets[f] = p
+        end
+        alias_method :pat_groups, :patgroups
+        alias_method :pattern_groups, :patgroups
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser/ac_spec.rb

@@ -0,0 +1,11 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class ACSpec
+          attr_accessor :collection
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser/dc_spec.rb

@@ -0,0 +1,36 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class DCSpec
+          attr_accessor :parser
+          attr_accessor :name, :categories
+          alias_method :symbol, :name
+
+          def initialize(name, categories, options = {})
+            @parser = options[:parser]
+            @name = name
+            @categories = categories
+            @values = {}
+          end
+
+          def add_values(components)
+            @categories.each_with_index do |category, i|
+              @values[category] ||= {}
+              @values[category]['Typ'] ||= components[5 + (i * 3) + 0]
+              @values[category]['Min'] ||= components[5 + (i * 3) + 1]
+              @values[category]['Max'] ||= components[5 + (i * 3) + 2]
+            end
+          end
+
+          def lookup(category, selector)
+            v = @values[category]
+            if v
+              v[selector]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/ultraflex/parser/dc_specs.rb

@@ -0,0 +1,50 @@
+module Origen
+  module Tester
+    class Ultraflex
+      class Parser
+        class DCSpecs < Origen::Tester::Parser::SearchableHash
+          attr_accessor :parser
+
+          def initialize(options = {})
+            @parser = options[:parser]
+          end
+
+          def import(file)
+            @categories = []
+            File.readlines(file).each do |line|
+              unless line.strip.empty?
+                components = line.split("\t")
+                if components[3] == 'Selector'
+                  extract_categories(components)
+                else
+                  unless components[1] == 'DC Specs' || components[1] == 'Symbol'
+                    extract_spec(components)
+                  end
+                end
+              end
+            end
+          end
+
+          def inspect
+            "<DCSpecs: #{size}>"
+          end
+
+          def extract_categories(components)
+            components.each_with_index do |val, i|
+              if i > 4
+                @categories << val unless val.strip.empty?
+              end
+            end
+            @categories.uniq!
+          end
+
+          def extract_spec(components)
+            name = components[1]
+            self[name] ||= DCSpec.new(name, @categories, parser: parser)
+            self[name].add_values(components)
+          end
+        end
+      end
+    end
+  end
+end