origen_testers 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 178b8cf6021e69d8d2aaae349f0859c17fd0f24c
+  data.tar.gz: f0319a6493a112d78e9da2adb9a60d88231cdd0f
+SHA512:
+  metadata.gz: ea7347a99664f973ccb5ccd28509c83ccfe833b5ef9d6e46ab6c6b2d0ccd796a454d79457622d361e9a9b5e4ecd96cb4b8e85d32cf51c8a018adbae7296f70e1
+  data.tar.gz: 7b049c9a0fc92729dda392d35271314c0a7484dcece3792e4a24c9614ff265abb0a726eabce9d171e423f2c7d103e2b49514f91588f3aa7f72757cbc2574c12d

data/config/application.rb

@@ -0,0 +1,140 @@
+class OrigenTestersApplication < Origen::Application
+  # See http://origen.freescale.net/origen/latest/api/Origen/Application/Configuration.html
+  # for a full list of the configuration options available
+
+  config.shared = {
+    :command_launcher => "config/shared_commands.rb"
+  }
+
+  # This information is used in headers and email templates, set it specific
+  # to your application
+  config.name     = 'Origen Testers'
+  config.initials = 'OrigenTesters'
+  self.name = 'origen_testers'
+  self.namespace = 'OrigenTesters'
+  config.rc_url   = "git@github.com:Origen-SDK/origen_testers.git"
+  config.release_externally = true
+
+  # Added list of directory to exclude when run running origen rc unman
+  config.unmanaged_dirs = %w[spec/patterns/bin]
+
+  config.unmanaged_files = %w[]
+
+  config.web_directory = "git@github.com:Origen-SDK/Origen-SDK.github.io.git/testers"
+  config.web_domain = "http://origen-sdk.org/testers"
+
+  # When false Origen will be less strict about checking for some common coding errors,
+  # it is recommended that you leave this to true for better feedback and easier debug.
+  # This will be the default setting in Origen v3.
+  config.strict_errors = true
+
+  config.semantically_version = true
+
+  # By default all generated output will end up in ./output.
+  # Here you can specify an alternative directory entirely, or make it dynamic such that
+  # the output ends up in a setup specific directory.
+  config.output_directory do
+    "#{Origen.root}/output/#{$tester.name}"
+  end
+
+  # Similary for the reference files, generally you want to setup the reference directory
+  # structure to mirror that of your output directory structure.
+  config.reference_directory do
+    "#{Origen.root}/.ref/#{$tester.name}"
+  end
+  
+  # Setting this to the spec area for testing of compiler
+  config.pattern_output_directory do
+    "#{Origen.root}/spec/patterns/atp"
+  end
+
+  # Run the tests before deploying to generate test coverage numbers
+  def before_deploy_site
+    Dir.chdir Origen.root do
+      system 'origen examples -c'
+      system 'origen specs -c'
+      dir = "#{Origen.root}/web/output/coverage"
+      FileUtils.remove_dir(dir, true) if File.exist?(dir)
+      system "mv #{Origen.root}/coverage #{dir}"
+    end
+  end
+
+  # This will automatically deploy your documentation after every tag
+  def after_release_email(tag, note, type, selector, options)
+    command = 'origen web compile --remote --api'
+    Dir.chdir Origen.root do
+      system command
+    end
+  end
+
+  # Ensure that all tests pass before allowing a release to continue
+   def validate_release
+    if !system("origen examples") # || !system("origen specs")
+      puts "Sorry but you can't release with failing tests, please fix them and try again."
+      exit 1
+    else
+      puts "All tests passing, proceeding with release process!"
+    end
+   end
+
+  # Help to find patterns based on an iterator
+  config.pattern_name_translator do |name|
+    if name == 'dummy_name'
+      { :source => 'timing', :output => 'timing' }
+    else
+      name.gsub(/_b\d/, '_bx')
+    end
+  end
+
+  if current?  # Standalone only configs
+
+    # By block iterator
+    config.pattern_iterator do |iterator|
+      iterator.key = :by_block
+  
+      iterator.loop do |&pattern|
+        $nvm.blocks.each do |block|
+          pattern.call(block)
+        end
+      end
+  
+      iterator.setup do |block|
+        blk = $nvm.find_block_by_id(block.id)
+        blk.select
+        blk
+      end
+  
+      iterator.pattern_name do |name, block|
+        name.gsub('_bx', "_b#{block.id}")
+      end
+    end
+  
+    # By setting iterator
+    config.pattern_iterator do |iterator|
+      iterator.key = :by_setting
+  
+      iterator.loop do |settings, &pattern|
+        settings.each do |setting|
+          pattern.call(setting)
+        end
+      end
+  
+      iterator.pattern_name do |name, setting|
+        name.gsub('_x', "_#{setting}")
+      end
+    end
+  
+  end # standalone only configs
+
+  # Set up lint test
+  config.lint_test = {
+    # Require the lint tests to pass before allowing a release to proceed
+    :run_on_tag => true,
+    # Auto correct violations where possible whenever 'origen lint' is run
+    :auto_correct => true,
+    # Limit the testing for large legacy applications
+    #:level => :easy,
+    # Run on these directories/files by default
+    #:files => ["lib", "config/application.rb"],
+  }
+end

data/config/commands.rb

@@ -0,0 +1,73 @@
+# This file should be used to extend the origen command line tool with tasks 
+# specific to your application.
+# The comments below should help to get started and you can also refer to
+# lib/origen/commands.rb in your Origen core workspace for more examples and 
+# inspiration.
+#
+# Also see the official docs on adding commands:
+#   http://origen.freescale.net/origen/latest/guides/custom/commands/
+
+# Map any command aliases here, for example to allow origen -x to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases = {
+#  "-x" => "execute",
+  "g"  => "generate"
+}
+
+# The requested command is passed in here as @command, this checks it against
+# the above alias table and should not be removed.
+@command = aliases[@command] || @command
+
+# Now branch to the specific task code
+case @command
+
+# Run the unit tests  
+when "specs"
+  require "rspec"
+  exit RSpec::Core::Runner.run(['spec'])
+
+# Run the example-based (diff) tests
+when "examples", "test"
+  Origen.load_application
+  status = 0
+
+  Dir["#{Origen.root}/examples/*.rb"].each do |example|
+    require example
+  end
+
+  # Compiler tests
+#    ARGV = %w(templates/example.txt.erb -t debug -r approved)
+#    load "origen/commands/compile.rb"
+
+  if Origen.app.stats.changed_files == 0 &&
+     Origen.app.stats.new_files == 0 &&
+     Origen.app.stats.changed_patterns == 0 &&
+     Origen.app.stats.new_patterns == 0
+
+    Origen.app.stats.report_pass
+  else
+    Origen.app.stats.report_fail
+    status = 1
+  end
+  puts
+  if @command == "test"
+    Origen.app.unload_target!
+    require "rspec"
+    result = RSpec::Core::Runner.run(['spec'])
+    status = status == 1 ? 1 : result
+  end
+  exit status  # Exit with a 1 on the event of a failure per std unix result codes
+
+# Always leave an else clause to allow control to fall back through to the
+# Origen command handler.
+# You probably want to also add the command details to the help shown via
+# origen -h, you can do this be assigning the required text to @application_commands
+# before handing control back to Origen. Un-comment the example below to get started.
+else
+  @application_commands = <<-EOT
+ specs        Run the specs (tests), -c will enable coverage
+ examples     Run the examples (tests), -c will enable coverage
+ test         Run both specs and examples, -c will enable coverage
+  EOT
+
+end 

data/config/development.rb

@@ -0,0 +1,12 @@
+# This file is only loaded when the testers is running standalone,
+# therefore anything required here will be loaded for development only
+require "origen_testers/test/dut.rb"
+require "origen_testers/test/block.rb"
+require "origen_testers/test/dut2.rb"
+require "origen_testers/test/nvm.rb"
+
+require "origen_testers/test/j750_interface"
+require "origen_testers/test/ultraflex_interface"
+require "origen_testers/test/j750_hpt_interface"
+require "origen_testers/test/v93k_interface"
+require "origen_testers/test/basic_interface"

data/config/environment.rb

@@ -0,0 +1 @@
+require "origen_testers"

data/config/shared_commands.rb

@@ -0,0 +1,47 @@
+# This file should be used to extend the origen command line tool with tasks 
+# specific to your application.
+# The comments below should help to get started and you can also refer to
+# lib/origen/commands.rb in your Origen core workspace for more examples and 
+# inspiration.
+#
+# Also see the official docs on adding commands:
+#   http://origen.freescale.net/origen/latest/guides/custom/commands/
+
+# Map any command aliases here, for example to allow origen -x to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases ={
+  "g"  => "generate"
+}
+
+# The requested command is passed in here as @command, this checks it against
+# the above alias table and should not be removed.
+@command = aliases[@command] || @command
+
+case @command
+
+  #when "latpc"
+  #  require "#{Origen.root(:testers)}/lib/commands/latpc"
+  # Need to see if --compile is included and setup compiler
+  when "generate"
+  @application_options << ["--compile", "Compile the current pattern or the list"]
+  @application_options << ["-v", "--vector_comments", "Add the vector and cycle number to the vector comments"]
+  if ARGV.include?('--compile')
+    compiler_instance_name = ARGV[ARGV.index('--compile')+1]
+    if compiler_instance_name.nil?
+      $compiler = :use_app_default
+    else
+      ARGV.delete(compiler_instance_name) 
+      $compiler = compiler_instance_name.to_sym
+    end
+    ARGV.delete("--compile")
+  end
+  $_testers_enable_vector_comments = ARGV.delete("-v") || ARGV.delete("--vector_comments")
+
+  when "testers:build"
+   require "#{Origen.root!}/lib/commands/build"
+    exit 0
+
+  else
+  @plugin_commands << " testers:build   Build a test program from a collection of sub-programs"
+
+end 

data/config/users.rb

@@ -0,0 +1,18 @@
+# This file defines the users associated with your project, it is basically the 
+# mailing list for release notes.
+#
+# You can split your users into "admin" and "user" groups, the main difference 
+# between the two is that admin users will get all tag emails, users will get
+# emails on external/official releases only.
+#
+# Users are also prohibited from running the "origen tag" task, but this is 
+# really just to prevent a casual user from executing it inadvertently and is
+# not intended to be a serious security gate.
+module Origen
+  module Users
+    def users
+      @users ||= [
+      ]
+    end
+  end
+end

data/config/version.rb

@@ -0,0 +1,8 @@
+module OrigenTesters
+  MAJOR = 0
+  MINOR = 4
+  BUGFIX = 0
+  DEV = nil
+
+  VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
+end

data/lib/commands/build.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+require 'pathname'
+
+options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = <<-EOT
+Build a test program from a collection of sub-programs.
+
+The user must supply a manifest file to define the test program's flows. Each flow definition will state
+which sub-program modules that the flow is comprised of, and the order in which they should be executed.
+The manifest file is written in YAML format and a new manifest file can be generated for the current target
+tester by running the command with the --new option.
+
+Upon launch the command will parse all of the sub-program files into memory. It will then combine and render
+them out to new files, making edits on the fly where necessary to enable the sub-programs to co-exist within
+the same test program.
+The generated files can be tracked and diff-checked by Origen in the usual way.
+
+Usage: origen testers:build MANIFEST [options]
+  EOT
+  opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+  opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  opts.on('-pl', '--plugin PLUGIN_NAME', String, 'Set current plugin') { |pl_n|  options[:current_plugin] = pl_n }
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.on('-n', '--new', 'Generate a new manifest file for the current tester platform') { options[:new] = true }
+  opts.on('-o', '--output DIR', String, 'Override the default output directory') { |o| options[:output] = o }
+  opts.on('-r', '--reference DIR', String, 'Override the default reference directory') { |o| options[:reference] = o }
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+end
+
+opt_parser.parse! ARGV
+
+Origen.load_application
+Origen.current_plugin.temporary = options[:current_plugin] if options[:current_plugin]
+Origen.environment.temporary = options[:environment] if options[:environment]
+Origen.target.temporary = options[:target] if options[:target]
+Origen.app.load_target!
+
+manifest = ARGV.first
+
+unless manifest
+  puts 'You must supply a path to a manifest file'
+  exit 1
+end
+unless $tester.v93k?
+  puts "Sorry but the #{$tester.name} tester is not yet supported by the build command :-("
+  exit 1
+end
+
+if options[:new]
+  template = "#{Origen.root!}/templates/manifest/#{$tester.name}.yaml.erb"
+  manifest += '.yaml' unless manifest =~ /\..*/
+
+  Origen.app.runner.launch action:            :compile,
+                           files:             template,
+                           output:            Pathname.new(manifest).dirname.to_s,
+                           output_file_name:  Pathname.new(manifest).basename.to_s,
+                           quiet:             true,
+                           check_for_changes: false
+
+  puts "New #{$tester.name} manifest created: #{manifest}"
+  exit 0
+end
+
+# Ideally should auto select the correct test platform here, for now hardcoding to V93K
+eval("#{$tester.class}::Builder").new.build(manifest, options)

data/lib/origen_testers.rb

@@ -0,0 +1,23 @@
+require 'origen'
+require 'active_support/concern'
+require 'require_all'
+
+module OrigenTesters
+  autoload :VectorBasedTester, 'origen_testers/vector_based_tester'
+  autoload :Vector,            'origen_testers/vector'
+  autoload :VectorPipeline,    'origen_testers/vector_pipeline'
+  autoload :Interface,         'origen_testers/interface'
+  autoload :Generator,         'origen_testers/generator'
+  autoload :Parser,            'origen_testers/parser'
+  autoload :BasicTestSetups,   'origen_testers/basic_test_setups'
+  autoload :ProgramGenerators, 'origen_testers/program_generators'
+  # not yet autoload :Time,    'origen_testers/time'
+end
+
+require 'origen_testers/igxl_based_tester'
+require 'origen_testers/smartest_based_tester'
+require 'origen_testers/pattern_compilers'
+
+require 'origen_testers/callback_handlers'
+require_relative '../config/application.rb'
+require_relative '../config/environment.rb'

data/lib/origen_testers/api.rb

@@ -0,0 +1,258 @@
+module OrigenTesters
+  # This module implements the basic set of methods that a tester must have
+  # in order for Origen to talk to it.
+  #
+  # They can be overridden by tester specific classes and who may go on to add
+  # additional methods of their own.
+  #
+  # Essentially this API means that any class that includes Origen::Tester will
+  # function as a tester, although it might not do very much!
+  module API
+    attr_accessor :includes
+    attr_accessor :comment_level
+    attr_accessor :generating
+
+    def name
+      @name || self.class
+    end
+
+    def generate?
+      true
+    end
+
+    def generating_pattern?
+      @generating == :pattern
+    end
+
+    def generating_program?
+      @generating == :program
+    end
+
+    def pat_extension
+      @pat_extension || 'txt'
+    end
+    alias_method :pattern_extension, :pat_extension
+
+    def comment_char
+      @comment_char || '//'
+    end
+
+    def program_comment_char
+      @program_comment_char || comment_char
+    end
+
+    def pattern_header(*args)
+    end
+
+    def pattern_footer(*args)
+    end
+
+    def step_comment_prefix
+      @step_comment_prefix || '##'
+    end
+
+    def is_vector_based?
+      return @vector_based if defined?(@vector_based)
+      true
+    end
+
+    def is_command_based?
+      !is_vector_based?
+    end
+
+    def j750?
+      is_a?(OrigenTesters::IGXLBasedTester::J750)
+    end
+
+    def j750_hpt?
+      is_a?(OrigenTesters::IGXLBasedTester::J750_HPT)
+    end
+
+    def v93k?
+      is_a?(OrigenTesters::SmartestBasedTester::V93K)
+    end
+
+    def ultraflex?
+      is_a?(OrigenTesters::IGXLBasedTester::UltraFLEX)
+    end
+    alias_method :uflex?, :ultraflex?
+
+    def doc?
+      false
+    end
+
+    def annotate(msg, options = {})
+    end
+
+    # Ignore fails on the given pins for the duration of the given block, this
+    # has the effect of temporarily setting the states of the given pins to
+    # don't care.
+    def ignore_fails(*pins)
+      pins.each(&:suspend)
+      yield
+      pins.each(&:resume)
+    end
+
+    # Output a comment in the pattern, normally you would not call this directly
+    # and instead use these shorthand methods:
+    #   cc "Some comment"
+    #   ss "A single line step comment"
+    #   step_comment do
+    #       cc "A multi line"
+    #       cc "step comment"
+    #   end
+    def c1(msg, options = {})
+      prefix = comment_char + ' '
+      prefix += step_comment_prefix + ' ' if @step_comment_on
+      push_comment(prefix + msg.to_s)
+    end
+
+    def c2(msg, options = {})
+      c1(msg, options)
+    end
+
+    def pattern_section(msg)
+      if generating_program?
+        yield
+      else
+        step_comment(msg)
+        yield
+      end
+    end
+
+    def ss(msg = nil)
+      div = step_comment_prefix.length
+      div = 1 if div == 0
+      c1(step_comment_prefix * (70 / div))
+      @step_comment_on = true
+      if block_given?
+        yield
+      else
+        c1(msg)
+      end
+      @step_comment_on = false
+      c1(step_comment_prefix * (70 / div))
+    end
+
+    def snip(number, options = {})
+      yield
+    end
+
+    # Allows a section to be run without actually generating any vectors. This can be useful
+    # to ensure the pin states end up as they otherwise would have if the section had been run.
+    # Classic example of this is a subroutine pattern, wrap this around a call to the startup
+    # routine to ensure the pin states are as they would have been immediately after the startup.
+    # ==== Example
+    #   # Setup state as if I had run startup without actually doing so
+    #   $tester.inhibit_vectors_and_comments do
+    #       $soc.startup
+    #       $top.startup
+    #   end
+    def inhibit_vectors_and_comments
+      inhibit_vectors = @inhibit_vectors
+      inhibit_comments = @inhibit_comments
+      @inhibit_vectors = true
+      @inhibit_comments = true
+      yield
+      @inhibit_vectors = inhibit_vectors      # Restore to their initial state
+      @inhibit_comments = inhibit_comments
+    end
+
+    # Generate a vector.
+    # Calling this method will generate a vector in the output pattern based on the
+    # current pin states and timeset.
+    def cycle(options = {})
+      options = {
+        microcode: '',
+        timeset:   current_timeset,
+        pin_vals:  current_pin_vals,
+        repeat:    nil
+      }.merge(options)
+
+      if any_clocks_running?
+        update_running_clocks
+        if options[:repeat]
+          slice_repeats(options).each do |slice|
+            options[:repeat] = slice[0]
+            delay(options.delete(:repeat), options) do |options|
+              push_vector(options)
+            end
+            slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+            options[:pin_vals] = current_pin_vals
+          end
+        else
+          push_vector(options)
+          pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+        end
+      else
+        if options[:repeat]
+          delay(options.delete(:repeat), options) do |options|
+            push_vector(options)
+          end
+        else
+          push_vector(options)
+        end
+      end
+    end
+
+    def import_test_time(file, options = {})
+      puts "Sorry but an importer doesn't exist for: #{Origen.tester.class}"
+    end
+
+    def any_clocks_running?
+      @clocks_running.nil? ? false : @clocks_running.count > 0
+    end
+
+    def clocks_running
+      @clocks_running
+    end
+    alias_method :running_clocks, :clocks_running
+
+    def push_running_clock(pin)
+      @clocks_running.nil? ? @clocks_running = { pin.name.to_s => pin } : @clocks_running[pin.name.to_s] = pin
+    end
+
+    def pop_running_clock(pin)
+      fail "ERROR: No clocks running, doesn't make sense to pop one" unless any_clocks_running?
+      @clocks_running.delete(pin.name.to_s)
+    end
+
+    def slice_repeats(options = {})
+      slices = {}
+      repeat_ary = []
+      clocks_running.each do |name, clock_pin|
+        if clock_pin.next_edge < (cycle_count + options[:repeat])
+          pin_slices = (clock_pin.next_edge..(cycle_count + options[:repeat])).step(clock_pin.half_period).to_a
+          pin_slices.insert(0, cycle_count)
+        else
+          pin_slices = [cycle_count]
+        end
+        pin_slices.each do |cycle|
+          slices[cycle].nil? ? slices[cycle] = name : slices[cycle] = "#{slices[cycle]},#{name}"
+        end
+        slices[cycle_count + options[:repeat]] = '' if pin_slices[-1] != cycle_count + options[:repeat]
+      end
+      slices.keys.sort.each do |edge_cycles|
+        # puts "Toggle #{slices[edge_cycles]} on #{edge_cycles}"
+        repeat_ary.push([edge_cycles, slices[edge_cycles].split(',')])
+      end
+
+      (repeat_ary.count - 1).downto(1).each { |i| repeat_ary[i][0] = repeat_ary[i][0] - repeat_ary[i - 1][0] }
+      repeat_ary[1..-1]
+    end
+
+    def pins_need_toggling
+      toggle_ary = []
+      clocks_running.each do |name, clock_pin|
+        toggle_ary.push("#{name}") if clock_pin.next_edge == cycle_count
+      end
+      toggle_ary
+    end
+
+    def update_running_clocks
+      clocks_running.each do |name, clock_pin|
+        clock_pin.update_clock
+      end
+    end
+  end
+end