origen 0.0.1 → 0.0.2

data/lib/origen/tester/vector_generator.rb

@@ -0,0 +1,633 @@
+require 'active_support/concern'
+module Origen
+  module Tester
+    module VectorGenerator
+      extend ActiveSupport::Concern
+
+      require 'erb'
+
+      included do
+        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
+
+      # 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
+
+      # init cycle count when first accessed, otherwise return value
+      def cycle_count
+        @cycle_count ||= 0
+      end
+
+      # increment cycle count
+      def inc_cycle_count(num = 1)
+        cycle_count if @cycle_count.nil? # define if not already
+        @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
+        @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|
+          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 push_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 :microcode, :push_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
+          stage.store Vector.new(attrs)
+          inc_vec_count
+          inc_cycle_count(attrs[:repeat] || 1)
+          if @preset_next_vector_cleanup
+            @preset_next_vector_cleanup.call
+            @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|
+          # These may eventually be merged to the same method, but splitting for now
+          # so that multi mode development can proceed without upsetting single mode
+          if vector_group_size > 1
+            multi_mode_optimize(vec, section: section) do |line|
+              yield line
+            end
+          else
+            optimize(vec, section: section) do |line|
+              yield line
+            end
+          end
+        end
+        # now flush buffer if there is still a vector
+        if vector_group_size > 1
+          pipeline.empty do |vector|
+            expand_vector(vector) do |line|
+              yield line
+            end
+          end
+        else
+          if @buffered_vector
+            expand_vector(@buffered_vector) do |line|
+              yield line
+            end
+            @buffered_vector = nil
+          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 multi_mode_optimize(vec, _options = {})
+        pipeline << vec
+        pipeline.flush do |vector|
+          expand_vector(vector) do |line|
+            yield line
+          end
+        end
+      end
+
+      def optimize(vec, options = {})
+        options = { section: false
+                }.merge(options)
+
+        # Flush the buffer if this vector is not compressible or if it doesn't
+        # match the existing buffer (to get ready for new vector)
+        if @buffered_vector && (!(compressable_vector?(vec) && vec == @buffered_vector) ||
+          @buffered_vector.repeat == @max_repeat_loop)
+          expand_vector(@buffered_vector) do |line|
+            # if last vector in pattern then pad if insufficient vectors
+            if options[:section] == :footer && (@min_pattern_vectors) && (vec_count < @min_pattern_vectors)
+              yield "#{comment_char} PADDING VECTORS ADDED TO MEET MIN #{@min_pattern_vectors} FOR PATTERN"
+              (@min_pattern_vectors - vec_count + 1).times do
+                yield line
+              end
+              inc_vec_count(@min_pattern_vectors - vec_count)
+            else
+              yield line
+            end
+          end
+          @buffered_vector = nil
+        end
+        if compressable_vector?(vec)
+          # The new vector has already been identified as equal to the buffer
+          # so just increment vector if buffered already, otherwise it is the
+          # first encounter with this vector and create buffer with it
+          if @buffered_vector
+            # simply increment repeat count
+            @buffered_vector.repeat += vec.repeat
+            # decrement vector count only once with each added repeat
+            dec_vec_count(1)
+            # if new repeat exceeds @max_repeat_loop
+            if @buffered_vector.repeat > @max_repeat_loop
+              delay(@buffered_vector.repeat) do |options|
+                @buffered_vector.repeat = options[:repeat]
+                if options[:repeat] == @max_repeat_loop
+                  expand_vector(@buffered_vector) do |line|
+                    yield line
+                  end
+                end
+              end
+            end
+          else
+            # not buffered vector, set buffer to vector
+            @buffered_vector = vec
+          end
+        else
+          # not compressible
+          expand_vector(vec) do |line|
+            yield line
+          end
+        end
+      end
+      alias_method :buffer, :optimize
+
+      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
+
+      def compressable_vector?(vec)
+        !!(compress && vec.is_a?(Vector) && !vec.has_microcode? &&
+           vec.pin_vals && !vec.dont_compress)
+      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 the 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
+
+      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 == @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
+
+      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?
+          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
+    end
+  end
+end