origen_testers 0.41.0 → 0.42.0

data/lib/origen_testers/origen_ext/pins/timing/timeset.rb

@@ -0,0 +1,29 @@
+require 'origen/pins/timing/timeset'
+
+module Origen
+  module Pins
+    module Timing
+      class Timeset
+        attr_reader :_timeset_
+
+        # Bind to the original initialize method in Origen and add registering
+        # the DUT timeset to the tester.
+        @orig_init = instance_method(:initialize)
+        define_method(:initialize) do |*args|
+          self.class.instance_variable_get(:@orig_init).bind(self).call(*args)
+          instance_variable_set(:@_timeset_, OrigenTesters::Timing.lookup_or_register_timeset(self))
+        end
+
+        # Defer any missing methods to the corresponding timeset object on the tester side.
+        # If the method isn't found their either, raise the standard NoMethod error.
+        def method_missing(m, *args, &block)
+          if _timeset_.respond_to?(m)
+            _timeset_.send(m, *args, &block)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/pattern_compilers/v93k/digcap.rb

@@ -9,7 +9,10 @@ module OrigenTesters
             @owner = owner
             @pins = nil
 
-            if options && options[:pins] && options[:vps]
+            if options && options[:skip_setup]
+              @skip_setup = options[:skip_setup]   # optional: force skip of AVI digcap setup
+              #                                                e.g. handled by RDI
+            elsif options && options[:pins] && options[:vps]
               @pins = options[:pins]           # required: pins to be captured
               @vps = options[:vps]             # required: vecotrs per sample
               @nrf = options[:nrf] || 1        # optional: nr_frames (defaults to 1)
@@ -21,15 +24,17 @@ module OrigenTesters
 
           def render_aiv_lines
             lines = []
-            lines << ''
-            lines << 'AI_DIGCAP_SETTINGS {'
-            lines << render_digcap_header
-            avc_files.each do |f|
-              if vec_per_frame[f.to_sym] > 0
-                lines << render_digcap_entry(f)
+            unless @skip_setup
+              lines << ''
+              lines << 'AI_DIGCAP_SETTINGS {'
+              lines << render_digcap_header
+              avc_files.each do |f|
+                if vec_per_frame[f.to_sym] > 0
+                  lines << render_digcap_entry(f)
+                end
               end
+              lines << '};'
             end
-            lines << '};'
             lines
           end
 

data/lib/origen_testers/smartest_based_tester.rb

@@ -2,6 +2,8 @@ module OrigenTesters
   module SmartestBasedTester
     autoload :Base,                'origen_testers/smartest_based_tester/base'
     autoload :V93K,                'origen_testers/smartest_based_tester/v93k'
+
+    require 'origen_testers/smartest_based_tester/decompiler'
   end
   # Convenience/Legacy names without the SmartestBasedTester namespace
   autoload :V93K,                  'origen_testers/smartest_based_tester/v93k'

data/lib/origen_testers/smartest_based_tester/base.rb

@@ -411,7 +411,7 @@ module OrigenTesters
       def handshake(options = {})
         options = {
         }.merge(options)
-        Pattern.split(options)
+        ::Pattern.split(options)
       end
 
       # Do a frequency measure.
@@ -421,7 +421,7 @@ module OrigenTesters
       def freq_count(_pin, options = {})
         options = {
         }.merge(options)
-        Pattern.split(options)
+        ::Pattern.split(options)
       end
 
       # Generates a match loop on up to two pins.

data/lib/origen_testers/smartest_based_tester/decompiler.rb

@@ -0,0 +1,43 @@
+module OrigenTesters
+  module SmartestBasedTester
+    def self.suitable_decompiler_for(pattern: nil, tester: nil, **options)
+      if pattern && (Pathname(pattern).extname == '.avc')
+        OrigenTesters::SmartestBasedTester::Pattern
+      elsif tester && tester == 'v93k'
+        OrigenTesters::SmartestBasedTester::Pattern
+      end
+    end
+    extend OrigenTesters::Decompiler::API
+    register_decompiler(self)
+
+    class Pattern < OrigenTesters::Decompiler::Pattern
+      require_relative './decompiler/avc'
+      extend Avc
+
+      @platform = 'v93k'
+      @splitter_config = {
+        pinlist_start: /^FORMAT/,
+
+        # The vectors start will be picked up right after the pinlist is parsed.
+        # We'll throw away any whitespace we encounter between the pinlist and
+        #   first vector element though.
+        vectors_start: proc do |line:, index:, current_indices:|
+          # The pinlist was encountered. Start the vectors at the next line
+          # that's not just whitespace
+          if current_indices[:pinlist_start] && line !~ /^\s/
+            next true
+          end
+          false
+        end,
+
+        # V93K doesn't have any endmatter, or vector end delimiter, so just
+        # grab vectors until the end of the file is reached.
+        vectors_end:   -1
+      }
+
+      @platform_tokens = {
+        comment_start: '#'
+      }
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/decompiler/avc.rb

@@ -0,0 +1,76 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Pattern
+      require_relative './nodes'
+
+      module Avc
+        def nodes_namespace
+          OrigenTesters::SmartestBasedTester::Decompiler::Avc
+        end
+
+        def parse_frontmatter(raw_frontmatter:, context:)
+          # So far, only seen patterns that have comments and/or whitespace in
+          # the frontmatter. Not sure if anything else is allowed.
+          # For this, every comment will be considered the 'header'
+          header = []
+          raw_frontmatter.each_with_index do |l, i|
+            if !(l =~ Regexp.new('^\s*#')).nil?
+              header << l.chomp
+            elsif l.strip.empty?
+              # Whitespace. Do nothing.
+            else
+              Origen.app!.fail!("Unable to parse pattern frontmatter, at line: #{i}")
+            end
+          end
+          OrigenTesters::Decompiler::Nodes::Frontmatter.new(context:        context,
+                                                            pattern_header: header,
+                                                            comments:       []
+                                                           )
+        end
+
+        def parse_pinlist(raw_pinlist:, context:)
+          raw_pinlist = raw_pinlist.join('')
+          # The pinlist can be parsed by grabbing everything between the 'format' token and the ';'
+          # character then splitting by whitespace. Whitespace is then stripped to clean
+          # up the names.
+          # E.g.: FORMAT TCLK TDI TDO TMS;
+          OrigenTesters::Decompiler::Nodes::Pinlist.new(context: context,
+                                                        pins:    raw_pinlist[raw_pinlist.index('FORMAT')..raw_pinlist.index(';') - 1].split(/\s+/)[1..-1].map(&:strip)
+                                                       )
+        end
+
+        def parse_vector(raw_vector:, context:, meta:)
+          if raw_vector =~ Regexp.new('^\s*#')
+            # Comment
+            OrigenTesters::Decompiler::Nodes::CommentBlock.new(context:  context,
+                                                               comments: raw_vector.split("\n")
+                                                              )
+          elsif raw_vector =~ Regexp.new('^R\d+\s')
+            # Vector
+            elements = raw_vector.split(/\s+/, 2 + context.pinlist.size)
+            elements[-1] = elements[-1].split(/\s/, 2)
+            elements[-1][0] = elements[-1][0].gsub(';', '').chomp
+            elements[-1][1] = elements[-1][1].gsub(';', '').chomp
+
+            nodes_namespace::Vector.new(context:    context,
+                                        repeat:     elements[0].gsub('R', '').to_i,
+                                        timeset:    elements[1],
+                                        pin_states: (elements[2..-2] || []) << elements[-1][0],
+                                        comment:    elements[-1][1]
+                                       )
+          else
+            # Anything that doesn't start with Rxyz where xyz is some integer
+            # will be considered a sequencer instruction
+            inst_plus_args = raw_vector.split(/\s+/)
+            inst_plus_args.last.gsub!(';', '').strip!
+
+            nodes_namespace::SequencerInstruction.new(context:     context,
+                                                      instruction: inst_plus_args[0],
+                                                      arguments:   inst_plus_args[1..-1]
+                                                     )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/decompiler/nodes.rb

@@ -0,0 +1,23 @@
+module OrigenTesters
+  module SmartestBasedTester
+    module Decompiler
+      module Avc
+        class SequencerInstruction < OrigenTesters::Decompiler::Nodes::Node
+          PLATFORM_NODES = [:instruction, :arguments]
+
+          def initialize(instruction:, arguments: [], context:)
+            @execute = false
+
+            @instruction = instruction
+            @arguments = arguments
+
+            super(context: context, type: :sequencer_instruction)
+          end
+        end
+
+        class Vector < OrigenTesters::Decompiler::Nodes::Vector
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/stil_based_tester/base.rb

@@ -105,16 +105,16 @@ module OrigenTesters
         end
       end
 
-      def set_timeset(timeset, period_in_ns = nil)
+      def set_timeset(t, period_in_ns = nil)
         super
         if pattern_only
           # Why does D10 not include this?
-          # microcode "W #{timeset};"
+          # microcode "W #{t};"
         else
           @wavesets ||= []
           wave_number = nil
           @wavesets.each_with_index do |w, i|
-            if w[:name] == @timeset.name && w[:period] = @timeset.period_in_ns
+            if w[:name] == timeset.name && w[:period] = timeset.period_in_ns
               wave_number = i
             end
           end
@@ -123,7 +123,7 @@ module OrigenTesters
             ordered_pins.each do |pin|
               if pin.direction == :input || pin.direction == :io
                 line = "#{pin.name} { 01 { "
-                wave = pin.drive_wave
+                wave = pin.drive_wave if tester.timeset.dut_timeset
                 (wave ? wave.evaluated_events : []).each do |t, v|
                   line << "'#{t}ns' "
                   if v == 0
@@ -140,7 +140,7 @@ module OrigenTesters
               end
               if pin.direction == :output || pin.direction == :io
                 line = "#{pin.name} { LHX { "
-                wave = pin.compare_wave
+                wave = pin.compare_wave if tester.timeset.dut_timeset
                 (wave ? wave.evaluated_events : []).each_with_index do |tv, i|
                   t, v = *tv
                   if i == 0 && t != 0
@@ -160,7 +160,7 @@ module OrigenTesters
                 lines << line
               end
             end
-            @wavesets << { name: @timeset.name, period: @timeset.period_in_ns, lines: lines }
+            @wavesets << { name: timeset.name, period: timeset.period_in_ns, lines: lines }
             wave_number = @wavesets.size
           end
           microcode "W Waveset#{wave_number};"

data/lib/origen_testers/test/complex_timing.rb

@@ -0,0 +1,22 @@
+module OrigenTesters
+  module Test
+    class ComplexTimingDUT
+      include Origen::TopLevel
+
+      def initialize(options = {})
+        add_timeset(:complex_timing)
+        timeset(:complex_timing) do |t|
+          t.period_in_ns = 1
+          t.drive_wave(:tclk) do |w|
+            w.drive(0, at: 0)
+            w.drive(:data, at: 'period/2')
+          end
+        end
+      end
+
+      def startup
+        tester.set_timeset(:complex_timing)
+      end
+    end
+  end
+end