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.
- checksums.yaml +4 -4
- data/README.md +139 -79
- data/lib/HDLRuby/hdr_samples/constant_in_function.rb +2 -1
- data/lib/HDLRuby/hdr_samples/with_ref_expr.rb +30 -0
- data/lib/HDLRuby/hdr_samples/with_sequencer.rb +32 -37
- data/lib/HDLRuby/hdr_samples/with_sequencer_enumerable.rb +103 -69
- data/lib/HDLRuby/hdr_samples/with_sequencer_enumerator.rb +10 -10
- data/lib/HDLRuby/hdr_samples/with_sequencer_func.rb +63 -0
- data/lib/HDLRuby/hdrcc.rb +1 -1
- data/lib/HDLRuby/hruby_high.rb +23 -5
- data/lib/HDLRuby/hruby_low_without_subsignals.rb +50 -11
- data/lib/HDLRuby/hruby_types.rb +5 -5
- data/lib/HDLRuby/hruby_values.rb +7 -7
- data/lib/HDLRuby/hruby_verilog.rb +101 -17
- data/lib/HDLRuby/hruby_verilog_name.rb +49 -42
- data/lib/HDLRuby/std/fsm.rb +10 -1
- data/lib/HDLRuby/std/sequencer.rb +281 -53
- data/lib/HDLRuby/std/sequencer_func.rb +533 -0
- data/lib/HDLRuby/std/std.rb +1 -0
- data/lib/HDLRuby/version.rb +1 -1
- data/tuto/tutorial_sw.md +267 -61
- metadata +5 -3
- data/lib/HDLRuby/hdr_samples/with_register_stack.rb +0 -150
@@ -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
|
-
|
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
|
-
(
|
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 <= (
|
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(
|
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
|
323
|
-
res45
|
351
|
+
# hprint("@0\n")
|
352
|
+
res44 <= 0
|
353
|
+
res45 <= 0
|
354
|
+
res44X <= 0
|
355
|
+
res45X <= 0
|
324
356
|
step
|
325
|
-
res44
|
326
|
-
res45
|
327
|
-
|
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("
|
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("
|
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(
|
434
|
+
repeat(500) do
|
401
435
|
!10.ns
|
402
436
|
clk <= ~clk
|
403
437
|
end
|