origen_testers 0.46.1 → 0.48.3

data/lib/origen_testers/smartest_based_tester/v93k/templates/vars.tf.erb

@@ -3,11 +3,13 @@ language_revision = 1;
 
 declarations
 
-% declarations.each do |var|
-%   if var.is_a?(Array)
+% if declarations
+%   declarations.each do |var|
+%     if var.is_a?(Array)
 @<%= var[0].to_s %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
-%   else
+%     else
 @<%= var.to_s %> = 0;
+%     end
 %   end
 % end
 
@@ -15,11 +17,13 @@ end
 -----------------------------------------------------------------
 flags
 
-% flags.each do |var|
-%   if var.is_a?(Array)
+% if flags
+%   flags.each do |var|
+%     if var.is_a?(Array)
 user <%= var[0].to_s %> = <%= var[1].is_a?(String) || var[1].is_a?(Symbol) ? "\"#{var[1]}\"" : var[1] %>;
-%   else
+%     else
 user <%= var.to_s %> = 0;
+%     end
 %   end
 % end
 

data/lib/origen_testers/test/interface.rb

@@ -2,6 +2,7 @@ module OrigenTesters
   module Test
     class Interface
       include OrigenTesters::ProgramGenerators
+      include OrigenTesters::Charz
 
       attr_accessor :include_additional_prb2_test
       attr_reader :environment
@@ -10,6 +11,45 @@ module OrigenTesters
       # desired to configure your interface
       def initialize(options = {})
         @environment = options[:environment]
+        add_charz
+      end
+
+      def add_charz
+        add_charz_routine :routine1 do |routine|
+          routine.name = '_cz__rt1'
+        end
+        add_charz_routine :routine2 do |routine|
+          routine.name = '_cz__rt2'
+        end
+        add_charz_routine :routine3 do |routine|
+          routine.name = '_cz__rt3'
+        end
+        add_charz_routine :routine4 do |routine|
+          routine.name = '_cz__rt4'
+        end
+        add_charz_routine :routine5 do |routine|
+          routine.name = '_cz__rt5'
+        end
+        add_charz_routine :routine6 do |routine|
+          routine.name = '_cz__rt6'
+        end
+        add_charz_profile :cz do |profile|
+          profile.routines = [:routine3]
+        end
+        add_charz_profile :cz_only do |profile|
+          profile.charz_only = true
+          profile.routines = [:routine1]
+        end
+        add_charz_profile :simple_gates do |profile|
+          profile.flags = :my_flag
+          profile.enables = :my_enable
+          profile.routines = [:routine1]
+        end
+        add_charz_profile :complex_gates do |profile|
+          profile.flags = { ['$MyFlag1'] => [:routine1, :routine2], ['$MyFlag2'] => [:routine3], '$MyFlag3' => :routine4 }
+          profile.enables = { ['$MyEnable1'] => [:routine1], ['$MyEnable2'] => [:routine2, :routine3], '$MyEnable3' => :routine5 }
+          profile.routines = [:routine1, :routine2, :routine3, :routine4, :routine5, :routine6]
+        end
       end
 
       # Test that the block form of flow control methods like this can
@@ -86,6 +126,46 @@ module OrigenTesters
         end
       end
 
+      def func_with_charz(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        if tester.v93k?
+          if tester.smt7?
+            tm = test_methods.ac_tml.ac_test.functional_test
+            ts = test_suites.run(name, options)
+            ts.test_method = tm
+            ts.pattern = 'charz_example'
+
+            test_level_charz = false
+            if options[:charz]
+              charz_on(*options[:charz])
+              test_level_charz = true
+            end
+
+            unless charz_only? && !options[:charz_test]
+              options[:parent_test_name] = name
+              set_conditional_charz_id(options)
+              flow.test ts, options
+            end
+
+            unless options[:charz_test]
+              insert_charz_tests(options.merge(parent_test_name: name, charz_test: true)) do |options|
+                charz_name = :"#{name}_#{charz_routines[options[:current_routine]].name}"
+                func_with_charz(charz_name, options)
+              end
+            end
+
+            charz_off if test_level_charz
+          else
+            fail 'Only SMT7 is Implemented for Charz'
+          end
+        else
+          fail "Tester #{tester.name} Not Yet Implemented for Charz"
+        end
+      end
+
       def func_with_comment(name, options = {})
         if tester.v93k?
           options = {
@@ -205,6 +285,31 @@ module OrigenTesters
         end
       end
 
+      def meas_multi_limits(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        name = "measmulti_#{name}" unless name.to_s =~ /measmulti/
+
+        if tester.uflex?
+          ins = test_instances.functional(name)
+          ins.set_wait_flags(:a) if options[:duration] == :dynamic
+          ins.pin_levels = options.delete(:pin_levels) if options[:pin_levels]
+          ins.defer_limits = options[:defer_limits]
+
+          # some made up sub test limits
+          options[:sub_tests] = [sub_test('limit1', lo: 0, hi: 7), sub_test('limit2', lo: 3, hi: 8)]
+
+          pname = "#{name}_pset"
+          patsets.add(pname, [{ pattern: "#{name}.PAT" },
+                              { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+          ins.pattern = pname
+
+          flow.test(ins, options)
+        end
+      end
+
       def meas(name, options = {})
         options = {
           duration: :static

data/program/charz.rb

@@ -0,0 +1,48 @@
+# An instance of the interface is
+# passed in here, iterators and other
+# argument passing will be supported
+# similar to Pattern.create.
+Flow.create interface: 'OrigenTesters::Test::Interface' do
+  flow.flow_description = '' if tester.v93k?
+
+  if tester.v93k? && tester.smt7?
+    charz_on :complex_gates, { on_result: :fail }
+    func_with_charz :func_complex_gates_on_fail
+    charz_off
+
+    charz_on :complex_gates, { enables: :my_enable }
+    func_with_charz :func_complex_flag_simple_enable
+    charz_off
+
+    charz_on :complex_gates, { flags: :my_flag } do
+      func_with_charz :func_complex_enable_simple_flag
+    end
+
+    charz_on :cz_only, { placement: :eof }
+    func_with_charz :func_charz_only
+    charz_off
+
+    func_with_charz :func_test_level_routine, charz: [:routine1, { type: :routine }]
+
+    charz_on :cz
+    func_with_charz :func_skip_group, skip_group: true
+    charz_pause
+    func_with_charz :func_pause_charz
+    charz_resume
+    func_with_charz :func_resume_charz
+    charz_off
+
+    charz_on :simple_gates, { on_result: :pass } do 
+      func_with_charz :func_simple_gates_on_pass
+    end
+    
+    charz_on :simple_gates, { enables: nil }
+    func_with_charz :func_simple_flags
+    charz_off
+
+    charz_on :simple_gates, { flags: nil }
+    func_with_charz :func_simple_enables
+    charz_off
+  end
+
+end

data/program/flow_control_flag_bug.rb

@@ -0,0 +1,25 @@
+# Flow to exercise the Flow Control API
+#
+# Some of the other flows also cover the flow control API and those tests are used
+# to guarantee that the test ID references work when sub-flows are involved.
+# This flow provides a full checkout of all flow control methods.
+Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Control Testing" do
+  flow.flow_description = 'Flow to exercise the Flow Control API' if tester.v93k?
+
+  self.resources_filename = 'flow_control'
+
+  log "Mixed-case manual flags"
+  test :test1, on_fail: { set_flag: :$My_Mixed_Flag }, continue: true, number: 51420
+  test :test2, if_flag: "$My_Mixed_Flag", number: 51430
+  unless_flag "$My_Mixed_Flag" do
+    test :test3, number: 51440
+  end
+  
+  log "Mixed-case manual flags - induce frozen string error"
+  test :test4, on_fail: { set_flag: :$My_Mixed_Flag }, continue: true, number: 51450
+  test :test5, if_flag: "$My_Mixed_Flag", number: 51460
+  unless_flag "$My_Mixed_Flag" do
+    test :test6, number: 51470
+  end
+
+end

data/program/prb1.rb

@@ -13,7 +13,7 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_description: 'Prob
   import 'test' # import top-level test.rb directly, note that Flow.create options of sub-flow will be ignored!
 
   # Test that a reference to a deeply nested test works (mainly for SMT8)
-  test :on_deep_1, if_failed: :deep_test
+  test :on_deep_1, if_failed: :deep_test, test_text: "some_custom_text"
 
   pass 1, description: "Good die!", softbin: 1
 end

data/program/test.rb

@@ -28,6 +28,8 @@ Flow.create interface: 'OrigenTesters::Test::Interface' do
   end
 
   if tester.uflex?
+    meas_multi_limits :bin_now, tnum: 3000, bin: 119, soft_bin: 2
+    meas_multi_limits :bin_later, tnum: 3000, bin: 119, soft_bin: 2, defer_limits: true
     log "Test of ultraflex render API"
     line = flow.ultraflex.use_limit
     line.units = "Hz"

data/templates/origen_guides/pattern/ultraflex.md.erb~

@@ -0,0 +1,30 @@
+% render "layouts/guides.html" do
+
+This page will be used to document any UltraFLEX-only APIs related to pattern generation,
+however the goal is to have as few of these as possible so that Origen pattern source code can re-target
+automatically to any supported platform.
+
+There are no significant APIs in this category currently, therefore refer to the
+[Common Pattern API](<%= path "guides/pattern/common" %>) which can fully target the UltraFLEX.
+
+### DigSrc
+
+UltraFlex supports <code>:digsrc</code> as a <code>tester.overlay_style</code> set like this:
+
+~~~ruby
+  tester.overlay_style = :digsrc
+~~~
+
+By default Origen will automatically place the digsrc start opcode at the beginning of the resulting pattern
+when overlay is used. In some cases (like when the pattern is used in a pattern set that has already started
+the instrument in a previous pattern, or possibly in svm_patterns) this behavior is undesirable.
+
+The insertion of this start opcode can be disabled by placing the following code **before** any overlay operations
+for a given pin.
+
+~~~ruby
+  tester.digsrc_skip_start :pin_or_group_name if tester.ultraflex?
+  # Overlay operations can happen after this point
+~~~
+
+% end

data/templates/origen_guides/program/charz.md.erb

@@ -0,0 +1,221 @@
+% render "layouts/guides.html" do
+
+Be sure to read and understand the guide to
+[Creating an Interface](<%= path "guides/program/interface" %>) before
+reading this guide.
+This guide covers aspects of the Characterization (charz) API. 
+
+Currently, the charz API has only been proven out for V93K SMT7, but isn't inherently designed around working only for that environment.
+
+The Charz API is enabled by including the Charz module in your interface:
+
+~~~ruby
+# app/lib/my_app/interface.rb
+module MyApp
+  class Interface
+    include OrigenTesters::ProgramGenerators
+    include OrigenTesters::Charz
+~~~
+
+Note this guide assumes the audience is familiar with interface creation and custom test methods, and will not go into detail explaining those topics.
+
+## Overview
+
+The Characterization API allows a flow to add characterization to existing production tests with little additional overhead.
+
+First specify charz routines to set charz test options, then create a profile with flow creation meta for the resulting tests.
+Afterwards, the `charz_on` method can be called in the flow to activate charz profiles, which is explained below.
+
+### Charz Routines
+
+Charz routines contain relevant charz data thats specific to a charz test to be created. Created routines are stored in the `@charz_routines` attribute.
+The data stored within a routine will be used in combination with the options used to make a production test to make a charz variant of the production test.
+
+The interface adds charz routines by calling the `add_charz_routine` method:
+
+~~~ruby
+add_charz_routine :vmin do |routine|
+  routine.name = 'cz_vmin_vdd'
+  routine.start = 1.0.V
+  routine.stop = 0.5.V
+  routine.res = 5.mV
+  routine.spec = 'VDD'
+end
+~~~
+
+### Charz Profiles
+
+Charz profiles contain a collection of routines, as well as test creation meta data related to test placement, production test result dependence, and conditional execution.
+
+The interface adds charz profiles by calling the `add_charz_profile` method. To create a profile that contains previously defined vmin and vmax search routines, whose resulting searches
+only run if the production test failed, and sets the vmax search routine to only run if the 'VmaxEnable' variable is set:
+
+~~~ruby
+add_charz_profile :fail_searches do |profile|
+  profile.name = 'fail_searches'
+  profile.on_result = :on_fail
+  profile.routines = [:vmin, :vmax]
+  profile.enables = { ['$VmaxEnable'] => [:vmax] }
+end
+~~~
+
+### Charz Session
+
+The charz session (stored in your interfaces `@charz_session` attribute) monitors the current state of characterization at a given point in flow generation.
+
+The API provides some key methods for querying that state during generation, such as:
+
+ * `charz_active?` : indicates if applicable productions tests should be generating charz tests as well
+ * `charz_only?`   : indicates if the production tests should be added to the flow or not, only generating the resulting charz test
+
+## Interface Considerations
+
+A couple of enhancements will need to be added to your interface to take advantage of the API in addition to adding `include OrigenTesters::Charz` as shown above.
+The charz routines and profiles will need to be added, and your flow methods will need to be updated to know what to do when a charz session is active.
+
+### Adding charz routines and profiles
+
+As long as the desired routines and profiles exist in the interface's @charz_routines and @charz_profiles hashes, the rest of the API will work as expected.
+One option is to add them during the interface initialization:
+
+~~~ruby
+# app/lib/my_app/interface.rb
+module MyApp
+  class Interface
+    include OrigenTesters::ProgramGenerators
+    include OrigenTesters::Charz
+
+    def add_charz
+      add_charz_routine :my_routine do |routine|
+        routine.name = 'cz_vmin_vdd'
+        routine.start = 1.0.V
+        routine.stop = 0.5.V
+        routine.res = 5.mV
+        routine.spec = 'VDD'
+      end
+      add_charz_profile :my_profile do |profile|
+        profile.name = 'vmin_search'
+        profile.routines = [:vmin]
+      end
+    end
+
+    def initialize(options = {})
+      add_charz
+    end
+~~~
+
+### Configuring Existing Flow Methods
+
+Now that your interface has defined some routines and profiles, the flow methods needs to be updated to work with an active charz session.
+
+Lets take a simplistic example functional flow method defined in `MyApp::Interface`:
+
+~~~ruby
+# V93K SMT7 example
+def func(name, options = {})
+  tm = test_methods.ac_tml.ac_test.functional_test
+  ts = test_suites.run(name, options)
+  ts.test_method = tm
+  ts.pattern = 'example'
+  flow.test ts, options
+end
+~~~
+
+And now we'll add the ability for this flow method to generate a charz test as well:
+
+~~~ruby
+# V93K SMT7 example
+def func(name, options = {})
+  if options[:routine]
+    tm = test_methods.ac_tml.ac_test.spec_search
+  else
+    tm = test_methods.ac_tml.ac_test.functional_test
+  end
+  ts = test_suites.run(name, options)
+  ts.test_method = tm
+  ts.pattern = 'example'
+
+  if options[:routine]
+    ts.spec = options[:routine].spec
+    ts.min = options[:routine].stop
+    ts.max = options[:routine].start
+    ts.resolution = options[:routine].res
+  end
+
+  flow.test ts, options
+
+  unless options[:charz_test]
+    insert_charz_tests(options.merge(parent_test_name: name, charz_test: true)) do |options|
+      charz_name = :"#{name}_#{charz_routines[options[:current_routine]].name}"
+      options[:routine] = charz_routines[options[:current_routine]]
+      func(charz_name, options)
+    end
+  end
+end
+~~~
+
+### #insert_charz_tests
+
+The `insert_charz_tests` method handles everything regarding adding the charz test into the flow except determining the actual name and parameters of the test, which is
+done by the local interface in the block passed to the `insert_charz_tests` method. This method handles:
+
+ * querying the charz session
+ * test placement
+ * charz test grouping
+ * production test result dependency
+ * gate processing (enables, flags) 
+
+The block that gets passed is yielded the latest options (with id removed if passed for the production test, so it doesn't get re-used for charz tests).
+Routines in the current session are yielded one at a time, with their id being returned in `options[:current_routine]`.
+
+#### Company Plugin Oppurtunity
+
+If your company is already using a plugin to distribute the definitions of these flow methods, this is a good oppurtunity to add charz variants of those methods
+that take routine as an input. This can really streamline the process, for example if you combine the charz flow methods plugin with a central flow entry point method called by
+all flow methods, then the implementation becomes:
+
+~~~ruby
+def add_to_flow(ts, options = {})
+  flow.test ts, options
+
+  unless options[:charz_test]
+    insert_charz_tests(options.merge(parent_test_name: name, charz_test: true)) do |options|
+      insert_current_charz_test(options)
+    end
+  end
+end
+~~~
+
+Where insert_current_charz_test is a method defined in the company charz flow method plugin.
+
+### Flow Usage Examples
+
+Now that the interface has charz routines and profiles, lets look at how to use the API within the flow itself:
+
+~~~ruby
+Flow.create(interface: 'MyApp:Interface') do
+
+  # regular non charz test
+  func :my_test1
+
+  # create charz test variants of my_test2 following the production
+  # version of my_test2 using the routines in :my_profile
+  charz_on :my_profile do
+    func :my_test2
+  end
+
+  # conditional charz enablement
+  # besides dut.enable_charz? check, identical to above
+  charz_on :my_profile if dut.enable_charz?
+  func :my_test3
+  charz_off if dut.enable_charz?
+
+  # override session values at the flow level
+  charz_on :my_profile, placement: :eof do
+    func :my_test4
+  end
+
+end
+~~~
+
+% end