Bump for 3.2.0-RC2

Author: ucbjrl

.circleci/config.yml

@@ -124,7 +124,7 @@ jobs:
     executor: chisel-executor
     steps:
       - test-chisel:
-          scalaVersion: "++2.12.7"
+          scalaVersion: "++2.12.10"
 
   checkstyle-chisel:
     executor: chisel-executor

build.sbt

@@ -28,18 +28,18 @@ def javacOptionsVersion(scalaVersion: String): Seq[String] = {
   }
 }
 
-val defaultVersions = Map("firrtl" -> "1.2-091719-SNAPSHOT")
+val defaultVersions = Map("firrtl" -> "1.2.0-RC2")
 
 lazy val commonSettings = Seq (
   resolvers ++= Seq(
     Resolver.sonatypeRepo("snapshots"),
     Resolver.sonatypeRepo("releases")
   ),
   organization := "edu.berkeley.cs",
-  version := "3.2-091719-SNAPSHOT",
+  version := "3.2.0-RC2",
   autoAPIMappings := true,
-  scalaVersion := "2.12.9",
-  crossScalaVersions := Seq("2.12.9", "2.11.12"),
+  scalaVersion := "2.12.10",
+  crossScalaVersions := Seq("2.12.10", "2.11.12"),
   scalacOptions := Seq("-deprecation", "-feature") ++ scalacOptionsVersion(scalaVersion.value),
   libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value,
   addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.0" cross CrossVersion.full),

build.sc

@@ -32,10 +32,10 @@ object chiselCompileOptions {
   )
 }
 
-val crossVersions = Seq("2.12.9", "2.11.12")
+val crossVersions = Seq("2.12.10", "2.11.12")
 
 // Provide a managed dependency on X if -DXVersion="" is supplied on the command line.
-val defaultVersions = Map("firrtl" -> "1.2-091719-SNAPSHOT")
+val defaultVersions = Map("firrtl" -> "1.2.0-RC2")
 
 def getVersion(dep: String, org: String = "edu.berkeley.cs") = {
   val version = sys.env.getOrElse(dep + "Version", defaultVersions(dep))
@@ -67,7 +67,7 @@ trait CommonChiselModule extends SbtModule {
 
 trait PublishChiselModule extends CommonChiselModule with PublishModule {
   override def artifactName = "chisel3"
-  def publishVersion = "3.2-091719-SNAPSHOT"
+  def publishVersion = "3.2.0-RC2"
 
   def pomSettings = PomSettings(
     description = artifactName(),
@@ -99,6 +99,10 @@ object chisel3 extends Cross[ChiselTopModule](crossVersions: _*) {
     chisel3(crossVersions.head).test.test()
   }
 
+  def testOne(args: String*) = T.command {
+    chisel3(crossVersions.head).test.testOne(args: _*)
+  }
+
   def publishLocal = T{
     chisel3(crossVersions.head).publishLocal()
   }
@@ -224,6 +228,11 @@ trait AbstractChiselModule extends PublishChiselModule with CommonBuild.BuildInf
       ivy"org.scalacheck::scalacheck:1.14.0"
     )
     def testFrameworks = Seq("org.scalatest.tools.Framework")
+
+    def testOne(args: String*) = T.command {
+      super.runMain("org.scalatest.run", args: _*)
+    }
+
   }
 
   // This is required for building a library, but not for a `run` target.

chiselFrontend/src/main/scala/chisel3/Aggregate.scala

@@ -263,6 +263,37 @@ sealed class Vec[T <: Data] private[chisel3] (gen: => T, val length: Int)
     // scalastyle:on if.brace
     PString("Vec(") + Printables(elts) + PString(")")
   }
+
+  /** A reduce operation in a tree like structure instead of sequentially
+    * @example An adder tree
+    * {{{
+    * val sumOut = inputNums.reduceTree((a: T, b: T) => (a + b))
+    * }}}
+    */
+  def reduceTree(redOp: (T, T) => T): T = macro VecTransform.reduceTreeDefault
+
+  /** A reduce operation in a tree like structure instead of sequentially
+    * @example A pipelined adder tree
+    * {{{
+    * val sumOut = inputNums.reduceTree(
+    *   (a: T, b: T) => RegNext(a + b),
+    *   (a: T) => RegNext(a)
+    * )
+    * }}}
+    */
+  def reduceTree(redOp: (T, T) => T, layerOp: (T) => T): T = macro VecTransform.reduceTree
+
+  def do_reduceTree(redOp: (T, T) => T, layerOp: (T) => T = (x: T) => x)
+                   (implicit sourceInfo: SourceInfo, compileOptions: CompileOptions) : T = {
+    require(!isEmpty, "Cannot apply reduction on a vec of size 0")
+    var curLayer = this
+    while (curLayer.length > 1) {
+      curLayer = VecInit(curLayer.grouped(2).map( x =>
+        if (x.length == 1) layerOp(x(0)) else redOp(x(0), x(1))
+      ).toSeq)
+    }
+    curLayer(0)
+  }
 }
 
 object VecInit extends SourceInfoDoc {

coreMacros/src/main/scala/chisel3/internal/sourceinfo/SourceInfoTransform.scala

@@ -84,6 +84,12 @@ class VecTransform(val c: Context) extends SourceInfoTransformMacro {
   def contains(x: c.Tree)(ev: c.Tree): c.Tree = {
     q"$thisObj.do_contains($x)($implicitSourceInfo, $ev, $implicitCompileOptions)"
   }
+  def reduceTree(redOp: c.Tree, layerOp: c.Tree): c.Tree = {
+    q"$thisObj.do_reduceTree($redOp,$layerOp)($implicitSourceInfo, $implicitCompileOptions)"
+  }
+  def reduceTreeDefault(redOp: c.Tree ): c.Tree = {
+    q"$thisObj.do_reduceTree($redOp)($implicitSourceInfo, $implicitCompileOptions)"
+  }
 }
 
 /** "Automatic" source information transform / insertion macros, which generate the function name

project/build.properties

@@ -1 +1 @@
-sbt.version=1.2.7
+sbt.version=1.3.0

project/plugins.sbt

@@ -1,8 +1,8 @@
-resolvers += Resolver.url("scalasbt", new URL("http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases")) (Resolver.ivyStylePatterns)
+resolvers += Resolver.url("scalasbt", new URL("https://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases")) (Resolver.ivyStylePatterns)
 
 resolvers += Classpaths.sbtPluginReleases
 
-resolvers += "jgit-repo" at "http://download.eclipse.org/jgit/maven"
+resolvers += "jgit-repo" at "https://download.eclipse.org/jgit/maven"
 
 addSbtPlugin("org.scalastyle" %% "scalastyle-sbt-plugin" % "1.0.0")
 

src/test/scala/chiselTests/AdderTree.scala

@@ -0,0 +1,33 @@
+package chiselTests
+
+import chisel3._
+import chisel3.testers.BasicTester
+
+class AdderTree[T <: Bits with Num[T]](genType: T, vecSize: Int) extends Module {
+  val io = IO(new Bundle {
+    val numIn = Input(Vec(vecSize, genType))
+    val numOut = Output(genType)
+  })
+  io.numOut := io.numIn.reduceTree((a : T, b : T) => (a + b))
+}
+
+class AdderTreeTester(bitWidth: Int, numsToAdd: List[Int]) extends BasicTester {
+  val genType = UInt(bitWidth.W)
+  val dut = Module(new AdderTree(genType, numsToAdd.size))
+  dut.io.numIn := VecInit(numsToAdd.map(x => x.asUInt(bitWidth.W)))
+  val sumCorrect = dut.io.numOut === (numsToAdd.reduce(_+_) % (1 << bitWidth)).asUInt(bitWidth.W)
+  assert(sumCorrect)
+  stop()
+}
+
+class AdderTreeSpec extends ChiselPropSpec {
+  property("All numbers should be added correctly by an Adder Tree") {
+    forAll(safeUIntN(20)) {
+      case (w: Int, v: List[Int]) => {
+        whenever(v.size > 0 && w > 0) {
+          assertTesterPasses { new AdderTreeTester(w, v.map(x => math.abs(x) % ( 1 << w )).toList) }
+        }
+      }
+    }
+  }
+}