Module: OrigenTesters::VectorGenerator

Extended by:
ActiveSupport::Concern
Defined in:
lib/origen_testers/vector_generator.rb

Instance Method Summary collapse

Instance Method Details

#_render(method) ⇒ Object

:nodoc:



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/origen_testers/vector_generator.rb', line 169

def _render(method)  # :nodoc:
  if respond_to?(method)
    template = send(method)
    # Record the current file, this can be used to resolve any relative path
    # references in the file about to be compiled
    Origen.file_handler.current_file = template
    # Ran into crosstalk problems when rendering ERB templates recursively, setting eoutvar based
    # on the name of the file will causes each template to be rendered into its own 'bank'.
    # Not sure why the final gsub is needed but seems to fail to parse correctly otherwise.
    eoutvar = Pathname.new(template).basename('.*').basename('.*').to_s.gsub('-', '_')
    # Make the file name available to the template
    Origen.generator.compiler.options[:file] = template
    push_microcode Origen.generator.compiler.insert(ERB.new(File.read(template.to_s), trim_mode: Origen.config.erb_trim_mode, eoutvar: eoutvar).result)
  end
end

#add_microcode_to_last_or_cycle(code) ⇒ Object

Adds the given microcode to the last vector if possible. If not possible (meaning the vector already contains microcode) then a new cycle will be added with the given microcode.



272
273
274
275
 
# File 'lib/origen_testers/vector_generator.rb', line 272

def add_microcode_to_last_or_cycle(code)
  cycle if !stage.last_vector || stage.last_vector.has_microcode?
  stage.last_vector.update(microcode: code)
end

#align ⇒ Object Also known as: align_to_first

Duplicate the last vector as required until aligned with the start of the next vector group



40
41
42
 
# File 'lib/origen_testers/vector_generator.rb', line 40

def align
  stage.store :align
end

#align_to_last ⇒ Object

Duplicate the last vector as required until aligned to the last vector of the current vector group



47
48
49
 
# File 'lib/origen_testers/vector_generator.rb', line 47

def align_to_last
  stage.store :align_last
end

#before_write_pattern_line(line) ⇒ Object

Tester models can overwrite this if they wish to inject any additional pattern lines at final pattern dump time



319
320
321
 
# File 'lib/origen_testers/vector_generator.rb', line 319

def before_write_pattern_line(line)
  [line]
end

#current_pin_vals ⇒ Object 



542
543
544
 
# File 'lib/origen_testers/vector_generator.rb', line 542

def current_pin_vals
  ordered_pins_cache.map(&:to_vector).join(' ')
end

#cycle_count ⇒ Object

Returns the current cycle count



75
76
77
 
# File 'lib/origen_testers/vector_generator.rb', line 75

def cycle_count
  @cycle_count ||= 0
end

#dec_vec_count(num = 1) ⇒ Object

decrement vector count



69
70
71
72
 
# File 'lib/origen_testers/vector_generator.rb', line 69

def dec_vec_count(num = 1)
  vec_count if @vec_count.nil?  # define if not already
  @vec_count = @vec_count - num
end

#dont_compress ⇒ Object 



327
328
329
330
331
332
333
334
335
336
 
# File 'lib/origen_testers/vector_generator.rb', line 327

def dont_compress
  if block_given?
    orig = @dont_compress
    @dont_compress = true
    yield
    @dont_compress = orig
  else
    @dont_compress
  end
end

#dont_compress=(val) ⇒ Object 



338
339
340
 
# File 'lib/origen_testers/vector_generator.rb', line 338

def dont_compress=(val)
  @dont_compress = val
end

#execution_time_in_ns ⇒ Object

Returns the current execution time



80
81
82
 
# File 'lib/origen_testers/vector_generator.rb', line 80

def execution_time_in_ns
  @execution_time_in_ns ||= 0
end

#expand_vector(vec) ⇒ Object

expands (un-compresses to pattern) vector if desired or leaves it as is allows for tracking and formatting of vector if comment then return without modification



345
346
347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/origen_testers/vector_generator.rb', line 345

def expand_vector(vec)
  if vec.is_a?(Vector)
    if expand_repeats
      vec.repeat.times do
        vec.repeat = 1
        yield track_and_format_vector(vec)
      end
    else
      yield track_and_format_vector(vec)
    end
  else
    yield track_and_format_comment(vec)  # Return comments without modification
  end
end

#format(vector_array, section) ⇒ Object

Final pass of a generator vector array which returns lines suitable for writing to the output file. This gives the tester model a chance to concatenate repeats and any other last optimization/formatting changes it wishes to make.

At this point vector array contains a combination of non-vector lines and uncompressed Vector objects (vector lines)



284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
 
# File 'lib/origen_testers/vector_generator.rb', line 284

def format(vector_array, section)
  tester_writing_pattern = respond_to?(:open_and_write_pattern)
  # Go through vector_array and print out both
  # vectors and non-vectors to pattern (via 'yield line')
  vector_array.each do |vec|
    # skip here important for the ways delays are currently handled
    # TODO: This seems like an upstream bug that should be investigated, why is such
    # a vector even generated?
    if vec.is_a?(String)
      if vec.strip[0] == comment_char
        pipeline.push_comment(vec)
      else
        pipeline.push_microcode(vec)
      end
    else
      next if vec.respond_to?(:repeat) && vec.repeat == 0 # skip vectors with repeat of 0!

      pipeline << vec
    end
    pipeline.flush do |vector|
      expand_vector(vector) do |line|
        yield line unless tester_writing_pattern
      end
    end
  end
  # now flush buffer if there is still a vector
  pipeline.empty(min_vectors: section == :footer ? @min_pattern_vectors : nil) do |vector|
    expand_vector(vector) do |line|
      yield line unless tester_writing_pattern
    end
  end
end

#format_pin_state(pin) ⇒ Object

See Also:

  • Origen::Pins::Pin#to_vector


640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
 
# File 'lib/origen_testers/vector_generator.rb', line 640

def format_pin_state(pin)
  if pin.repeat_previous? && @support_repeat_previous
    @repeat_previous || '-'
  elsif pin.driving?
    if pin.value == 1
      if pin.high_voltage?
        @drive_very_hi_state || '2'
      else
        @drive_hi_state || '1'
      end
    else
      @drive_lo_state || '0'
    end
  elsif pin.comparing_midband?
    @expect_mid_state || 'M'
  elsif pin.comparing?
    if pin.value == 1
      @expect_hi_state || 'H'
    else
      @expect_lo_state || 'L'
    end
  elsif pin.driving_mem?
    @drive_mem_state || 'D'
  elsif pin.comparing_mem?
    @expect_mem_state || 'E'
  elsif pin.to_be_captured?
    @capture_state || 'C'
  else
    @dont_care_state || 'X'
  end
end

#format_vector(vec) ⇒ Object 



388
389
 
# File 'lib/origen_testers/vector_generator.rb', line 388

def format_vector(vec)
end

#get_pingroup(pin) ⇒ Object 



604
605
606
607
608
609
 
# File 'lib/origen_testers/vector_generator.rb', line 604

def get_pingroup(pin)
  pingroup_map.each do |id, pins|
    return id if pins.include? pin
  end
  nil
end

#inc_cycle_count(num = 1, options = {}) ⇒ Object

increment cycle count



85
86
87
88
89
90
91
 
# File 'lib/origen_testers/vector_generator.rb', line 85

def inc_cycle_count(num = 1, options = {})
  num, options = 1, num if num.is_a?(Hash)
  cycle_count if @cycle_count.nil? # define if not already
  execution_time_in_ns if @execution_time_in_ns.nil? # define if not already
  @execution_time_in_ns += num * (options[:period_in_ns] || tester.timeset.period_in_ns)
  @cycle_count = @cycle_count + num
end

#inc_vec_count(num = 1) ⇒ Object

increment vector count



63
64
65
66
 
# File 'lib/origen_testers/vector_generator.rb', line 63

def inc_vec_count(num = 1)
  vec_count if @vec_count.nil?  # define if not already
  @vec_count = @vec_count + num
end

#inhibit_pin(*pins) ⇒ Object Also known as: inhibit_pins

Call to prevent the given pins from appearing in the generated vectors.

This is a convenient way to inhibit something like a J750 mux pin from appearing in the patterns when generating the pattern for a different platform.

When used this method must be called before the first vector is generated - it will not be retrospectively applied to existing vectors.



109
110
111
112
113
114
115
116
117
 
# File 'lib/origen_testers/vector_generator.rb', line 109

def inhibit_pin(*pins)
  pins.each do |pin|
    pin = $dut.pin(pin) if pin.is_a?(Symbol)
    inhibited_pins << pin
  end
  inhibited_pins.uniq!
  inhibited_pins.compact!
  inhibited_pins
end

#inhibited_pins ⇒ Object

Returns an array of pin IDs that are currently inhibited (will not be included when vectors are generated)



53
54
55
 
# File 'lib/origen_testers/vector_generator.rb', line 53

def inhibited_pins
  @inhibited_pins ||= []
end

#last_object(offset = 0) ⇒ Object 



209
210
211
 
# File 'lib/origen_testers/vector_generator.rb', line 209

def last_object(offset = 0)
  stage.last_object(offset)
end

#last_vector(offset = 0) ⇒ Object 



205
206
207
 
# File 'lib/origen_testers/vector_generator.rb', line 205

def last_vector(offset = 0)
  stage.last_vector(offset)
end

#microcode(code, options = {}) ⇒ Object Also known as: push_microcode 



194
195
196
197
198
199
200
201
202
 
# File 'lib/origen_testers/vector_generator.rb', line 194

def microcode(code, options = {})
  unless @inhibit_vectors
    if options[:offset] && options[:offset] != 0
      stage.insert_from_end code, options[:offset]
    else
      stage.store code
    end
  end
end

#ordered_pins(options = {}) ⇒ Object 



410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
 
# File 'lib/origen_testers/vector_generator.rb', line 410

def ordered_pins(options = {})
  options = {
    include_inhibited_pins: false,
    include_pingroups:      true
  }.merge(options)

  result = nil

  Origen.profile 'Working out pin pattern order' do
    pinorder = Origen.app.pin_pattern_order.dup
    pinexclude = Origen.app.pin_pattern_exclude.dup

    if Origen.app.pin_pattern_order.last.is_a?(Hash)
      options.merge!(pinorder.pop)
    end
    if Origen.app.pin_pattern_exclude.last.is_a?(Hash)
      options.merge!(pinexclude.pop)
    end

    ordered_pins = []

    # Create a copy of all pins and groups to be output, pins/groups will be delete from here as
    # they are output, so that at the end of the user defined pin order what is left in here can
    # either be discarded or output at the end
    pins = Origen.pin_bank.pins.dup
    pingroups = Origen.pin_bank.pin_groups.dup

    if pinorder && pinorder.size > 0
      pinorder.each do |id|
        # If the ID refers to a pin group
        if group = Origen.pin_bank.pin_groups[id]
          # If the group has still to be output just do that now
          if pingroups.include? group.id
            ordered_pins << group
            # Now delete the group from the list of groups still to be output and all of its pins
            # from the list pins still to be output
            group.each do |pin|
              pins.delete(pin.id)
              pin.groups.each do |name, _group|
                pingroups.delete(name)
              end
            end
            pingroups.delete(group.id)
          # To get here the some of the pins in the group have already been output which is preventing
          # output of the complete group at this point, in that case output any of its pins that have
          # still to go
          else
            group.each do |pin|
              if pins.include? pin.id
                ordered_pins << pin
                pin.groups.each do |name, _group|
                  pingroups.delete(name)
                end
              end
            end
          end
        # this is a pin
        else
          pin = Origen.pin_bank.find(id)
          fail "Undefined pin (#{id}) added to pin_pattern_order" unless pin

          ordered_pins << pin
          pin.groups.each do |name, _group|
            pingroups.delete(name)
          end
          pin.name = id
          pins.delete(pin.id)
        end
      end
    end

    if pinexclude && pinexclude.size > 0
      pinexclude.each do |id|
        if group = Origen.pin_bank.pin_groups[id]
          # see if group is already in ordered_pins
          fail "Pin group #{id} is defined both in pin_pattern_order and pin_pattern_exclude" unless pingroups.include? id

          # this is a pin group, delete all pins in group
          pingroups.delete(id)
          group.each do |pin|
            fail "Pin (#{pin.name}) in group (#{group.id}) is defined both in pin_pattern_order and pin_pattern_exclude" unless pins.include? pin.id

            pins.delete(pin.id)
          end
        else # this is a pin, delete the pin
          pin = Origen.pin_bank.find(id)
          fail "Undefined pin (#{id}) added to pin_pattern_exclude" unless pin
          fail "Pin #{pin.name} is defined both in pin_pattern_order and pin_pattern_exclude" unless pins.include? pin.id

          pin.name = id
          pins.delete(pin.id)
          pin.groups.each do |name, _group|
            pingroups.delete(name)
          end
        end
      end
    end

    unless options[:only]
      # all the rest of the pins to the end of the pattern order
      pins.each do |_id, pin|
        # check for port
        if pin.belongs_to_a_pin_group?
          # Are any of this pin's groups still waiting to be output? pingroups at this point contains
          # those groups which have not been rendered yet
          group = pingroups.find do |_id, group|
            pin.groups.any? { |_pid, pgroup| group == pgroup }
          end
          if group
            ordered_pins << group[1]
            group[1].each { |pin| pins.delete(pin.id) }
          else
            ordered_pins << pin
          end
        else
          ordered_pins << pin
        end
      end
    end

    result = ordered_pins.map do |pin|
      if options[:include_inhibited_pins]
        pin
      else
        inhibited_pins.include?(pin) ? nil : pin
      end
    end
    result = result.compact
  end
  result
end

#ordered_pins_cache(options = {}) ⇒ Object

Cache any pin ordering for later use since all vectors should be formatted the same



396
397
398
 
# File 'lib/origen_testers/vector_generator.rb', line 396

def ordered_pins_cache(options = {})
  @ordered_pins_cache ||= ordered_pins(options)
end

#ordered_pins_name ⇒ Object

Retrieve optional ‘name’ meta passed in with the pin_pattern_order call



401
402
403
404
405
406
407
408
 
# File 'lib/origen_testers/vector_generator.rb', line 401

def ordered_pins_name
  pinorder = Origen.app.pin_pattern_order.dup
  if Origen.app.pin_pattern_order.last.is_a?(Hash)
    options = pinorder.pop
    name = options[:name]
  end
  name
end

#pingroup_map ⇒ Object 



391
392
393
 
# File 'lib/origen_testers/vector_generator.rb', line 391

def pingroup_map
  Origen.app.pingroup_map
end

#pipeline ⇒ Object 



323
324
325
 
# File 'lib/origen_testers/vector_generator.rb', line 323

def pipeline
  @pipeline ||= VectorPipeline.new(vector_group_size)
end

#preset_next_vector(attrs = {}, &block) ⇒ Object

Allows the attributes for the next vector to be setup prior to generating it.

A block can be optionally supplied to act as a clean up method, that is the block will be saved and executed after the next cycle has been generated.

See the V93K store_next_cycle method for an example of using this.



222
223
224
225
 
# File 'lib/origen_testers/vector_generator.rb', line 222

def preset_next_vector(attrs = {}, &block)
  @preset_next_vector = attrs
  @preset_next_vector_cleanup = block
end

#push_comment(msg) ⇒ Object 



189
190
191
192
 
# File 'lib/origen_testers/vector_generator.rb', line 189

def push_comment(msg)
  # Comments are stored verbatim for now, can't see much use for a dedicated comment object
  stage.store msg unless @inhibit_comments
end

#push_vector(attrs = {}) ⇒ Object Also known as: vector

Called by every $tester.cycle command to push a vector to the stage object



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/origen_testers/vector_generator.rb', line 228

def push_vector(attrs = {})
  attrs = {
    dont_compress: @dont_compress
  }.merge(attrs)
  unless @inhibit_vectors
    if @preset_next_vector
      attrs = @preset_next_vector.merge(attrs) do |key, preset, current|
        if preset && current && current != ''
          fail "Value for #{key} set by preset_next_vector clashed with the next vector!"
        else
          preset || current
        end
      end
      @preset_next_vector = nil
    end
    v = Vector.new(attrs)
    stage.store Vector.new(attrs)
    inc_vec_count
    inc_cycle_count(attrs[:repeat] || 1, period_in_ns: v.timeset.period_in_ns)
    if @preset_next_vector_cleanup
      @preset_next_vector_cleanup.call(v)
      @preset_next_vector_cleanup = nil
    end
  end
end

#regex_for_pin(pin) ⇒ Object

Returns a regular expression that can be used to get the value of the given pin within the string returned by current_pin_vals.

str = $tester.current_pin_vals                  # => "1 1 XX10 H X1"
regex = $tester.regex_for_pin($dut.pins(:jtag)) # => /\w{1} \w{1} (\w{4}) \w{1} \w{2}/
regex.match(str)
Regexp.last_match(1)   # => "XX10"

See Also:



554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
 
# File 'lib/origen_testers/vector_generator.rb', line 554

def regex_for_pin(pin)
  @regex_for_pins ||= {}
  # Cache this as potentially called many times during pattern generation
  @regex_for_pins[pin] ||= begin
    regex = '/'
    ordered_pins_cache.each do |p|
      if pin == p
        regex += "(\\w{#{p.size}}) "
      else
        regex += "\\w{#{p.size}} "
      end
    end
    eval(regex.strip + '/')
  end
end

#regex_for_pin_sub(pin) ⇒ Object

Returns a regular expression that can be used to change the value of the given pin within the string returned by current_pin_vals.

str = $tester.current_pin_vals                      # => "1 1 XX10 H X1"
regex = $tester.regex_for_pin_sub($dut.pins(:jtag)) # => /(\w{1} \w{1} )(\w{4})( \w{1} \w{2})/
str.sub(regex, '\1LLLL\3')  # => "1 1 LLLL H X1"

See Also:



577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
 
# File 'lib/origen_testers/vector_generator.rb', line 577

def regex_for_pin_sub(pin)
  @regex_for_pin_subs ||= {}
  # Cache this as potentially called many times during pattern generation
  @regex_for_pin_subs[pin] ||= begin
    regex = '/'
    first_pin_done = false
    match_pin_done = false
    ordered_pins_cache.each do |p|
      if pin == p
        regex += ')' if first_pin_done
        regex += "(\\w{#{p.size}})( "
      else
        regex += '(' unless first_pin_done
        regex += "\\w{#{p.size}} "
      end
      first_pin_done = true
    end
    regex.strip!
    if regex[-1] == '('
      regex.chop!
    else
      regex += ')'
    end
    eval(regex + '/')
  end
end

#remove_store_from_vector(vector) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



673
674
675
 
# File 'lib/origen_testers/vector_generator.rb', line 673

def remove_store_from_vector(vector)
  vector.pin_vals.sub!('C', 'X')
end

#render(template, options = {}) ⇒ Object

Render content directly into a pattern, any options will be passed to the template



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/origen_testers/vector_generator.rb', line 121

def render(template, options = {})
  # Record the current file, this can be used to resolve any relative path
  # references in the file about to be compiled
  Origen.file_handler.current_file = template
  # Ran into crosstalk problems when rendering ERB templates recursively, setting eoutvar based
  # on the name of the file will causes each template to be rendered into its own 'bank'.
  # Not sure why the final gsub is needed but seems to fail to parse correctly otherwise.
  eoutvar = Pathname.new(template).basename('.*').basename('.*').to_s.gsub('-', '_')
  # Make the file name available to the template
  Origen.generator.compiler.options[:file] = template
  options.each { |k, v| Origen.generator.compiler.options[k] = v }
  code = Origen.generator.compiler.insert(ERB.new(File.read(template.to_s), trim_mode: Origen.config.erb_trim_mode, eoutvar: eoutvar).result)
  code.strip!
  push_microcode code
end

#render_body ⇒ Object

Same as the render method, except the template method should be called body_template.



147
148
149
 
# File 'lib/origen_testers/vector_generator.rb', line 147

def render_body
  _render(:body_template)
end

#render_footer ⇒ Object

If the tester defines a method named footer_template this method will compile whatever template file is returned by that method.

This method is called automatically during the footer section of a Pattern.create operation.



156
157
158
 
# File 'lib/origen_testers/vector_generator.rb', line 156

def render_footer
  _render(:footer_template)
end

#render_header ⇒ Object

If the tester defines a method named header_template this method will compile whatever template file is returned by that method.

This method is called automatically during the header section of a Pattern.create operation.



165
166
167
 
# File 'lib/origen_testers/vector_generator.rb', line 165

def render_header
  _render(:header_template)
end

#render_template ⇒ Object

If the tester defines a method named template this method will compile whatever template file is returned by that method.

This method is called automatically after the body section of a Pattern.create operation has completed.



142
143
144
 
# File 'lib/origen_testers/vector_generator.rb', line 142

def render_template
  _render(:template)
end

#reset_cycle_count(num = 0) ⇒ Object

reset_cycle_count



94
95
96
97
98
 
# File 'lib/origen_testers/vector_generator.rb', line 94

def reset_cycle_count(num = 0)
  cycle_count if @cycle_count.nil? # define if not already
  @execution_time_in_ns = 0
  @cycle_count = num
end

#stage ⇒ Object 



185
186
187
 
# File 'lib/origen_testers/vector_generator.rb', line 185

def stage
  Origen.generator.stage
end

#track_and_format_comment(comment) ⇒ Object 



360
361
362
 
# File 'lib/origen_testers/vector_generator.rb', line 360

def track_and_format_comment(comment)
  comment
end

#track_and_format_vector(vec) ⇒ Object

Update tracking info (stats object) and allow for any additional formatting via format_vector method if overridden



367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'lib/origen_testers/vector_generator.rb', line 367

def track_and_format_vector(vec)
  unless vec.timeset
    puts 'No timeset defined!'
    puts 'Add one to your top level startup method or target like this:'
    puts '$tester.set_timeset("nvmbist", 40)   # Where 40 is the period in ns'
    exit 1
  end
  stats = Origen.app.stats
  stats.add_vector
  if vector_group_size > 1 && vec.repeat > 1
    stats.add_cycle(1)
    stats.add_cycle((vec.repeat - 1) * vector_group_size)
    stats.add_time_in_ns(vec.timeset.period_in_ns)
    stats.add_time_in_ns((vec.repeat - 1) * vector_group_size * vec.timeset.period_in_ns)
  else
    stats.add_cycle(vec.repeat)
    stats.add_time_in_ns(vec.repeat * vec.timeset.period_in_ns)
  end
  format_vector(vec)
end

#update_pin_from_formatted_state(pin, state) ⇒ Object 



611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
 
# File 'lib/origen_testers/vector_generator.rb', line 611

def update_pin_from_formatted_state(pin, state)
  if state == @repeat_previous || state == '-'
    pin.repeat_previous = true
  elsif state == @drive_very_hi_state || state == '2'
    pin.drive_very_hi
  elsif state == @drive_hi_state || state == '1'
    pin.drive_hi
  elsif state == @drive_lo_state || state == '0'
    pin.drive_lo
  elsif state == @expect_hi_state || state == 'H'
    pin.expect_hi
  elsif state == @expect_lo_state || state == 'L'
    pin.expect_lo
  elsif state == @expect_mid_state || state == 'M'
    pin.expect_mid
  elsif state == @drive_mem_state || state == 'D'
    pin.drive_mem
  elsif state == @expect_mem_state || state == 'E'
    pin.expect_mem
  elsif state == @capture_state || state == 'C'
    pin.capture
  elsif state == @dont_care_state || state == 'X'
    pin.dont_care
  else
    fail "Unknown pin state: #{state}"
  end
end

#update_vector(attrs = {}) ⇒ Object 



255
256
257
258
259
260
 
# File 'lib/origen_testers/vector_generator.rb', line 255

def update_vector(attrs = {})
  unless @inhibit_vectors
    offset = (attrs.delete(:offset) || 0).abs
    stage.last_vector(offset).update(attrs)
  end
end

#update_vector_pin_val(pin, options = {}) ⇒ Object 



262
263
264
265
266
267
 
# File 'lib/origen_testers/vector_generator.rb', line 262

def update_vector_pin_val(pin, options = {})
  unless @inhibit_vectors
    offset = (options.delete(:offset) || 0).abs
    stage.last_vector(offset).update_pin_val(pin)
  end
end

#vec_count ⇒ Object

init vector count when first accessed, otherwise return value



58
59
60
 
# File 'lib/origen_testers/vector_generator.rb', line 58

def vec_count
  @vec_count ||= 0
end

#vector_group_size ⇒ Object 



17
18
19
 
# File 'lib/origen_testers/vector_generator.rb', line 17

def vector_group_size
  @vector_group_size || 1
end

#vector_group_size=(number) ⇒ Object 



21
22
23
24
25
26
27
28
29
 
# File 'lib/origen_testers/vector_generator.rb', line 21

def vector_group_size=(number)
  if number > 1 && number.odd?
    fail 'Only even numbers can be supplied for the vector_group_size!'
  end

  # Each pattern should run with its own tester instance, but just in case
  @pipeline = nil
  @vector_group_size = number
end

#with_vector_group_size(number) ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/origen_testers/vector_generator.rb', line 31

def with_vector_group_size(number)
  orig = vector_group_size
  self.vector_group_size = number
  yield
  self.vector_group_size = orig
end