origen_testers 0.4.0

data/lib/origen_testers/igxl_based_tester/parser/test_instance.rb

@@ -0,0 +1,341 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class TestInstance
+        attr_accessor :parser
+
+        TYPES = %w(
+          functional board_pmu empty pin_pmu power_supply mto_memory
+        )
+
+        TYPE_ALIASES = {
+          functional_t:         :functional,
+          boardpmu_t:           :board_pmu,
+          nvmboardpmucal_t:     :board_pmu,
+          nvmboardpmumeasure_t: :board_pmu,
+          empty_t:              :empty,
+          pinpmu_t:             :pin_pmu,
+          nvmpinpmucal_t:       :pin_pmu,
+          nvmpinpmumeas_t:      :pin_pmu,
+          powersupply_t:        :power_supply,
+          mto_memory_t:         :mto_memory
+        }
+
+        attributes = %w(
+          test_name proc_type proc_name proc_called_as dc_category dc_selector ac_category ac_selector
+          time_sets edge_sets pin_levels overlay
+        )
+        80.times do |i|
+          attributes << "arg#{i}"
+        end
+        attributes << 'comment'
+
+        ATTRS = attributes
+
+        ALIASES = {
+          name:       :test_name,
+
+          functional: {
+            pattern:             :arg0,
+            start_func:          :arg1,
+            pre_pat_func:        :arg2,
+            pre_test_func:       :arg3,
+            post_test_func:      :arg4,
+            post_pat_func:       :arg5,
+            end_func:            :arg6,
+            set_pass_fail:       :arg7,
+            start_func_args:     :arg13,
+            pre_pat_func_args:   :arg14,
+            pre_test_func_args:  :arg15,
+            post_test_func_args: :arg16,
+            post_pat_func_args:  :arg17,
+            end_func_args:       :arg18,
+            wait_flags:          :arg21,
+            wait_time:           :arg22,
+            pat_flag_func:       :arg23,
+            pat_flag_func_args:  :arg24,
+            relay_mode:          :arg25,
+            threading:           :arg26,
+            match_all_sites:     :arg27,
+            capture_mode:        :arg30,
+            capture_what:        :arg31,
+            capture_memory:      :arg32,
+            capture_size:        :arg33,
+            datalog_mode:        :arg34,
+            data_type:           :arg35
+          },
+
+          board_pmu:  {
+            hsp_start:           :arg0,
+            start_func:          :arg1,
+            pre_pat_func:        :arg2,
+            pre_test_func:       :arg3,
+            post_test_func:      :arg4,
+            post_pat_func:       :arg5,
+            end_func:            :arg6,
+            precond_pat:         :arg7,
+            hold_state_pat:      :arg8,
+            holdstate_pat:       :arg8,
+            pattern:             :arg8,
+            pcp_stop:            :arg9,
+            wait_flags:          :arg10,
+            start_lo:            :arg11,
+            init_lo:             :arg11,
+            start_hi:            :arg12,
+            init_hi:             :arg12,
+            start_hiz:           :arg13,
+            init_hiz:            :arg13,
+            float_pins:          :arg14,
+            pinlist:             :arg15,
+            measure_mode:        :arg16,
+            irange:              :arg17,
+            clamp:               :arg18,
+            vrange:              :arg19,
+            sampling_time:       :arg20,
+            samples:             :arg21,
+            setting_time:        :arg22,
+            hi_lo_lim_valid:     :arg23,
+            hi_limit:            :arg24,
+            lo_limit:            :arg25,
+            force_cond_1:        :arg26,
+            force_cond_2:        :arg27,
+            gang_pins_tested:    :arg28,
+            relay_mode:          :arg29,
+            wait_time_out:       :arg30,
+            start_func_args:     :arg31,
+            pre_pat_func_args:   :arg32,
+            pre_test_func_args:  :arg33,
+            post_test_func_args: :arg34,
+            post_pat_func_args:  :arg35,
+            end_func_args:       :arg36,
+            pcp_start:           :arg37,
+            pcp_check_pg:        :arg38,
+            hsp_stop:            :arg39,
+            hsp_check_pg:        :arg40,
+            resume_pat:          :arg41,
+            utility_pins_1:      :arg42,
+            utility_pins_0:      :arg43,
+            pre_charge_enable:   :arg44,
+            pre_charge:          :arg45,
+            threading:           :arg46
+          },
+
+          pin_pmu:    {
+            hsp_start:           :arg0,
+            start_func:          :arg1,
+            pre_pat_func:        :arg2,
+            pre_test_func:       :arg3,
+            post_test_func:      :arg4,
+            post_pat_func:       :arg5,
+            end_func:            :arg6,
+            precond_pat:         :arg7,
+            hold_state_pat:      :arg8,
+            holdstate_pat:       :arg8,
+            pattern:             :arg8,
+            pcp_stop:            :arg9,
+            wait_flags:          :arg10,
+            start_lo:            :arg11,
+            init_lo:             :arg11,
+            start_hi:            :arg12,
+            init_hi:             :arg12,
+            start_hiz:           :arg13,
+            init_hiz:            :arg13,
+            float_pins:          :arg14,
+            pinlist:             :arg15,
+            measure_mode:        :arg16,
+            irange:              :arg17,
+            setting_time:        :arg18,
+            hi_lo_lim_valid:     :arg19,
+            hi_limit:            :arg20,
+            lo_limit:            :arg21,
+            force_cond_1:        :arg22,
+            force_cond_2:        :arg23,
+            fload:               :arg24,
+            f_load:              :arg24,
+            relay_mode:          :arg25,
+            wait_time_out:       :arg26,
+            start_func_args:     :arg27,
+            pre_pat_func_args:   :arg28,
+            pre_test_func_args:  :arg29,
+            post_test_func_args: :arg30,
+            post_pat_func_args:  :arg31,
+            end_func_args:       :arg32,
+            pcp_start:           :arg33,
+            pcp_check_pg:        :arg34,
+            hsp_stop:            :arg35,
+            hsp_check_pg:        :arg36,
+            sampling_time:       :arg37,
+            samples:             :arg38,
+            resume_pat:          :arg39,
+            vcl:                 :arg40,
+            vch:                 :arg41,
+            utility_pins_1:      :arg42,
+            utility_pins_0:      :arg43,
+            pre_charge_enable:   :arg44,
+            pre_charge:          :arg45,
+            threading:           :arg46
+          },
+          mto_memory: {
+            patterns:                  :arg0,
+            pattern:                   :arg0,
+            start_func:                :arg1,
+            start_of_body_f:           :arg1,
+            pre_pat_func:              :arg2,
+            pre_pat_f:                 :arg2,
+            pre_test_func:             :arg3,
+            pre_test_f:                :arg3,
+            post_test_func:            :arg4,
+            post_test_f:               :arg4,
+            post_pat_func:             :arg5,
+            post_pat_f:                :arg5,
+            end_of_body_func:          :arg6,
+            end_of_body_f:             :arg6,
+            set_pass_fail:             :arg7,
+            init_lo:                   :arg8,
+            start_lo:                  :arg8,
+            init_hi:                   :arg9,
+            start_hi:                  :arg9,
+            init_hiz:                  :arg10,
+            start_hiz:                 :arg10,
+            float_pins:                :arg11,
+            start_of_body_func_args:   :arg12,
+            start_of_body_f_args:      :arg12,
+            pre_pat_func_args:         :arg13,
+            pre_pat_f_args:            :arg13,
+            pre_test_func_args:        :arg14,
+            pre_test_f_args:           :arg14,
+            post_test_func_args:       :arg15,
+            post_test_f_args:          :arg15,
+            post_pat_f_args:           :arg16,
+            end_of_body_func_args:     :arg17,
+            end_of_body_f_args:        :arg17,
+            utility_pins_1:            :arg18,
+            utility_pins_0:            :arg19,
+            wait_flags:                :arg20,
+            wait_time_out:             :arg21,
+            PatFlagF:                  :arg22,
+            pat_flag_f:                :arg22,
+            pat_flag_func_args:        :arg23,
+            pat_flag_f_args:           :arg23,
+            relay_mode:                :arg24,
+            x_enable_mask:             :arg29,
+            x_shift_direction:         :arg30,
+            x_shift_input:             :arg31,
+            y_enable_mask:             :arg36,
+            y_shift_direction:         :arg37,
+            y_shift_input:             :arg38,
+            dga:                       :arg39,
+            dgb:                       :arg40,
+            dgc:                       :arg41,
+            dgd:                       :arg42,
+            dg_enable_mask:            :arg43,
+            dg_shift_direction:        :arg44,
+            dg_shift_input:            :arg45,
+            x_coincidence_enable_mask: :arg46,
+            y_coincidence_enable_mask: :arg47,
+            two_bit_dg_setup:          :arg48,
+            x_scramble_algorithm:      :arg49,
+            y_scramble_algorithm:      :arg50,
+            topo_inversion_algorithm:  :arg51,
+            utility_counter_a:         :arg52,
+            utility_counter_b:         :arg53,
+            utility_counter_c:         :arg54,
+            dut_data_source:           :arg55,
+            scramble_addr:             :arg56,
+            speed_mode:                :arg57,
+            resource_map:              :arg58,
+            receive_data:              :arg59,
+            data_to_capture:           :arg60,
+            capture_marker:            :arg61,
+            enable_wrapping:           :arg62,
+            capture_scrambled_address: :arg63,
+            mapmem_0_input_set:        :arg64,
+            mapmem_1_input_set:        :arg65,
+            threading:                 :arg69,
+            match_all_sites:           :arg70
+          }
+
+        }
+
+        # Make readers for each low level attribute
+        ATTRS.each do |attr|
+          attr_reader attr
+        end
+
+        # And the aliases
+        ALIASES.each do |_alias, attr|
+          define_method("#{_alias}") do
+            send(attr)
+          end
+        end
+
+        def initialize(line, options = {})
+          @parser = options[:parser]
+          @line = line
+          parse
+          if valid?
+            ATTRS.each_with_index do |attr, i|
+              instance_variable_set("@#{attr}", components[i + 1])
+            end
+            if ALIASES[type]
+              ALIASES[type].each do |_alias, attr|
+                define_singleton_method("#{_alias}") do
+                  send(attr)
+                end
+              end
+            end
+          end
+        end
+
+        def inspect  # :nodoc:
+          "<TestInstance: #{name}, Type: #{type}>"
+        end
+
+        def description
+          parser.descriptions.test_instance(name: name)
+        end
+
+        def type
+          TYPE_ALIASES[proc_name.downcase.to_sym] || :unsupported
+        end
+
+        def parse
+          @components = @line.split("\t") unless @line.strip.empty?
+        end
+
+        def valid?
+          components[4] && ['Excel Macro', 'VB DLL'].include?(components[4])
+        end
+
+        def components
+          @components ||= []
+        end
+
+        # Returns an array of all pattern names referenced in this test instance
+        def patterns
+          if self.respond_to?(:pattern)
+            pattern.split(',').map do |pat|
+              extract_pattern_from_patset(pat)
+            end.flatten.map { |pat| pat.gsub(/.*[\\\/]/, '').gsub(/\..*/, '') }
+          end
+        end
+
+        def extract_pattern_from_patset(patset)
+          pset = parser.pattern_sets.where(name: patset, exact: true)
+          if pset.size > 1
+            puts "Warning multiple pattern sets called #{patset} found, using the first one"
+          end
+          if pset.size == 0
+            patset
+          else
+            pset.first.pattern_names
+          end
+        end
+
+        def vdd
+          parser.dc_specs.where(name: 'VDD', exact: true).first.lookup(dc_category, dc_selector)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/parser/test_instances.rb

@@ -0,0 +1,24 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class TestInstances < ::OrigenTesters::Parser::SearchableHash
+        attr_accessor :parser
+
+        def initialize(options = {})
+          @parser = options[:parser]
+        end
+
+        def import(file)
+          File.readlines(file).each do |line|
+            l = TestInstance.new(line, parser: parser)
+            self[l.name] = l if l.valid?
+          end
+        end
+
+        def inspect
+          "<TestInstances: #{size}>"
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/parser/timeset.rb

@@ -0,0 +1,13 @@
+module OrigenTesters
+  class IGXLBasedTester
+    class Parser
+      class Timeset
+        attr_accessor :parser
+
+        def initialize(options = {})
+          @parser = options[:parser]
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/ultraflex.rb

@@ -0,0 +1,477 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class UltraFLEX < Base
+      autoload :Generator,   'origen_testers/igxl_based_tester/ultraflex/generator.rb'
+
+      # Tester model to generate .atp patterns for the Teradyne UltraFLEX
+      #
+      # == Basic Usage
+      #   $tester = Testers::UltraFLEX.new
+      #   $tester.cycle       # Generate a vector
+      #
+      # Many more methods exist to generate UltraFLEX specific micro-code, see below for
+      # details.
+      #
+      # Also note that this class inherits from the base IGXLBasedTester class and so all methods
+      # described there are also available.
+
+      # Returns a new UltraFLEX instance, normally there would only ever be one of these
+      # assigned to the global variable such as $tester by your target.
+      def initialize
+        super
+        @pipeline_depth = 255  # for single mode
+        @software_version = '8.10.10'
+        @name = 'ultraflex'
+        @opcode_mode = :single   # there is also :dual
+        @counter_lsb_bits = 16   # individual counter bit length
+        @counter_msb_bits = 12   # temporary register commonly used to extend all counters
+
+        @flags = %w(cpuA_cond cpuB_cond cpuC_cond cpuD_cond)
+        @microcode[:enable] = 'branch_expr ='
+        @microcode[:set_flag] = 'set_cpu_cond'
+        @microcode[:mask_vector] = 'mask'
+
+        # Min required for a VM module-- not for SRM modules
+        # this handled in pattern_header below
+        @min_pattern_vectors = (@opcode_mode == :single) ? 64 : 128
+
+        @digital_instrument = 'hsdm' # 'hsdm' for HSD1000 and UP800, ok with UP1600 though
+
+        @capture_state = 'V'            # STV requires valid 'V' expect data
+      end
+
+      def freq_count(pin, options = {})
+        fail 'Method freq_count not yet supported for UltraFLEX!'
+      end
+
+      def memory_test(options = {})
+        options = {
+          gen_vector:          true,                 # Default generate vector not just MTO opcode
+          init_counter_x:      false,            # initialize counter X
+          inc_counter_x:       false,             # increment counter X
+          init_counter_y:      false,            # initialize counter X
+          inc_counter_y:       false,             # increment counter X
+          capture_vector:      false,            # capture vector to memory using all mem types
+          capture_vector_mem0: false,       # capture vector to memory type 0, here for J750 will be stv_m0
+          capture_vector_mem1: false,       # capture vector to memory type 1, here for J750 will be stv_m1
+          capture_vector_mem2: false,       # capture vector to memory type 2, here for J750 will be stv_c
+          pin:                 false,                       # pin on which to drive or expect data, pass pin object here!
+          pin_data:            false,                  # pin data (:none, :drive, :expect)
+          use_dgen_group:      false,
+          set_msb:             false
+        }.merge(options)
+
+        mto_opcode = ''
+
+        if options[:init_counter_x]
+          mto_opcode += ' xenable_load jam_reg xa jam_reg'
+        end
+
+        if options[:init_counter_y]
+          mto_opcode += ' yenable_load jam_reg ya jam_reg'
+        end
+
+        if options[:inc_counter_x]
+          mto_opcode += ' xa inc'
+        end
+
+        if options[:inc_counter_y]
+          mto_opcode += ' ya inc'
+        end
+
+        if options[:use_dgen_group]
+          mto_opcode += ' dgroup 0'
+        end
+
+        if options[:set_msb]
+          microcode 'set_msb 1'
+        end
+
+        unless mto_opcode.eql?('')
+          mto_opcode = '(mto =' + mto_opcode + ')'
+        end
+
+        if options[:pin_data] == :expect
+          mto_opcode = 'stv'
+        end
+
+        if options[:gen_vector]
+          if options[:pin]
+            case options[:pin_data]
+              when :drive
+                # store current pin state
+                cur_pin_state = options[:pin].state.to_sym
+                options[:pin].drive_mem
+              when :expect
+                # store current pin state
+                cur_pin_state = options[:pin].state.to_sym
+                options[:pin].expect_mem
+            end
+          end
+          cycle(microcode: "#{mto_opcode}", dont_compress: false)
+          if options[:pin]
+            # restore previous pin state
+            case options[:pin_data]
+              when :drive
+                options[:pin].state = cur_pin_state
+              when :expect
+                options[:pin].state = cur_pin_state
+            end
+          end
+        else
+          microcode "#{mto_opcode}"
+        end
+      end
+
+      def call_match
+        fail 'Method call_match not yet supported for UltraFLEX!'
+      end
+
+      def set_code(code)
+        Origen.log.warning 'Method set_code not supported for UltraFLEX! Find alternative solution.'
+        cc '*** WARNING! *** Method set_code not supported for UltraFLEX! Find alternative solution.'
+      end
+
+      def loop_vectors(name, number_of_loops, global = false, label_first = false)
+        if number_of_loops > 1
+          @loop_counters ||= {}
+          if @loop_counters[name]
+            @loop_counters[name] += 1
+          else
+            @loop_counters[name] = 0
+          end
+          loop_name = @loop_counters[name] == 0 ? name : "#{name}_#{@loop_counters[name]}"
+          if label_first
+            global_opt = (global) ? 'global ' : ''
+            microcode "#{global_opt}#{loop_name}: "
+          end
+
+          if "#{loop_name}" == 'row_loop'
+            cycle(microcode: 'loop c0')
+          elsif "#{loop_name}" == 'quad_loop'
+            cycle(microcode: 'loop c1')
+          elsif "#{loop_name}" == 'page_loop_red'
+            cycle(microcode: 'loop c2')
+          elsif "#{loop_name}" == 'page_loop_ecc'
+            cycle(microcode: 'loop c3')
+          elsif "#{loop_name}" == 'page_loop_data'
+            cycle(microcode: 'loop c4')
+          end
+
+          unless label_first
+            global_opt = (global) ? 'global ' : ''
+            cycle(microcode: "#{global_opt}#{loop_name}: ")
+          end
+          yield
+          cycle(microcode: "end_loop #{loop_name}")
+        else
+          yield
+        end
+      end
+
+      alias_method :loop_vector, :loop_vectors
+
+      def pattern_header(options = {})
+        options = {
+          instruments: {}
+        }.merge(options)
+
+        case $tester.vector_group_size
+        when 1
+          @opcode_mode = :single
+        when 2
+          @opcode_mode = :dual
+        when 4
+          @opcode_mode = :quad
+        end
+
+        options[:memory_test] = memory_test_en
+        options[:dc_pins] = get_dc_instr_pins
+
+        if options[:dc_pins]
+          options[:dc_pins].each do |pin|
+            options[:instruments].merge!(pin => 'DCVS')
+          end
+        end
+
+        # If memory test, then add to instruments hash
+        if options[:memory_test]
+          options[:instruments].merge!('mto' => 'nil')
+        end
+
+        super(options.merge(digital_inst: @digital_instrument,
+                            memory_test:  false,
+                            high_voltage: false,
+                            svm_only:     false
+                           )) do |pin_list|
+          microcode "#{options[:subroutine_pat] ? 'srm_vector' : 'vm_vector'}"
+          microcode "#{options[:pattern]} ($tset, #{pin_list})"
+          microcode '{'
+          # override min vector limit if subroutine pattern
+          @min_pattern_vectors = 0 if options[:subroutine_pat]
+          unless options[:subroutine_pat]
+            microcode "start_label #{options[:pattern]}_st:"
+          end
+        end
+      end
+
+      def pattern_footer(options = {})
+        super(options.merge(end_module: false))
+      end
+
+      # Generates a match loop based on vector condition passed in via block
+      #
+      # This method is not really intended to be called directly, rather you should call
+      # via Tester#wait:
+      #      e.g. $tester.wait(:match => true) do
+      #             reg(:status_reg).bit(:done).read(1)!  # vector condition that you want to match
+      #           end
+      #
+      # The timeout should be provided in cycles, however when called via the wait method the
+      # time-based helpers (time_in_us, etc) will be converted to cycles for you.
+      #
+      # The following options are available to tailor the match loop behavior, defaults in
+      # parenthesis:
+      # * :force_fail_on_timeout (true) - Force a vector mis-compare if the match loop times out
+      # * :on_timeout_goto ("") - Optionally supply a label to branch to on timeout, by default will continue from the end of the match loop
+      # * :on_block_match_goto ("") - Optionally supply a label to branch to when block condition is met, by default will continue from the end of the match loop
+      # * :multiple_entries (false) - Supply an integer to generate multiple entries into the match (each with a unique readcode), this can be useful when debugging patterns with multiple matches
+      # * :force_fail_on_timeout (true) - force pattern to fail if timeout occurs
+      # * :global_loops (false) - whether match loop loops should use global labels
+      # * :manual_stop (false) - whether to use extra cpuB flag to resolve IG-XL v.3.50.xx bug where VBT clears cpuA immediately
+      #                          at start of PatFlagFunc instead of at end.  Use will have to manually clear cpuB to resume this pattern.
+      # ==== Examples
+      #   $tester.wait(:match => true, :time_in_us => 5000, :pin => $top.pin(:done), :state => :high) do
+      #     <vectors>
+      #   end
+      def match_block(timeout, options = {}, &block)
+        options = {
+          check_for_fails:       false,
+          on_timeout_goto:       false,
+          on_block_match_goto:   false,
+          multiple_entries:      false,
+          force_fail_on_timeout: true,
+          global_loops:          false,
+          manual_stop:           false,
+          clr_fail_post_match:   false
+        }.merge(options)
+
+        unless block_given?
+          fail 'ERROR: block not passed to match_block!'
+        end
+
+        if options[:check_for_fails]
+          cc 'NOTE: check for fails prior to match loop not necessary on UltraFlex'
+        end
+
+        ss 'WARNING: MATCH LOOP FOR ULTRAFLEX STILL UNDER DEVELOPMENT'
+
+        # Create BlockArgs objects in order to receive multiple blocks
+        match_conditions = Origen::Utility::BlockArgs.new
+        fail_conditions = Origen::Utility::BlockArgs.new
+
+        # yield object to calling routine to get populated with blocks
+        if block.arity > 0
+          yield match_conditions, fail_conditions
+        else
+          # for backwards compatibility with Origen core call to match_block
+          match_conditions.add(&block)
+          fail_conditions.add(&block)
+        end
+
+        # Now do the main match loop
+        cc 'Start the match loop'
+
+        cycle # (:microcode => "set_msb #{counter_msb}")  # set_msb microcode will be set below after counting match loop cycles
+        set_msb_vector = last_vector # remember the vector with set_msb opcode
+
+        cycle(microcode: 'branch_expr = (fail)')
+
+        global_opt = (options[:global_loops]) ? 'global ' : ''
+        microcode "#{global_opt}match_loop_#{@unique_counter}:"
+
+        cycle # (:microcode => "set c0 #{counter_lsb}")
+        set_c0_vector = last_vector # remember the vector with set_c0 opcode
+
+        microcode "match_result_loop_#{@unique_counter}:"
+        cycle(microcode: 'loop c0')
+
+        # count cycles in match loop block passed to help with meeting
+        # desired timeout value (have to back assign microcodes above)
+        prematch_cycle_count = cycle_count
+        match_conditions.each_with_index do |condition, i|
+          mask_fails(true)
+          condition.call # match condition
+          mask_fails(false)
+
+          cc ' Wait for the result to propagate through the pipeline'
+          cycle(microcode: 'pipe_minus 1')
+          inc_cycle_count(@pipeline_depth - 1)              # Account for pipeline depth
+          cc "Branch if block condition #{i} not yet met"
+          cycle(microcode: "if (branch_expr) jump block_#{i}_notyet_matched_#{@unique_counter}")
+          cc 'Match found'
+          cycle(microcode: 'pop_loop')
+          cycle(microcode: 'return') # DH ONLY IF SUBROUTINE!!
+          cc 'Match not yet found'
+          cycle(microcode: "block_#{i}_notyet_matched_#{@unique_counter}:")
+        end
+
+        match_conditions_cycle_count = cycle_count - prematch_cycle_count
+        cc "Match loop cycle count = #{match_conditions_cycle_count}"
+
+        # reduce timeout requested by match loop cycle count
+        timeout = (timeout.to_f / match_conditions_cycle_count).ceil
+
+        # Calculate the counter values appropriately hit the timeout requested
+        match_delay_cycles = false
+
+        # Determine full value of counter0
+        counter_value = timeout.to_f.floor
+
+        if counter_value < (2**@counter_lsb_bits)
+          # small value, don't need msb temp register
+          counter_msb = 1
+          counter_lsb = counter_value
+        elsif counter_value < (2**(@counter_lsb_bits + @counter_msb_bits))
+          # larger value, but smaller than counter maximum
+          counter_msb = counter_value   # set MSB (lowest LSB bits get ignored)
+          counter_lsb = counter_value & (2**@counter_lsb_bits - 1) # set LSB
+        elsif counter_value < (2**(@counter_lsb_bits + @counter_msb_bits)) * @max_repeat_loop
+          # larger value, greater than counter, so add time delay per instance of loop to avoid using second counter
+          match_delay_cycles = (counter_value.to_f / (2**(@counter_lsb_bits + @counter_msb_bits))).ceil
+          counter_msb = (counter_value / match_delay_cycles).floor   # set MSB (lowest LSB bits get ignored)
+          counter_lsb = counter_msb & (2**@counter_lsb_bits - 1) # set LSB
+        else
+          abort 'ERROR: timeout value too large in tester match method!'
+        end
+
+        # retroactively modify the counters based on cycles in match loop conditions
+        set_msb_vector.microcode = "set_msb #{counter_msb}"
+        set_c0_vector.microcode = "set c0 #{counter_lsb}"
+
+        if match_delay_cycles
+          cc 'Delay to meet timeout value'
+          cycle(repeat: match_delay_cycles) if match_delay_cycles
+        end
+
+        cycle(microcode: "end_loop match_result_loop_#{@unique_counter}")
+
+        if options[:force_fail_on_timeout]
+          cc 'To get here something has gone wrong, check blocks again to force a pattern failure'
+          fail_conditions.each do |condition|
+            cycle(microcode: 'pipe_minus 1')
+            condition.call
+          end
+        end
+
+        @unique_counter += 1  # Increment so a different label will be applied if another
+        # handshake is called in the same pattern
+      end
+
+      # Handshake with the tester.
+      #
+      # Will set a cpu flag (A) and wait for it to be cleared by the tester, optionally
+      # pass in a read code to pass information to the tester.
+      #
+      # ==== Examples
+      #   $tester.handshake                   # Pass control to the tester for a measurement
+      #   $tester.handshake(:readcode => 10)  # Trigger a specific action by the tester
+      def handshake(options = {})
+        options = {
+          readcode:    false,
+          manual_stop: false,    # set a 2nd CPU flag in case 1st flag is automatically cleared
+        }.merge(options)
+        if options[:readcode]
+          set_code(options[:readcode])
+        end
+        if options[:manual_stop]
+          cycle(microcode: "#{@microcode[:enable]} (#{@flags[1]})")
+          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]} #{@flags[1]})")
+        else
+          cycle(microcode: "#{@microcode[:enable]} (#{@flags[0]})")
+          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]})")
+        end
+        cycle(microcode: "loop_here_#{@unique_counter}: if (branch_expr) jump loop_here_#{@unique_counter}")
+
+        @unique_counter += 1  # Increment so a different label will be applied if another
+        # handshake is called in the same pattern
+      end
+
+      # Capture a vector to the tester HRAM.
+      #
+      # This method applys a store vector (stv) opcode to the previous vector, note that is does
+      # not actually generate a new vector.
+      #
+      # Sometimes when generating vectors within a loop you may want to apply a stv opcode
+      # retrospectively to a previous vector, passing in an offset option will allow you
+      # to do this.
+      #
+      # On J750 the pins argument is ignored since the tester only supports whole vector capture.
+      #
+      # @example
+      #   $tester.cycle                # This is the vector you want to capture
+      #   $tester.store                # This applys the STV opcode
+      #
+      #   $tester.cycle                # This one gets stored
+      #   $tester.cycle
+      #   $tester.cycle
+      #   $tester.store(:offset => -2) # Just realized I need to capture that earlier vector
+      def store(*pins)
+        options = pins.last.is_a?(Hash) ? pins.pop : {}
+        options = { offset: 0
+                  }.merge(options)
+        pins = pins.flatten.compact
+        if pins.empty?
+          fail 'For the UltraFLEX you must supply the pins to store/capture'
+        end
+        pins.each do |pin|
+          pin.restore_state do
+            pin.capture
+            update_vector microcode: 'stv', offset: options[:offset]
+            update_vector_pin_val pin, microcode: 'stv', offset: options[:offset]
+            last_vector(options[:offset]).dont_compress = true
+          end
+        end
+      end
+      alias_method :to_hram, :store
+      alias_method :capture, :store
+
+      def reload_counters(name)
+        microcode "reload #{name}"
+      end
+
+      def set_msb(name)
+        microcode "set_msb #{name}"
+      end
+
+      # Capture the next vector generated to HRAM
+      #
+      # This method applies a store vector (stv) opcode to the next vector to be generated,
+      # note that is does not actually generate a new vector.
+      #
+      # pin argument must be provided so that 'V' (valid) state can be applied to the pin
+      # if not already.
+      #
+      # @example
+      #   $tester.store_next_cycle
+      #   $tester.cycle                # This is the vector that will be captured
+      def store_next_cycle(*pins)
+        options = pins.last.is_a?(Hash) ? pins.pop : {}
+        options = {
+        }.merge(options)
+        pins = pins.flatten.compact
+        if pins.empty?
+          fail 'For the UltraFLEX you must supply the pins to store/capture'
+        end
+        pins.each { |pin| pin.save; pin.capture }
+        # Register this clean up function to be run after the next vector
+        # is generated (SMcG: cool or what! DH: Yes, very cool!)
+        preset_next_vector(microcode: 'stv') do
+          pins.each(&:restore)
+        end
+      end
+      alias_method :store!, :store_next_cycle
+    end
+  end
+  UltraFLEX = IGXLBasedTester::UltraFLEX
+end