Merge branch 'master' into 1.4.x

Author: chick

.scalafmt.conf

@@ -0,0 +1,20 @@
+maxColumn = 120
+align = most
+continuationIndent.defnSite = 2
+assumeStandardLibraryStripMargin = true
+docstrings = ScalaDoc
+lineEndings = preserve
+includeCurlyBraceInSelectChains = false
+danglingParentheses = true
+
+align.tokens.add = [
+  {
+    code = ":"
+  }
+]
+
+newlines.alwaysBeforeCurlyBraceLambdaParams
 = false
+
+optIn.annotationNewlines = true
+
+rewrite.rules = [SortImports, PreferCurlyFors, AvoidInfix]

rocket/src/main/scala/amba/apb/Node.scala

@@ -42,7 +42,7 @@ case class BundleBridgeToAPBNode(masterParams: APBMasterPortParameters)(implicit
     dFn = { mp =>
       masterParams
     },
-    uFn = { slaveParams => BundleBridgeParams(None) }
+    uFn = { slaveParams => BundleBridgeNull() }
   )
 
 object BundleBridgeToAPBNode {

src/main/scala/dsptools/dspmath/ExtendedEuclid.scala

@@ -0,0 +1,19 @@
+// See LICENSE for license details.
+
+package dsptools.dspmath
+
+object ExtendedEuclid {
+  /** Extended Euclidean Algorithm
+    * ax + by = gcd(a, b)
+    * Inputs: a, b
+    * Outputs: gcd, x, y
+    */
+  def egcd(a: Int, b: Int): (Int, Int, Int) = {
+    if (a == 0) {
+      (b, 0, 1)
+    } else {
+      val (gcd, y, x) = egcd(b % a, a)
+      (gcd, x - (b / a) * y, y)
+    }
+  }
+}

src/main/scala/dsptools/dspmath/Factorization.scala

@@ -0,0 +1,135 @@
+// See LICENSE for license details.
+
+package dsptools.dspmath
+
+import org.scalatest.{FlatSpec, Matchers}
+
+case class RadPow(rad: Int, pow: Int) {
+  /** `r ^ p` */
+  def get: Int = BigInt(rad).pow(pow).toInt
+  /** Factorize i.e. rad = 4, pow = 3 -> Seq(4, 4, 4) */
+  def factorize: Seq[Int] = Seq.fill(pow)(rad)
+}
+
+case class Factorization(supportedRadsUnsorted: Seq[Seq[Int]]) {
+  /** Supported radices, MSD First */
+  private val supportedRads = supportedRadsUnsorted.map(_.sorted.reverse)
+
+  /** Factor n into powers of supported radices and store RadPow i.e. r^p, separated by coprimes
+    * i.e. if supportedRads = Seq(Seq(4, 2), Seq(3)),
+    * output =  Seq(Seq(RadPow(4, 5), RadPow(2, 1)), Seq(RadPow(3, 7)))
+    * implies n = 4^5 * 2^1 * 3^7
+    */
+  private def getRadPows(n: Int): Seq[Seq[RadPow]] = {
+    // Test if n can be factored by each of the supported radices (mod = 0)
+    // Count # of times it can be factored
+    var unfactorized = n
+    val radPows = for (primeGroup <- supportedRads) yield { for (rad <- primeGroup) yield {
+      var (mod, pow) = (0, 0)
+      while (mod == 0) {
+        mod = unfactorized % rad
+        if (mod == 0) {
+          pow = pow + 1
+          unfactorized = unfactorized / rad
+        }
+      }
+      RadPow(rad, pow)
+    }}
+    // If n hasn't completely been factorized, then an unsupported radix is required
+    require(unfactorized == 1, s"$n is invalid for supportedRads.")
+    radPows
+  }
+
+  /** Factor n into powers of supported radices (flattened)
+    * i.e. if supportedRads = Seq(Seq(4, 2), Seq(3)),
+    * output = Seq(5, 1, 7)
+    * implies `n = 4^5 * 2^1 * 3^7`
+    * If supportedRads contains more radices than the ones used, a power of 0 will be
+    * associated with the unused radices.
+    */
+  def getPowsFlat(n: Int): Seq[Int] = {
+    getRadPows(n).flatMap(_.map(_.pow))
+  }
+
+  /** Break n into coprimes i.e.
+    * n = 4^5 * 2^1 * 3^7
+    * would result in Seq(4^5 * 2^1, 3^7)
+    * If supportedRads contains more coprime groups than the ones used, 1 will be
+    * associated with the unused groups.
+    */
+  def getCoprimes(n: Int): Seq[Int] = {
+    getRadPows(n).map(_.map(_.get).product)
+  }
+
+  /** Factorizes the coprime into digit radices (mixed radix)
+    * i.e. n = 8 -> Seq(4, 2)
+    * Note: there's no padding!
+    */
+  def factorizeCoprime(n: Int): Seq[Int] = {
+    // i.e. if supportedRads = Seq(Seq(4, 2), Seq(3)) and n = 8,
+    // correspondingPrimeGroup = Seq(4, 2)
+    val correspondingPrimeGroup = supportedRads.filter(n % _.min == 0)
+    require(correspondingPrimeGroup.length == 1, "n (coprime) must not be divisible by other primes.")
+    // Factorize coprime -- only correspondingPrimeGroup should actually add to factorization length
+    getRadPows(n).flatten.flatMap(_.factorize)
+  }
+
+  /** Gets associated base prime for n (assuming n isn't divisible by other primes)
+    * WARNING: Assumes supportedRads contains the base prime!
+    */
+  def getBasePrime(n: Int): Int = {
+    val primeTemp = supportedRads.map(_.min).filter(n % _ == 0)
+    require(primeTemp.length == 1, "n should only be divisible by 1 prime")
+    primeTemp.head
+  }
+
+}
+
+class FactorizationSpec extends FlatSpec with Matchers {
+
+  val testSupportedRads = Seq(Seq(4, 2), Seq(3), Seq(5), Seq(7))
+
+  behavior of "Factorization"
+  it should "properly factorize" in {
+    case class FactorizationTest(n: Int, pows: Seq[Int], coprimes: Seq[Int])
+    val tests = Seq(
+      FactorizationTest(
+        n = (math.pow(4, 5) * math.pow(2, 1) * math.pow(3, 7)).toInt,
+        pows = Seq(5, 1, 7),
+        coprimes = Seq((math.pow(4, 5) * math.pow(2, 1)).toInt, math.pow(3, 7).toInt)
+      ),
+      FactorizationTest(n = 15, pows = Seq(0, 0, 1, 1), coprimes = Seq(1, 3, 5))
+    )
+
+    tests foreach { case FactorizationTest(n, pows, coprimes) =>
+      val powsFill = Seq.fill(testSupportedRads.flatten.length - pows.length)(0)
+      val coprimesFill = Seq.fill(testSupportedRads.length - coprimes.length)(1)
+      require(
+        Factorization(testSupportedRads).getPowsFlat(n) == pows ++ powsFill,
+        "Should factorize to get the right powers -- includes padding."
+      )
+      require(
+        Factorization(testSupportedRads).getCoprimes(n) == coprimes ++ coprimesFill,
+        "Should factorize into the right coprimes -- includes padding."
+      )
+    }
+  }
+
+  it should "properly factorize coprime" in {
+    case class CoprimeFactorizationTest(n: Int, factorization: Seq[Int], basePrime: Int)
+    val tests = Seq(
+      CoprimeFactorizationTest(n = 8, factorization = Seq(4, 2), basePrime = 2),
+      CoprimeFactorizationTest(n = 16, factorization = Seq(4, 4), basePrime = 2)
+    )
+    tests foreach { case CoprimeFactorizationTest(n, factorization, basePrime) =>
+      require(
+        Factorization(testSupportedRads).factorizeCoprime(n) == factorization,
+        "Should factorize coprime properly."
+      )
+      require(
+        Factorization(testSupportedRads).getBasePrime(n) == basePrime,
+        "Should get the correct base prime."
+      )
+    }
+  }
+}

src/main/scala/dsptools/intervals/IAUtility.scala

@@ -0,0 +1,56 @@
+// See LICENSE for license details.
+
+package dsptools.intervals
+
+import chisel3.internal.firrtl.IntervalRange
+import firrtl.ir.Closed
+
+object IAUtility {
+
+  /** Expand range by n (twice of `halfn`). If n is negative, shrink. */
+  def expandBy(range: IntervalRange, halfn: Double): IntervalRange = {
+    val newMinT = getMin(range) - halfn
+    val newMax = getMax(range) + halfn
+    val newMin = if (newMinT > newMax) newMax else newMinT
+    if (newMinT > newMax) println("Attempting to shrink range too much!")
+    /*
+    println(
+      (if (halfn < 0) s"[shrink $halfn]: " else s"[expand $halfn]: ") +
+        s"old min: ${getMin(range)} old max: ${getMax(range)}; " +
+        s"new min: $newMin new max: $newMax"
+    )
+    */
+    IntervalRange(Closed(newMin), Closed(newMax), range.binaryPoint)
+  }
+
+  /** Shift range to the right by n. If n is negative, shift left.  */
+  def shiftRightBy(range: IntervalRange, n: Double): IntervalRange = {
+    val newMin = getMin(range) + n
+    val newMax = getMax(range) + n
+    IntervalRange(Closed(newMin), Closed(newMax), range.binaryPoint)
+  }
+
+  /** Check if range contains negative numbers. */
+  def containsNegative(range: IntervalRange): Boolean = getMin(range) < 0
+
+  /** Get the # of bits required to represent the integer portion of the
+    * rounded bounds (including sign bit if necessary).
+    */
+  def getIntWidth(range: IntervalRange):Int = {
+    require(range.binaryPoint.get == 0, "getIntWidth only works for bp = 0")
+    val min = range.getLowestPossibleValue.get.toBigInt()
+    val max = range.getHighestPossibleValue.get.toBigInt()
+
+    val minWidth = if (min < 0) min.bitLength + 1 else min.bitLength
+    val maxWidth = if (max < 0) max.bitLength + 1 else max.bitLength
+    math.max(minWidth, maxWidth)
+  }
+
+  /** Gets min */
+  def getMin(range: IntervalRange): BigDecimal = range.getLowestPossibleValue.get
+  /** Gets max */
+  def getMax(range: IntervalRange): BigDecimal = range.getPossibleValues.max
+  /** Gets width of range */
+  def getRange(range: IntervalRange): BigDecimal = getMax(range) - getMin(range)
+
+}

src/main/scala/dsptools/misc/BitWidth.scala

@@ -0,0 +1,60 @@
+// See LICENSE for license details.
+
+package dsptools.misc
+
+object BitWidth {
+  /**
+    * Utility function that computes bits required for a number
+    *
+    * @param n number of interest
+    * @return
+    */
+  def computeBits(n: BigInt): Int = {
+    n.bitLength + (if(n < 0) 1 else 0)
+  }
+
+  /**
+    * return the smallest number of bits required to hold the given number in
+    * an SInt
+    * Note: positive numbers will get one minimum width one higher than would be
+    * required for a UInt
+    *
+    * @param num number to find width for
+    * @return minimum required bits for an SInt
+    */
+  def requiredBitsForSInt(num: BigInt): Int = {
+    if(num == BigInt(0) || num == -BigInt(1)) {
+      1
+    }
+    else {
+      if (num < 0) {
+        computeBits(num)
+      }
+      else {
+        computeBits(num) + 1
+      }
+    }
+  }
+
+  def requiredBitsForSInt(low: BigInt, high: BigInt): Int = {
+    requiredBitsForSInt(low).max(requiredBitsForSInt(high))
+  }
+
+  /**
+    * return the smallest number of bits required to hold the given number in
+    * an UInt
+    * Note: positive numbers will get one minimum width one higher than would be
+    * required for a UInt
+    *
+    * @param num number to find width for
+    * @return minimum required bits for an SInt
+    */
+  def requiredBitsForUInt(num: BigInt): Int = {
+    if(num == BigInt(0)) {
+      1
+    }
+    else {
+      computeBits(num)
+    }
+  }
+}

src/main/scala/dsptools/numbers/algebra_types/helpers/Sign.scala

@@ -48,8 +48,8 @@ object Sign {
   case object Negative extends Sign(Some(false), Some(true))
 
   def apply(zero: Bool, neg: Bool): Sign = {
-    val zeroLit = zero.litArg.map{_.num != BigInt(0)}
-    val negLit  = neg.litArg.map{_.num != BigInt(0)}
+    val zeroLit = zero.litOption.map{_ != BigInt(0)}
+    val negLit  = neg.litOption.map{_ != BigInt(0)}
     val isLit = zeroLit.isDefined && negLit.isDefined
     val wireWrapIfNotLit: Sign => Sign = s => if (isLit) { s } else Wire(s)
     val bundle = wireWrapIfNotLit(

src/main/scala/dsptools/numbers/binary_types/BinaryRepresentation.scala

@@ -1,3 +1,5 @@
+// See LICENSE for license details.
+
 package dsptools.numbers
 
 import chisel3.{Data, UInt, Bool}
@@ -20,5 +22,8 @@ trait BinaryRepresentation[A <: Data] extends Any {
   def mul2(a: A, n: Int): A = shl(a, n)
   // Trim to n fractional bits (with DspContext) -- doesn't affect DspReal
   def trimBinary(a: A, n: Int): A = trimBinary(a, Some(n))
-  def trimBinary(a: A, n: Option[Int]): A 
+  def trimBinary(a: A, n: Option[Int]): A
+
+  // Clip A to B (range)
+  def clip(a: A, b: A): A
 }

src/main/scala/dsptools/numbers/chisel_concrete/DspComplex.scala

@@ -5,7 +5,6 @@ package dsptools.numbers
 import chisel3._
 import chisel3.experimental.{FixedPoint, Interval}
 import dsptools.DspException
-import implicits._
 import breeze.math.Complex
 
 object DspComplex {

src/main/scala/dsptools/numbers/chisel_types/DspComplexTypeClass.scala

@@ -96,14 +96,15 @@ class DspComplexEq[T <: Data:Eq] extends Eq[DspComplex[T]] with hasContext {
   }
 }
 
-class DspComplexBinaryRepresentation[T <: Data:Ring:BinaryRepresentation] extends 
+class DspComplexBinaryRepresentation[T <: Data:Ring:BinaryRepresentation] extends
     BinaryRepresentation[DspComplex[T]] with hasContext {
   override def shl(a: DspComplex[T], n: Int): DspComplex[T] = throw DspException("Can't shl on complex")
   override def shl(a: DspComplex[T], n: UInt): DspComplex[T] = throw DspException("Can't shl on complex")
   override def shr(a: DspComplex[T], n: Int): DspComplex[T] = throw DspException("Can't shr on complex")
   override def shr(a: DspComplex[T], n: UInt): DspComplex[T] = throw DspException("Can't shr on complex")
   override def div2(a: DspComplex[T], n: Int): DspComplex[T] = DspComplex.wire(a.real.div2(n), a.imag.div2(n))
   override def mul2(a: DspComplex[T], n: Int): DspComplex[T] = DspComplex.wire(a.real.mul2(n), a.imag.mul2(n))
+  def clip(a: DspComplex[T], b: DspComplex[T]): DspComplex[T] = throw DspException("Can't clip on complex")
   def signBit(a: DspComplex[T]): Bool = throw DspException("Can't get sign bit on complex")
   def trimBinary(a: DspComplex[T], n: Option[Int]): DspComplex[T] = 
     DspComplex.wire(BinaryRepresentation[T].trimBinary(a.real, n), BinaryRepresentation[T].trimBinary(a.imag, n))