origen_testers 0.41.0 → 0.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05743e4c62f21fdda22dcf6eae8056c1e2db75dfd97d6cf311e7d5577a4e0b6
-  data.tar.gz: a1c877c1b3e3da3566958e11a711ec4aea246b5be91b6420ae6f9c3bda7dc131
+  metadata.gz: b61e30758057f753a3f11c3f9e804ec902c04b11ab5d044eead50e933396dcc4
+  data.tar.gz: 56e4f2859a2dd2d3440f41b8f0025764a1fdbe49dd54266ec46f3f18f6ed4315
 SHA512:
-  metadata.gz: 995f309c1e5894066c36623f8243ff8f88fa6329e8304d276333536f668ec0d89655bd3a49ada8cf29e184a2e4b12952c8bce9aab31f736cdb9939cb89f0b28a
-  data.tar.gz: 01e0fdbb2784d33693d145b013f523013017ad0b4a83a6f363defe47ea0ff0be428522ae15f1010abc554245f2d7bf1f23ad36a24aa28a01d129a30c9d958759
+  metadata.gz: 218203f35e42e7d2de5fa2668dca505dff43339e598ce231d9a5d57f6f8dd02d90f5fb3b53e6d4aef3bc6036eeebe4bc09663190fb192fa72e1aed3ed3e7eb2c
+  data.tar.gz: 83d9e9baee738fac32b9123d8991f18b5b4b3c00cbfda40b74fde58c75c7d052f3da23533e090c8cef611207ae037a151da9d78bad8446a0b696240cf10788c2

data/approved/j750/decompiler/sample/sample.atp

@@ -0,0 +1,16 @@
+// Sample pattern text for the J750
+// Source located at: lib/origen_testers/igxl_based_tester/decompiler
+
+import tset tp0;
+svm_only_file = no;
+opcode_mode = extended;
+compressed = yes;
+
+vector ($tset, tclk, tdi, tdo, tms)
+{
+start_label pattern_st:
+// Start of vector body
+repeat 2 > tp0 X X X X ; // First Vector
+repeat 5 > tp0 1 0 X 1 ;
+end_module   > tp0 X X X X ; // Last Vector
+}

data/config/application.rb

@@ -40,6 +40,12 @@ class OrigenTestersApplication < Origen::Application
         section.page :custom, heading: "Creating Custom Testers"
         section.page :generating, heading: "Running the ProgGen"
       end
+      index.section :decompilation, heading: "Decompilation", before: :simulation do |section|
+        section.page :overview, heading: "Overview & Example"
+        section.page :decompilerapi, heading: "Decompiling, Adding Pins, & Executing"
+        section.page :universalapi, heading: "Working with Decompiled Patterns"
+        section.page :platformspecifics, heading: "Platform Specifics"
+      end
     end
   }
 

data/config/boot.rb

@@ -5,6 +5,9 @@ require "origen_testers"
 require "origen_testers/test/dut.rb"
 require "origen_testers/test/block.rb"
 require "origen_testers/test/dut2.rb"
+require "origen_testers/test/empty_dut.rb"
+require "origen_testers/test/complex_timing.rb"
+
 # NOTE: Before adding new duts-- consider adding option to DUT class 
 # so we don't reduce overall code coverage-- thx, mgmt
 require "origen_testers/test/nvm.rb"

data/config/commands.rb

@@ -21,6 +21,151 @@ aliases = {
 # Now branch to the specific task code
 case @command
 
+# Generates a pattern model given the input file(s).
+when "generate_pattern_model"
+  Origen.load_target
+  approved = ARGV.delete('--approve')
+  ARGV.each do |pat|
+    puts "Generating pattern model for #{pat}"
+    model = OrigenTesters::Decompiler.decompile(pat)
+    path = model.write_spec_yaml(approved: approved)
+    puts "Wrote model to: #{path}"
+    puts
+  end
+  exit 0
+
+when "analyze_decompiler_performance", 'analyze_decomp_perf' 
+  options = {
+    output_csv: Origen.app.root.join('tmp/origen_testers/analyze_decompiler_performance.csv'),
+    ramp: [1]
+  }
+
+  envs = {
+    j750: {output: "#{Origen.app!.root}/output/j750/pin_flip.atp", count_scale: 1.0},
+    v93k: {output: "#{Origen.app!.root}/output/v93k/pin_flip.avc", count_scale: 1.0},
+    stil: {output: "#{Origen.app!.root}/output/stil/pin_flip.stil", count_scale: 1.0},
+  }
+
+  opt_parser = OptionParser.new do |opts|
+    opts.banner = 'Run a performance test for the available decompilers.'
+    opts.on('-c', '--count COUNT', Integer, 'Overrides the full-toggle count (number of vectors)') { |c| options[:count] = c }
+    opts.on('-s', '--scale SCALE', Float, 'Overrides the default scale of 1.0 for all decompilers') do |s|
+      envs.each { |e, o| o[:count_scale] *= s }
+    end
+    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('-p', '--pin NAME', String, 'Override the default pin for toggling. Default is \'tclk\'') { |t| options[:pin] = t }
+    opts.on('--output_csv CSV_FILE', String, "Override the default output name & directory for the resulting CSV file. Default: #{options[:output_csv]}") { |o| options[:output_csv] = Pathname(o) }
+    opts.on('-r', '--ramp [RAMPS]', String, 'Run multiple tests, applying an additional count_scale of 0.1, 0.5, 1, 5, 10, 50, 100 each time. Note: with the default scale count of 10k, this becomes: 1k, 5k, 10k, 50k, 100k, 500k, 1mil. Or, supplying custom ramps formatted as count1,count2,...') do |r|
+      if r
+        options[:ramp] = r.split(',').map(&:to_f)
+      else
+        options[:ramp] = [0.1, 0.5, 1, 5, 10, 50, 100]
+      end
+    end
+
+    envs.each do |env, o|
+      opts.on("--#{env}_scale SCALE", Float, "Additinally scales the #{env} platform") { |s| envs[env][:count_scale] *= s }
+    end
+
+    opts.separator ''
+    opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+  end
+  opt_parser.parse! ARGV
+  unless options[:output_csv].dirname.exist?
+    FileUtils.mkdir_p(options[:output_csv].dirname)
+  end
+  
+  Origen.log.info "Testing Decompiler Performance..."
+  Origen.log.info "Performing setup..."
+
+  Origen.target.temporary = options[:target] || 'default'
+  Origen.load_target
+  ENV['ORIGEN_TESTERS_BIT_FLIP_PIN'] = options[:pin] || 'tclk'
+
+  Origen.log.info
+  Origen.log.info "Generating pattern 'pin_flip' toggling pin #{ENV['ORIGEN_TESTERS_BIT_FLIP_PIN']}..."
+
+  File.open(options[:output_csv], 'w') do |c|
+    c.puts('Base Count (vectors),' + envs.keys.map { |e| "#{e} (User Time (Seconds))" }.join(','))
+
+    options[:ramp].each do |r|
+      count = (options[:count] || 10_000) * r
+      envs.each do |e, opts|
+        env_count = (opts[:count_scale] * count).to_i.to_s
+        Origen.log.info "  Generating pattern for environment: #{e}.rb... "
+        Origen.log.info "    Target Count: #{env_count}"
+
+        ENV['ORIGEN_TESTERS_BIT_FLIP_COUNT'] = env_count
+        Origen.environment.temporary = "#{e}.rb"
+        Origen.load_target
+        Origen.app.runner.generate(patterns: 'pin_flip')
+      end
+      
+      target_env = options[:environment] || 'v93k.rb'
+      Origen.log.info
+      Origen.log.info "Conversion Target Env: #{target_env}"
+      Origen.log.info "Converting Patterns..."
+      fields = {'User Time' => 0, 'System time' => 1, 'Elapsed Time' => 3, 'Peak Memory Usage' => 8}
+      resource_usages = {}
+      maxes = fields.map { |k, v| [k, [0.0, nil]] }.to_h
+      mins = fields.map { |k, v| [k, [Float::INFINITY, nil]] }.to_h
+      envs.each do |env, opts|
+        usage = {}
+        cmd = "/usr/bin/time -v origen convert #{opts[:output]} -e #{target_env} -o #{Origen.app!.root}/output/performance_test/#{env} -t #{Origen.target.name}"
+        puts cmd
+        out, err, stat = Open3.capture3(cmd)
+        output = err.split("\n")
+        fields.each do |f, i|
+          if f == 'Elapsed Time'
+            t = Time.parse("0:#{output[i+1].split(': ').last}")
+            usage[f] = ((t.min * 60) + t.sec).to_f
+          else
+            usage[f] = output[i+1].split(': ').last.to_f
+          end
+          if usage[f] > maxes[f][0]
+            maxes[f] = [usage[f], env]
+          end
+          if usage[f] < mins[f][0]
+            mins[f] = [usage[f], env]
+          end
+        end
+        
+        resource_usages[env] = usage
+        puts out
+        puts err
+      end
+      
+      Origen.log.info
+      Origen.log.info "Usage Report:"
+      Origen.log.info "Count Scales:"
+      envs.each do |env, opts|
+        Origen.log.info "  #{env}: #{opts[:count_scale]} (#{opts[:count_scale] * count.to_i})"
+      end
+      Origen.log.info "File sizes:"
+      envs.each do |env, opts|
+        Origen.log.info "  #{opts[:output]}: %.2f MiB" % (File.size(opts[:output]).to_f / 2**20)
+      end
+      fields.keys.each do |f|
+        Origen.log.info "  #{f}:"
+        Origen.log.info "    Max:  #{maxes[f][0]} (#{maxes[f][1]})"
+        Origen.log.info "    Min:  #{mins[f][0]} (#{mins[f][1]})"
+        s = '%.2f' % (maxes[f][0] - mins[f][0])
+        Origen.log.info "    Diff Max-to-Min: #{s}"
+        s = '%.2f' % ((mins[f][0] / maxes[f][0]) * 100)
+        Origen.log.info "    Scale Max-to-Min: #{s}%"
+        s = '%.2f' % ((maxes[f][0] / mins[f][0]) * 100)
+        Origen.log.info "    Scale Min-to-Max: #{s}%"
+      end
+      
+      c.puts("#{count}," + resource_usages.values.collect { |u| u['User Time'] }.join(','))
+    end
+  end
+  Origen.log.info
+  Origen.log.info "Output CSV available at: #{options[:output_csv]}"
+
+  exit 0
+
 when "tags"
   Dir.chdir Origen.root do
     system "ripper-tags --recursive lib"
@@ -45,9 +190,9 @@ when "examples", "test"
 #    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.new_files == 0 &&
+    Origen.app.stats.changed_patterns == 0 &&
+    Origen.app.stats.new_patterns == 0
 
     Origen.app.stats.report_pass
   else

data/config/version.rb

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

data/lib/commands/convert.rb

@@ -67,19 +67,25 @@ else
 end
 
 def converter(file, options = {})
-  snippet = IO.read(file, 2000)  # Read first 2000 characters
-  case snippet
-  when /STIL \d+\.\d+/
+  if OrigenTesters.decompiler_for?(file)
     lambda do
-      STIL.add_pins(file)
-      # Use raw pin names in the output pattern and not the ALL pin group or similar, maybe
-      # make this an option in future though
-      dut.pin_pattern_order(*dut.pins.map { |id, pin| id })
-      STIL.execute(file, set_timesets: true)
+      OrigenTesters.execute(file)
     end
   else
-    Origen.log.error "Unknown input format for file: #{file}"
-    nil
+    snippet = IO.read(file, 2000)  # Read first 2000 characters
+    case snippet
+    when /STIL \d+\.\d+/
+      lambda do
+        STIL.add_pins(file)
+        # Use raw pin names in the output pattern and not the ALL pin group or similar, maybe
+        # make this an option in future though
+        dut.pin_pattern_order(*dut.pins.map { |id, pin| id })
+        STIL.execute(file, set_timesets: true)
+      end
+    else
+      Origen.log.error "Unknown input format for file: #{file}"
+      nil
+    end
   end
 end
 

data/lib/origen_testers.rb

@@ -38,6 +38,9 @@ module OrigenTesters
       ATP::Program.load(f)
     end
   end
+
+  require 'origen_testers/decompiler'
+  extend Decompiler::API
 end
 autoload :ATP, 'origen_testers/atp_deprecation'
 
@@ -51,3 +54,5 @@ require 'origen_testers/pattern_compilers/runner'
 require 'origen_testers/callback_handlers'
 require 'origen_testers/origen_ext/pins/pin'
 require 'origen_testers/origen_ext/pins/pin_collection'
+require 'origen_testers/origen_ext/pins/timing'
+require 'origen_testers/origen_ext/pins/timing/timeset'

data/lib/origen_testers/api.rb

@@ -239,6 +239,10 @@ module OrigenTesters
         repeat:    nil
       }.merge(options)
 
+      unless timeset.period_in_ns?
+        fail "You must supply a period_in_ns to timeset '#{timeset.name}' before you can cycle the tester!"
+      end
+      timeset.cycled = true
       if PatSeq.thread
         PatSeq.thread.cycle(options)
       else

data/lib/origen_testers/decompiler.rb

@@ -0,0 +1,9 @@
+require_relative 'decompiler/decompiler_api'
+require_relative 'decompiler/nodes'
+require_relative 'decompiler/pattern'
+
+module OrigenTesters
+  module Decompiler
+    extend API
+  end
+end

data/lib/origen_testers/decompiler/decompiler_api.rb

@@ -0,0 +1,163 @@
+module OrigenTesters
+  module Decompiler
+    module API
+      @registered_decompilers = []
+
+      # Decompiles the given pattern, returning
+      def decompile(pattern, options = {})
+        decompiled_pattern(pattern, options).decompile
+      end
+
+      # @note This method is the same as #decompile except that the module's
+      #   #decompile method won't be automatically called.
+      def decompiled_pattern(pattern, options = {})
+        # decompiler!(pattern).decompiled_pattern(pattern)
+        _decompiler = options.delete(:decompiler)
+        _decompiler.nil? ? decompiler!(pattern).new(pattern, options) : _decompiler.new(pattern, options)
+      end
+
+      # Creates a decompiled pattern from the raw input directly.
+      # In this case, no attempts to figure out the decompiler are made. The
+      # suitable decompiler should either be given with the :decompiler parameter,
+      # or the current environment will be used.
+      def decompile_text(text, decompiler: nil)
+        if decompiler.nil?
+          select_decompiler!.new(text, direct_source: true).decompile
+        else
+          decompiler.new(text, direct_source: true).decompile
+        end
+      end
+      alias_method :decompile_str, :decompile_text
+      alias_method :decompile_string, :decompile_text
+      alias_method :decompile_raw_input, :decompile_text
+
+      # Returns the decompiler module that will be uesd to decompile the
+      # given pattern source.
+      def select_decompiler(pattern = nil, options = {})
+        if pattern.is_a?(Hash)
+          options = pattern
+          pattern = nil
+        elsif pattern.nil?
+          options = {}
+          pattern = nil
+        end
+
+        # if respond_to?(:suitable_decompiler_for)
+        # puts "HI".red
+        #  puts self
+        #  registered_decompilers = [self]
+        # end
+
+        _registered_decompilers = respond_to?(:suitable_decompiler_for) ? [self] : registered_decompilers
+
+        # We have the list of modules that support decompilation, but those modules
+        # could have sub-modules that support other decompilation flavors.
+        # We'll select the decompiler by just iterating through each support
+        # decompiler and until we find one that supports either the file extension,
+        # or the current tester name.
+        _registered_decompilers.each do |m|
+          if pattern
+            mod = m.suitable_decompiler_for(pattern: pattern, **options)
+          elsif tester.nil?
+            return nil
+          else
+            mod = m.suitable_decompiler_for(tester: Origen.tester.name.to_s, **options)
+          end
+
+          if mod
+            return mod
+          end
+        end
+
+        nil
+      end
+      alias_method :decompiler, :select_decompiler
+      alias_method :decompiler_for, :select_decompiler
+
+      def select_decompiler!(pattern = nil, options = {})
+        mod = select_decompiler(pattern, options)
+
+        if mod.nil? && pattern
+          # Origen.log.error "Unknown decompiler for file extension '#{File.extname(pattern)}'"
+          Origen.app!.fail(
+            message:         "Cannot find a suitable decompiler for pattern source '#{pattern}' ('#{File.extname(pattern)}')",
+            exception_class: OrigenTesters::Decompiler::NoSuitableDecompiler
+          )
+        elsif mod.nil?
+          # Origen.log.error "Unknown decompiler for tester #{Origen.tester.name}"
+          # fail "Current environment '#{Orige.current_environment}' does not contain a suitable decompiler! Cannot select this as the decompiler."
+          Origen.app!.fail(
+            message:         "Current environment '#{Origen.environment.file.basename}' does not contain a suitable decompiler! Cannot select this as the decompiler.",
+            exception_class: OrigenTesters::Decompiler::NoSuitableDecompiler
+          )
+        end
+        mod
+      end
+      alias_method :decompiler!, :select_decompiler!
+      alias_method :decompiler_for!, :select_decompiler!
+
+      # Returns all the registered decompiler modules.
+      # @note Registered decompilers are stored on the OrigenTesters::Decompiler module.
+      def registered_decompilers
+        OrigenTesters::Decompiler::API.instance_variable_get(:@registered_decompilers)
+      end
+
+      # Registers a new decompiler module.
+      # @return [TrueClass, FalseClass] Like Ruby's #require method, returns
+      #   true if decompiler is now registered and returns false if the mod
+      #   was previously registered.
+      #   If there are problems registering the mod, an exception is raised.
+      # @raise [NoModule]
+      def register_decompiler(mod)
+        if mod.is_a?(String)
+          mod = eval(mod)
+        end
+
+        if registered_decompiler?(mod)
+          false
+        else
+          verify_decompiler_mod!(mod)
+          registered_decompilers << mod
+          true
+        end
+      end
+
+      # Verifies that the registered decompiler has the required methods
+      # available. Namely: #select_decompiler and #decompiled_pattern
+      def verify_decompiler_mod!(mod)
+        unless mod.respond_to?(:suitable_decompiler_for)
+          Origen.app!.fail(
+            exception_class: OrigenTesters::Decompiler::NoMethodError,
+            message:         "No method #suitable_decompiler_for found on #{mod}. Cannot register as a decompiler."
+          )
+        end
+        true
+      end
+
+      # Queries if a decompiler is available for the given pattern.
+      def decompiler_for?(pattern = nil, options = {})
+        !select_decompiler(pattern, options).nil?
+      end
+
+      # Queries if the decompiler in mod has been registered.
+      def registered_decompiler?(mod)
+        if mod.is_a?(String)
+          mod = eval(mod)
+        end
+
+        registered_decompilers.include?(mod)
+      end
+
+      def execute(pattern, options = {})
+        decompile(pattern, options).execute(options)
+      end
+
+      def add_pins(pattern, options = {})
+        decompile(pattern, options).add_pins
+      end
+
+      def self.convert(pattern)
+      end
+    end
+  end
+end