origen_testers 0.5.7 → 0.6.0

data/lib/origen_testers/generator.rb

@@ -8,7 +8,6 @@ module OrigenTesters
   module Generator
     autoload :Placeholder,   'origen_testers/generator/placeholder'
     autoload :IdentityMap,   'origen_testers/generator/identity_map'
-    autoload :FlowControlAPI, 'origen_testers/generator/flow_control_api'
 
     extend ActiveSupport::Concern
 
@@ -16,19 +15,8 @@ module OrigenTesters
       include Origen::Generator::Comparator
     end
 
-    # The program source files are executed by eval to allow the tester to filter the
-    # source contents before executing. For examples the doc tester replaces all comments
-    # with a method call containing each comment so that they can be captured.
     def self.execute_source(file)
-      if Origen.interface.respond_to?(:filter_source)
-        File.open(file) do |f|
-          src = f.read
-          src = Origen.interface.filter_source(src)
-          eval(src, global_binding)
-        end
-      else
-        load file
-      end
+      load file
     end
 
     # When called on a generator no output files will be created from it
@@ -97,6 +85,11 @@ module OrigenTesters
       @filename = name
     end
 
+    def name
+      @filename.to_sym
+    end
+    alias_method :id, :name
+
     def filename(options = {})
       options = {
         include_extension: true
@@ -111,6 +104,12 @@ module OrigenTesters
       ext = f.extname.empty? ? file_extension : f.extname
       body = f.basename(".#{ext}").to_s
       body.gsub!('_resources', '')
+      if defined? self.class::OUTPUT_PREFIX
+        # Unless the fixfix is already in the name
+        unless body =~ /#{self.class::OUTPUT_PREFIX}$/i
+          body = "#{self.class::OUTPUT_PREFIX}_#{body}"
+        end
+      end
       if defined? self.class::OUTPUT_POSTFIX
         # Unless the postfix is already in the name
         unless body =~ /#{self.class::OUTPUT_POSTFIX}$/i
@@ -157,13 +156,14 @@ module OrigenTesters
         if defined? self.class::TEMPLATE || Origen.tester.is_a?(OrigenTesters::Doc)
           write_from_template(options)
         else
-          fail "Don't know hot to write without a template!"
+          fail "Don't know how to write without a template!"
         end
         stats.completed_files += 1
       end
     end
 
     def write_from_template(options = {})
+      return unless Origen.interface.write?
       options = {
         quiet:     false,
         skip_diff: false
@@ -186,18 +186,8 @@ module OrigenTesters
         else
           @append = false
           Origen.file_handler.preserve_state do
-            if Origen.tester.is_a?(OrigenTesters::Doc)
-              if options[:return_model]
-                OrigenTesters::Doc.model.add_flow(filename(include_extension: false), to_yaml)
-              else
-                Origen.file_handler.open_for_write(output_file) do |f|
-                  f.puts YAML.dump(to_yaml(include_descriptions: false))
-                end
-              end
-            else
-              File.open(output_file, 'w') do |out|
-                out.puts compiler.insert(ERB.new(File.read(self.class::TEMPLATE), 0, Origen.config.erb_trim_mode).result(binding))
-              end
+            File.open(output_file, 'w') do |out|
+              out.puts compiler.insert(ERB.new(File.read(self.class::TEMPLATE), 0, Origen.config.erb_trim_mode).result(binding))
             end
           end
           @@opened_files << output_file
@@ -239,10 +229,23 @@ module OrigenTesters
     end
 
     def render(file, options = {})
-      if options.delete(:_inline)
-        super Origen.file_handler.clean_path_to_sub_template(file), options
+      # Since the flow is now handled via ATP, render the string immediately
+      # for insertion into the AST
+      if try(:is_the_flow?)
+        val = nil
+        Origen.file_handler.preserve_current_file do
+          Origen.file_handler.default_extension = file_extension
+          file = Origen.file_handler.clean_path_to_sub_template(file)
+          placeholder = compiler.render(file, options)
+          val = compiler.insert(placeholder).chomp
+        end
+        val
       else
-        collection << Placeholder.new(:render, file, options)
+        if options.delete(:_inline)
+          super Origen.file_handler.clean_path_to_sub_template(file), options
+        else
+          collection << Placeholder.new(:render, file, options)
+        end
       end
     end
 

data/lib/origen_testers/igxl_based_tester/base/ac_specsets.rb

@@ -0,0 +1,79 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class ACSpecsets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :ac_specs
+        attr_accessor :ac_specsets
+
+        OUTPUT_PREFIX = 'SpecsAC'
+        # OUTPUT_POSTFIX = 'SpecsAC'
+
+        def initialize # :nodoc:
+          ## Hash Autovivification
+          l = ->(h, k) { h[k] = Hash.new(&l) }
+
+          @ac_specs = []
+          @ac_specsets = Hash.new(&l)
+        end
+
+        # Assigns an AC spec value object to the given variable for this specset
+        #   The attrs hash is expected to defined as follows:
+        #     attrs = {
+        #       specset:  :specset_name,    # if not defined, specset = :default
+        #                                   # Spec selectors that contain both the scope and value of the spec
+        #       nom:      { typ:  1.8 },    # typ is an example of the UFlex scope, nom is the spec selector
+        #       min:      { min:  1.7 },    # Users can defined any number of selectors in this fashion
+        #       max:      { max:  1.9 }
+        #     }
+        def add(spec, attrs = {})
+          attrs = {
+            specset: :default
+          }.merge(attrs)
+
+          specset = attrs.delete(:specset)
+
+          @ac_specs << spec unless @ac_specs.include?(spec)
+
+          attrs.each do |selector, value|
+            @ac_specsets[specset][spec][selector] = value
+          end
+        end
+
+        # Prepare the spec information for file output
+        def format_uflex_ac_spec(data, options = {})
+          case data
+          when NilClass
+            data_new = 0
+          when Fixnum, Float
+            case
+            when data == 0
+              data_new = data.to_s
+            when data.abs < 1e-9
+              data_new = (data * 1_000_000_000_000).round(4).to_s + '*ps'
+            when data.abs < 1e-6
+              data_new = (data * 1_000_000_000).round(4).to_s + '*ns'
+            when data.abs < 1e-3
+              data_new = (data * 1_000_000).round(4).to_s + '*us'
+            when data.abs < 1
+              data_new = (data * 1_000).round(4).to_s + '*ms'
+            else
+              data_new = data.to_s
+            end
+            data_new = data_new.gsub(/^/, '=')
+          when String
+            data_new = data.gsub(/^/, '=').gsub(/(\W)([a-zA-Z])/, '\1_\2')
+            # Remove underscores from unit designations
+            data_new.gsub!(/(\W)_(nS|uS|mS|S)(\W)/i, '\1\2\3')
+            data_new.gsub!(/(\W)_(nS|uS|mS|S)$/i, '\1\2')
+          else
+            Origen.log.error "Unknown class type (#{data.class}) for spec value:  #{data}"
+            fail
+          end
+          data_new
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/dc_specsets.rb

@@ -0,0 +1,98 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class DCSpecsets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :dc_specs
+        attr_accessor :dc_specsets
+
+        OUTPUT_PREFIX = 'SpecsDC'
+        # OUTPUT_POSTFIX = 'SpecsDC'
+
+        def initialize # :nodoc:
+          ## Hash Autovivification
+          l = ->(h, k) { h[k] = Hash.new(&l) }
+
+          @dc_specs = []
+          @dc_specsets = Hash.new(&l)
+        end
+
+        # Assigns a DC spec value object to the given variable for this specset
+        #   The attrs hash is expected to defined as follows:
+        #     attrs = {
+        #       specset:  :specset_name,    # if not defined, specset = :default
+        #                                   # Spec selectors that contain both the scope and value of the spec
+        #       nom:      { typ:  1.8 },    # typ is an example of the UFlex scope, nom is the spec selector
+        #       min:      { min:  1.7 },    # Users can defined any number of selectors in this fashion
+        #       max:      { max:  1.9 }
+        #     }
+        def add(spec, attrs = {})
+          attrs = {
+            specset: :default
+          }.merge(attrs)
+
+          specset = attrs.delete(:specset)
+
+          @dc_specs << spec unless @dc_specs.include?(spec)
+
+          attrs.each do |selector, value|
+            @dc_specsets[specset][spec][selector] = value
+          end
+        end
+
+        # Prepare the spec information for file output
+        def format_uflex_dc_spec(data, options = {})
+          options = {
+            spec: nil
+          }.update(options)
+
+          case options[:spec]
+          when /(voh|vol|vt|vcl|vch|vdd)/i
+            spec_type = 'volt'
+          when /(ioh|iol)/i
+            spec_type = 'curr'
+          else
+            spec_type = nil
+          end
+
+          case data
+          when NilClass
+            data_new = 0
+          when Fixnum, Float
+            case
+            when data == 0
+              data_new = data.to_s
+            when data.abs < 1e-6
+              data_new = (data * 1_000_000_000).round(4).to_s + '*nV' if spec_type == 'volt'
+              data_new = (data * 1_000_000_000).round(4).to_s + '*nA' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            when data.abs < 1e-3
+              data_new = (data * 1_000_000).round(4).to_s + '*uV' if spec_type == 'volt'
+              data_new = (data * 1_000_000).round(4).to_s + '*uA' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            when data.abs < 1
+              data_new = data.to_s + '*V' if spec_type == 'volt'
+              data_new = (data * 1_000).round(4).to_s + '*mA' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            else
+              data_new = data.to_s + '*V' if spec_type == 'volt'
+              data_new = data.to_s + '*A' if spec_type == 'curr'
+              data_new = data.to_s if spec_type.nil?
+            end
+            data_new = data_new.gsub(/^/, '=')
+          when String
+            data_new = data.gsub(/^/, '=').gsub(/(\W)([a-zA-Z])/, '\1_\2')
+            # Remove underscores from unit designations
+            data_new.gsub!(/(\W)_(nV|uV|mV|V|nA|uA|mA|A)(\W)/i, '\1\2\3')
+            data_new.gsub!(/(\W)_(nV|uV|mV|V|nA|uA|mA|A)$/i, '\1\2')
+          else
+            Origen.log.error "Unknown class type (#{data.class}) for spec value:  #{data}"
+            fail
+          end
+          data_new
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edge.rb

@@ -0,0 +1,60 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edge
+        attr_accessor :d_src, :d_fmt, :d0_edge, :d1_edge, :d2_edge, :d3_edge  # Input pin timing information
+        attr_accessor :c_mode, :c1_edge, :c2_edge                             # Output pin timing information
+        attr_accessor :t_res, :clk_per
+
+        def initialize(options = {}) # :nodoc:
+          options = {
+            d_src:   'PAT',     # source of the channel drive data (e.g. pattern, drive_hi, drive_lo, etc.)
+            d_fmt:   'NR',      # drive data format (NR, RL, RH, etc.)
+            d0_edge: '',        # time at which the input drive is turned on
+            d1_edge: '',        # time of the initial data drive edge
+            d2_edge: '',        # time of the return format data drive edge
+            d3_edge: '',        # time at which the input drive is turned off
+            c_mode:  'Edge',    # output compare mode
+            c1_edge: '',        # time of the initial output compare edge
+            c2_edge: '',        # time of the final output compare edge (window compare)
+            t_res:   'Machine', # timing resolution (possibly ATE-specific)
+            clk_per: ''         # clock period equation - for use with MCG
+          }.merge(options)
+          @d_src    = options[:d_src]
+          @d_fmt    = options[:d_fmt]
+          @d0_edge  = options[:d0_edge]
+          @d1_edge  = options[:d1_edge]
+          @d2_edge  = options[:d2_edge]
+          @d3_edge  = options[:d3_edge]
+          @c_mode   = options[:c_mode]
+          @c1_edge  = options[:c1_edge]
+          @c2_edge  = options[:c2_edge]
+          @t_res    = options[:t_res]
+          @clk_per  = options[:clk_per]
+        end
+
+        def ==(edge)
+          if edge.is_a? Edge
+            d_src == edge.d_src &&
+              d_fmt == edge.d_fmt &&
+              d0_edge == edge.d0_edge &&
+              d1_edge == edge.d1_edge &&
+              d2_edge == edge.d2_edge &&
+              d3_edge == edge.d3_edge &&
+              c_mode == edge.c_mode &&
+              c1_edge == edge.c1_edge &&
+              c2_edge == edge.c2_edge &&
+              t_res == edge.t_res &&
+              clk_per == edge.clk_per
+          else
+            super
+          end
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edges.rb

@@ -0,0 +1,24 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edges
+        include ::OrigenTesters::Generator
+
+        attr_accessor :edges
+
+        def initialize(options = {}) # :nodoc:
+          @edges = Hash.new do |h, k|
+            h[k] = {}
+          end
+        end
+
+        # Defines a new Edge object for the category and pin name
+        def add(grp, pin, options = {})
+          grp = grp.to_sym unless grp.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+          edges[grp][pin] = platform::Edge.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edgeset.rb

@@ -0,0 +1,39 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edgeset
+        attr_accessor :period, :t_mode  # Edgeset information
+        attr_accessor :pins
+        attr_accessor :spec_sheet
+        attr_accessor :name
+
+        def initialize(name, pin, edge, attrs = {}) # :nodoc:
+          attrs = {
+            period:     '',        # tester cycle duration
+            t_mode:     '',        # timing mode (possibly ATE-specific)
+            spec_sheet: 'default'  # defines which specset sheet to put variables in (e.g. func, scan) when generating specset files
+          }.merge(attrs)
+          @period     = attrs[:period]
+          @t_mode     = attrs[:t_mode]
+          @spec_sheet = attrs[:spec_sheet]
+          @pins       = { pin => edge }
+          self.name = name
+        end
+
+        # Assigns a timing edge object to the given pin for this edgeset
+        def add_edge(pin, edge)
+          if @pins.key?(pin)
+            Origen.log.error "Pin #{pin} already exists in edgeset"
+            fail
+          else
+            @pins[pin] = edge
+          end
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/edgesets.rb

@@ -0,0 +1,97 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Edgesets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :es
+        attr_accessor :es_sheet_pins
+
+        OUTPUT_PREFIX = 'ES'
+        # OUTPUT_POSTFIX = 'ES'
+
+        def initialize # :nodoc:
+          @es = {}
+        end
+
+        def add(esname, pin, edge, options = {})
+          esname = esname.to_sym unless esname.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+          @es.key?(esname) ? @es[esname].add_edge(pin, edge) : @es[esname] = platform::Edgeset.new(esname, pin, edge, options)
+          @es_sheet_pins = options[:es_sheet_pins] unless @es_sheet_pins
+          @es
+        end
+
+        def finalize(options = {})
+        end
+
+        # Populate an array of pins based on the pin or pingroup
+        def get_pin_objects(grp)
+          pins = []
+          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
+             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
+            pins << Origen.top_level.pin(grp)
+          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
+            Origen.top_level.pin(grp).each do |pin|
+              pins << pin
+            end
+          else
+            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
+          end
+          pins
+        end
+
+        # Equality check to compare full contents of edge object
+        def edges_eql?(edge1, edge2)
+          edge1 == edge2
+        end
+
+        # Globally modify text within the edge object
+        def gsub_edges!(edge, old_val, new_val)
+          edge.d_src   = edge.d_src.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d_fmt   = edge.d_fmt.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d0_edge = edge.d0_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d1_edge = edge.d1_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d2_edge = edge.d2_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.d3_edge = edge.d3_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.c_mode  = edge.c_mode.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.c1_edge = edge.c1_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.c2_edge = edge.c2_edge.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.t_res   = edge.t_res.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          edge.clk_per = edge.clk_per.gsub(/#{Regexp.escape(old_val)}/, new_val)
+        end
+
+        # Prepare the edge information for ES/TS file output
+        def format_uflex_edge(data, line_cnt, options = {})
+          options = {
+            no_disable: false
+          }.merge(options)
+
+          if data !~ /^\s*$/
+            data = data.gsub(/^/, '=')
+          end
+          data = data.gsub(/(\W)([a-zA-Z])/, '\1_\2')
+
+          case data
+          when /_d0_edge|_d_on/
+            data = data.gsub(/_d0_edge|_d_on/, "F#{line_cnt}")
+          when /_d1_edge|_d_data/
+            data = data.gsub(/_d1_edge|_d_data/, "G#{line_cnt}")
+          when /_d2_edge|_dret/
+            data = data.gsub(/_d2_edge|_dret/, "H#{line_cnt}")
+          when /_d3_edge|_d_off/
+            data = data.gsub(/_d3_edge|_d_off/, "I#{line_cnt}")
+          when /_c1_edge|_c_open/
+            data = data.gsub(/_c1_edge|_c_open/, "K#{line_cnt}")
+          when /_c2_edge|_c_close/
+            data = data.gsub(/_c2_edge|_c_close/, "L#{line_cnt}")
+          when /^\s*$/
+            options[:no_disable] ? data = '' : data = 'disable'
+          else
+            data
+          end
+        end
+      end
+    end
+  end
+end