HDLRuby 3.0.0 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,7 +1,8 @@
1
1
  # Sample for testing constant declaration in function.
2
2
 
3
3
 
4
- function :func do |addr|
4
+ # function :func do |addr|
5
+ hdef :func do |addr|
5
6
  bit[4][-4].constant tbl: [ _b1000, _b1001, _b1010, _b1011 ]
6
7
 
7
8
  tbl[addr]
@@ -0,0 +1,30 @@
1
+
2
+ # A benchmark for testing range reference and index reference on expressions.
3
+ system :with_concat do
4
+ [8].inner :val0,:val1
5
+ inner :val2
6
+ [4].inner :val3, :count
7
+ inner :val4
8
+ [4].inner :val5
9
+
10
+ val2 <= (val0+val1)[4]
11
+ val3 <= (val0+val1)[3..0]
12
+
13
+ val4 <= val0[4]
14
+ val5 <= val0[3..0]
15
+
16
+ timed do
17
+ val0 <= _b00001111
18
+ val1 <= _b11000011
19
+ count <= 0
20
+ !10.ns
21
+ val0 <= _b11110000
22
+ val1 <= _b00111100
23
+ count <= 1
24
+ !10.ns
25
+ val0 <= _b10101010
26
+ val1 <= _b01010101
27
+ count <= 2
28
+ !10.ns
29
+ end
30
+ end
@@ -22,68 +22,68 @@ system :my_seqencer do
22
22
  [16].inner :u, :v,:res0
23
23
 
24
24
  sequencer(clk.posedge,rst) do
25
- hprint("#0\n")
25
+ # hprint("#0\n")
26
26
  u <= 0
27
27
  v <= 1
28
28
  step
29
29
  res0 <= 0
30
- hprint("#1 res0=",res0,"\n")
30
+ # hprint("#1 res0=",res0,"\n")
31
31
  swhile(v < 100) do
32
32
  v <= u + v
33
33
  u <= v - u
34
- hprint("#2 v=",v,"\n")
34
+ # hprint("#2 v=",v,"\n")
35
35
  end
36
36
  res0 <= v
37
- hprint("#3 res0=",res0,"\n")
37
+ # hprint("#3 res0=",res0,"\n")
38
38
  end
39
39
 
40
40
  [16].inner :uu, :vv
41
41
  sequencer(clk.posedge,rst) do
42
- hprint("##0\n")
42
+ # hprint("##0\n")
43
43
  uu <= 0
44
44
  vv <= 1
45
45
  swhile(vv<10000) do
46
46
  vv <= uu + vv
47
47
  uu <= vv - uu
48
48
  step
49
- hprint("##1 vv=",vv,"\n")
49
+ # hprint("##1 vv=",vv,"\n")
50
50
  sif(vv >= 100) { sterminate }
51
51
  end
52
- hprint("##2 vv=",vv,"... But should not be here!\n")
52
+ # hprint("##2 vv=",vv,"... But should not be here!\n")
53
53
  end
54
54
 
55
55
  [16].inner :uuu, :vvv, :res00
56
56
 
57
57
  sequencer(clk.posedge,rst) do
58
- hprint("###0\n")
58
+ # hprint("###0\n")
59
59
  res00 <= 0
60
+ steps(3) # Checks 3 steps
60
61
  uuu <= 0
61
62
  vvv <= 1
62
63
  swhile(vvv<10000) do
63
64
  vvv <= uuu + vvv
64
65
  uuu <= vvv - uuu
65
- step
66
- hprint("##1 vvv=",vvv,"\n")
66
+ # hprint("##1 vvv=",vvv,"\n")
67
67
  sif(vvv >= 100) { sbreak }
68
68
  selse { res00 <= res00 + 1 }
69
69
  end
70
- hprint("##2 res00=",res00,"... and should be here!\n")
70
+ # hprint("##2 res00=",res00,"... and should be here!\n")
71
71
  end
72
72
 
73
73
  [8].inner :a,:b
74
74
 
75
75
  sequencer(clk.posedge,rst) do
76
- hprint("=0\n")
76
+ # hprint("=0\n")
77
77
  a <= 0
78
78
  b <= 0
79
79
  sfor(0..19) do
80
80
  a <= a + 1
81
- hprint("=1 a=",a,"\n")
81
+ # hprint("=1 a=",a,"\n")
82
82
  sif(a % 4) { scontinue }
83
83
  b <= b + 1
84
- hprint("=2 b=",b,"\n")
84
+ # hprint("=2 b=",b,"\n")
85
85
  end
86
- hprint("=3 a=",a," b=",b,"\n")
86
+ # hprint("=3 a=",a," b=",b,"\n")
87
87
  end
88
88
 
89
89
 
@@ -93,41 +93,36 @@ system :my_seqencer do
93
93
 
94
94
  sequencer(clk.posedge,rst) do
95
95
  res1 <= 0
96
- hprint("$0 res1=",res1,"\n")
97
- # sfor(buf) do |elem,idx|
98
- # buf.seach.with_index do |elem,idx|
99
- # res1 <= elem * elem
100
- # hprint("$1 res1=",res1," idx=",idx,"\n")
101
- # end
96
+ # hprint("$0 res1=",res1,"\n")
102
97
  buf.seach do |elem|
103
98
  res1 <= elem * elem
104
- hprint("$1 elem=",elem," res1=",res1,"\n")
99
+ # hprint("$1 elem=",elem," res1=",res1,"\n")
105
100
  end
106
- hprint("$2 res1=",res1,"\n")
101
+ # hprint("$2 res1=",res1,"\n")
107
102
  end
108
103
 
109
104
  [32].inner :res2
110
105
 
111
106
  sequencer(clk.posedge,rst) do
112
107
  res2 <= 0
113
- hprint("%0 res2=",res2,"\n")
114
- (0..7).seach do |elem|
108
+ # hprint("%0 res2=",res2,"\n")
109
+ (_h00000000.._h00000007).seach do |elem|
115
110
  res2 <= elem * elem
116
- hprint("%1 elem=",elem," res2=",res2,"\n")
111
+ # hprint("%1 elem=",elem," res2=",res2,"\n")
117
112
  end
118
- hprint("%2 res2=",res2,"\n")
113
+ # hprint("%2 res2=",res2,"\n")
119
114
  end
120
115
 
121
116
  [32].inner :res3
122
117
 
123
118
  sequencer(clk.posedge,rst) do
124
119
  res3 <= 0
125
- hprint("&0 res3=",res3,"\n")
120
+ # hprint("&0 res3=",res3,"\n")
126
121
  5.supto(10).with_index do |elem,idx|
127
122
  res3 <= [elem[15..0],idx[15..0]]
128
- hprint("&1 elem=",elem," idx=",idx," res3=",res3,"\n")
123
+ # hprint("&1 elem=",elem," idx=",idx," res3=",res3,"\n")
129
124
  end
130
- hprint("&2 res3=",res3,"\n")
125
+ # hprint("&2 res3=",res3,"\n")
131
126
  end
132
127
 
133
128
  bit[8][-8].inner ar0: [_h01,_h02,_h04,_h08, _h10,_h20,_h40,_h80]
@@ -138,19 +133,19 @@ system :my_seqencer do
138
133
  sfor(ar0) do |elem,idx|
139
134
  res4[idx] <= elem + ar1[idx]
140
135
  end
141
- hprint("res4=",res4,"\n")
136
+ # hprint("res4=",res4,"\n")
142
137
  end
143
138
 
144
139
  [8].inner :res5
145
140
 
146
141
  sequencer(clk.posedge,rst) do
147
142
  res5 <= 0
148
- hprint("(0 res5=",res5,"\n")
143
+ # hprint("(0 res5=",res5,"\n")
149
144
  (ar0.seach + ar1).seach do |elem|
150
145
  res5 <= elem
151
- hprint("(1 res5=",res5,"\n")
146
+ # hprint("(1 res5=",res5,"\n")
152
147
  end
153
- hprint("(2 res5=",res5,"\n")
148
+ # hprint("(2 res5=",res5,"\n")
154
149
  end
155
150
 
156
151
 
@@ -158,12 +153,12 @@ system :my_seqencer do
158
153
 
159
154
  sequencer(clk.posedge,rst) do
160
155
  res6 <= 0
161
- hprint(")0 res6=",res6,"\n")
156
+ # hprint(")0 res6=",res6,"\n")
162
157
  10.sdownto(1) do |elem|
163
158
  res6 <= elem
164
- hprint(")1 res6=",res6,"\n")
159
+ # hprint(")1 res6=",res6,"\n")
165
160
  end
166
- hprint(")2 res6=",res6,"\n")
161
+ # hprint(")2 res6=",res6,"\n")
167
162
  end
168
163
 
169
164
 
@@ -34,6 +34,34 @@ include HDLRuby::High::Std
34
34
  # - The twenty nineth sequencer checks stake and stake_while
35
35
  # - The thirtieth sequencer checks suniq
36
36
  # - The thirty first sequencer checks szip
37
+ #
38
+ # __WARNING__: All the operations on enumerators generate their own result
39
+ # signal. Therefore, in a real circuit, there is no need to
40
+ # declare your own signal for it, as demonstrated in this sample.
41
+ # In other words, the res<num> signals are unnecessary, and
42
+ # assigning the result to them only slows down the circuit without
43
+ # any benefit. Instead, they can be replaced with Ruby variables
44
+ # as shown below:
45
+ # from: res<num> <= <enumerator operation>
46
+ # to: <ruby variable> = <enumerator operation>
47
+ # In this sample it is done this way for an easy vizualization of
48
+ # the multiple results.
49
+ #
50
+ # For instance the first example should be rewritten from:
51
+ # [16].inner :res0, :res1
52
+ # sequencer(clk.posedge,rst) do
53
+ # res0 <= 0; res1 <= 1
54
+ # step
55
+ # res0 <= vals.sall? { |val| val!= _h11 }
56
+ # res1 <= vals.sall? { |val| val!= _h5C }
57
+ # end
58
+ # to:
59
+ # res0 = nil; res1 = nil
60
+ # sequencer(clk.posedge,rst) do
61
+ # res0 = vals.sall? { |val| val!= _h11 }
62
+ # res1 = vals.sall? { |val| val!= _h5C }
63
+ # end
64
+ #
37
65
  system :my_seqencer do
38
66
 
39
67
  inner :clk,:rst
@@ -43,258 +71,258 @@ system :my_seqencer do
43
71
  [16].inner :res0, :res1
44
72
 
45
73
  sequencer(clk.posedge,rst) do
46
- hprint("#0\n")
74
+ # hprint("#0\n")
47
75
  res0 <= 0
48
76
  res1 <= 0
49
77
  step
50
78
  res0 <= vals.sall? { |val| val != _h11 }
51
79
  res1 <= vals.sall? { |val| val != _h5C }
52
- hprint("#1 res0=",res0," res1=",res1,"\n")
80
+ # hprint("#1 res0=",res0," res1=",res1,"\n")
53
81
  end
54
82
 
55
83
  [16].inner :res2, :res3
56
84
 
57
85
  sequencer(clk.posedge,rst) do
58
- hprint("$0\n")
86
+ # hprint("$0\n")
59
87
  res2 <= 0
60
88
  res3 <= 0
61
89
  step
62
90
  res2 <= vals.sany? { |val| val == _h11 }
63
91
  res3 <= vals.sany? { |val| val == _h5C }
64
- hprint("$1 res2=",res2," res3=",res3,"\n")
92
+ # hprint("$1 res2=",res2," res3=",res3,"\n")
65
93
  end
66
94
 
67
95
  [16].inner :res4
68
96
 
69
97
  sequencer(clk.posedge,rst) do
70
- hprint("!0\n")
98
+ # hprint("!0\n")
71
99
  res4 <= 0
72
100
  vals.schain(0..10).seach do |elem|
73
101
  res4 <= elem
74
- hprint("!1 res4=",res4,"\n")
102
+ # hprint("!1 res4=",res4,"\n")
75
103
  end
76
- hprint("!2 res4=",res4,"\n")
104
+ # hprint("!2 res4=",res4,"\n")
77
105
  end
78
106
 
79
107
  [8*8].inner :res5
80
108
 
81
109
  sequencer(clk.posedge,rst) do
82
- hprint("%0\n");
110
+ # hprint("%0\n");
83
111
  res5 <= 0
84
112
  res5 <= vals.smap { |val| val + 1 }
85
- hprint("%1 res5=",res5,"\n");
113
+ # hprint("%1 res5=",res5,"\n");
86
114
  end
87
115
 
88
116
  [8*8].inner :res6
89
117
 
90
118
  sequencer(clk.posedge,rst) do
91
- hprint("&0\n");
119
+ # hprint("&0\n");
92
120
  res6 <= 0
93
121
  res6 <= vals.smap.with_index { |val,i| val + i }
94
- hprint("&1 res6=",res6,"\n");
122
+ # hprint("&1 res6=",res6,"\n");
95
123
  end
96
124
 
97
125
  bit[8][-8].inner vals2: [ _h00, _h10, _h00, _h0B, _hFE, _h00, _h5C, _h00 ]
98
126
  [8*8].inner :res7
99
127
 
100
128
  sequencer(clk.posedge,rst) do
101
- hprint("|0\n");
129
+ # hprint("|0\n");
102
130
  res7 <= 0
103
131
  res7 <= vals2.scompact
104
- hprint("|1 res7=",res7,"\n");
132
+ # hprint("|1 res7=",res7,"\n");
105
133
  end
106
134
 
107
135
  [8].inner :res8, :res9, :res10
108
136
 
109
137
  sequencer(clk.posedge,rst) do
110
- hprint("(0\n");
138
+ # hprint("(0\n");
111
139
  res8 <= 0
112
140
  res9 <= 0
113
141
  res10 <= 0
114
142
  res8 <= vals2.scount
115
143
  res9 <= vals2.scount(_h00)
116
144
  res10 <= vals2.scount {|elem| elem > _h10 }
117
- hprint("(1 res8=",res8," res9=",res9," res10=",res10,"\n");
145
+ # hprint("(1 res8=",res8," res9=",res9," res10=",res10,"\n");
118
146
  end
119
147
 
120
148
  [8].inner :res11, :res12
121
149
 
122
150
  sequencer(clk.posedge,rst) do
123
- hprint(")0\n")
151
+ # hprint(")0\n")
124
152
  res11 <= 0
125
153
  res12 <= 0
126
154
  vals.scycle(2) { |elem| res11 <= elem }
127
- hprint(")1 res11=",res11,"\n")
155
+ # hprint(")1 res11=",res11,"\n")
128
156
  vals2.scycle { |elem| res12 <= elem }
129
- hprint(")2 Should never be here! ... res12=",res12,"\n")
157
+ # hprint(")2 Should never be here! ... res12=",res12,"\n")
130
158
  end
131
159
 
132
160
  [8].inner :res13, :res14
133
161
 
134
162
  sequencer(clk.posedge,rst) do
135
- hprint("=0\n")
163
+ # hprint("=0\n")
136
164
  res13 <= 0
137
165
  res14 <= 0
138
166
  res13 <= vals.sfind(-1) { |elem| elem > 0 }
139
167
  res14 <= vals.sfind(-1) { |elem| elem == _hAA }
140
- hprint("=1 res13=",res13," res14=",res14,"\n")
168
+ # hprint("=1 res13=",res13," res14=",res14,"\n")
141
169
  end
142
170
 
143
171
  [8*8].inner :res15, :res16
144
172
 
145
173
  sequencer(clk.posedge,rst) do
146
- hprint("+0\n")
174
+ # hprint("+0\n")
147
175
  res15 <= 0
148
176
  res16 <= 0
149
177
  res15 <= vals.sdrop(3)
150
178
  res16 <= vals.sdrop_while { |elem| elem < _hAA }
151
- hprint("+1 res15=",res15," res16=",res16,"\n")
179
+ # hprint("+1 res15=",res15," res16=",res16,"\n")
152
180
  end
153
181
 
154
182
  [8].inner :res17
155
183
 
156
184
  sequencer(clk.posedge,rst) do
157
- hprint("*0\n")
185
+ # hprint("*0\n")
158
186
  res17 <= 0
159
187
  vals.seach_cons(3) { |a,b,c| res17 <= a+b+c }
160
- hprint("*1 res17=",res17,"\n")
188
+ # hprint("*1 res17=",res17,"\n")
161
189
  end
162
190
 
163
191
  [8].inner :res18
164
192
 
165
193
  sequencer(clk.posedge,rst) do
166
- hprint("/0\n")
194
+ # hprint("/0\n")
167
195
  res18 <= 0
168
196
  vals.seach_slice(3) { |a,b,c| res18 <= a+b+c }
169
- hprint("/1 res18=",res18,"\n")
197
+ # hprint("/1 res18=",res18,"\n")
170
198
  end
171
199
 
172
200
  [32*4].inner :res19
173
201
 
174
202
  sequencer(clk.posedge,rst) do
175
- hprint("~0\n")
203
+ # hprint("~0\n")
176
204
  res19 <= 0
177
- res19 <= (1..4).seach.sto_a
178
- hprint("~1 res19=",res19,"\n")
205
+ res19 <= (_h00000001.._h00000004).seach.sto_a
206
+ # hprint("~1 res19=",res19,"\n")
179
207
  end
180
208
 
181
209
  [8].inner :res21, :res22
182
210
 
183
211
  sequencer(clk.posedge,rst) do
184
- hprint(">0\n")
212
+ # hprint(">0\n")
185
213
  res21 <= 0
186
214
  res22 <= 0
187
215
  res21 <= vals.sfind_index(_h0B)
188
216
  res22 <= vals.sfind_index { |elem| elem < _hAA }
189
- hprint(">1 res21=",res21," res22=",res22,"\n")
217
+ # hprint(">1 res21=",res21," res22=",res22,"\n")
190
218
  end
191
219
 
192
220
  [4*8].inner :res23
193
221
 
194
222
  sequencer(clk.posedge,rst) do
195
- hprint("<0\n")
223
+ # hprint("<0\n")
196
224
  res23 <= 0
197
225
  res23 <= vals.sfirst(4)
198
- hprint("<1 res23=",res23,"\n")
226
+ # hprint("<1 res23=",res23,"\n")
199
227
  end
200
228
 
201
229
  inner :res24, :res25
202
230
 
203
231
  sequencer(clk.posedge,rst) do
204
- hprint("!0\n")
232
+ # hprint("!0\n")
205
233
  res24 <= 0
206
234
  res25 <= 0
207
235
  res24 <= vals.sinclude?(_h0B)
208
236
  res25 <= vals.sinclude?(_hAA)
209
- hprint("!1 res24=",res24," res25=",res25,"\n")
237
+ # hprint("!1 res24=",res24," res25=",res25,"\n")
210
238
  end
211
239
 
212
240
  [8].inner :res26, :res27
213
241
 
214
242
  sequencer(clk.posedge,rst) do
215
- hprint(":0\n")
243
+ # hprint(":0\n")
216
244
  res26 <= 0
217
245
  res27 <= 0
218
- res26 <= vals.sinject(1) { |a,b| a+b }
246
+ res26 <= vals.sinject(_h01) { |a,b| a+b }
219
247
  res27 <= vals.sinject(:+)
220
- hprint(":1 res26=",res26," res27=",res27,"\n")
248
+ # hprint(":1 res26=",res26," res27=",res27,"\n")
221
249
  end
222
250
 
223
251
  [8].inner :res28
224
252
  [8*3].inner :res29
225
253
 
226
254
  sequencer(clk.posedge,rst) do
227
- hprint(";0\n")
255
+ # hprint(";0\n")
228
256
  res28 <= 0
229
257
  res29 <= 0
230
258
  res28 <= vals.smax
231
259
  res29 <= vals.smax(3)
232
- hprint(";1 res28=",res28," res29=",res29,"\n")
260
+ # hprint(";1 res28=",res28," res29=",res29,"\n")
233
261
  end
234
262
 
235
263
  [8].inner :res30
236
264
  [8*3].inner :res31
237
265
 
238
266
  sequencer(clk.posedge,rst) do
239
- hprint(",0\n")
267
+ # hprint(",0\n")
240
268
  res30 <= 0
241
269
  res31 <= 0
242
270
  res30 <= vals.smax_by {|e| e.to_signed }
243
271
  res31 <= vals.smax_by(3) {|e| e.to_signed }
244
- hprint(",1 res30=",res30," res31=",res31,"\n")
272
+ # hprint(",1 res30=",res30," res31=",res31,"\n")
245
273
  end
246
274
 
247
275
  [8].inner :res32
248
276
  [8*3].inner :res33
249
277
 
250
278
  sequencer(clk.posedge,rst) do
251
- hprint(".0\n")
279
+ # hprint(".0\n")
252
280
  res32 <= 0
253
281
  res33 <= 0
254
282
  res32 <= vals.smin
255
283
  res33 <= vals.smin(3)
256
- hprint(".1 res32=",res32," res33=",res33,"\n")
284
+ # hprint(".1 res32=",res32," res33=",res33,"\n")
257
285
  end
258
286
 
259
287
  [8].inner :res34
260
288
  [8*3].inner :res35
261
289
 
262
290
  sequencer(clk.posedge,rst) do
263
- hprint(":0\n")
291
+ # hprint(":0\n")
264
292
  res34 <= 0
265
293
  res35 <= 0
266
294
  res34 <= vals.smin_by {|e| e.to_signed }
267
295
  res35 <= vals.smin_by(3) {|e| e.to_signed }
268
- hprint(":1 res34=",res34," res35=",res35,"\n")
296
+ # hprint(":1 res34=",res34," res35=",res35,"\n")
269
297
  end
270
298
 
271
299
  [16].inner :res36, :res37
272
300
 
273
301
  sequencer(clk.posedge,rst) do
274
- hprint("]0\n")
302
+ # hprint("]0\n")
275
303
  res36 <= 0
276
304
  res37 <= 0
277
305
  res36 <= vals.sminmax
278
306
  res37 <= vals.sminmax_by {|e| e.to_signed }
279
- hprint("]1 res36=",res36," res37=",res37,"\n")
307
+ # hprint("]1 res36=",res36," res37=",res37,"\n")
280
308
  end
281
309
 
282
310
  [8].inner :res38, :res39
283
311
 
284
312
  sequencer(clk.posedge,rst) do
285
- hprint("[0\n")
313
+ # hprint("[0\n")
286
314
  res38 <= 0
287
315
  res39 <= 0
288
316
  step
289
317
  res38 <= vals.snone? { |val| val == _h11 }
290
318
  res39 <= vals.snone?(_h5C)
291
- hprint("[1 res38=",res38," res39=",res39,"\n")
319
+ # hprint("[1 res38=",res38," res39=",res39,"\n")
292
320
  end
293
321
 
294
322
  [8].inner :res40, :res41, :res42
295
323
 
296
324
  sequencer(clk.posedge,rst) do
297
- hprint("[0\n")
325
+ # hprint("[0\n")
298
326
  res40 <= 0
299
327
  res41 <= 0
300
328
  res42 <= 0
@@ -302,54 +330,60 @@ system :my_seqencer do
302
330
  res40 <= vals.sone?(_h5C)
303
331
  res41 <= vals.sone? { |val| val == _h11 }
304
332
  res42 <= vals2.sone? { |val| val == _h00 }
305
- hprint("[1 res40=",res40," res41=",res41," res42=",res42,"\n")
333
+ # hprint("[1 res40=",res40," res41=",res41," res42=",res42,"\n")
306
334
  end
307
335
 
308
336
  [8].inner :res43
309
337
 
310
338
  sequencer(clk.posedge,rst) do
311
- hprint("_0\n")
339
+ # hprint("_0\n")
312
340
  res43 <= 0
313
341
  step
314
342
  (4..10).sreverse_each { |val| res43 <= val }
315
- hprint("_1 res43=",res43,"\n")
343
+ # hprint("_1 res43=",res43,"\n")
316
344
  end
317
345
 
346
+ [8*10].inner :res44X, :res45X
318
347
  [8*8].inner :res44, :res45
348
+ bit[8][-10].inner valsX: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44, _h01, _h82 ]
319
349
 
320
350
  sequencer(clk.posedge,rst) do
321
- hprint("@0\n")
322
- res44 <= 0
323
- res45 <= 0
351
+ # hprint("@0\n")
352
+ res44 <= 0
353
+ res45 <= 0
354
+ res44X <= 0
355
+ res45X <= 0
324
356
  step
325
- res44 <= vals.ssort
326
- res45 <= vals.ssort_by { |val| val.to_signed }
327
- hprint("@1 res44=",res44," res45=",res45,"\n")
357
+ res44 <= vals.ssort
358
+ res45 <= vals.ssort_by { |val| val.to_signed }
359
+ res44X <= valsX.ssort
360
+ res45X <= valsX.ssort_by { |val| val.to_signed }
361
+ # hprint("@1 res44=",res44," res45=",res45,"\n")
328
362
  end
329
363
 
330
364
  [8].inner :res46, :res47
331
365
 
332
366
  sequencer(clk.posedge,rst) do
333
- hprint("`0\n")
367
+ # hprint("`0\n")
334
368
  res46 <= 0
335
369
  res47 <= 0
336
370
  step
337
371
  res46 <= vals.ssum
338
372
  res47 <= vals.ssum { |val| val & _h0F }
339
- hprint("`1 res46=",res46," res47=",res47,"\n")
373
+ # hprint("`1 res46=",res46," res47=",res47,"\n")
340
374
  end
341
375
 
342
376
  [8*3].inner :res48
343
377
  [8*8].inner :res49
344
378
 
345
379
  sequencer(clk.posedge,rst) do
346
- hprint("`0\n")
380
+ # hprint("`0\n")
347
381
  res48 <= 0
348
382
  res49 <= 0
349
383
  step
350
384
  res48 <= vals.stake(3)
351
385
  res49 <= vals.stake_while { |val| val < _hAA }
352
- hprint("`1 res48=",res48," res49=",res49,"\n")
386
+ # hprint("`1 res48=",res48," res49=",res49,"\n")
353
387
  end
354
388
 
355
389
  bit[8][-8].inner vals3: [ _hFE, _h10, _hA5, _h10, _hFE, _h34, _h5C, _h10 ]
@@ -357,13 +391,13 @@ system :my_seqencer do
357
391
  [8*8].inner :res50,:res51
358
392
 
359
393
  sequencer(clk.posedge,rst) do
360
- hprint("\"0\n")
394
+ # hprint("~0\n")
361
395
  res50 <= 0
362
396
  res51 <= 0
363
397
  step
364
398
  res50 <= vals3.suniq
365
399
  res51 <= vals.suniq { |val| val & _h0F }
366
- hprint("\"1 res50=",res50," res51=",res51,"\n")
400
+ # hprint("~1 res50=",res50," res51=",res51,"\n")
367
401
  end
368
402
 
369
403
  [8*4*2].inner :res52
@@ -371,13 +405,13 @@ system :my_seqencer do
371
405
  [3].inner :idx
372
406
 
373
407
  sequencer(clk.posedge,rst) do
374
- hprint("}0\n")
408
+ # hprint("}0\n")
375
409
  res52 <= 0
376
410
  idx <= 0
377
411
  step
378
412
  res52 <= vals.szip((1..6).to_a.map {|i| i.to_expr.as(bit[8]) })
379
413
  vals.szip([_h12]*8) { |a,b| res53[idx] <= a+b; idx <= idx + 1 }
380
- hprint("}1 res52=",res52," res53=",res53,"\n")
414
+ # hprint("}1 res52=",res52," res53=",res53,"\n")
381
415
  end
382
416
 
383
417
 
@@ -397,7 +431,7 @@ system :my_seqencer do
397
431
  rst <= 0
398
432
  !10.ns
399
433
  clk <= 1
400
- repeat(100) do
434
+ repeat(500) do
401
435
  !10.ns
402
436
  clk <= ~clk
403
437
  end