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
|
// SPDX-License-Identifier: Apache-2.0
package chiselTests.aop
import chisel3.testers.BasicTester
import chiselTests.ChiselFlatSpec
import chisel3._
import chisel3.aop.Select.{PredicatedConnect, When, WhenNot}
import chisel3.aop.{Aspect, Select}
import chisel3.experimental.ExtModule
import chisel3.stage.{ChiselGeneratorAnnotation, DesignAnnotation}
import firrtl.AnnotationSeq
import scala.reflect.runtime.universe.TypeTag
class SelectTester(results: Seq[Int]) extends BasicTester {
val values = VecInit(results.map(_.U))
val counter = RegInit(0.U(results.length.W))
val added = counter + 1.U
counter := added
val overflow = counter >= values.length.U
val nreset = reset.asBool() === false.B
val selected = values(counter)
val zero = 0.U + 0.U
when(overflow) {
counter := zero
stop()
}.otherwise {
when(nreset) {
assert(counter === values(counter))
printf("values(%d) = %d\n", counter, selected)
}
}
}
case class SelectAspect[T <: RawModule, X](selector: T => Seq[X], desired: T => Seq[X]) extends Aspect[T] {
override def toAnnotation(top: T): AnnotationSeq = {
val results = selector(top)
val desiredSeq = desired(top)
assert(results.length == desiredSeq.length, s"Failure! Results $results have different length than desired $desiredSeq!")
val mismatches = results.zip(desiredSeq).flatMap {
case (res, des) if res != des => Seq((res, des))
case other => Nil
}
assert(mismatches.isEmpty,s"Failure! The following selected items do not match their desired item:\n" + mismatches.map{
case (res: Select.Serializeable, des: Select.Serializeable) => s" ${res.serialize} does not match:\n ${des.serialize}"
case (res, des) => s" $res does not match:\n $des"
}.mkString("\n"))
Nil
}
}
class SelectSpec extends ChiselFlatSpec {
def execute[T <: RawModule, X](dut: () => T, selector: T => Seq[X], desired: T => Seq[X])(implicit tTag: TypeTag[T]): Unit = {
val ret = new chisel3.stage.ChiselStage().run(
Seq(
new chisel3.stage.ChiselGeneratorAnnotation(dut),
SelectAspect(selector, desired),
new chisel3.stage.ChiselOutputFileAnnotation("test_run_dir/Select.fir")
)
)
}
"Test" should "pass if selecting correct registers" in {
execute(
() => new SelectTester(Seq(0, 1, 2)),
{ dut: SelectTester => Select.registers(dut) },
{ dut: SelectTester => Seq(dut.counter) }
)
}
"Test" should "pass if selecting correct wires" in {
execute(
() => new SelectTester(Seq(0, 1, 2)),
{ dut: SelectTester => Select.wires(dut) },
{ dut: SelectTester => Seq(dut.values) }
)
}
"Test" should "pass if selecting correct printfs" in {
execute(
() => new SelectTester(Seq(0, 1, 2)),
{ dut: SelectTester => Seq(Select.printfs(dut).last) },
{ dut: SelectTester =>
Seq(Select.Printf(
Seq(
When(Select.ops("eq")(dut).last.asInstanceOf[Bool]),
When(dut.nreset),
WhenNot(dut.overflow)
),
Printable.pack("values(%d) = %d\n", dut.counter, dut.selected),
dut.clock
))
}
)
}
"Test" should "pass if selecting correct connections" in {
execute(
() => new SelectTester(Seq(0, 1, 2)),
{ dut: SelectTester => Select.connectionsTo(dut)(dut.counter) },
{ dut: SelectTester =>
Seq(PredicatedConnect(Nil, dut.counter, dut.added, false),
PredicatedConnect(Seq(When(dut.overflow)), dut.counter, dut.zero, false))
}
)
}
"Test" should "pass if selecting ops by kind" in {
execute(
() => new SelectTester(Seq(0, 1, 2)),
{ dut: SelectTester => Select.ops("tail")(dut) },
{ dut: SelectTester => Seq(dut.added, dut.zero) }
)
}
"Test" should "pass if selecting ops" in {
execute(
() => new SelectTester(Seq(0, 1, 2)),
{ dut: SelectTester => Select.ops(dut).collect { case ("tail", d) => d} },
{ dut: SelectTester => Seq(dut.added, dut.zero) }
)
}
"Test" should "pass if selecting correct stops" in {
execute(
() => new SelectTester(Seq(0, 1, 2)),
{ dut: SelectTester => Seq(Select.stops(dut).last) },
{ dut: SelectTester =>
Seq(Select.Stop(
Seq(
When(Select.ops("eq")(dut).dropRight(1).last.asInstanceOf[Bool]),
When(dut.nreset),
WhenNot(dut.overflow)
),
1,
dut.clock
))
}
)
}
"Blackboxes" should "be supported in Select.instances" in {
class BB extends ExtModule { }
class Top extends RawModule {
val bb = Module(new BB)
}
val top = ChiselGeneratorAnnotation(() => {
new Top()
}).elaborate(1).asInstanceOf[DesignAnnotation[Top]].design
val bbs = Select.collectDeep(top) { case b: BB => b }
assert(bbs.size == 1)
}
}
|
