Module: Origen::Tester::API

Included in:
Origen::Tester
Defined in:
lib/origen/tester/api.rb

Overview

This module implements the basic set of methods that a tester must have in order for Origen to talk to it.

They can be overridden by tester specific classes and who may go on to add additional methods of their own.

Essentially this API means that any class that includes Origen::Tester will function as a tester, although it might not do very much!

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#comment_level ⇒ Object

Returns the value of attribute comment_level.



13
14
15
 
# File 'lib/origen/tester/api.rb', line 13

def comment_level
  @comment_level
end

#generating ⇒ Object

Returns the value of attribute generating.



14
15
16
 
# File 'lib/origen/tester/api.rb', line 14

def generating
  @generating
end

#includes ⇒ Object

Returns the value of attribute includes.



12
13
14
 
# File 'lib/origen/tester/api.rb', line 12

def includes
  @includes
end

#inhibit_comments ⇒ Object

See Also:



172
173
174
 
# File 'lib/origen/tester/api.rb', line 172

def inhibit_comments
  @inhibit_comments
end

#inhibit_vectors ⇒ Object

See Also:



164
165
166
 
# File 'lib/origen/tester/api.rb', line 164

def inhibit_vectors
  @inhibit_vectors
end

Instance Method Details

#annotate(_msg, _options = {}) ⇒ Object 



86
87
 
# File 'lib/origen/tester/api.rb', line 86

def annotate(_msg, _options = {})
end

#any_clocks_running? ⇒ Boolean

Returns:

  • (Boolean) 


220
221
222
 
# File 'lib/origen/tester/api.rb', line 220

def any_clocks_running?
  @clocks_running.nil? ? false : @clocks_running.count > 0
end

#c1(msg, _options = {}) ⇒ Object

Output a comment in the pattern, normally you would not call this directly and instead use these shorthand methods:

cc "Some comment"
ss "A single line step comment"
step_comment do
    cc "A multi line"
    cc "step comment"
end



106
107
108
109
110
 
# File 'lib/origen/tester/api.rb', line 106

def c1(msg, _options = {})
  prefix = comment_char + ' '
  prefix += step_comment_prefix + ' ' if @step_comment_on
  push_comment(prefix + msg.to_s)
end

#c2(msg, options = {}) ⇒ Object 



112
113
114
 
# File 'lib/origen/tester/api.rb', line 112

def c2(msg, options = {})
  c1(msg, options)
end

#clocks_running ⇒ Object Also known as: running_clocks 



224
225
226
 
# File 'lib/origen/tester/api.rb', line 224

def clocks_running
  @clocks_running
end

#comment_char ⇒ Object 



39
40
41
 
# File 'lib/origen/tester/api.rb', line 39

def comment_char
  @comment_char || '//'
end

#cycle(options = {}) ⇒ Object

Generate a vector. Calling this method will generate a vector in the output pattern based on the current pin states and timeset.



182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/origen/tester/api.rb', line 182

def cycle(options = {})
  options = {
    microcode: '',
    timeset:   current_timeset,
    pin_vals:  current_pin_vals,
    repeat:    nil
  }.merge(options)

  if any_clocks_running?
    update_running_clocks
    if options[:repeat]
      slice_repeats(options).each do |slice|
        options[:repeat] = slice[0]
        delay(options.delete(:repeat), options) do |options|
          push_vector(options)
        end
        slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
        options[:pin_vals] = current_pin_vals
      end
    else
      push_vector(options)
      pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
    end
  else
    if options[:repeat]
      delay(options.delete(:repeat), options) do |options|
        push_vector(options)
      end
    else
      push_vector(options)
    end
  end
end

#doc? ⇒ Boolean

Returns:

  • (Boolean) 


78
79
80
 
# File 'lib/origen/tester/api.rb', line 78

def doc?
  false
end

#generate? ⇒ Boolean

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/origen/tester/api.rb', line 22

def generate?
  true
end

#generating_pattern? ⇒ Boolean

Returns:

  • (Boolean) 


26
27
28
 
# File 'lib/origen/tester/api.rb', line 26

def generating_pattern?
  @generating == :pattern
end

#generating_program? ⇒ Boolean

Returns:

  • (Boolean) 


30
31
32
 
# File 'lib/origen/tester/api.rb', line 30

def generating_program?
  @generating == :program
end

#ignore_fails(*pins) ⇒ Object

Ignore fails on the given pins for the duration of the given block, this has the effect of temporarily setting the states of the given pins to don’t care.



92
93
94
95
96
 
# File 'lib/origen/tester/api.rb', line 92

def ignore_fails(*pins)
  pins.each(&:suspend)
  yield
  pins.each(&:resume)
end

#import_test_time(_file, _options = {}) ⇒ Object 



216
217
218
 
# File 'lib/origen/tester/api.rb', line 216

def import_test_time(_file, _options = {})
  puts "Sorry but an importer doesn't exist for: #{Origen.tester.class}"
end

#inhibit_vectors_and_comments ⇒ Object

Allows a section to be run without actually generating any vectors. This can be useful to ensure the pin states end up as they otherwise would have if the section had been run. Classic example of this is a subroutine pattern, wrap this around a call to the startup routine to ensure the pin states are as they would have been immediately after the startup.

Example

# Setup state as if I had run startup without actually doing so
$tester.inhibit_vectors_and_comments do
    $soc.startup
    $top.startup
end



153
154
155
156
157
158
159
160
161
 
# File 'lib/origen/tester/api.rb', line 153

def inhibit_vectors_and_comments
  inhibit_vectors = @inhibit_vectors
  inhibit_comments = @inhibit_comments
  @inhibit_vectors = true
  @inhibit_comments = true
  yield
  @inhibit_vectors = inhibit_vectors      # Restore to their initial state
  @inhibit_comments = inhibit_comments
end

#is_command_based? ⇒ Boolean

Returns:

  • (Boolean) 


62
63
64
 
# File 'lib/origen/tester/api.rb', line 62

def is_command_based?
  !is_vector_based?
end

#is_vector_based? ⇒ Boolean

Returns:

  • (Boolean) 


57
58
59
60
 
# File 'lib/origen/tester/api.rb', line 57

def is_vector_based?
  return @vector_based if defined?(@vector_based)
  true
end

#j750? ⇒ Boolean

Returns:

  • (Boolean) 


66
67
68
 
# File 'lib/origen/tester/api.rb', line 66

def j750?
  false
end

#j750_hpt? ⇒ Boolean

Returns:

  • (Boolean) 


82
83
84
 
# File 'lib/origen/tester/api.rb', line 82

def j750_hpt?
  false
end

#name ⇒ Object 



18
19
20
 
# File 'lib/origen/tester/api.rb', line 18

def name
  @name || self.class
end

#pat_extension ⇒ Object Also known as: pattern_extension 



34
35
36
 
# File 'lib/origen/tester/api.rb', line 34

def pat_extension
  @pat_extension || 'txt'
end

#pattern_footer(*_args) ⇒ Object 



50
51
 
# File 'lib/origen/tester/api.rb', line 50

def pattern_footer(*_args)
end

#pattern_header(*_args) ⇒ Object 



47
48
 
# File 'lib/origen/tester/api.rb', line 47

def pattern_header(*_args)
end

#pattern_section(msg) ⇒ Object 



116
117
118
119
120
121
122
123
 
# File 'lib/origen/tester/api.rb', line 116

def pattern_section(msg)
  if generating_program?
    yield
  else
    step_comment(msg)
    yield
  end
end

#pins_need_toggling ⇒ Object 



262
263
264
265
266
267
268
 
# File 'lib/origen/tester/api.rb', line 262

def pins_need_toggling
  toggle_ary = []
  clocks_running.each do |name, clock_pin|
    toggle_ary.push("#{name}") if clock_pin.next_edge == cycle_count
  end
  toggle_ary
end

#pop_running_clock(pin) ⇒ Object 



233
234
235
236
 
# File 'lib/origen/tester/api.rb', line 233

def pop_running_clock(pin)
  fail "ERROR: No clocks running, doesn't make sense to pop one" unless any_clocks_running?
  @clocks_running.delete(pin.name.to_s)
end

#program_comment_char ⇒ Object 



43
44
45
 
# File 'lib/origen/tester/api.rb', line 43

def program_comment_char
  @program_comment_char || comment_char
end

#push_running_clock(pin) ⇒ Object 



229
230
231
 
# File 'lib/origen/tester/api.rb', line 229

def push_running_clock(pin)
  @clocks_running.nil? ? @clocks_running = { pin.name.to_s => pin } : @clocks_running[pin.name.to_s] = pin
end

#slice_repeats(options = {}) ⇒ Object 



238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/origen/tester/api.rb', line 238

def slice_repeats(options = {})
  slices = {}
  repeat_ary = []
  clocks_running.each do |name, clock_pin|
    if clock_pin.next_edge < (cycle_count + options[:repeat])
      pin_slices = (clock_pin.next_edge..(cycle_count + options[:repeat])).step(clock_pin.half_period).to_a
      pin_slices.insert(0, cycle_count)
    else
      pin_slices = [cycle_count]
    end
    pin_slices.each do |cycle|
      slices[cycle].nil? ? slices[cycle] = name : slices[cycle] = "#{slices[cycle]},#{name}"
    end
    slices[cycle_count + options[:repeat]] = '' if pin_slices[-1] != cycle_count + options[:repeat]
  end
  slices.keys.sort.each do |edge_cycles|
    # puts "Toggle #{slices[edge_cycles]} on #{edge_cycles}"
    repeat_ary.push([edge_cycles, slices[edge_cycles].split(',')])
  end

  (repeat_ary.count - 1).downto(1).each { |i| repeat_ary[i][0] = repeat_ary[i][0] - repeat_ary[i - 1][0] }
  repeat_ary[1..-1]
end

#snip(_number, _options = {}) ⇒ Object 



139
140
141
 
# File 'lib/origen/tester/api.rb', line 139

def snip(_number, _options = {})
  yield
end

#ss(msg = nil) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/origen/tester/api.rb', line 125

def ss(msg = nil)
  div = step_comment_prefix.length
  div = 1 if div == 0
  c1(step_comment_prefix * (70 / div))
  @step_comment_on = true
  if block_given?
    yield
  else
    c1(msg)
  end
  @step_comment_on = false
  c1(step_comment_prefix * (70 / div))
end

#step_comment_prefix ⇒ Object 



53
54
55
 
# File 'lib/origen/tester/api.rb', line 53

def step_comment_prefix
  @step_comment_prefix || '##'
end

#ultraflex? ⇒ Boolean

Returns:

  • (Boolean) 


74
75
76
 
# File 'lib/origen/tester/api.rb', line 74

def ultraflex?
  false
end

#update_running_clocks ⇒ Object 



270
271
272
273
274
 
# File 'lib/origen/tester/api.rb', line 270

def update_running_clocks
  clocks_running.each do |_name, clock_pin|
    clock_pin.update_clock
  end
end

#v93k? ⇒ Boolean

Returns:

  • (Boolean) 


70
71
72
 
# File 'lib/origen/tester/api.rb', line 70

def v93k?
  false
end