Chisel variable Declaration Syntax Meaning rvs: Bool*

Question

Looking at object DecoupledHelper and class DecoupledHelper code, I see the following.

object DecoupledHelper {
 def apply(rvs: Bool*) = new DecoupledHelper(rvs)
}

class DecoupledHelper(val rvs: Seq[Bool]) {
 def fire(exclude: Bool, includes: Bool*) = {

   (rvs.filter(_ ne exclude) ++ includes).reduce(_ && _)
 }
}

I don't understand the parameters declaration syntax in apply method. (rvs: Bool*). What is the meaning of * at end of Type Bool. Looking at constructor parameters of class DecoupledHelper, it expects (rvs: Seq[Bool])

Does this mean that type Bool* is automatically converted to type Seq[Bool]?

While at this, can anyone also explain what rvs.filter method is doing?

That’s Scala’s syntax for functions with variable number of arguments. More info here: alvinalexander.com/scala/… — ɹɐʎɯɐʞ

Jack Koenig Jack Koenig · Accepted Answer · 2020-02-26T20:35:49

As Kamyar said, Type* is the Scala syntax for variable number of arguments (also known as "varags"). It let's you call the DecoupledHelper apply method like so:

val helper = DecoupledHelper(a, b, c) // calling apply on the companion object
// instead of
val helper2 = new DecoupledHelper(Seq(a, b, c)) // calling constructor of the class

For those new to Chisel and Scala, note that apply is a special function Scala that is called when you "apply" parentheses to an object or instance. Thus DecoupledHelper(a, b, c) is equivalent to DecoupledHelper.apply(a, b, c).

While at this, can anyone also explain what rvs.filter method is doing?

It is taking advantage of the implementation of Chisel which I would not recommend doing. ne is the Scala function for not referentially equal. It lets you check if two object are not the same object in memory.

In this case, it let's you do things like the following:

val helper = DecoupledHelper(a, b, c)
helper.fire()   // a && b && c
helper.fire(b)  // a && c

Now because this is dangerously using referential equality instead of actual hardware equality (and there are limitations of the implementation that motivated this), something that should work does not:

val helper = DecoupledHelper(a, b, c)
val d = b           // Same reference
val e = WireInit(b) // Equivalent Wire but different reference
helper.fire(d)  // a && c
helper.fire(e)  // a && b && c

d points to the same object on the heap as b, but e does not despite the fact that it is equivalent from the hardware perspective.

For more information, see the related bug report and discussion: https://github.com/chipsalliance/rocket-chip/issues/1616

Chisel variable Declaration Syntax Meaning rvs: Bool*

1 Answers