origen 0.2.6 → 0.3.0

data/lib/origen/tester/vector.rb

@@ -1,86 +0,0 @@
-module Origen
-  module Tester
-    # A simple class to model a vector
-    class Vector
-      attr_accessor :repeat, :microcode, :timeset, :pin_vals,
-                    :number, :cycle_number, :dont_compress,
-                    :comments
-
-      def initialize(attrs = {})
-        attrs.each do |attribute, value|
-          send("#{attribute}=", value)
-        end
-      end
-
-      def comments
-        @comments ||= []
-      end
-
-      def update(attrs = {})
-        attrs.each do |attribute, value|
-          send("#{attribute}=", value)
-        end
-      end
-
-      # Updates the pin values to reflect the value currently held by the given pin
-      def update_pin_val(pin)
-        vals = pin_vals.split(' ')
-        if pin.belongs_to_a_pin_group? && !pin.is_a?(Origen::Pins::PinCollection)
-          port = nil
-          pin.groups.each { |i| port = i[1] if port.nil? && Origen.tester.ordered_pins.include?(i[1]) } # see if group is included in ordered pins
-          if port
-            ix = Origen.tester.ordered_pins.index(port) # find index of port
-            i = port.index(pin)
-          else
-            ix = Origen.tester.ordered_pins.index(pin)
-            i = 0
-          end
-        else
-          ix = Origen.tester.ordered_pins.index(pin)
-          i = 0
-        end
-
-        if Origen.pin_bank.pin_groups.keys.include? pin.id
-          val = pin.map { |p| Origen.tester.format_pin_state(p) }.join('')
-          vals[ix] = val
-        else
-          val = Origen.tester.format_pin_state(pin)
-          vals[ix][i] = val
-        end
-
-        self.pin_vals = vals.join(' ')
-      end
-
-      def ordered_pins
-        Origen.app.pin_map.sort_by { |_id, pin| pin.order }.map { |_id, pin| pin }
-      end
-
-      def microcode=(val)
-        if has_microcode? && @microcode != val
-          fail "Trying to assign microcode: #{val}, but vector already has microcode: #{@microcode}"
-        else
-          @microcode = val
-        end
-      end
-
-      # Since repeat 0 is non-intuitive every vector implicitly has a repeat of 1
-      def repeat
-        @repeat || 1
-      end
-
-      def has_microcode?
-        @microcode && !@microcode.empty?
-      end
-
-      def ==(obj)
-        if obj.is_a?(Vector)
-          self.has_microcode? == obj.has_microcode? &&
-            timeset == obj.timeset &&
-            pin_vals == obj.pin_vals
-        else
-          super obj
-        end
-      end
-    end
-  end
-end

data/lib/origen/tester/vector_generator.rb

@@ -1,637 +0,0 @@
-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 == @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
-
-      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
-    end
-  end
-end