origen_testers 0.4.0

data/lib/origen_testers/vector_pipeline.rb

@@ -0,0 +1,288 @@
+module OrigenTesters
+  class VectorPipeline
+    attr_reader :group_size, :pipeline
+    # Used to keep track of how many vectors since the last reset of the pipeline (i.e.
+    # since pattern start). This is used to implement padding if there is a minimum
+    # vector requirement.
+    attr_reader :vector_count
+    attr_reader :cycle_count
+
+    def initialize(group_size)
+      @group_size = group_size
+      @pipeline = []
+      # A new pipeline is instantiated per-pattern, so don't need to worry about
+      # clearing this
+      @vector_count = 0
+      @cycle_count = 0
+    end
+
+    def push_comment(comment)
+      comments << comment
+    end
+
+    def push_microcode(code)
+      if $tester.v93k? && code =~ /JSUB/
+        @vector_count += 1
+      end
+      comments << code
+    end
+
+    # Add a vector/comment to the pipeline
+    def <<(vector)
+      if vector.is_a?(Vector)
+        level_period(vector) do |vector|
+          consume_comments(vector)
+          if vector.repeat > 1
+            add_repeat_vector(vector)
+          else
+            pipeline << vector
+          end
+        end
+        # Keep a persistent record of the last vector so that we know what it
+        # was after the pipeline has been flushed
+        @last_vector = pipeline.last
+      elsif vector.is_a?(Symbol)
+        case vector
+        when :align
+          duplicate_last_vector until aligned?
+        when :align_last
+          duplicate_last_vector until aligned_to_last?
+        else
+          fail "Uknown vector generator instruction: #{vector}"
+        end
+      else
+        comments << vector
+      end
+    end
+
+    # If there are complete groups sitting at the top of the pipeline
+    # then this will yield them back line by line, stopping after the last
+    # complete group and leaving any remaining single vectors in the pipeline
+    #
+    # If there are no complete groups present then it will just return
+    def flush(&block)
+      while lead_group_finalized?
+        lead_group.each do |vector|
+          vector.comments.each do |comment|
+            yield comment
+          end
+          yield_vector(vector, &block)
+        end
+        pipeline.shift(group_size)
+      end
+    end
+
+    # Call at the end to force a flush out of any remaining vectors
+    def empty(options = {}, &block)
+      if !pipeline.empty? || !comments.empty?
+        if options[:min_vectors]
+          comment_written = false
+          while @vector_count < options[:min_vectors] - pipeline.size
+            unless comment_written
+              yield "#{$tester.comment_char} PADDING VECTORS ADDED TO MEET MIN #{options[:min_vectors]} FOR PATTERN"
+              comment_written = true
+            end
+            yield_vector(@last_vector, &block)
+          end
+        end
+        duplicate_last_vector until aligned?
+        pipeline.each do |vector|
+          vector.comments.each do |comment|
+            yield comment
+          end
+          yield_vector(vector, &block)
+        end
+
+        comments.each do |comment|
+          yield comment
+        end
+        @pipeline = []
+        @comments = []
+      end
+    end
+
+    private
+
+    def yield_vector(vector, &block)
+      vector.cycle = @cycle_count
+      vector.number = @vector_count
+      r = vector.repeat || 1
+      if $tester.min_repeat_loop && r < $tester.min_repeat_loop
+        vector.repeat = 1
+        r.times do
+          yield vector
+        end
+        @vector_count += r
+        @cycle_count += r
+      else
+        yield vector
+        @vector_count += 1
+        @cycle_count += r
+      end
+    end
+
+    def level_period(vector)
+      if $tester.level_period?
+        vector.convert_to_timeset($tester.min_period_timeset) do |vector|
+          yield vector
+        end
+      else
+        yield vector
+      end
+    end
+
+    # Pushes a duplicate of the given vector with its repeat set to 1
+    #
+    # Also clears any comments associated with the vector with the rationale that we only
+    # want to see them the first time.
+    #
+    # Any microcode is cleared with the rationale that the caller is responsible for aligning
+    # this to the correct vector if required.
+    def push_duplicate(vector, options = {})
+      v = vector.dup
+      v.microcode = nil
+      v.repeat = 1
+      pipeline << v
+      if options[:existing_vector]
+        v.comments = []
+      else
+        vector.comments = []
+      end
+    end
+
+    def duplicate_last_vector
+      v = @last_vector.dup
+      v.comments = []
+      v.timeset = $tester.timeset
+      v.repeat = 1
+      v.microcode = nil
+      pipeline << v
+    end
+
+    def add_repeat_vector(vector)
+      count = vector.repeat
+      # Align to the start of a new group by splitting off single vectors
+      # to complete the current group
+      while !aligned? && count > 0
+        push_duplicate(vector)
+        count -= 1
+      end
+      if count > group_size
+        remainder = count % group_size
+        # Create a group with the required repeat
+        group_size.times do
+          push_duplicate(vector)
+        end
+        pipeline.last.repeat = (count - remainder) / group_size
+        # Then expand out any leftover
+        remainder.times do
+          push_duplicate(vector)
+        end
+      # For small repeats that fit within the group just expand them
+      else
+        while count > 0
+          push_duplicate(vector)
+          count -= 1
+        end
+      end
+    end
+
+    # Returns true of the next vector to be added to the pipeline will
+    # be at the start of a new group
+    def aligned?
+      (pipeline.size % group_size) == 0
+    end
+
+    # Returns true if the next vector to be added to the pipeline will
+    # complete the current group
+    def aligned_to_last?
+      (pipeline.size % group_size) == (group_size - 1)
+    end
+
+    def consume_comments(vector)
+      vector.comments = comments
+      @comments = []
+    end
+
+    def comments
+      @comments ||= []
+    end
+
+    # When true the lead group is complete and a further repeat of it is not possible
+    # Calling this will compress the 2nd group into the 1st if possible
+    def lead_group_finalized?
+      if first_group_present? && second_group_present?
+        if second_group_is_duplicate_of_first_group? && first_group_repeat != $tester.max_repeat_loop
+          # Consume the second group by incrementing the first group repeat counter
+          self.first_group_repeat = first_group_repeat + second_group_repeat
+          # Delete the second group
+          group_size.times { pipeline.delete_at(group_size) }
+
+          # Now deal with any overflow of the first group repeat counter
+          if first_group_repeat > $tester.max_repeat_loop
+            r = first_group_repeat - $tester.max_repeat_loop
+            self.first_group_repeat = $tester.max_repeat_loop
+            group_size.times { |i| push_duplicate(pipeline[i], existing_vector: true) }
+            self.second_group_repeat = r
+            true
+          elsif first_group_repeat == $tester.max_repeat_loop
+            true
+          else
+            false
+          end
+        else
+          # Second group has started and is already different from the first group
+          true
+        end
+      end
+    end
+
+    def first_group_repeat
+      # This is currently hardcoded to the Teradyne concept of the repeat being applied
+      # to the last vector in the group. May need an abstraction here if other ATEs don't
+      # adhere to that approach.
+      first_group.last.repeat || 1
+    end
+
+    def first_group_repeat=(val)
+      first_group.last.repeat = val
+    end
+
+    def second_group_repeat
+      second_group.last.repeat || 1
+    end
+
+    def second_group_repeat=(val)
+      second_group.last.repeat = val
+    end
+
+    def second_group_is_duplicate_of_first_group?
+      i = -1
+      second_group.all? do |vector|
+        i += 1
+        (pipeline[i] == vector) && (vector.comments.size == 0) &&
+          # Don't consider vectors with matching microcode duplicates, caller is
+          # responsible for laying out microcode with the correct alignment
+          !pipeline[i].has_microcode? && !vector.has_microcode? &&
+          !vector.dont_compress
+      end
+    end
+
+    def first_group_present?
+      lead_group.size == group_size
+    end
+
+    def second_group_present?
+      second_group.size == group_size
+    end
+
+    def lead_group
+      pipeline[0..group_size - 1]
+    end
+    alias_method :first_group, :lead_group
+
+    def second_group
+      pipeline[group_size..(group_size * 2) - 1]
+    end
+  end
+end

data/pattern/dc_instr.rb

@@ -0,0 +1,7 @@
+# Pattern to exercise the DC instrument test feature of tester
+
+Pattern.create() do
+  
+#  Execute standard soc method -- pins should magically get set with Pset if needed here 
+  
+end

data/pattern/delay.rb

@@ -0,0 +1,7 @@
+# Pattern to exercise a simple time delay
+
+Pattern.create() do
+  
+ $tester.wait(:time_in_ms => 40) 
+  
+end

data/pattern/mem_test.rb

@@ -0,0 +1,8 @@
+unless $tester.v93k?
+  # Pattern to exercise the memory test feature of tester
+  Pattern.create(:memory_test => true) do
+    
+    $dut.memory_test
+    
+  end
+end

data/pattern/multi_vector.rb

@@ -0,0 +1,117 @@
+class SetupTester
+  include Origen::PersistentCallbacks
+
+  def before_pattern(pattern_name)
+    case
+    when pattern_name =~ /^mm_single\./
+      $tester.vector_group_size = 1
+    when pattern_name =~ /^mm_dual\./
+      $tester.vector_group_size = 2
+    when pattern_name =~ /^mm_quad\./
+      $tester.vector_group_size = 4
+    else
+      # To avoid breaking later tests
+      $tester.vector_group_size = 1
+    end
+  end
+end
+SetupTester.new
+
+[:single, :dual, :quad].each do |size|
+  # Startup is being skipped here since it is currently a test of the ability
+  # to render (i.e. paste) vectors, therefore they are not compressible by
+  # Origen and which makes debugging this confusing!
+  Pattern.create(name: "mm_#{size}", skip_startup: true) do
+    $tester.set_timeset("nvmbist", 40)
+
+    ss "$tester.cycle(repeat: 128)"
+    $tester.cycle(repeat: 128)
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "Test of period levelling"
+    end
+    $tester.timing_toggled_pins << $dut.pin(:tclk)
+    $dut.pin(:tdo).assert(0)
+    8.cycles
+    $tester.set_timeset("nvmbist_readout", 160)
+    8.cycles
+    $dut.pin(:tdo).dont_care
+    $tester.set_timeset("nvmbist", 40)
+
+    if $tester.vector_group_size == 1
+      ss do
+        cc "Test that these collapse to a single repeat in the single vector case"
+      end
+      $dut.pin(:tdi).drive(1)
+      $tester.wait cycles: 60000
+      $tester.cycle
+      $dut.pin(:tdi).dont_care
+    end
+
+    ss do
+      cc "Test that these collapse to correct multiple repeats"
+    end
+    $dut.pin(:tdi).drive(1)
+    $tester.wait cycles: 300000
+    $dut.pin(:tdi).dont_care
+
+    ss do
+      cc "Verify that comments at the end of the pattern work OK"
+    end
+    $dut.pin(:tdi).drive(0)
+    $tester.wait cycles: 1200
+    cc "This comment should appear after the delay 1200"
+
+    # Don't add anything new here, the above test should be last in this pattern
+
+  end
+end

data/pattern/multi_vector_plus1.rb

@@ -0,0 +1,125 @@
+# This pattern is to test that patterns pad correctly when they end on an
+# odd number of vectors.
+# Don't add things to the main body, modify multi_vector.rb instead.
+
+class SetupTester
+  include Origen::PersistentCallbacks
+
+  def before_pattern(pattern_name)
+    case
+    when pattern_name =~ /^mm_single_plus1\./
+      $tester.vector_group_size = 1
+    when pattern_name =~ /^mm_dual_plus1\./
+      $tester.vector_group_size = 2
+    when pattern_name =~ /^mm_quad_plus1\./
+      $tester.vector_group_size = 4
+    else
+      # To avoid breaking later tests
+      $tester.vector_group_size = 1
+    end
+  end
+end
+SetupTester.new
+
+[:single, :dual, :quad].each do |size|
+  # Startup is being skipped here since it is currently a test of the ability
+  # to render (i.e. paste) vectors, therefore they are not compressible by
+  # Origen and which makes debugging this confusing!
+  Pattern.create(name: "mm_#{size}_plus1", skip_startup: true) do
+    $tester.set_timeset("nvmbist", 40)
+
+    ss "$tester.cycle(repeat: 128)"
+    $tester.cycle(repeat: 128)
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "Test of period levelling"
+    end
+    8.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+    $tester.set_timeset("nvmbist_readout", 80)
+    8.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+    $tester.set_timeset("nvmbist", 40)
+
+    if $tester.vector_group_size == 1
+      ss do
+        cc "Test that these collapse to a single repeat in the single vector case"
+      end
+      $dut.pin(:tdi).drive(1)
+      $tester.wait cycles: 60000
+      $tester.cycle
+      $dut.pin(:tdi).dont_care
+    end
+
+    ss do
+      cc "Test that these collapse to correct multiple repeats"
+    end
+    $dut.pin(:tdi).drive(1)
+    $tester.wait cycles: 300000
+    $dut.pin(:tdi).dont_care
+
+    ss do
+      cc "Verify that comments at the end of the pattern work OK"
+    end
+    $dut.pin(:tdi).drive(0)
+    $tester.wait cycles: 1200
+    cc "This comment should appear after the delay 1200"
+    $tester.cycle
+
+    # Don't add anything new here, the above test should be last in this pattern
+
+  end
+end