1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
// SPDX-License-Identifier: Apache-2.0
package chiselTests
import chisel3._
import chisel3.util._
import chisel3.testers.BasicTester
class MemVecTester extends BasicTester {
val mem = Mem(2, Vec(2, UInt(8.W)))
// Circuit style tester is definitely the wrong abstraction here
val (cnt, wrap) = Counter(true.B, 2)
mem(0)(0) := 1.U
when (cnt === 1.U) {
assert(mem.read(0.U)(0) === 1.U)
stop()
}
}
class SyncReadMemTester extends BasicTester {
val (cnt, _) = Counter(true.B, 5)
val mem = SyncReadMem(2, UInt(2.W))
val rdata = mem.read(cnt - 1.U, cnt =/= 0.U)
switch (cnt) {
is (0.U) { mem.write(cnt, 3.U) }
is (1.U) { mem.write(cnt, 2.U) }
is (2.U) { assert(rdata === 3.U) }
is (3.U) { assert(rdata === 2.U) }
is (4.U) { stop() }
}
}
class SyncReadMemWriteCollisionTester extends BasicTester {
val (cnt, _) = Counter(true.B, 5)
// Write-first
val m0 = SyncReadMem(2, UInt(2.W), SyncReadMem.WriteFirst)
val rd0 = m0.read(cnt)
m0.write(cnt, cnt)
// Read-first
val m1 = SyncReadMem(2, UInt(2.W), SyncReadMem.ReadFirst)
val rd1 = m1.read(cnt)
m1.write(cnt, cnt)
// Read data from address 0
when (cnt === 3.U) {
assert(rd0 === 2.U)
assert(rd1 === 0.U)
}
when (cnt === 4.U) {
stop()
}
}
class SyncReadMemWithZeroWidthTester extends BasicTester {
val (cnt, _) = Counter(true.B, 3)
val mem = SyncReadMem(2, UInt(0.W))
val rdata = mem.read(0.U, true.B)
switch (cnt) {
is (1.U) { assert(rdata === 0.U) }
is (2.U) { stop() }
}
}
// TODO this can't actually simulate with FIRRTL behavioral mems
class HugeSMemTester(size: BigInt) extends BasicTester {
val (cnt, _) = Counter(true.B, 5)
val mem = SyncReadMem(size, UInt(8.W))
val rdata = mem.read(cnt - 1.U, cnt =/= 0.U)
switch (cnt) {
is (0.U) { mem.write(cnt, 3.U) }
is (1.U) { mem.write(cnt, 2.U) }
is (2.U) { assert(rdata === 3.U) }
is (3.U) { assert(rdata === 2.U) }
is (4.U) { stop() }
}
}
class HugeCMemTester(size: BigInt) extends BasicTester {
val (cnt, _) = Counter(true.B, 5)
val mem = Mem(size, UInt(8.W))
val rdata = mem.read(cnt)
switch (cnt) {
is (0.U) { mem.write(cnt, 3.U) }
is (1.U) { mem.write(cnt, 2.U) }
is (2.U) { assert(rdata === 3.U) }
is (3.U) { assert(rdata === 2.U) }
is (4.U) { stop() }
}
}
class SyncReadMemBundleTester extends BasicTester {
val (cnt, _) = Counter(true.B, 5)
val tpe = new Bundle {
val foo = UInt(2.W)
}
val mem = SyncReadMem(2, tpe)
val rdata = mem.read(cnt - 1.U, cnt =/= 0.U)
switch (cnt) {
is (0.U) {
val w = Wire(tpe)
w.foo := 3.U
mem.write(cnt, w)
}
is (1.U) {
val w = Wire(tpe)
w.foo := 2.U
mem.write(cnt, w)
}
is (2.U) { assert(rdata.foo === 3.U) }
is (3.U) { assert(rdata.foo === 2.U) }
is (4.U) { stop() }
}
}
class MemBundleTester extends BasicTester {
val tpe = new Bundle {
val foo = UInt(2.W)
}
val mem = Mem(2, tpe)
// Circuit style tester is definitely the wrong abstraction here
val (cnt, wrap) = Counter(true.B, 2)
mem(0) := {
val w = Wire(tpe)
w.foo := 1.U
w
}
when (cnt === 1.U) {
assert(mem.read(0.U).foo === 1.U)
stop()
}
}
class MemorySpec extends ChiselPropSpec {
property("Mem of Vec should work") {
assertTesterPasses { new MemVecTester }
}
property("SyncReadMem should work") {
assertTesterPasses { new SyncReadMemTester }
}
property("SyncReadMems of Bundles should work") {
assertTesterPasses { new SyncReadMemBundleTester }
}
property("Mems of Bundles should work") {
assertTesterPasses { new MemBundleTester }
}
property("SyncReadMem write collision behaviors should work") {
assertTesterPasses { new SyncReadMemWriteCollisionTester }
}
property("SyncReadMem should work with zero width entry") {
assertTesterPasses { new SyncReadMemWithZeroWidthTester }
}
property("Massive memories should be emitted in Verilog") {
val addrWidth = 65
val size = BigInt(1) << addrWidth
val smem = compile(new HugeSMemTester(size))
smem should include (s"reg /* sparse */ [7:0] mem [0:$addrWidth'd${size-1}];")
val cmem = compile(new HugeCMemTester(size))
cmem should include (s"reg /* sparse */ [7:0] mem [0:$addrWidth'd${size-1}];")
}
property("Implicit conversions with Mem indices should work") {
"""
|import chisel3._
|import chisel3.util.ImplicitConversions._
|class MyModule extends Module {
| val io = IO(new Bundle {})
| val mem = Mem(32, UInt(8.W))
| mem(0) := 0.U
|}
|""".stripMargin should compile
}
}
|
