Implement SRT class

.gitignore

@@ -24,4 +24,5 @@ verdiLog
 *.out
 *.cmd
 *.log
-*.json
+*.json
+*.iml

arithmetic/src/addition/prefixadder/graph/PrefixGraph.scala

@@ -53,7 +53,7 @@ object PrefixGraph {
 }
 
 object CommonSumByConsole extends HasPrefixSumWithGraphImp with CommonPrefixSum {
-  val filePath = Path(io.StdIn.readLine("Import your graph generated by `dot -Txdot_json`: "), pwd)
+  val filePath = Path(scala.io.StdIn.readLine("Import your graph generated by `dot -Txdot_json`: "), pwd)
   val fileName = filePath.baseName
   val prefixGraph: PrefixGraph = PrefixGraph(filePath)
 }

arithmetic/src/division/srt/SRT.scala

@@ -0,0 +1,68 @@
+package division.srt
+
+import division.srt.srt4._
+import division.srt.srt8._
+import division.srt.srt16._
+import chisel3._
+import chisel3.util.{DecoupledIO, ValidIO}
+
+class SRT(
+  dividendWidth:  Int,
+  dividerWidth:   Int,
+  n:              Int, // the longest width
+  radixLog2:      Int = 2,
+  a:              Int = 2,
+  dTruncateWidth: Int = 4,
+  rTruncateWidth: Int = 4)
+    extends Module {
+//  val x = (radixLog2, a, dTruncateWidth)
+//  val tips = x match {
+//    case (2,2,4) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//    case (2,2,5) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//    case (2,2,6) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//
+//    case (3,4,6) => require(rTruncateWidth >= 7, "rTruncateWidth need >= 7")
+//    case (3,4,7) => require(rTruncateWidth >= 6, "rTruncateWidth need >= 6")
+//
+//    case (3,5,5) => require(rTruncateWidth >= 5, "rTruncateWidth need >= 5")
+//    case (3,5,6) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//
+//    case (3,6,4) => require(rTruncateWidth >= 6, "rTruncateWidth need >= 6")
+//    case (3,6,5) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//
+//    case (3,7,4) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//    case (3,7,5) => require(rTruncateWidth >= 3, "rTruncateWidth need >= 3")
+//
+//    case (4,2,4) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//    case (4,2,5) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//    case (4,2,6) => require(rTruncateWidth >= 4, "rTruncateWidth need >= 4")
+//
+//    case _       => println("this srt is not supported")
+//  }
+
+  val input = IO(Flipped(DecoupledIO(new SRTInput(dividendWidth, dividerWidth, n))))
+  val output = IO(ValidIO(new SRTOutput(dividerWidth, dividendWidth)))
+
+//   select radix
+  if (radixLog2 == 2) { // SRT4
+    val srt = Module(new SRT4(dividendWidth, dividerWidth, n, radixLog2, a, dTruncateWidth, rTruncateWidth))
+    srt.input <> input
+    output <> srt.output
+  } else if (radixLog2 == 3) { // SRT8
+    val srt = Module(new SRT8(dividendWidth, dividerWidth, n, radixLog2, a, dTruncateWidth, rTruncateWidth))
+    srt.input <> input
+    output <> srt.output
+  } else if (radixLog2 == 4) { //SRT16
+    val srt = Module(new SRT16(dividendWidth, dividerWidth, n, radixLog2 >> 1, a, dTruncateWidth, rTruncateWidth))
+    srt.input <> input
+    output <> srt.output
+  }
+
+//  val srt = radixLog2 match {
+//    case 2 => Module(new SRT4(dividendWidth, dividerWidth, n, radixLog2, a, dTruncateWidth, rTruncateWidth))
+//    case 3 => Module(new SRT8(dividendWidth, dividerWidth, n, radixLog2, a, dTruncateWidth, rTruncateWidth))
+//    case 4 => Module(new SRT16(dividendWidth, dividerWidth, n, radixLog2 >> 1, a, dTruncateWidth, rTruncateWidth))
+//  }
+//  srt.input <> input
+//  output <> srt.output
+}

arithmetic/src/division/srt/SRTIO.scala

@@ -0,0 +1,38 @@
+package division.srt
+
+import chisel3._
+import chisel3.util.log2Ceil
+// SRTIO
+class SRTInput(dividendWidth: Int, dividerWidth: Int, n: Int) extends Bundle {
+  val dividend = UInt(dividendWidth.W) //.***********
+  val divider = UInt(dividerWidth.W) //.1**********
+  val counter = UInt(log2Ceil(n).W) //the width of quotient.
+}
+
+class SRTOutput(reminderWidth: Int, quotientWidth: Int) extends Bundle {
+  val reminder = UInt(reminderWidth.W)
+  val quotient = UInt(quotientWidth.W)
+}
+
+//OTFIO
+class OTFInput(qWidth: Int, ohWidth: Int) extends Bundle {
+  val quotient = UInt(qWidth.W)
+  val quotientMinusOne = UInt(qWidth.W)
+  val selectedQuotientOH = UInt(ohWidth.W)
+}
+
+class OTFOutput(qWidth: Int) extends Bundle {
+  val quotient = UInt(qWidth.W)
+  val quotientMinusOne = UInt(qWidth.W)
+}
+
+// QDSIO
+class QDSInput(rWidth: Int, partialDividerWidth: Int) extends Bundle {
+  val partialReminderCarry: UInt = UInt(rWidth.W)
+  val partialReminderSum:   UInt = UInt(rWidth.W)
+  val partialDivider:       UInt = UInt(partialDividerWidth.W)
+}
+
+class QDSOutput(ohWidth: Int) extends Bundle {
+  val selectedQuotientOH: UInt = UInt(ohWidth.W)
+}

arithmetic/src/division/srt/SRTTable.scala

@@ -0,0 +1,194 @@
+package division.srt
+
+import com.cibo.evilplot.colors.HTMLNamedColors
+import com.cibo.evilplot.numeric.Bounds
+import com.cibo.evilplot.plot._
+import com.cibo.evilplot.plot.aesthetics.DefaultTheme._
+import com.cibo.evilplot.plot.renderers.PointRenderer
+import os.Path
+import spire.implicits._
+import spire.math._
+
+/** Base SRT class.
+  *
+  * @param radix is the radix of SRT.
+  *              It defined how many rounds can be calculate in one cycle.
+  *              @note 5.2
+  */
+case class SRTTable(
+  radix:          Algebraic,
+  a:              Algebraic,
+  dTruncateWidth: Algebraic,
+  xTruncateWidth: Algebraic,
+  dMin:           Algebraic = 0.5,
+  dMax:           Algebraic = 1) {
+  require(a > 0)
+  lazy val xMin: Algebraic = -rho * dMax * radix
+  lazy val xMax: Algebraic = rho * dMax * radix
+
+  /** P-D Diagram
+    *
+    * @note Graph 5.17(b)
+    */
+  lazy val pd: Plot = Overlay((aMin.toBigInt to aMax.toBigInt).flatMap { k: BigInt =>
+    Seq(
+      FunctionPlot.series(
+        _ * uRate(k.toInt).toDouble,
+        s"U($k)",
+        HTMLNamedColors.blue,
+        Some(Bounds(dMin.toDouble, dMax.toDouble)),
+        strokeWidth = Some(1)
+      ),
+      FunctionPlot.series(
+        _ * lRate(k.toInt).toDouble,
+        s"L($k)",
+        HTMLNamedColors.red,
+        Some(Bounds(dMin.toDouble, dMax.toDouble)),
+        strokeWidth = Some(1)
+      )
+    ) ++ qdsPoints :+ mesh
+  }: _*)
+    .title(s"P-D Graph of $this")
+    .xLabel("d")
+    .yLabel(s"${radix.toInt}ω[j]")
+    .rightLegend()
+    .standard()
+
+  lazy val aMax:   Algebraic = a
+  lazy val aMin:   Algebraic = -a
+  lazy val deltaD: Algebraic = pow(2, -dTruncateWidth.toDouble)
+  lazy val deltaX: Algebraic = pow(2, -xTruncateWidth.toDouble)
+
+  /** redundancy factor
+    * @note 5.8
+    */
+  lazy val rho: Algebraic = a / (radix - 1)
+  //                     k            d       m    xSet
+  lazy val tables: Seq[(Int, Seq[(Algebraic, Seq[Algebraic])])] = {
+    (aMin.toInt to aMax.toInt).drop(1).map { k =>
+      k -> dSet.dropRight(1).map { d =>
+        val (floor, ceil) = xRange(k, d, d + deltaD)
+        val m: Seq[Algebraic] = xSet.filter { x: Algebraic => x <= (ceil - deltaX) && x >= floor }
+        (d, m)
+      }
+    }
+  }
+  lazy val qdsPoints: Seq[Plot] = {
+    tables.map {
+      case (i, ps) =>
+        ScatterPlot(
+          ps.flatMap { case (d, xs) => xs.map(x => com.cibo.evilplot.numeric.Point(d.toDouble, x.toDouble)) },
+          Some(
+            PointRenderer
+              .default[com.cibo.evilplot.numeric.Point](pointSize = Some(1), color = Some(HTMLNamedColors.gold))
+          )
+        )
+    }
+  }
+
+  // TODO: select a Constant from each m, then offer the table to QDS.
+  // todo: ? select rule: symmetry and draw a line parallel to the X-axis, how define the rule
+  lazy val tablesToQDS: Seq[Seq[Int]] = {
+    (aMin.toInt to aMax.toInt).drop(1).map { k =>
+      k -> dSet.dropRight(1).map { d =>
+        val (floor, ceil) = xRange(k, d, d + deltaD)
+        val m: Seq[Algebraic] = xSet.filter { x: Algebraic => x <= (ceil - deltaX) && x >= floor }
+        (d, m.head)
+      }
+    }
+  }.flatMap {
+    case (i, ps) =>
+      ps.map {
+        case (x, y) => (x.toDouble, y.toDouble * (1 << xTruncateWidth.toInt))
+      }
+  }.groupBy(_._1).toSeq.sortBy(_._1).map { case (x, y) => y.map { case (x, y) => y.toInt }.reverse }
+
+  private val xStep = (xMax - xMin) / deltaX
+  // @note 5.7
+  require(a >= radix / 2)
+  private val xSet = Seq.tabulate((xStep / 2 + 1).toInt) { n => deltaX * n } ++ Seq.tabulate((xStep / 2 + 1).toInt) {
+    n => -deltaX * n
+  }
+
+  private val dStep: Algebraic = (dMax - dMin) / deltaD
+  assert((rho > 1 / 2) && (rho <= 1))
+  private val dSet = Seq.tabulate((dStep + 1).toInt) { n => dMin + deltaD * n }
+
+  private val mesh =
+    ScatterPlot(
+      xSet.flatMap { y =>
+        dSet.map { x =>
+          com.cibo.evilplot.numeric.Point(x.toDouble, y.toDouble)
+        }
+      },
+      Some(
+        PointRenderer
+          .default[com.cibo.evilplot.numeric.Point](pointSize = Some(0.5), color = Some(HTMLNamedColors.gray))
+      )
+    )
+
+  override def toString: String =
+    s"SRT${radix.toInt} with quotient set: from ${aMin.toInt} to ${aMax.toInt}"
+
+  /** Robertson Diagram
+    *
+    * @note Graph 5.17(a)
+    */
+  def robertson(d: Algebraic): Plot = {
+    require(d > dMin && d < dMax)
+    Overlay((aMin.toBigInt to aMax.toBigInt).map { k: BigInt =>
+      FunctionPlot.series(
+        _ - (Algebraic(k) * d).toDouble,
+        s"$k",
+        HTMLNamedColors.black,
+        xbounds = Some(Bounds(((Algebraic(k) - rho) * d).toDouble, ((Algebraic(k) + rho) * d).toDouble))
+      )
+    }: _*)
+      .title(s"Robertson Graph of $this divisor: $d")
+      .xLabel("rω[j]")
+      .yLabel("ω[j+1]")
+      .xbounds((-radix * rho * dMax).toDouble, (radix * rho * dMax).toDouble)
+      .ybounds((-rho * d).toDouble, (rho * d).toDouble)
+      .rightLegend()
+      .standard()
+  }
+
+  def dumpGraph(plot: Plot, path: Path) = {
+    javax.imageio.ImageIO.write(
+      plot.render().asBufferedImage,
+      "png",
+      path.wrapped.toFile
+    )
+  }
+
+  // select four points, then drop the first and the last one.
+  /** for range `dLeft` to `dRight`, return the `rOmegaCeil` and `rOmegaFloor`
+    * this is used for constructing the rectangle where m_k(i) is located.
+    */
+  private def xRange(k: Algebraic, dLeft: Algebraic, dRight: Algebraic): (Algebraic, Algebraic) = {
+    Seq(L(k, dLeft), L(k, dRight), U(k - 1, dLeft), U(k - 1, dRight))
+      // not safe
+      .sortBy(_.toDouble)
+      .drop(1)
+      .dropRight(1) match { case Seq(l, r) => (l, r) }
+  }
+
+  // U_k = (k + rho) * d, L_k = (k - rho) * d
+  /** find the intersection point between L`k` and `d` */
+  private def L(k: Algebraic, d: Algebraic): Algebraic = lRate(k) * d
+
+  /** slope factor of L_k
+    *
+    * @note 5.56
+    */
+  private def lRate(k: Algebraic): Algebraic = k - rho
+
+  /** find the intersection point between U`k` and `d` */
+  private def U(k: Algebraic, d: Algebraic): Algebraic = uRate(k) * d
+
+  /** slope factor of U_k
+    *
+    * @note 5.56
+    */
+  private def uRate(k: Algebraic): Algebraic = k + rho
+}

arithmetic/src/division/srt/srt16/OTF.scala

@@ -0,0 +1,50 @@
+package division.srt.srt16
+
+import division.srt._
+import chisel3._
+import chisel3.util.Mux1H
+
+class OTF(radixLog2: Int, qWidth: Int, ohWidth: Int) extends Module {
+  val input = IO(Input(new OTFInput(qWidth, ohWidth)))
+  val output = IO(Output(new OTFOutput(qWidth)))
+
+  val radix: Int = 1 << radixLog2
+  // datapath
+  // q_j+1 in this circle, only for srt4
+  val qNext: UInt = Mux1H(
+    Seq(
+      input.selectedQuotientOH(0) -> "b110".U,
+      input.selectedQuotientOH(1) -> "b111".U,
+      input.selectedQuotientOH(2) -> "b000".U,
+      input.selectedQuotientOH(3) -> "b001".U,
+      input.selectedQuotientOH(4) -> "b010".U
+    )
+  )
+
+  // val cShiftQ:  Bool = qNext >= 0.U
+  // val cShiftQM: Bool = qNext <=  0.U
+  val cShiftQ:  Bool = input.selectedQuotientOH(ohWidth - 1, ohWidth / 2).orR
+  val cShiftQM: Bool = input.selectedQuotientOH(ohWidth / 2, 0).orR
+  val qIn:      UInt = Mux(cShiftQ, qNext, radix.U + qNext)(radixLog2 - 1, 0)
+  val qmIn:     UInt = Mux(!cShiftQM, qNext - 1.U, (radix - 1).U + qNext)(radixLog2 - 1, 0)
+
+  output.quotient := Mux(cShiftQ, input.quotient, input.quotientMinusOne)(qWidth - radixLog2, 0) ## qIn
+  output.quotientMinusOne := Mux(!cShiftQM, input.quotient, input.quotientMinusOne)(qWidth - radixLog2, 0) ## qmIn
+}
+
+object OTF {
+  def apply(
+    radixLog2:          Int,
+    qWidth:             Int,
+    ohWidth:            Int
+  )(quotient:           UInt,
+    quotientMinusOne:   UInt,
+    selectedQuotientOH: UInt
+  ): Vec[UInt] = {
+    val m = Module(new OTF(radixLog2, qWidth, ohWidth))
+    m.input.quotient := quotient
+    m.input.quotientMinusOne := quotientMinusOne
+    m.input.selectedQuotientOH := selectedQuotientOH
+    VecInit(m.output.quotient, m.output.quotientMinusOne)
+  }
+}