STIL equations and convert improvements
add groups to stil output fix decompile of reverse compiled patterns
Characterization AND functionality and some documentation updates - @joshwman92 (Joshua Waldman)
added global flag feature - James Creamer
Added ability to override default syntax behavior where flag or enable word names are made lowercase and any double-scores removed. See PR 187.
Codebase fixes for Ruby3
make uflex digital instrument programmable
Added program_comment_char support for v93k (smt7 and smt8). Added ability for user to modify comment_char or program_comment_char for any tester at app level.
Added support for flow control loops for v93k only (SMT7).
Added a couple of features for 93k support: - added priority support for stm8 (PR #166) - added custom label comments support to permit label-type overlays (PR #174)
several bug fixes
allow defered binning with uflex flow generation when all limits are provided as sub-tests
Interface can now specify the subdirectory location in the output folder. Default behavior is unchanged to ensure backwards compatibility.
added tester.digsrc_skip_start(:pin_or_group_name) to skip start insertion for digsrc overlay
Bugfix for force_serial local_flag implementation
Fix V93K capture vector counting when loops are involved (TS Chung)
import :my_sub_flow, name: 'new_sub_flow_name'
Fixed V93K subroutine pattern generation
Enabled Bypass option on the 93K
Allow import of top-level flow during test program generation.
Added decompilation support and updated timesets for better syncing between the tester and the dut instances. See the guides for details on both.
force_serial test method parameterwhen* conditional statements for V93K flow generationif_any_site and if_all_sites control options for IG-XL flow
generationAdded support for V93K SMT8
Added support for attributes to be defined as boolean types in V93K custom test method definitions
Incorporated ATP gem into OrigenTesters
origen convert path/to/my_pattern.stil -e v93k_smt7
When run outside an app an annonymous DUT is created. The environment option defines
the output currently j750, uflex and v93k_smt7. The only input format supported
is STIL. Other input formats will be supported in the future.
Add STIL tester OrigenTesters::STIL.new<\code>
Add multi-limit with unique TName support for UFlex program generation
functional :test2, sbin: 101, number: 20020, sub_tests: [ sub_test(:limit_name1, lo: -2, hi: 2), sub_test(:limit_name2, lo: -1, hi: 1) ]
Flow.create interface: 'MyInterface' do flow.flow_name = 'SETUP' flow.flow_description = 'Setup Variables and Guardbands' test :setup_test, cont: true end
renders:
-----------------------------------------------------------------
test_flow
{
run(setup_test);
}, open,"SETUP","Set Variables and Guardbands"
end
-----------------------------------------------------------------
Flow.create interface: 'MyInterface', flow_name: 'SETUP', flow_description: 'Setup Variables and Guardbands' do test :setup_test, cont: true end
renders:
test_flow
{
run(setup_test);
}, open,"SETUP","Set Variables and Guardbands"
end
# Comments about this flow Flow.create interface: 'MyInterface', flow_name: 'SETUP' do test :setup_test, cont: true end
renders:
test_flow
{
run(setup_test);
}, open,"SETUP","Comments about this flow"
end
func :test1n, number: 51960, bin: 12, bin_attrs: { not_over_on: true }
renders:
run_and_branch(test1n)
then
{
}
else
{
stop_bin "", "fail", , bad, noreprobe, red, 12, not_over_on;
}
flow file:
# The is auto-generated comment from hasttag func_with_comment :test1 cc 'The is auto-generated comment from cc' func_with_comment :test2
interface:
def func_with_comment(name, options = {}) tm = test_methods.ac_tml.ac_test.functional_test ts = test_suites.run(name, options) ts.test_method = tm ts.levels = options.delete(:pin_levels) if options[:pin_levels] ts.comment = options.delete(:comment) || flow.active_description flow.test ts, options end
renders tf:
test1:
comment = "The is auto-generated comment from hasttag";
local_flags = output_on_pass, output_on_fail, value_on_pass, value_on_fail,
per_pin_on_pass, per_pin_on_fail;
override = 1;
override_seqlbl = "test1";
override_testf = tm_1;
site_control = "parallel:";
site_match = 2;
test2:
comment = "The is auto-generated comment from cc";
local_flags = output_on_pass, output_on_fail, value_on_pass, value_on_fail,
per_pin_on_pass, per_pin_on_fail;
override = 1;
override_seqlbl = "test2";
override_testf = tm_2;
site_control = "parallel:";
site_match = 2;
*Bug fix to ignore compare characters in comment lines (RE: V93k Digcap)
Added additional v93k capability including:
cc style comments are now supported in test flow files to enable dynamic comments
to be created for documentation (Code Briscoe)
# Regular Ruby comments can still be used to provide static documentation of tests # in a test program flow file test :my_test cc "The cc method can be used to create comments that contain dynamic data: #{4 + 4}" test :my_test # This is expected to be most useful when generating tests in a loop: [:min, :nom, :max].each do |vdd| cc "Test something at #{vdd} vdd" test :my_test end
The test name for the main limits in a V93K test method can be set by a limits_id
attribute instead of test_name. When limits_id is used it will set the name
of the limits but will not appear in the test methods attribute list (unlike
test_name which will). (Brian Caquelin)
Now warns instead of crashing in the case where set_timeset is called before instantiating the DUT. This was allowed in previous versions OrigenTesters and improves backwards compatibility.
# origen_site_config.yml origen_testers: :v93k_linux_pattern_compiler: '/path/to/v93k/tool/set' :j750_windows_pattern_compiler: '/path/to/j750/compiler'
Moved some code around to be shared with J750 compiler enablement, but functionally works the same as before.
# inside of dut class @ultraflex_compiler_options = { path: "#{Origen.root}/spec/patterns/atp/functional", clean: true, location: :local, recursive: false, output_directory: "#{Origen.root}/spec/patterns/bin", opcode_mode: 'single', comments: false, verbose: true } # dut.add_pattern_compiler(:id1, :ultraflex, dut.ultraflex_compiler_options)
Works pretty much same as UltraFLEX, of course with J750-specific options and it’s own, unique toolset path.
# inside of dut class @j750_compiler_options = { path: "#{Origen.root}/spec/patterns/atp/j750", clean: true, location: :local, recursive: false, output_directory: "#{Origen.root}/spec/patterns/bin/j750", pinmap_workbook: "#{Origen.root}/spec/patterns/atp/bist/bist_pins.txt", opcode_mode: 'single', comments: false } # dut.add_pattern_compiler(:id2, :j750, dut.j750_compiler_options)
# inside of dut class @v93k_compiler_options = { config_dir: "#{Origen.root}/spec/patterns", pinconfig: "compiler_pins.cfg", tmf: "timing_map_file.tmf", multiport: { port_bursts: { p_1: 'pattern_burst_1', p_2: 'pat_burst_two' }, port_in_focus: 'p_FOCUS', prefix: 'mpb' }, digcap: { pins: :porta, vps: 1, nrf: 1, }, } # dut.add_pattern_compiler(:id3, :v93k, dut.v93k_compiler_options)
fixed label overlay behavior for IGXL testers V93K flow enhancements
Provide accessor to min_repeat_loop so user can change if desired.
This release contains significant optimization of the V93K test flow output, making better use of the available if/else branching constructs and eliminating the use of many runtime flags/variables.
Significant additional test coverage has been added to origen_testers to verify this and the output has been reviewed on at least 3 independent Origen applications, so the chances of a bug hitting an application is low. However, users are advised to review the changes that this release makes to their flow output to be sure.
Additional changes included in this release:
Added support for mixed-case flag references (arkohler)
Patch to apply any in-line flow conditions passed to render
tester handled overlay added 93k flow generation updated
Added V93K flow enable word feature, see: http://origen-sdk.org/origen/guides/program/v93k/#Flow_Considerations
Added bitmap testcase for keep_alive capability. Fixed type on J750 side.
Added capability for UltraFLEX to support pattern keep alive using keep_alive subroutine. Updated 2pin match capability to support custom jump label usage.
Bug fix for V93K test program generation - flow control vars are now initialized correctly upon each flow execution, whereas previously the value from one run would carry over into the next.
Added support for utility pins for functional test on J750 tester. #
Added capability for UFLEX pattern generation to be able to have subroutines contained in their own module. This permits pattern sequencer on tester to swap the subroutines in and out. Closes issue #31.
flow.render is now supported for V93K
93K Test numbers
More flexible V93K testmethod naming
Gem server path update to fix unsuccessful release issue.
Origen.interface.add_tml :new_method, class_name: 'MCLASS', set_and_check_fuses: { class_name: 'MCLASS.MethodDescription', _param_one: [:string, nil], _param_two: [:string, nil], param_three: [:string, nil], param_four: [:string, nil], }
Generates:
testmethodparameters tm_1: "ParamOne" = ""; "ParamTwo" = ""; "paramThree" = ""; "paramFour" = "";
Patch to allow the flow control methods, e.g. if_job, to be be overridden by an interface.
Also cleaned up the development environment a lot, to align the way that targets, environments and interface are handled with the latest best practices.
Clean up to how inline comments are handled on V93K which should fix the following issues:
Inline comments can now be disabled from your environment setup file like this:
tester.inline_comments = false
Minor changes to 93K, change min repeat to 33 and cut comments at 250 chars
Minor patch to prevent a runtime error if pattern = nil or false is ever called on a 93K test suite object.
Added meta attribute to test instance and test suite objects. If present, this will be included in test flow documentation.
# Generate a test instance/method if tester.j750? i = test_instances.functional(name, options) elsif tester.v93k? i = test_suites.add(name, options) i.test_method = origen.functional_test end i.pattern = "rambist_march" # Add meta data i.meta = { "Test" => i.name, # 'Test' and 'Pattern' will be used in documentation "Pattern" => i.pattern, # to name the tests, all other attrs will simply "Vdd" => vdd, # be output verbatim "Cycles" => cycles } # Insert test into flow as normal flow.test(i, options)
fix missed pull request
Bugfix - Previously only the first test method object in a V93K test program had it’s finalize method called (if defined). Now they are all called.
Re-tagging as 0.8.0
Include header comments in-line with embedded ‘ctrl-m’ so they are visible in gui Move comments before ‘;’ so they translate into binl
Patch to allow interfaces to include Origen::Callbacks
Standardized the boot order of this plugin, fixes warnings in Origen 0.7.24 onwards
Fixes for Github issues #10 and #20
Added a variables file to the V93K program generator output (output to OUTPUT/testflow/mfh.testflow.setup/).
By default this is a global file but it can be made flow specific by setting resources_filename as per other file generators.
Various updates for V93K, this release puts the support for V93K on a par with that for J750 and UltraFLEX.
my_test_method: { force_mode: [:string, 'VOLT', %w(VOLT CURR)], force_value: [:force_mode, 3800.mV], # Type will be :voltage when force_mode set to 'VOLT' spmu_clamp: [:force_modeb, 0] # Type will be :current when force_mode set to 'VOLT' }
# From the app's test program interface... # The original API is still supported, this will add a reference to # list/referenced.list and the .pmfl (and .aiv) referenced_patterns << "some_pattern" # This is equivalent with the new API record_pattern_reference("some_pattern") # V93K needs to know if the reference is to a subroutine, this can be # indicated like this record_pattern_reference("some_pattern", subroutine: true) # To make the reference appear in Origen's list/referenced.list only record_pattern_reference("some_pattern", type: :origen) # To make the reference appear in the .pmfl (and .aiv) only record_pattern_reference("some_pattern", type: :ate)
Added a timestamp to all major step comments, useful when looking at a pattern in simulation.
Bug fix for flow.render when called from a plugin via a top-level app.
Fixed some syntax bugs in V93K flow output
Updates from Thao
Added Frequency Counter support for UltraFLEX.
Minor update to smartest_based_tester to allow for lower-case naming of pin groups of size 1 (or more).
# Application interface module MyApp class Interface # All interfaces should include this, adds the program generator APIs for all # platforms supported by OrigenTesters, and now also any platforms provided # by 3rd parties include OrigenTesters::ProgramGenerators end end # 3rd Party Plugin, this is the class that will be instantiated in the target/environment module MyTester class Tester # By defining this constant OrigenTesters will load the API into the interface # whenever an instance of this class is the current tester loaded by the target TEST_PROGRAM_GENERATOR = MyTester::Generator end end # 3rd Party Plugin, this implements the program generator API module MyTester class Generator extend ActiveSupport::Concern included do include OrigenTesters::Interface # adds the interface helpers/Origen hook-up end # This method will now be available within the above application interface def some_api_method # Generator some test program item end end end
Updates to the UltraFLEX Interface to support a few extra features that were previously not included.
Fixed bug from additional capture cycles being inserted into period levelled vector on V93K, now works correctly like this:
$tester.set_timeset("fast", 40)
2.cycles # fast 1 0 C 1 0
# fast 1 0 C 1 0
$tester.level_period = false # Without levelling enabled
$tester.set_timeset("slow", 80)
2.cycles # slow 1 0 C 1 0
# slow 1 0 C 1 0
$tester.level_period = true # With levelling enabled
$tester.set_timeset("slow", 80)
2.cycles # fast 1 0 X 1 0
# fast 1 0 C 1 0
# fast 1 0 X 1 0
# fast 1 0 C 1 0
Added check for size in header case change Patch for operation on Windows Corrected ‘GlobalSpecs’ output file for examples check 93K - Allow pingroups and aliases to have lower case letters Updated sheet prefix for Global Specs Added UFlex sheet generation support for Timeset Basic, Global Specs,…
Minor patch to create the test program output directory if it doesn’t exist
Added link? method to the common API (i.e. available on all tester objects) to check if the current tester is an OrigenLink driver
Some major feature additions:
Completely overhauled test flow generator backend, which now fully supports the same test flow source code rendering to J750, UltraFLEX and V93K.
Official documentation for this is still to follow, but for now see the comments in the pull-request for some examples: PR #3
Added generator APIs for UltraFLEX pinmaps, edgesets, timesets, levelsets, and AC and DC spec sets (Aaron Burgmeier).
Again the documentation is still to come, but examples of using these APIs can be found in lib/origen_testers/test/ultraflex_interface.rb
# Importing UltraFLEX tester config $tester.import_tester_config('FT', "#{Origen.root}/spec/atehardware/CurrentConfig_sample.txt") $tester.default_testerconfig # => 'FT' $tester.get_tester_instrument('FT', 1) # => 'HSD-4G' $tester.get_instrument_slots('FT', 'HSD-U') # => [12, 14, 15, 17, 20] # Importing UltraFLEX channel map $tester.import_chanmap('FTx4', "#{Origen.root}/spec/atehardware/atehardware_chanmap.txt") $tester.default_channelmap # => 'FTx4' $tester.get_tester_channel('FTx4', :pin1, 0) # => '14.ch28' $tester.get_tester_channel('FTx4', :pin2, 3) # => '20.ch231' $tester.channelmap['FTx4'].size # => 4 $tester.merged_channels('FTx4', :avdd, 1) # => 'x2' $tester.is_hexvs_plus('FT', 18) # => '+' $tester.is_vhdvs_plus('FT', 0) # => '+' $tester.is_vhdvs_hc('FTx4', :cvdd, 2) # '_HC' # Retrieving ATEHardware data properly $tester.ate_hardware('HSD-M').ppmu.vclamp.min # => -2 $tester.ate_hardware('HSD-4G').ppmu.measv.min # => -1 $tester.ate_hardware('HSS-6G').ppmu.vclamp.max # => 3.9 $tester.ate_hardware('VSM').supply.forcev.max # => 4 $tester.ate_hardware('VSMx2').supply.irange.max # => 162 $tester.ate_hardware('HexVS').supply.forcev.max # => 5.5 $tester.ate_hardware('HexVSx2').supply.filter # => 10_000 $tester.ate_hardware('HexVSx4').supply.bandwidth.size # => 8 $tester.ate_hardware('HexVSx6').supply.irange.size # => 2 $tester.ate_hardware('HexVS+').supply.forcev.max # => 5.5 $tester.ate_hardware('HexVS+x2').supply.filter # => 10_000 $tester.ate_hardware('HexVS+x4').supply.bandwidth.size # => 8 $tester.ate_hardware('HexVS+x6').supply.irange.size # => 2 $tester.ate_hardware('HDVS1').supply.sink_fold_i.min # => 5.mA $tester.ate_hardware('HDVS1x2').supply.meter_vrange # => 7 $tester.ate_hardware('HDVS1x4').supply.source_fold_i.max # => 4 $tester.ate_hardware('VHDVS').supply.irange.size # => 6 $tester.ate_hardware('VHDVS_HC').supply.sink_fold_t.max # => 2 $tester.ate_hardware('VHDVSx2').supply.meter_vrange # => 18 $tester.ate_hardware('VHDVS_HCx2').supply.forcev.min # => -2 $tester.ate_hardware('VHDVS_HCx4').supply.source_fold_t.min # => 300.uS $tester.ate_hardware('VHDVS_HCx8').supply.bandwidth.max # => 255 $tester.ate_hardware('VHDVS+').supply.irange.size # => 6 $tester.ate_hardware('VHDVS_HC+').supply.sink_fold_t.max # => 2 $tester.ate_hardware('VHDVS+x2').supply.meter_vrange # => 18 $tester.ate_hardware('VHDVS_HC+x2').supply.forcev.min # => -2 $tester.ate_hardware('VHDVS_HC+x4').supply.source_fold_t.min # => 300.uS $tester.ate_hardware('VHDVS_HC+x8').supply.bandwidth.max # => 255 # Pin objects are connected up to their underlying tester resource $dut.pins(:pin1).ate_hardware.instrument # => 'HSD-U' $dut.pins(:pin1).ate_hardware.ppmu.forcei.max # => 0.05 $dut.pins(:k1).instrument_type.instrument # => 'SupportBoard' $dut.power_pin_groups(:avdd).ate_hardware.instrument # => 'VHDVS_HC+x2' $dut.power_pin_groups(:avdd).ate_hardware.supply.forcev.cover?(4) # => true
Added initial support for Teradyne hardware configuration modelling (Scott Chen):
Fixed bug causing some vectors marked as ‘dont_compress’ to be compressed anyway.
Updated API support setting of diff-friendly output mode. Mainly for regression testing support.
Can be set via : ~~~ruby $tester.diff_friendly_output = true ~~~
Currently sets test number output to 0 for IG-XL program generation only.
Bug fix to IG-Xl custom test instance API. If a finalize method is defined it will now be called on all instances.
Added initial API to define custom test instance libraries for IG-XL based testers:
# app_interface.rb def initialize(options = {}) add_custom_til end # Example of how to use the custom library def custom(name, options = {}) ti = test_instances.mylib.test_a ti.my_arg0 = 'my_val' ti.my_arg2_alias = 'curr' ti.set_my_arg4('arg4_val_from_method') end # Add a custom test instance library def add_custom_til add_til :mylib, test_a: { # Basic arg my_arg0: :arg0, # Basic arg with default value my_arg1: [:arg1, 'a_default_value'], # Basic arg with default value and predefined set of possible values, Origen will raise an error # if it is ever set to a value not in the list my_arg2: [:arg2, 'volt', %w(volt curr)], my_arg3: :arg3, my_arg4: :arg4, # Attribute aliases can be defined like this: aliases: { my_arg_alias: :my_arg, my_arg1_alias: :my_arg1, my_arg2_alias: :my_arg2 }, # Define any methods you want the test instance to have methods: { # An optional finalize function can be supplied to do any final test instance configuration, this # function will be called immediately before the test instance is finally rendered. The test instance # object itself will be passed in as an argument. finalize: lambda do |ti| ti.my_arg3 = 'arg3_set_from_finalize' end, # Example of a custom method. # In all cases the test method object will be passed in as the first argument. set_my_arg4: lambda do |ti, val| ti.my_arg4 = val end } }, test_b: { # ... } end
Patch to make J750 multi-block match loops exit if any of the blocks passes. If multiple conditions should be ANDed together then the user should defined them within the same block.
Various V93K updates, this version produces patterns and test program that have been verified to work on the tester
Added in the Ultraflex DSSC DigSrc and DigCap capabilities (Jiang Liu).
All possible settings were added according to Ultraflex spec. To use these new features, users must define the pins to be used with DigSrc and DigCap in the $dut/$soc file, similar to how the DCVS instrument pins are defined today.
Then the ultraflex target file should call $tester.assign_digsrc_pins, $tester.assign_digcap_pins, $tester.apply_digsrc_settings and $tester.apply_digcap_settings methods. The patterns will then contain the appropriate instrument statements for digsrc and digcap including all the settings. For overlay, the user would create a subroutine pattern which contains the necessary microcodes for digsrc overlay, the user can use $tester.digsrc_start, $tester.digsrc_stop and $tester.digsrc_send methods as the basic building blocks for building the digsrc overlay subroutine.
Please refer to the digsrc_overlay method in origen_testers/test/dut.rb for an example of constructing an digsrc overlay subroutine. Digcap only supports capture with stv right now, this is currently the main way of using it. Added two new test cases in the subroutines.rb for self-testing these newly added features.
This plugin now contains the only official tester models, those from Origen core are being removed:
Fix for V93K program generator regression on Ruby 2.2.2
Initial Origen-based release
V93K updates after first round of on-tester debug:
Added ability for vector levelling to maintain the same number of clock pulses when the clk transition is controlled from timing: http://rgen.freescale.net/testers/latest/api/Testers/Timing.html#timing_toggled_pins-instance_method
Added vertical pin identification comments to Teradyne patterns.
Added the ability to include vector and cycle counts in the pattern comments. Either supply “-v” to the generate command or set $tester.vector_comments in the environment/target to enable it. It is off by default since while the RGen differ will ignore them, tkdiff/winmerge will not and it will make differences harder to view.
Added Midband state to vectoring (for comparing only).
$dut.pins(:tdo).assert_midband RGen.tester.cycle $dut.pins(:tdo).dont_care RGen.tester.cycle $dut.pins(:tdo).assert_midband! $dut.pins(:tdo).dont_care RGen.tester.cycle $dut.port(:test_port).assert_midband
Added a new shared command, testers:build, which provides ASCIIUtils-like test program build/integration functionality. So far only the V93K is supported but other platforms may be added in future.
The V93K implementation will currently merge flow and pattern master files which are the two files that are generated by this plugin. Additional files could be added in future.
The user must supply a manifest file which describes the flows to be built and the sub-programs from which they are comprised. The attributes of this file will be platform-dependent, here is an example for V93K:
flows: probe1: - continuity - scan - nvm probe2: - continuity - scan - functional sub_programs: - name: continuity # Paths can be relative to your RGen application root flow: output/v93k/testflow/continuity.flow - name: scan # Or relative to this file flow: ../../output/v93k/testflow/scan.flow pattern_master: ../../output/v93k/vectors/scan.pmfl - name: nvm # Or absolute flow: /proj/deviceX/test_program/v93k/testflow/nvm.flow pattern_master: /proj/deviceX/test_program/v93k/testflow/nvm.pmfl - name: functional flow: /proj/deviceX/test_program/v93k/testflow/functional.flow pattern_master: /proj/deviceX/test_program/v93k/testflow/functional.pmfl
A template manifest file can be built by running:
rgen testers:build my_manifest --new
test_method = test_methods.j750_tml.general_dc test_method.lo_limit = 100.uA test_method.hi_limit = 150.uA
module MyApp class Interface include Testers::ProgramGenerators def initialize(options={}) add_j750_tml if tester.v93k? end # Define the test methods for the J750 test method library for the V93K def add_j750_tml add_tml :j750_tml, class_name: 'J750Conversion', general_dc: { class_name: 'DigitalTest.GeneralDC', # Parameters can be defined with an underscored symbol as the name, this can be used # if the C++ implementation follows the standard V93K convention of calling the attribute # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this # first example. # The attribute definition has two required parameters, the type and the default value. # The type can be :string, :current, :voltage, :time, :frequency, or :integer # An optional 3rd parameter can be supplied to give an array of allowed values. If supplied, # RGen will raise an error upon an attempt to set it to an unlisted value. tester_state: [:string, 'CONNECTED', %w(CONNECTED UNCHANGED)], test_name: [:string, 'Functional'], # Parameters for PPMU 'UsePPMU' => [:string, 'YES', %w(YES NO)], 'UsePPMU.pinlist' => [:string, ''], 'UsePPMU.forceMode' => [:string, 'VOLT', %w(VOLT CURR)], 'UsePPMU.forceValue1' => ['UsePPMU.forceMode', 3800.mV], 'UsePPMU.forceValue2' => ['UsePPMU.forceMode', 0], 'UsePPMU.measureMode' => [:string, 'PAR', %w(PAR SER)], 'UsePPMU.samples' => [:integer, 1], 'UsePPMU.precharge' => [:string, 'OFF', %w(OFF ON)], 'UsePPMU.prechargeVoltage' => [:voltage, 0], 'UsePPMU.relaySwitchMode' => [:string, 'PARALLEL', ['BBM', 'MBB', 'PARALLEL(default)', 'PARALLEL']], 'UsePPMU.settlingTime' => [:time, 0], 'UsePPMU.termination' => [:string, 'OFF', %w(ON OFF)], 'UsePPMU.testName1' => [:string, ''], 'UsePPMU.testName2' => [:string, ''], # In cases where the C++ library has deviated from standard attribute naming conventions # (camel-cased with lower cased first character), the absolute attribute name can be given # as a string. # The Ruby/RGen accessor for these will be the underscored version, with '.' characters # converted to underscores, e.g. tm.use_interpose, tm.use_interpose_start_of_body_f, etc. 'UseInterpose' => [:string, 'NO', %w(NO YES)], 'UseInterpose.StartOfBodyF' => [:string, ''], 'UseInterpose.StartOfBodyFInput' => [:string, ''], 'UseInterpose.EndOfBodyF' => [:string, ''], 'UseInterpose.EndOfBodyFInput' => [:string, ''], # Attribute aliases can be defined like this: aliases: { start_of_body_f: 'UseInterpose.StartOfBodyF', start_of_body_f_args: 'UseInterpose.StartOfBodyFInput', end_of_body_f: 'UseInterpose.EndOfBodyF', end_of_body_f_args: 'UseInterpose.EndOfBodyFInput', }, # Define any methods you want the test method to have methods: { # An optional finalize function can be supplied to do any final test method configuration, this # function will be called immediately before the test method is finally rendered. The test method # object itself will be passed in as an argument. # In this example it is being used to automatically set the UseInterpose flag if any interpose # function arguments have been set. finalize: -> (tm) { if [:start_of_body_f, :start_of_body_f_args, :end_of_body_f, :end_of_body_f_args].any? do |arg| tm.send(arg) && !tm.send(arg).empty? end tm.use_interpose = "YES" end }, # Example of a custom method, here to emulate functionality available to Teradyne test instance objects. # In all cases the test method object will be passed in as the first argument. set_measure_mode: -> (tm, mode) { if mode == :current || mode == :fvmi tm.use_ppmu_force_mode = "VOLT" elsif mode == :voltage || mode == :fimv tm.use_ppmu_force_mode = "CURR" end }, } }, general_digital: { # Define another test method within this library... } end end
if tester.j750? i = test_instances.functional(name, options) elsif tester.v93k? i = test_suites.add(name, options) i.test_method = test_methods.j750_tml.general_digital end # Now you can treat these the same for many attributes. For example on V93K the pattern is # a test suite attribute whereas the interpose functions are provided by the (custom) test # method, however these can now be treated as if they are a single entity: i.pattern = name i.start_of_body_f = "TfsC90InterposeFunc" i.start_of_body_f_args = "PGM_CAL_PARAS,cal_paras"
module MyApp class Interface include Testers::ProgramGenerators def initialize(options={}) add_j750_tml if tester.v93k? end # Define the test methods for the J750 test method library for the V93K def add_j750_tml # Add a new test method library, this will be available as test_methods.j750_tml. # This method can be called multiple times to define multiple custom libraries. add_tml :j750_tml, # Optionally supply a class name attribute that will be prefixed to all test method # classes (meaning the C++ class name) defined herein class_name: 'J750Conversion', # Defines a test method called general_digital, a new instance of this can be created # by test_methods.j750_tml.general_digital general_digital: { # The full C++ class name will be 'J750Conversion.DigitalTest.GeneralDigital', this # is optional and by default will be the camel-cased version of the method name, e.g. # 'GeneralDigital' in this case. class_name: 'DigitalTest.GeneralDigital', # Parameters can be defined with an underscored symbol as the name, this can be used # if the C++ implementation follows the standard V93K convention of calling the attribute # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this # first example. # The attribute definition has two required parameters, the type and the default value. # The type can be :string, :current, :voltage, :time, :frequency, or :integer # An optional 3rd parameter can be supplied to give an array of allowed values. If supplied, # RGen will raise an error upon an attempt to set it to an unlisted value. tester_state: [:string, 'CONNECTED', %w(CONNECTED UNCHANGED)], test_name: [:string, 'Functional'], # In cases where the C++ library has deviated from standard attribute naming conventions # (camel-cased with lower cased first character), the absolute attribute name can be given # as a string. # The Ruby/RGen accessor for these will be the underscored version, with '.' characters # converted to underscores, e.g. tm.use_interpose, tm.use_interpose_start_of_body_f, etc. 'UseInterpose' => [:string, 'NO', %w(NO YES)], 'UseInterpose.StartOfBodyF' => [:string, ''], 'UseInterpose.StartOfBodyFInput' => [:string, ''], 'UseInterpose.EndOfBodyF' => [:string, ''], 'UseInterpose.EndOfBodyFInput' => [:string, ''], # Attribute aliases can be defined like this: aliases: { start_of_body_f: 'UseInterpose.StartOfBodyF', start_of_body_f_args: 'UseInterpose.StartOfBodyFInput', end_of_body_f: 'UseInterpose.EndOfBodyF', end_of_body_f_args: 'UseInterpose.EndOfBodyFInput', }, # An optional finalize function can be supplied to do any final test method configuration, this # function will be called immediately before the test method is finally rendered. The test method # object itself will be passed in as an argument. # In this example it is being used to automatically set the UseInterpose flag if any interpose # function arguments have been set. finalize: -> (tm) { if [:start_of_body_f, :start_of_body_f_args, :end_of_body_f, :end_of_body_f_args].any? do |arg| tm.send(arg) && !tm.send(arg).empty? end tm.use_interpose = "YES" end } }, general_dc: { # Define another test method within this library... } end end
Added fixes (and tests) for the following two bugs:
OLD: // Wait for 2.4ms repeat 60000 nvmbist 0 1 0 1 0 X X X repeat nvmbist 0 1 0 1 0 X X X NEW: // Wait for 2.4ms repeat 60001 nvmbist 0 1 0 1 0 X X X
OLD:
// Wait for 12.0us
> lynx 1
repeat 600 > lynx 1
// COMMENT: End Test
repeat 600 > lynx 1
> lynx 1
}
NEW:
// Wait for 12.0us
> lynx 1
repeat 600 > lynx 1
// COMMENT: End Test
> lynx 1
> lynx 1
}
Corrected minor bug that only occurred when tester wait called for time greater than maximum repeat count possible on tester. Extraneous vector was being generated after each max repeat count vector.
Added fix (and test) for setting resources_filename during interface initialize.
This update also ensures that the given platform generator module is loaded before initialize is called where an interface includes Testers::ProgramGenerators.
Changed internal implementation of TestInstance#set_wait_flags method to remove the need for a tester instance method
Initial release of the V93K test program generator and general feature improvements to support the creation of test programs for multiple platforms.
V93K
The V93K generator now has a similar level of functionality to the supported Teradyne platforms, here is an example of how to use it:
# Generate a functional test def functional(name, options = {}) test_suite = test_suites.run(name, options) test_method = test_methods.ac_tml.ac_test.functional_test test_suite.test_method = test_method test_suite.pattern = name flow.test(test_suite, options) end
The output is a complete flow file containing all test method and test suite definitions (equivalent to Teradyne test instances + patsets) and a pattern master file listing all patterns required by the given flow.
Notable things still todo:
NEW MULTI-PLATFORM FEATURES
The following features have been added to the Testers plugin to better support multi-platform test program generation (i.e. to make it easier to implement an app that supports multiple platforms), and also to make the program generator work better in a BOM-style application.
Previously, test program interfaces were automagically selected based on the current tester type, however that won’t work in a BOM app setup where potentially many sub-modules each implement their own interface (or they could share one) and it is impossible to know which one to pick. To solve this, top-level flows (i.e. not required for sub-flows which will inherit the interface from their parent) should now define the class of the interface that they want to use:
Flow.create interface: 'C90TFSNVMTester::Interface' do end
For now this is optional and the old-style lookup is still supported, but that will eventually be deprecated and supplying an interface option will be a hard required.
Note that the above interface example does not specify a test platform, this is because it is now possible to create a universal interface. Instead of including platform-specific generators, an app’s interface class can now include just a universal generator module:
module C90TFSNVMTester class Interface include Testers::ProgramGenerators end end
The interface instance will be automatically endowed with the methods to support the test platform being used at runtime. The bottom line is that an interface to support the J750 would otherwise be identical to how it used to be:
module C90TFSNVMTester class Interface include Testers::ProgramGenerators def functional(name, options = {}) ins = test_instances.functional(name, options) pname = "#{name}_pset" pset = patsets.add(pname, [{ pattern: "#{name}.PAT" }]) ins.pattern = pname line = flow.test(ins, options) end end end
Note that this means that the above interface would now also support UltraFLEX as well if it was run with the appropriate target.
It is now much easier to add support for additional test platforms rather than having separate interfaces and trying to juggle shared code between them. To add V93K support to the above interface you would do:
module C90TFSNVMTester class Interface include Testers::ProgramGenerators def functional(name, options = {}) if tester.j750? || tester.ultraflex? ins = test_instances.functional(name, options) pname = "#{name}_pset" pset = patsets.add(pname, [{ pattern: "#{name}.PAT" }]) ins.pattern = pname line = flow.test(ins, options) elsif tester.v93k? test_suite = test_suites.run(name, options) test_method = test_methods.ac_tml.ac_test.functional_test test_suite.test_method = test_method test_suite.pattern = name flow.test(test_suite, options) end end end end
This now opens the door to the creation of multi-platform test setup libraries (which was always the intention of the architecture design of the RGen program generator) and the Testers plugin will provide a basic library to make it easier to get started when dealing with basic tests (e.g. functional, current_measure, voltage_measure, etc.). It is of course envisaged that more complex domain-specific libraries will start to emerge within the community.
Initially the Tester plugin’s basic library is a proof of concept and provides a functional test setup which will work on all platforms (though it has not yet been tested on any).
To use it create a very simple interface in your app:
module C90TFSNVMTester class Interface include Testers::BasicTestSetups end end
In your flow you can now generate functional tests for any platform:
Flow.create interface: 'C90TFSNVMTester::Interface' do functional :erase, sbin: 100 functional :rd_all1, sbin: 110 end
It is possible to apply defaults (e.g. set bin 3 for all), or to tweak the output (e.g. add an interpose function call on Teradyne platforms) from the interface. See the API for details on how to do that: BasicTestSetups
Corrected bug in J750 match loop with multiple entries– extra set_code being called.
Fix for issue when requiring into a 3rd party app (introduced in pre29)
Updated the V93K generator class structure to match the conventions recently established for the IG-XL-based testers.
Added V93K interface and added the V93K program generator to the regression list (though it doesn’t currently generate any output).
Now ready to start adding functionality…
Fairly major internal refactor to support running multiple program generation runs back to back, this is necessary amongst other things to support testing the program generators. Regression tests have now been enabled for the J750, UltraFLEX and J750_HPT program generators.
This update restores the internal generator architecture to have a separate class structure for each supported platform, rather than customizing a single class at runtime. Unfortunately some fairly minor breaking changes will be apparent at application-level as a result of this change:
class MyJ750Interface include Testers::J750::Generator end
The patgroup generators are currently untested and could therefore be broken by this update, though it is unlikely.
Added vector levelling.
When enabled, all vectors will be converted to use the timeset with the smallest period that is encountered in the pattern. An error will be raised if a vector is encountered who’s period is not a multiple of the smallest period.
This feature is enabled for the V93K tester by default and disabled for Teradyne testers since there is no time penalty from modulating the period by switching timeset/timeplate on that platform.
Removed the original vector compression logic and made everything, including single mode patterns, now use the vector pipeline. This is to allow it to be used to create a period-levelling system which will be required for the V93K.
Added $tester.align and $tester.align_to_last methods to align the next vector to the start or end of a multi-vector frame. See the pattern_footer method in the IGXL-based tester class for an example where it is used to ensure that the end_module microcode falls on the last vector of a frame. Generally the tester classes will be responsible now for using these methods as required to ensure that their microcode will align properly in multi vector modes.
Added a multi-mode vector test to the regression list. The J750 output matches that from RGen core, not sure if the output on other platforms is valid yet - especially may not be right for UFlex case where vector padding kicks in on short patterns. This multi-mode pattern should be expanded in future as tester API methods become multi-mode aware.
Added more test coverage for V93K.
Added V93K generators from RGen core, without modification other than that required to make them run within the Testers plugin.
Added legacy test of V93K pattern generation compatibility to allow it to be safely deprecated from RGen core.
Enabled standard auto-linting.
Did some minor refactoring of existing code.
Wrapped standalone-dependent configs so that they aren’t run by app calling Testers gem.
Converted to gem.
Added MTO instrument statement back for all UltraFLEX patterns but controlled via target. So by default will not be included for all patterns but user can add it if desired.
updated pattern generation for multi-mode vector support - correct repeat counts are now being properly applied on the correct vectors. Vector padding is also being applied to fill out a complete vector group. Also vector repeats are also being split in order to preserve vector comments in their original position. Pattern header content has been adjusted to reflect the correct UltraFlex mode (single, dual, quad).
NOTE: An instrument statement for ‘mto’ was being erroneously included in all pattern headers. This has been changed such that it will only be included if the :memory_test option is set to true for the pattern header (this is the same solution used in the igxl_based_tester class). Be aware that this caused ‘rgen examples’ to fail four patterns that expected the ‘mto’ instrument to be declared. I have updated these patterns with the new pattern generation behavior (e.g. without the mto instrument).
Fixed bug where compiler woulf crash if users had not previously created a .atp file.
All of these bugs I am finding are due to writing documentation on how the compiler SHOULD work and it is clear that good, prompt documentation will improve our code base or at least my contributions to it.
Updated compiler to look for cmd line .atp patterns at RGen.root and below
updated ultraflex compiler to version 1.5.3.3
updated pattern compiler to handle callbacks natively instead of inside the user application
Updated the testers plugin to enable bitmapping support on the UltraFLEX using the MTO instrument.
updated pattern compiler to work with ‘rgen g’
Added in pattern compiler support for programmatic access. This works as follows:
module CompilerSpec class CompilerDUT include Testers::PatternCompilers include RGen::TopLevel attr_accessor :pinmap attr_reader :ltg_compiler_options attr_reader :functional_compiler_options attr_reader :bist_compiler_options def initialize @ltg_compiler_options = { path: "#{RGen.root}/spec/patterns/atp/ltg", clean: false, location: :local, recursive: false, output_directory: "#{RGen.root}/spec/patterns/bin", opcode_mode: 'single', comments: true } @functional_compiler_options = { path: "#{RGen.root}/spec/patterns/atp/functional", clean: true, location: :local, recursive: false, output_directory: "#{RGen.root}/spec/patterns/bin", opcode_mode: 'single', comments: false } @bist_compiler_options = { clean: true, location: :local, recursive: false, output_directory: "#{RGen.root}/spec/patterns/bin", pinmap_workbook: "#{RGen.root}/spec/patterns/atp/bist/bist_pins.txt", opcode_mode: 'single', comments: false } end end describe "Ultraflex Pattern Compiler" do before :all do RGen.target.temporary = 'ultraflex_compiler' RGen.app.load_target! RGen.load_application $dut = CompilerDUT.new $dut.pinmap = "#{RGen.root}/spec/patterns/compiler_pins.txt" # Clean up any .PAT and .log files in our spec testing area Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").each do |f| File.delete(f) end Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").each do |f| File.delete(f) end Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").each do |f| File.delete(f) end Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").each do |f| File.delete(f) end end it "creates pattern compiler instances correctly" do $dut.pattern_compilers.should == {} $dut.add_compiler(:ltg, :ultraflex, $dut.ltg_compiler_options) # pattern_compiler method will show compiler instances # for whatever the current tester platform is enabled $dut.pattern_compilers.keys.should == [:ltg] $dut.add_compiler(:functional, :ultraflex, $dut.functional_compiler_options) $dut.pattern_compilers.count.should == 2 end it "finds the correct number of patterns" do $dut.pattern_compilers[:ltg].find_jobs ltg_atp_count = $dut.pattern_compilers[:ltg].count ltg_atp_count.should == 1 end it "can search the compiler job queue" do $dut.pattern_compilers[:ltg].jobs(/fail/).should == false $dut.pattern_compilers[:ltg].jobs(/idreg/).should == true $dut.pattern_compilers[:ltg].jobs('ls2080').should == true $dut.pattern_compilers[:ltg].jobs(0).should == true $dut.pattern_compilers[:ltg].jobs($dut.pattern_compilers[:ltg].count+1).should == false end it "can compile the expected number of patterns" do ltg_atp_count = $dut.pattern_compilers[:ltg].count ltg_atp_count.should == 1 ltg_pat_matches = Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").count ltg_pat_matches.should == 0 $dut.pattern_compilers[:ltg].run ltg_pat_matches = Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").count ltg_atp_count.should == ltg_pat_matches end it "can save log files" do ltg_pat_matches = Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").count if $dut.ltg_compiler_options[:clean] == false Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").count.should == ltg_pat_matches else Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").count.should == 0 end end it "can find and compile patterns recursively/non-recursively in directories and lists" do # Clean up patterns and log files from previous spec testing Dir.glob("#{$dut.ltg_compiler_options[:output_directory]}/**/*.PAT").each do |f| File.delete(f) end Dir.glob("#{$dut.ltg_compiler_options[:path]}/**/*.log").each do |f| File.delete(f) end $dut.pattern_compilers[:functional].find_jobs functional_atp_count = $dut.pattern_compilers[:functional].count functional_atp_count.should == 1 functional_pat_matches = Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count functional_pat_matches.should == 0 $dut.pattern_compilers[:functional].run functional_pat_matches = Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count functional_atp_count.should == functional_pat_matches # Turn on the recursive flag which will find patterns and lists in sub-directories $dut.functional_compiler_options[:recursive] = true $dut.add_compiler(:functional_recursive, :ultraflex, $dut.functional_compiler_options) $dut.pattern_compilers[:functional_recursive].find_jobs functional_atp_count = $dut.pattern_compilers[:functional_recursive].count functional_atp_count.should == 7 functional_pat_matches = Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count # Should have one pattern from previous run functional_pat_matches.should == 1 $dut.pattern_compilers[:functional_recursive].run functional_pat_matches = Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count functional_atp_count.should == functional_pat_matches end it "can delete log files" do functional_pat_matches = Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").count if $dut.functional_compiler_options[:clean] == false Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").count.should == functional_pat_matches else Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").count.should == 0 end end it "allows users to pass files individually inside an enumeration" do # Clean up patterns and log files from previous spec testing Dir.glob("#{$dut.functional_compiler_options[:output_directory]}/**/*.PAT").each do |f| File.delete(f) end Dir.glob("#{$dut.functional_compiler_options[:path]}/**/*.log").each do |f| File.delete(f) end # This compiler instance does not specify path but does specify a pinmap # The pinmap passed as an option should override $dut.pinmap $dut.add_compiler(:bist, :ultraflex, $dut.bist_compiler_options) # The pinmap passed to the compiler as an option overrode the one at $dut.pinmap $dut.pinmap.should_not == $dut.pattern_compilers[:bist].pinmap.to_s bist_pattern_count = Dir["#{RGen.root}/spec/patterns/atp/bist/*.atp*"].count Dir["#{RGen.root}/spec/patterns/atp/bist/*.atp*"].each do |f| atp = Pathname.new(f) next unless atp.extname == '.gz' || atp.extname == '.atp' # Ignore patterns that do not have 'prod' in the name next unless atp.basename.to_s.match(/prod/) $dut.pattern_compilers[:bist].find_jobs(atp) end # Filtered one pattern $dut.pattern_compilers[:bist].count.should == 3 # Save the compiler queue to a pattern list file for diff or run later $dut.pattern_compilers[:bist].to_list(name: 'bist_compile', force: true, output_directory: $dut.bist_compiler_options[:output_directory]) $dut.pattern_compilers[:bist].run bist_pat_matches = Dir.glob("#{$dut.bist_compiler_options[:output_directory]}/**/*.PAT").count bist_pat_matches.should == bist_pattern_count - 1 # Clean up patterns and log files from previous spec testing Dir.glob("#{$dut.bist_compiler_options[:output_directory]}/**/*.PAT").each do |f| File.delete(f) end $dut.pattern_compilers[:bist].count.should == 0 end it "can compile a pattern list" do # Compile the patterns using the pattern list created ea $dut.pattern_compilers[:bist].run(list, $dut.bist_compiler_options) bist_pat_matches = Dir.glob("#{$dut.bist_compiler_options[:output_directory]}/**/*.PAT").count # compiled patterns count should match what we had when we wrote out the pattern list bist_pat_matches.should == 3 end end end
Also added hooks to allow ‘rgen g
Updated linux pattern compiler to work on cmd line AND offline so compile jobs can be done and prepared on Windows or Linux. Cmd line args changed slightly:
opt_parser = OptionParser.new do |opts| opts.banner = 'USAGE: rgen latpc [options] ; --pinmap is required.' opts.on('-f', '--path DIR|PATTERN|LIST', 'Pattern directory, individual pattern, or pattern list to be compiled. Required.') { |path| options[:path] = path } opts.on('-p', '--pinmap PINMAP', 'Path and filename for the pinmap to be used. Required.') { |pinfile| options[:pinmap_workbook] = pinfile } opts.on('-o', '--output DIRECTORY', 'Path to the directory to place compiled .PAT files') { |dir| options[:output_directory] = dir } opts.on('-c', '--clean', 'Deleted .log files after compilation') { |a| boptions[:clean] = true } opts.on('-t', '--target TARGET', 'Temporarily changes target to TARGET for this command') { |tar| options[:target] = tar } opts.on('-l', '--location LOCATION', "'local' or 'lsf', defaults to 'local'") { |locn| options[:location] = locn } opts.on('-r', '--recursive', "Do a recursive directory search for patterns if the '-f' arg is a directory") { |r| options[:recursive] = true } opts.on_tail('-h', '--help', 'Show this message') { puts opts; exit } end
When using the compiler offline (inside RGen) the following steps are required:
bist_options = {
path: "#{RGen.root}/output/patterns/atp/fslbist",
clean: true, # controls whether compiler log files are deleted after
compilation
target: nil, # allows user to temporarily set target and run compilation
location: 'local', # controls whether the commands go to the LSF or run locally
recursive: false, # controls whether to look for patterns in a directory
recursively
output_directory: "#{RGen.root}/output/patterns/bin",
pinmap_workbook: "#{RGen.root}/output/patterns/atp/fslbist/Pins.txt",
opcode_mode: 'dual',
comments: true
}
compiler = Testers::LinuxPatternCompiler.new(:fslbist, bist_options)
compiler.find_jobs # Find all patterns at options[:path] and create compiler jobs
compiler.run # Run the compiler using the jobs queue built by 'find_jobs' method
Users can view the compiler job queue by doing the following:
compiler.inspec_jobs | Job: 1 | Pattern: ls2080_lnx_07p2p1_idreg.atp | | | Pattern type: cmd_line | | | Pinmap: /proj/b4860/b07507/ls2085/rev1.0.0dev3/output/programs/ls2080_pins.txt | | | .atp directory: /proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/atp/ltg | | | .pat directory: /proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/bin/ltg | | | LSF: true | | | Delete log files: false | | | Compiler args: -opcode_mode:single | ------------------------------------------------------------------------------------------ ---------------------------------------------
Users can view the current state of the compiler by doing the following:
compiler.inspect | Option | Argument | Required | ------------------------------------------------------------------------------------------ ---------------------------------------- | path | output/patterns/atp/ltg | true | | reference_dir | /proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/atp | false | | recursive | false | false | | compiler | /proj/b4860/b07507/ls2085/.rev1.0.0dev3_imports_DO_NOT_HAND_MODIFY/testers/bin/atpc_Linux6 4_til/bin/atpcompiler| true | | pattern_type | cmd_line | true | | pinmap_workbook | /proj/b4860/b07507/ls2085/rev1.0.0dev3/output/programs/ls2080_pins.txt | true | | location | lsf | false | | clean | false | false | | output_directory | /proj/b4860/b07507/ls2085/rev1.0.0dev3/output/patterns/bin | false | | opcode_mode | single | false |
Users can save a compiler job queue by creating a pattern list which can then be run at a later time.
compiler.to_list(name: 'test', output_directory: '~', force: true, expand: true) options = { name: nil, directory: Dir.pwd, clean: false, location: 'local' }.update_common(list_options)
~~ruby options = { name: @pattern_type, output_directory: Dir.pwd, expand: true, force: false }.update_common(options) ~~~
The compiler can handle individual .atp, .atp.gz, .list files or a directory which can be parsed recursively or flat.
By allowing the users to instantiate a particular type of compiler for each pattern type that has unique compiler options required, standardization is enforced.
By allowing the users to send files or directories to the compiler inside of any Ruby loop/enumeration the user has much more flexibility in what get sent to the job queue vs. running strictly on the command line.
updated linux pattern compiler to use single file, pattern list, or directory (flat or recusive).
Command line args have changed slightly:
opts.on("-f", "--file DIR|PATTERN|LIST", "Pattern directory, individual pattern, or pattern list to be compiled. Required.") { |path| options[:path] = path } opts.on("-p", "--pinmap PINMAP", "Path and filename for the pinmap to be used. Required.") { |pinfile| options[:pinmap] = pinfile } opts.on("-o", "--output DIRECTORY", "Path to the directory to place compiled .PAT files") { |dir| options[:output] = dir } opts.on("-c", "--clean", "Deleted .log files after compilation") {|a| options[:clean]=true} opts.on("-t", "--target TARGET", "Temporarily changes target to TARGET for this command") { |tar| options[:target] = tar } opts.on("-l", "--lsf", "Submit job to the LSF") { |a| options[:lsf] = true} opts.on("-r", "--rec", "Do a recursive directory search for patterns if the '-f' arg is a directory") { |r| options[:rec] = true } opts.on_tail("-h", "--help", "Show this message") { puts opts; exit }
Merged Priyavadan’s changes to latpc.atp for supporting linux ultra-flex pattern compiler. Added DCVS instrument import to ultra-flex patterns to allow for pattern run-time voltage switching via PSets.
-Added Teradyne UltraFLEX ATP compiler to plugin, found under /bin -Added ‘latpc’ as a shared command for use in applications. See rgen latpc -h for more help. Only compatible with UF tester -Use $tester.pattern_compiler_pinmap or the -p option at command line to specify the pinmap to use for compilation of .atp files -Compiles all .atp files in the default output directory by default. You can specify a different directory with the -dir option, and also list specific .atp files for compilation instead of the entire directory.
log '"Run testme only if passcode neither present in location A or location B"' func :check_locationA, continue: true, id: :locA func :check_locationB, continue: true, id: :locB nop log '"OR to set a third master flag"' # BE SURE to indicate condition (:pass/:fail) to align to where used below since no pass/fail column used # need to deeper fix to handle automatically or_ids id1: :locA, id2: :locB, id: :do_testme, condition: :pass func :testme, if_passed: :do_testme # will run only if do_testme is true-- which only will happen if both passcodes above fail.
Messed up the ultraflex_interface.rb file on previous release, the use limit features are now correctly added, passing specs and examples.
Added Use_limit in flow.rb Added aliases for hilim and lolim Added :use_limit for DEFAULTS in flow_line.rb Added conditioning to ALIASES.each.do Added alias_method for :para in j750_interface.rb Added test flow file for testing measurement capability using limits.
Updated match loops for J750 and UltraFlex to count cycles of a block of code used for match conditions automatically, and adjust loops/counters accordingly.
Will very large timeout values:
Where num_cycles_to_match is number of cycles per match loop iteration, which includes delays to flush pipeline on each iteration.
E.G. for 60nS period UTI pattern on J750, max timeout => 158min E.G. for 60nS period UTI pattern on UltraFLEX, max timeout => 1116min E.G. for 250nS period Nexus pattern on J750, max timeout => 3758 min
For all purposes there is no limit.
For J750 match loop timeout is implemented using 2 16-bit counters nested.
For UltraFLEX match loop timeout is implemented using 1 28-bit counter with additional delay added via repeat count.
First semi-official release of Testers plug-in.
####J750 Pattern Generation
Added program generation capability for J750 and J750_HPT. Output matches against program generation examples from RGen core.
Updated ‘examples’ command to include both pattern and proggen checking capability.
Added vector padding capability if tester has fewer than some limit. Default is 0 (J750).
Mainly to support ultraflex which requires 64 min vectors for a VM module in single mode (128 in dual mode). Added reset pattern test to check this.
Initial release of Testers plug-in. Currently works only for pattern generation for J750 and J750_HPT testers. Will working to correlate all code aspects for J750/J750_HPT. ./