origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/vector_generator.rb

@@ -1,655 +1,655 @@
-require 'active_support/concern'
-module OrigenTesters
-  module VectorGenerator
-    extend ActiveSupport::Concern
-
-    require 'erb'
-
-    included do
-      # When set to true vector and cycle number comments will be appended to pattern vectors.
-      # This can also be enabled by running the generate command with the '-v' switch.
-      attr_accessor :vector_comments
-      attr_accessor :compress
-      attr_accessor :expand_repeats
-    end
-
-    def vector_group_size
-      @vector_group_size || 1
-    end
-
-    def vector_group_size=(number)
-      if number > 1 && number.odd?
-        fail 'Only even numbers can be supplied for the vector_group_size!'
-      end
-      # Each pattern should run with its own tester instance, but just in case
-      @pipeline = nil
-      @vector_group_size = number
-    end
-
-    def with_vector_group_size(number)
-      orig = vector_group_size
-      self.vector_group_size = number
-      yield
-      self.vector_group_size = orig
-    end
-
-    # Duplicate the last vector as required until aligned with the start of the
-    # next vector group
-    def align
-      stage.store :align
-    end
-    alias_method :align_to_first, :align
-
-    # Duplicate the last vector as required until aligned to the last vector of the
-    # current vector group
-    def align_to_last
-      stage.store :align_last
-    end
-
-    # Returns an array of pin IDs that are currently inhibited (will not
-    # be included when vectors are generated)
-    def inhibited_pins
-      @inhibited_pins ||= []
-    end
-
-    # init vector count when first accessed, otherwise return value
-    def vec_count
-      @vec_count ||= 0
-    end
-
-    # increment vector count
-    def inc_vec_count(num = 1)
-      vec_count if @vec_count.nil?  # define if not already
-      @vec_count = @vec_count + num
-    end
-
-    # decrement vector count
-    def dec_vec_count(num = 1)
-      vec_count if @vec_count.nil?  # define if not already
-      @vec_count = @vec_count - num
-    end
-
-    # Returns the current cycle count
-    def cycle_count
-      @cycle_count ||= 0
-    end
-
-    # Returns the current execution time
-    def execution_time_in_ns
-      @execution_time_in_ns ||= 0
-    end
-
-    # increment cycle count
-    def inc_cycle_count(num = 1, options = {})
-      num, options = 1, num if num.is_a?(Hash)
-      cycle_count if @cycle_count.nil? # define if not already
-      execution_time_in_ns if @execution_time_in_ns.nil? # define if not already
-      @execution_time_in_ns += num * (options[:period_in_ns] || tester.timeset.period_in_ns)
-      @cycle_count = @cycle_count + num
-    end
-
-    # reset_cycle_count
-    def reset_cycle_count(num = 0)
-      cycle_count if @cycle_count.nil? # define if not already
-      @execution_time_in_ns = 0
-      @cycle_count = num
-    end
-
-    # Call to prevent the given pins from appearing in the generated vectors.
-    #
-    # This is a convenient way to inhibit something like a J750 mux pin from
-    # appearing in the patterns when generating the pattern for a different
-    # platform.
-    #
-    # When used this
-    # method must be called before the first vector is generated - it will not be retrospectively
-    # applied to existing vectors.
-    def inhibit_pin(*pins)
-      pins.each do |pin|
-        pin = $dut.pin(pin) if pin.is_a?(Symbol)
-        inhibited_pins << pin
-      end
-      inhibited_pins.uniq!
-      inhibited_pins.compact!
-      inhibited_pins
-    end
-    alias_method :inhibit_pins, :inhibit_pin
-
-    # Render content directly into a pattern, any options will be passed to the template
-    def render(template, options = {})
-      # Record the current file, this can be used to resolve any relative path
-      # references in the file about to be compiled
-      Origen.file_handler.current_file = template
-      # Ran into crosstalk problems when rendering ERB templates recursively, setting eoutvar based
-      # on the name of the file will causes each template to be rendered into its own 'bank'.
-      # Not sure why the final gsub is needed but seems to fail to parse correctly otherwise.
-      eoutvar = Pathname.new(template).basename('.*').basename('.*').to_s.gsub('-', '_')
-      # Make the file name available to the template
-      Origen.generator.compiler.options[:file] = template
-      options.each { |k, v| Origen.generator.compiler.options[k] = v }
-      code = Origen.generator.compiler.insert(ERB.new(File.read(template.to_s), 0, Origen.config.erb_trim_mode, eoutvar).result)
-      code.strip!
-      push_microcode code
-    end
-
-    # If the tester defines a method named template this method will compile
-    # whatever template file is returned by that method.
-    #
-    # This method is called automatically after the body section of a Pattern.create
-    # operation has completed.
-    def render_template
-      _render(:template)
-    end
-
-    # Same as the render method, except the template method should be called body_template.
-    def render_body
-      _render(:body_template)
-    end
-
-    # If the tester defines a method named footer_template this method will compile
-    # whatever template file is returned by that method.
-    #
-    # This method is called automatically during the footer section of a Pattern.create
-    # operation.
-    def render_footer
-      _render(:footer_template)
-    end
-
-    # If the tester defines a method named header_template this method will compile
-    # whatever template file is returned by that method.
-    #
-    # This method is called automatically during the header section of a Pattern.create
-    # operation.
-    def render_header
-      _render(:header_template)
-    end
-
-    def _render(method)  # :nodoc:
-      if self.respond_to?(method)
-        template = send(method)
-        # Record the current file, this can be used to resolve any relative path
-        # references in the file about to be compiled
-        Origen.file_handler.current_file = template
-        # Ran into crosstalk problems when rendering ERB templates recursively, setting eoutvar based
-        # on the name of the file will causes each template to be rendered into its own 'bank'.
-        # Not sure why the final gsub is needed but seems to fail to parse correctly otherwise.
-        eoutvar = Pathname.new(template).basename('.*').basename('.*').to_s.gsub('-', '_')
-        # Make the file name available to the template
-        Origen.generator.compiler.options[:file] = template
-        push_microcode Origen.generator.compiler.insert(ERB.new(File.read(template.to_s), 0, Origen.config.erb_trim_mode, eoutvar).result)
-      end
-    end
-
-    def stage
-      Origen.generator.stage
-    end
-
-    def push_comment(msg)
-      # Comments are stored verbatim for now, can't see much use for a dedicated comment object
-      stage.store msg unless @inhibit_comments
-    end
-
-    def microcode(code, options = {})
-      unless @inhibit_vectors
-        if options[:offset] && options[:offset] != 0
-          stage.insert_from_end code, options[:offset]
-        else
-          stage.store code
-        end
-      end
-    end
-    alias_method :push_microcode, :microcode
-
-    def last_vector(offset = 0)
-      stage.last_vector(offset)
-    end
-
-    def last_object(offset = 0)
-      stage.last_object(offset)
-    end
-
-    # Allows the attributes for the next vector to be setup prior
-    # to generating it.
-    #
-    # A block can be optionally supplied to act as a clean up method,
-    # that is the block will be saved and executed after the next
-    # cycle has been generated.
-    #
-    # See the V93K store_next_cycle method for an example of using
-    # this.
-    def preset_next_vector(attrs = {}, &block)
-      @preset_next_vector = attrs
-      @preset_next_vector_cleanup = block
-    end
-
-    # Called by every $tester.cycle command to push a vector to the stage object
-    def push_vector(attrs = {})
-      attrs = {
-        dont_compress: @dont_compress
-      }.merge(attrs)
-      unless @inhibit_vectors
-        if @preset_next_vector
-          attrs = @preset_next_vector.merge(attrs) do |key, preset, current|
-            if preset && current && current != ''
-              fail "Value for #{key} set by preset_next_vector clashed with the next vector!"
-            else
-              preset || current
-            end
-          end
-          @preset_next_vector = nil
-        end
-        v = Vector.new(attrs)
-        stage.store Vector.new(attrs)
-        inc_vec_count
-        inc_cycle_count(attrs[:repeat] || 1, period_in_ns: v.timeset.period_in_ns)
-        if @preset_next_vector_cleanup
-          @preset_next_vector_cleanup.call(v)
-          @preset_next_vector_cleanup = nil
-        end
-      end
-    end
-    alias_method :vector, :push_vector
-
-    def update_vector(attrs = {})
-      unless @inhibit_vectors
-        offset = (attrs.delete(:offset) || 0).abs
-        stage.last_vector(offset).update(attrs)
-      end
-    end
-
-    def update_vector_pin_val(pin, options = {})
-      unless @inhibit_vectors
-        offset = (options.delete(:offset) || 0).abs
-        stage.last_vector(offset).update_pin_val(pin)
-      end
-    end
-
-    # Adds the given microcode to the last vector if possible. If not possible (meaning the
-    # vector already contains microcode) then a new cycle will be added with the given
-    # microcode.
-    def add_microcode_to_last_or_cycle(code)
-      cycle if !stage.last_vector || stage.last_vector.has_microcode?
-      stage.last_vector.update(microcode: code)
-    end
-
-    # Final pass of a generator vector array which returns lines suitable for writing to the
-    # output file. This gives the tester model a chance to concatenate repeats and any other
-    # last optimization/formatting changes it wishes to make.
-    #
-    # At this point vector array contains a combination of non-vector lines and uncompressed
-    # Vector objects (vector lines)
-    #
-    def format(vector_array, section)
-      # Go through vector_array and print out both
-      # vectors and non-vectors to pattern (via 'yield line')
-      vector_array.each do |vec|
-        # skip here important for the ways delays are currently handled
-        # TODO: This seems like an upstream bug that should be investigated, why is such
-        # a vector even generated?
-        if vec.is_a?(String)
-          if vec.strip[0] == comment_char
-            pipeline.push_comment(vec)
-          else
-            pipeline.push_microcode(vec)
-          end
-        else
-          next if vec.respond_to?(:repeat) && vec.repeat == 0 # skip vectors with repeat of 0!
-          pipeline << vec
-        end
-        pipeline.flush do |vector|
-          expand_vector(vector) do |line|
-            yield line
-          end
-        end
-      end
-      # now flush buffer if there is still a vector
-      pipeline.empty(min_vectors: section == :footer ? @min_pattern_vectors : nil) do |vector|
-        expand_vector(vector) do |line|
-          yield line
-        end
-      end
-    end
-
-    # Tester models can overwrite this if they wish to inject any additional pattern lines
-    # at final pattern dump time
-    def before_write_pattern_line(line)
-      [line]
-    end
-
-    def pipeline
-      @pipeline ||= VectorPipeline.new(vector_group_size)
-    end
-
-    def dont_compress
-      if block_given?
-        orig = @dont_compress
-        @dont_compress = true
-        yield
-        @dont_compress = orig
-      else
-        @dont_compress
-      end
-    end
-
-    def dont_compress=(val)
-      @dont_compress = val
-    end
-
-    # expands (uncompresses to pattern) vector if desired or leaves it as is
-    # allows for tracking and formatting of vector
-    # if comment then return without modification
-    def expand_vector(vec)
-      if vec.is_a?(Vector)
-        if expand_repeats
-          vec.repeat.times do
-            vec.repeat = 1
-            yield track_and_format_vector(vec)
-          end
-        else
-          yield track_and_format_vector(vec)
-        end
-      else
-        yield vec  # Return comments without modification
-      end
-    end
-
-    # Update tracking info (stats object) and allow for
-    # any additional formatting via format_vector
-    # method if overridden
-    def track_and_format_vector(vec)
-      unless vec.timeset
-        puts 'No timeset defined!'
-        puts 'Add one to your top level startup method or target like this:'
-        puts '$tester.set_timeset("nvmbist", 40)   # Where 40 is the period in ns'
-        exit 1
-      end
-      stats = Origen.app.stats
-      stats.add_vector
-      if vector_group_size > 1 && vec.repeat > 1
-        stats.add_cycle(1)
-        stats.add_cycle((vec.repeat - 1) * vector_group_size)
-        stats.add_time_in_ns(vec.timeset.period_in_ns)
-        stats.add_time_in_ns((vec.repeat - 1) * vector_group_size * vec.timeset.period_in_ns)
-      else
-        stats.add_cycle(vec.repeat)
-        stats.add_time_in_ns(vec.repeat * vec.timeset.period_in_ns)
-      end
-      format_vector(vec)
-    end
-
-    def format_vector(vec)
-    end
-
-    def pingroup_map
-      Origen.app.pingroup_map
-    end
-
-    # Cache any pin ordering for later use since all vectors should be formatted the same
-    def ordered_pins_cache(options = {})
-      @ordered_pins_cache ||= ordered_pins(options)
-    end
-
-    def ordered_pins(options = {})
-      options = {
-        include_inhibited_pins: false,
-        include_pingroups:      true
-      }.merge(options)
-
-      result = nil
-
-      Origen.profile 'Working out pin pattern order' do
-        pinorder = Origen.app.pin_pattern_order.dup
-        pinexclude = Origen.app.pin_pattern_exclude.dup
-
-        if Origen.app.pin_pattern_order.last.is_a?(Hash)
-          options.merge!(pinorder.pop)
-        end
-        if Origen.app.pin_pattern_exclude.last.is_a?(Hash)
-          options.merge!(pinexclude.pop)
-        end
-
-        ordered_pins = []
-
-        # Create a copy of all pins and groups to be output, pins/groups will be delete from here as
-        # they are output, so that at the end of the user defined pin order what is left in here can
-        # either be discarded or output at the end
-        pins = Origen.pin_bank.pins.dup
-        pingroups = Origen.pin_bank.pin_groups.dup
-
-        if pinorder && pinorder.size > 0
-          pinorder.each do |id|
-            # If the ID refers to a pin group
-            if group = Origen.pin_bank.pin_groups[id]
-              # If the group has still to be output just do that now
-              if pingroups.include? group.id
-                ordered_pins << group
-                # Now delete the group from the list of groups still to be output and all of its pins
-                # from the list pins still to be output
-                group.each do |pin|
-                  pins.delete(pin.id)
-                  pin.groups.each do |name, _group|
-                    pingroups.delete(name)
-                  end
-                end
-                pingroups.delete(group.id)
-              # To get here the some of the pins in the group have already been output which is preventing
-              # output of the complete group at this point, in that case output any of its pins that have
-              # still to go
-              else
-                group.each do |pin|
-                  if pins.include? pin.id
-                    ordered_pins << pin
-                    pin.groups.each do |name, _group|
-                      pingroups.delete(name)
-                    end
-                  end
-                end
-              end
-            # this is a pin
-            else
-              pin = Origen.pin_bank.find(id)
-              fail "Undefined pin (#{id}) added to pin_pattern_order" unless pin
-              ordered_pins << pin
-              pin.groups.each do |name, _group|
-                pingroups.delete(name)
-              end
-              pin.name = id
-              pins.delete(pin.id)
-            end
-          end
-        end
-
-        if pinexclude && pinexclude.size > 0
-          pinexclude.each do |id|
-            if group = Origen.pin_bank.pin_groups[id]
-              # see if group is already in ordered_pins
-              fail "Pin group #{id} is defined both in pin_pattern_order and pin_pattern_exclude" unless pingroups.include? id
-              # this is a pin group, delete all pins in group
-              pingroups.delete(id)
-              group.each do |pin|
-                fail "Pin (#{pin.name}) in group (#{group.id}) is defined both in pin_pattern_order and pin_pattern_exclude" unless pins.include? pin.id
-                pins.delete(pin.id)
-              end
-            else # this is a pin, delete the pin
-              pin = Origen.pin_bank.find(id)
-              fail "Undefined pin (#{id}) added to pin_pattern_exclude" unless pin
-              fail "Pin #{pin.name} is defined both in pin_pattern_order and pin_pattern_exclude" unless pins.include? pin.id
-              pin.name = id
-              pins.delete(pin.id)
-              pin.groups.each do |name, _group|
-                pingroups.delete(name)
-              end
-            end
-          end
-        end
-
-        unless options[:only]
-          # all the rest of the pins to the end of the pattern order
-          pins.each do |_id, pin|
-            # check for port
-            if pin.belongs_to_a_pin_group?
-              # Are any of this pin's groups still waiting to be output? pingroups at this point contains
-              # those groups which have not been rendered yet
-              group = pingroups.find do |_id, group|
-                pin.groups.any? { |_pid, pgroup| group == pgroup }
-              end
-              if group
-                ordered_pins << group[1]
-                group[1].each { |pin| pins.delete(pin.id) }
-              else
-                ordered_pins << pin
-              end
-            else
-              ordered_pins << pin
-            end
-          end
-        end
-
-        result = ordered_pins.map do |pin|
-          if options[:include_inhibited_pins]
-            pin
-          else
-            inhibited_pins.include?(pin) ? nil : pin
-          end
-        end
-        result = result.compact
-      end
-      result
-    end
-
-    def current_pin_vals
-      ordered_pins_cache.map(&:to_vector).join(' ')
-    end
-
-    # Returns a regular expression that can be used to get the value
-    # of the given pin within the string returned by current_pin_vals.
-    #   str = $tester.current_pin_vals                  # => "1 1 XX10 H X1"
-    #   regex = $tester.regex_for_pin($dut.pins(:jtag)) # => /\w{1} \w{1} (\w{4}) \w{1} \w{2}/
-    #   regex.match(str)
-    #   Regexp.last_match(1)   # => "XX10"
-    #
-    # @see Vector#pin_value
-    def regex_for_pin(pin)
-      @regex_for_pins ||= {}
-      # Cache this as potentially called many times during pattern generation
-      @regex_for_pins[pin] ||= begin
-        regex = '/'
-        ordered_pins_cache.each do |p|
-          if pin == p
-            regex += "(\\w{#{p.size}}) "
-          else
-            regex += "\\w{#{p.size}} "
-          end
-        end
-        eval(regex.strip + '/')
-      end
-    end
-
-    # Returns a regular expression that can be used to change the value
-    # of the given pin within the string returned by current_pin_vals.
-    #   str = $tester.current_pin_vals                      # => "1 1 XX10 H X1"
-    #   regex = $tester.regex_for_pin_sub($dut.pins(:jtag)) # => /(\w{1} \w{1} )(\w{4})( \w{1} \w{2})/
-    #   str.sub(regex, '\1LLLL\3')  # => "1 1 LLLL H X1"
-    #
-    # @see Vector#set_pin_value
-    def regex_for_pin_sub(pin)
-      @regex_for_pin_subs ||= {}
-      # Cache this as potentially called many times during pattern generation
-      @regex_for_pin_subs[pin] ||= begin
-        regex = '/'
-        first_pin_done = false
-        match_pin_done = false
-        ordered_pins_cache.each do |p|
-          if pin == p
-            regex += ')' if first_pin_done
-            regex += "(\\w{#{p.size}})( "
-          else
-            regex += '(' unless first_pin_done
-            regex += "\\w{#{p.size}} "
-          end
-          first_pin_done = true
-        end
-        regex.strip!
-        if regex[-1] == '('
-          regex.chop!
-        else
-          regex += ')'
-        end
-        eval(regex + '/')
-      end
-    end
-
-    def get_pingroup(pin)
-      pingroup_map.each do |id, pins|
-        return id if pins.include? pin
-      end
-      nil
-    end
-
-    def update_pin_from_formatted_state(pin, state)
-      if state == @repeat_previous || state == '-'
-        pin.repeat_previous = true
-      elsif state == @drive_very_hi_state || state == '2'
-        pin.drive_very_hi
-      elsif state == @drive_hi_state || state == '1'
-        pin.drive_hi
-      elsif state == @drive_lo_state || state == '0'
-        pin.drive_lo
-      elsif state == @expect_hi_state || state == 'H'
-        pin.expect_hi
-      elsif state == @expect_lo_state || state == 'L'
-        pin.expect_lo
-      elsif state == @expect_mid_state || state == 'M'
-        pin.expect_mid
-      elsif state == @drive_mem_state || state == 'D'
-        pin.drive_mem
-      elsif state == @expect_mem_state || state == 'E'
-        pin.expect_mem
-      elsif state == @capture_state || state == 'C'
-        pin.capture
-      elsif state == @dont_care_state || state == 'X'
-        pin.dont_care
-      else
-        fail "Unknown pin state: #{state}"
-      end
-    end
-
-    # @see Origen::Pins::Pin#to_vector
-    def format_pin_state(pin)
-      if pin.repeat_previous? && @support_repeat_previous
-        @repeat_previous || '-'
-      elsif pin.driving?
-        if pin.value == 1
-          if pin.high_voltage?
-            @drive_very_hi_state || '2'
-          else
-            @drive_hi_state || '1'
-          end
-        else
-          @drive_lo_state || '0'
-        end
-      elsif pin.comparing_midband?
-        @expect_mid_state || 'M'
-      elsif pin.comparing?
-        if pin.value == 1
-          @expect_hi_state || 'H'
-        else
-          @expect_lo_state || 'L'
-        end
-      elsif pin.driving_mem?
-        @drive_mem_state || 'D'
-      elsif pin.comparing_mem?
-        @expect_mem_state || 'E'
-      elsif pin.to_be_captured?
-        @capture_state || 'C'
-      else
-        @dont_care_state || 'X'
-      end
-    end
-
-    # @api private
-    def remove_store_from_vector(vector)
-      vector.pin_vals.sub!('C', 'X')
-    end
-  end
-end
+require 'active_support/concern'
+module OrigenTesters
+  module VectorGenerator
+    extend ActiveSupport::Concern
+
+    require 'erb'
+
+    included do
+      # When set to true vector and cycle number comments will be appended to pattern vectors.
+      # This can also be enabled by running the generate command with the '-v' switch.
+      attr_accessor :vector_comments
+      attr_accessor :compress
+      attr_accessor :expand_repeats
+    end
+
+    def vector_group_size
+      @vector_group_size || 1
+    end
+
+    def vector_group_size=(number)
+      if number > 1 && number.odd?
+        fail 'Only even numbers can be supplied for the vector_group_size!'
+      end
+      # Each pattern should run with its own tester instance, but just in case
+      @pipeline = nil
+      @vector_group_size = number
+    end
+
+    def with_vector_group_size(number)
+      orig = vector_group_size
+      self.vector_group_size = number
+      yield
+      self.vector_group_size = orig
+    end
+
+    # Duplicate the last vector as required until aligned with the start of the
+    # next vector group
+    def align
+      stage.store :align
+    end
+    alias_method :align_to_first, :align
+
+    # Duplicate the last vector as required until aligned to the last vector of the
+    # current vector group
+    def align_to_last
+      stage.store :align_last
+    end
+
+    # Returns an array of pin IDs that are currently inhibited (will not
+    # be included when vectors are generated)
+    def inhibited_pins
+      @inhibited_pins ||= []
+    end
+
+    # init vector count when first accessed, otherwise return value
+    def vec_count
+      @vec_count ||= 0
+    end
+
+    # increment vector count
+    def inc_vec_count(num = 1)
+      vec_count if @vec_count.nil?  # define if not already
+      @vec_count = @vec_count + num
+    end
+
+    # decrement vector count
+    def dec_vec_count(num = 1)
+      vec_count if @vec_count.nil?  # define if not already
+      @vec_count = @vec_count - num
+    end
+
+    # Returns the current cycle count
+    def cycle_count
+      @cycle_count ||= 0
+    end
+
+    # Returns the current execution time
+    def execution_time_in_ns
+      @execution_time_in_ns ||= 0
+    end
+
+    # increment cycle count
+    def inc_cycle_count(num = 1, options = {})
+      num, options = 1, num if num.is_a?(Hash)
+      cycle_count if @cycle_count.nil? # define if not already
+      execution_time_in_ns if @execution_time_in_ns.nil? # define if not already
+      @execution_time_in_ns += num * (options[:period_in_ns] || tester.timeset.period_in_ns)
+      @cycle_count = @cycle_count + num
+    end
+
+    # reset_cycle_count
+    def reset_cycle_count(num = 0)
+      cycle_count if @cycle_count.nil? # define if not already
+      @execution_time_in_ns = 0
+      @cycle_count = num
+    end
+
+    # Call to prevent the given pins from appearing in the generated vectors.
+    #
+    # This is a convenient way to inhibit something like a J750 mux pin from
+    # appearing in the patterns when generating the pattern for a different
+    # platform.
+    #
+    # When used this
+    # method must be called before the first vector is generated - it will not be retrospectively
+    # applied to existing vectors.
+    def inhibit_pin(*pins)
+      pins.each do |pin|
+        pin = $dut.pin(pin) if pin.is_a?(Symbol)
+        inhibited_pins << pin
+      end
+      inhibited_pins.uniq!
+      inhibited_pins.compact!
+      inhibited_pins
+    end
+    alias_method :inhibit_pins, :inhibit_pin
+
+    # Render content directly into a pattern, any options will be passed to the template
+    def render(template, options = {})
+      # Record the current file, this can be used to resolve any relative path
+      # references in the file about to be compiled
+      Origen.file_handler.current_file = template
+      # Ran into crosstalk problems when rendering ERB templates recursively, setting eoutvar based
+      # on the name of the file will causes each template to be rendered into its own 'bank'.
+      # Not sure why the final gsub is needed but seems to fail to parse correctly otherwise.
+      eoutvar = Pathname.new(template).basename('.*').basename('.*').to_s.gsub('-', '_')
+      # Make the file name available to the template
+      Origen.generator.compiler.options[:file] = template
+      options.each { |k, v| Origen.generator.compiler.options[k] = v }
+      code = Origen.generator.compiler.insert(ERB.new(File.read(template.to_s), 0, Origen.config.erb_trim_mode, eoutvar).result)
+      code.strip!
+      push_microcode code
+    end
+
+    # If the tester defines a method named template this method will compile
+    # whatever template file is returned by that method.
+    #
+    # This method is called automatically after the body section of a Pattern.create
+    # operation has completed.
+    def render_template
+      _render(:template)
+    end
+
+    # Same as the render method, except the template method should be called body_template.
+    def render_body
+      _render(:body_template)
+    end
+
+    # If the tester defines a method named footer_template this method will compile
+    # whatever template file is returned by that method.
+    #
+    # This method is called automatically during the footer section of a Pattern.create
+    # operation.
+    def render_footer
+      _render(:footer_template)
+    end
+
+    # If the tester defines a method named header_template this method will compile
+    # whatever template file is returned by that method.
+    #
+    # This method is called automatically during the header section of a Pattern.create
+    # operation.
+    def render_header
+      _render(:header_template)
+    end
+
+    def _render(method)  # :nodoc:
+      if self.respond_to?(method)
+        template = send(method)
+        # Record the current file, this can be used to resolve any relative path
+        # references in the file about to be compiled
+        Origen.file_handler.current_file = template
+        # Ran into crosstalk problems when rendering ERB templates recursively, setting eoutvar based
+        # on the name of the file will causes each template to be rendered into its own 'bank'.
+        # Not sure why the final gsub is needed but seems to fail to parse correctly otherwise.
+        eoutvar = Pathname.new(template).basename('.*').basename('.*').to_s.gsub('-', '_')
+        # Make the file name available to the template
+        Origen.generator.compiler.options[:file] = template
+        push_microcode Origen.generator.compiler.insert(ERB.new(File.read(template.to_s), 0, Origen.config.erb_trim_mode, eoutvar).result)
+      end
+    end
+
+    def stage
+      Origen.generator.stage
+    end
+
+    def push_comment(msg)
+      # Comments are stored verbatim for now, can't see much use for a dedicated comment object
+      stage.store msg unless @inhibit_comments
+    end
+
+    def microcode(code, options = {})
+      unless @inhibit_vectors
+        if options[:offset] && options[:offset] != 0
+          stage.insert_from_end code, options[:offset]
+        else
+          stage.store code
+        end
+      end
+    end
+    alias_method :push_microcode, :microcode
+
+    def last_vector(offset = 0)
+      stage.last_vector(offset)
+    end
+
+    def last_object(offset = 0)
+      stage.last_object(offset)
+    end
+
+    # Allows the attributes for the next vector to be setup prior
+    # to generating it.
+    #
+    # A block can be optionally supplied to act as a clean up method,
+    # that is the block will be saved and executed after the next
+    # cycle has been generated.
+    #
+    # See the V93K store_next_cycle method for an example of using
+    # this.
+    def preset_next_vector(attrs = {}, &block)
+      @preset_next_vector = attrs
+      @preset_next_vector_cleanup = block
+    end
+
+    # Called by every $tester.cycle command to push a vector to the stage object
+    def push_vector(attrs = {})
+      attrs = {
+        dont_compress: @dont_compress
+      }.merge(attrs)
+      unless @inhibit_vectors
+        if @preset_next_vector
+          attrs = @preset_next_vector.merge(attrs) do |key, preset, current|
+            if preset && current && current != ''
+              fail "Value for #{key} set by preset_next_vector clashed with the next vector!"
+            else
+              preset || current
+            end
+          end
+          @preset_next_vector = nil
+        end
+        v = Vector.new(attrs)
+        stage.store Vector.new(attrs)
+        inc_vec_count
+        inc_cycle_count(attrs[:repeat] || 1, period_in_ns: v.timeset.period_in_ns)
+        if @preset_next_vector_cleanup
+          @preset_next_vector_cleanup.call(v)
+          @preset_next_vector_cleanup = nil
+        end
+      end
+    end
+    alias_method :vector, :push_vector
+
+    def update_vector(attrs = {})
+      unless @inhibit_vectors
+        offset = (attrs.delete(:offset) || 0).abs
+        stage.last_vector(offset).update(attrs)
+      end
+    end
+
+    def update_vector_pin_val(pin, options = {})
+      unless @inhibit_vectors
+        offset = (options.delete(:offset) || 0).abs
+        stage.last_vector(offset).update_pin_val(pin)
+      end
+    end
+
+    # Adds the given microcode to the last vector if possible. If not possible (meaning the
+    # vector already contains microcode) then a new cycle will be added with the given
+    # microcode.
+    def add_microcode_to_last_or_cycle(code)
+      cycle if !stage.last_vector || stage.last_vector.has_microcode?
+      stage.last_vector.update(microcode: code)
+    end
+
+    # Final pass of a generator vector array which returns lines suitable for writing to the
+    # output file. This gives the tester model a chance to concatenate repeats and any other
+    # last optimization/formatting changes it wishes to make.
+    #
+    # At this point vector array contains a combination of non-vector lines and uncompressed
+    # Vector objects (vector lines)
+    #
+    def format(vector_array, section)
+      # Go through vector_array and print out both
+      # vectors and non-vectors to pattern (via 'yield line')
+      vector_array.each do |vec|
+        # skip here important for the ways delays are currently handled
+        # TODO: This seems like an upstream bug that should be investigated, why is such
+        # a vector even generated?
+        if vec.is_a?(String)
+          if vec.strip[0] == comment_char
+            pipeline.push_comment(vec)
+          else
+            pipeline.push_microcode(vec)
+          end
+        else
+          next if vec.respond_to?(:repeat) && vec.repeat == 0 # skip vectors with repeat of 0!
+          pipeline << vec
+        end
+        pipeline.flush do |vector|
+          expand_vector(vector) do |line|
+            yield line
+          end
+        end
+      end
+      # now flush buffer if there is still a vector
+      pipeline.empty(min_vectors: section == :footer ? @min_pattern_vectors : nil) do |vector|
+        expand_vector(vector) do |line|
+          yield line
+        end
+      end
+    end
+
+    # Tester models can overwrite this if they wish to inject any additional pattern lines
+    # at final pattern dump time
+    def before_write_pattern_line(line)
+      [line]
+    end
+
+    def pipeline
+      @pipeline ||= VectorPipeline.new(vector_group_size)
+    end
+
+    def dont_compress
+      if block_given?
+        orig = @dont_compress
+        @dont_compress = true
+        yield
+        @dont_compress = orig
+      else
+        @dont_compress
+      end
+    end
+
+    def dont_compress=(val)
+      @dont_compress = val
+    end
+
+    # expands (uncompresses to pattern) vector if desired or leaves it as is
+    # allows for tracking and formatting of vector
+    # if comment then return without modification
+    def expand_vector(vec)
+      if vec.is_a?(Vector)
+        if expand_repeats
+          vec.repeat.times do
+            vec.repeat = 1
+            yield track_and_format_vector(vec)
+          end
+        else
+          yield track_and_format_vector(vec)
+        end
+      else
+        yield vec  # Return comments without modification
+      end
+    end
+
+    # Update tracking info (stats object) and allow for
+    # any additional formatting via format_vector
+    # method if overridden
+    def track_and_format_vector(vec)
+      unless vec.timeset
+        puts 'No timeset defined!'
+        puts 'Add one to your top level startup method or target like this:'
+        puts '$tester.set_timeset("nvmbist", 40)   # Where 40 is the period in ns'
+        exit 1
+      end
+      stats = Origen.app.stats
+      stats.add_vector
+      if vector_group_size > 1 && vec.repeat > 1
+        stats.add_cycle(1)
+        stats.add_cycle((vec.repeat - 1) * vector_group_size)
+        stats.add_time_in_ns(vec.timeset.period_in_ns)
+        stats.add_time_in_ns((vec.repeat - 1) * vector_group_size * vec.timeset.period_in_ns)
+      else
+        stats.add_cycle(vec.repeat)
+        stats.add_time_in_ns(vec.repeat * vec.timeset.period_in_ns)
+      end
+      format_vector(vec)
+    end
+
+    def format_vector(vec)
+    end
+
+    def pingroup_map
+      Origen.app.pingroup_map
+    end
+
+    # Cache any pin ordering for later use since all vectors should be formatted the same
+    def ordered_pins_cache(options = {})
+      @ordered_pins_cache ||= ordered_pins(options)
+    end
+
+    def ordered_pins(options = {})
+      options = {
+        include_inhibited_pins: false,
+        include_pingroups:      true
+      }.merge(options)
+
+      result = nil
+
+      Origen.profile 'Working out pin pattern order' do
+        pinorder = Origen.app.pin_pattern_order.dup
+        pinexclude = Origen.app.pin_pattern_exclude.dup
+
+        if Origen.app.pin_pattern_order.last.is_a?(Hash)
+          options.merge!(pinorder.pop)
+        end
+        if Origen.app.pin_pattern_exclude.last.is_a?(Hash)
+          options.merge!(pinexclude.pop)
+        end
+
+        ordered_pins = []
+
+        # Create a copy of all pins and groups to be output, pins/groups will be delete from here as
+        # they are output, so that at the end of the user defined pin order what is left in here can
+        # either be discarded or output at the end
+        pins = Origen.pin_bank.pins.dup
+        pingroups = Origen.pin_bank.pin_groups.dup
+
+        if pinorder && pinorder.size > 0
+          pinorder.each do |id|
+            # If the ID refers to a pin group
+            if group = Origen.pin_bank.pin_groups[id]
+              # If the group has still to be output just do that now
+              if pingroups.include? group.id
+                ordered_pins << group
+                # Now delete the group from the list of groups still to be output and all of its pins
+                # from the list pins still to be output
+                group.each do |pin|
+                  pins.delete(pin.id)
+                  pin.groups.each do |name, _group|
+                    pingroups.delete(name)
+                  end
+                end
+                pingroups.delete(group.id)
+              # To get here the some of the pins in the group have already been output which is preventing
+              # output of the complete group at this point, in that case output any of its pins that have
+              # still to go
+              else
+                group.each do |pin|
+                  if pins.include? pin.id
+                    ordered_pins << pin
+                    pin.groups.each do |name, _group|
+                      pingroups.delete(name)
+                    end
+                  end
+                end
+              end
+            # this is a pin
+            else
+              pin = Origen.pin_bank.find(id)
+              fail "Undefined pin (#{id}) added to pin_pattern_order" unless pin
+              ordered_pins << pin
+              pin.groups.each do |name, _group|
+                pingroups.delete(name)
+              end
+              pin.name = id
+              pins.delete(pin.id)
+            end
+          end
+        end
+
+        if pinexclude && pinexclude.size > 0
+          pinexclude.each do |id|
+            if group = Origen.pin_bank.pin_groups[id]
+              # see if group is already in ordered_pins
+              fail "Pin group #{id} is defined both in pin_pattern_order and pin_pattern_exclude" unless pingroups.include? id
+              # this is a pin group, delete all pins in group
+              pingroups.delete(id)
+              group.each do |pin|
+                fail "Pin (#{pin.name}) in group (#{group.id}) is defined both in pin_pattern_order and pin_pattern_exclude" unless pins.include? pin.id
+                pins.delete(pin.id)
+              end
+            else # this is a pin, delete the pin
+              pin = Origen.pin_bank.find(id)
+              fail "Undefined pin (#{id}) added to pin_pattern_exclude" unless pin
+              fail "Pin #{pin.name} is defined both in pin_pattern_order and pin_pattern_exclude" unless pins.include? pin.id
+              pin.name = id
+              pins.delete(pin.id)
+              pin.groups.each do |name, _group|
+                pingroups.delete(name)
+              end
+            end
+          end
+        end
+
+        unless options[:only]
+          # all the rest of the pins to the end of the pattern order
+          pins.each do |_id, pin|
+            # check for port
+            if pin.belongs_to_a_pin_group?
+              # Are any of this pin's groups still waiting to be output? pingroups at this point contains
+              # those groups which have not been rendered yet
+              group = pingroups.find do |_id, group|
+                pin.groups.any? { |_pid, pgroup| group == pgroup }
+              end
+              if group
+                ordered_pins << group[1]
+                group[1].each { |pin| pins.delete(pin.id) }
+              else
+                ordered_pins << pin
+              end
+            else
+              ordered_pins << pin
+            end
+          end
+        end
+
+        result = ordered_pins.map do |pin|
+          if options[:include_inhibited_pins]
+            pin
+          else
+            inhibited_pins.include?(pin) ? nil : pin
+          end
+        end
+        result = result.compact
+      end
+      result
+    end
+
+    def current_pin_vals
+      ordered_pins_cache.map(&:to_vector).join(' ')
+    end
+
+    # Returns a regular expression that can be used to get the value
+    # of the given pin within the string returned by current_pin_vals.
+    #   str = $tester.current_pin_vals                  # => "1 1 XX10 H X1"
+    #   regex = $tester.regex_for_pin($dut.pins(:jtag)) # => /\w{1} \w{1} (\w{4}) \w{1} \w{2}/
+    #   regex.match(str)
+    #   Regexp.last_match(1)   # => "XX10"
+    #
+    # @see Vector#pin_value
+    def regex_for_pin(pin)
+      @regex_for_pins ||= {}
+      # Cache this as potentially called many times during pattern generation
+      @regex_for_pins[pin] ||= begin
+        regex = '/'
+        ordered_pins_cache.each do |p|
+          if pin == p
+            regex += "(\\w{#{p.size}}) "
+          else
+            regex += "\\w{#{p.size}} "
+          end
+        end
+        eval(regex.strip + '/')
+      end
+    end
+
+    # Returns a regular expression that can be used to change the value
+    # of the given pin within the string returned by current_pin_vals.
+    #   str = $tester.current_pin_vals                      # => "1 1 XX10 H X1"
+    #   regex = $tester.regex_for_pin_sub($dut.pins(:jtag)) # => /(\w{1} \w{1} )(\w{4})( \w{1} \w{2})/
+    #   str.sub(regex, '\1LLLL\3')  # => "1 1 LLLL H X1"
+    #
+    # @see Vector#set_pin_value
+    def regex_for_pin_sub(pin)
+      @regex_for_pin_subs ||= {}
+      # Cache this as potentially called many times during pattern generation
+      @regex_for_pin_subs[pin] ||= begin
+        regex = '/'
+        first_pin_done = false
+        match_pin_done = false
+        ordered_pins_cache.each do |p|
+          if pin == p
+            regex += ')' if first_pin_done
+            regex += "(\\w{#{p.size}})( "
+          else
+            regex += '(' unless first_pin_done
+            regex += "\\w{#{p.size}} "
+          end
+          first_pin_done = true
+        end
+        regex.strip!
+        if regex[-1] == '('
+          regex.chop!
+        else
+          regex += ')'
+        end
+        eval(regex + '/')
+      end
+    end
+
+    def get_pingroup(pin)
+      pingroup_map.each do |id, pins|
+        return id if pins.include? pin
+      end
+      nil
+    end
+
+    def update_pin_from_formatted_state(pin, state)
+      if state == @repeat_previous || state == '-'
+        pin.repeat_previous = true
+      elsif state == @drive_very_hi_state || state == '2'
+        pin.drive_very_hi
+      elsif state == @drive_hi_state || state == '1'
+        pin.drive_hi
+      elsif state == @drive_lo_state || state == '0'
+        pin.drive_lo
+      elsif state == @expect_hi_state || state == 'H'
+        pin.expect_hi
+      elsif state == @expect_lo_state || state == 'L'
+        pin.expect_lo
+      elsif state == @expect_mid_state || state == 'M'
+        pin.expect_mid
+      elsif state == @drive_mem_state || state == 'D'
+        pin.drive_mem
+      elsif state == @expect_mem_state || state == 'E'
+        pin.expect_mem
+      elsif state == @capture_state || state == 'C'
+        pin.capture
+      elsif state == @dont_care_state || state == 'X'
+        pin.dont_care
+      else
+        fail "Unknown pin state: #{state}"
+      end
+    end
+
+    # @see Origen::Pins::Pin#to_vector
+    def format_pin_state(pin)
+      if pin.repeat_previous? && @support_repeat_previous
+        @repeat_previous || '-'
+      elsif pin.driving?
+        if pin.value == 1
+          if pin.high_voltage?
+            @drive_very_hi_state || '2'
+          else
+            @drive_hi_state || '1'
+          end
+        else
+          @drive_lo_state || '0'
+        end
+      elsif pin.comparing_midband?
+        @expect_mid_state || 'M'
+      elsif pin.comparing?
+        if pin.value == 1
+          @expect_hi_state || 'H'
+        else
+          @expect_lo_state || 'L'
+        end
+      elsif pin.driving_mem?
+        @drive_mem_state || 'D'
+      elsif pin.comparing_mem?
+        @expect_mem_state || 'E'
+      elsif pin.to_be_captured?
+        @capture_state || 'C'
+      else
+        @dont_care_state || 'X'
+      end
+    end
+
+    # @api private
+    def remove_store_from_vector(vector)
+      vector.pin_vals.sub!('C', 'X')
+    end
+  end
+end