init

Author: sequencer

.github/workflows/push.yml

@@ -0,0 +1,13 @@
+on: [pull_request]
+jobs:
+  checks:
+    runs-on: ubuntu-latest
+    container: archlinux/archlinux:latest
+    steps:
+      - name: Install dependencies
+        run: pacman -Syu --noconfirm make mill z3
+      - uses: actions/checkout@v2
+      - name: Check Format
+        run: make checkformat
+      - name: Test
+        run: make test

.gitignore

@@ -0,0 +1,6 @@
+# mill
+out/
+.bsp/
+.idea/
+.idea_modules/
+test_run_dir/

.scalafmt.conf

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

Makefile

@@ -0,0 +1,20 @@
+compile:
+	mill -i __.compile
+
+bsp:
+	mill -i mill.bsp.BSP/install
+
+clean:
+	git clean -fd
+
+cleanAll:
+	git clean -fdx
+
+reformat:
+	mill -i __.reformat
+
+checkformat:
+	mill -i __.checkFormat 
+
+test:
+	mill -i __.test

build.sc

@@ -0,0 +1,33 @@
+// import Mill dependency
+import mill._
+import mill.scalalib._
+import mill.scalalib.scalafmt.ScalafmtModule
+import mill.scalalib.TestModule.Utest
+// support BSP
+import mill.bsp._
+
+object playground extends ScalaModule with ScalafmtModule { m =>
+  override def scalaVersion = "2.12.13"
+  override def scalacOptions = Seq(
+    "-Xsource:2.11",
+    "-language:reflectiveCalls",
+    "-deprecation",
+    "-feature",
+    "-Xcheckinit",
+    // Enables autoclonetype2 in 3.4.x (on by default in 3.5)
+    "-P:chiselplugin:useBundlePlugin"
+  )
+  override def ivyDeps = Agg(
+    ivy"edu.berkeley.cs::chisel3:3.4.3",
+  )
+  override def scalacPluginIvyDeps = Agg(
+    ivy"edu.berkeley.cs:::chisel3-plugin:3.4.3",
+    ivy"org.scalamacros:::paradise:2.1.1"
+  )
+  object test extends Tests with Utest {
+    override def ivyDeps = m.ivyDeps() ++ Agg(
+      ivy"com.lihaoyi::utest:0.7.10",
+      ivy"edu.berkeley.cs::chiseltest:0.3.3",
+    )
+  }
+}

playground/src/DecoupledGCD.scala

@@ -0,0 +1,69 @@
+import chisel3._
+import chisel3.util.Decoupled
+
+class GcdInputBundle(val w: Int) extends Bundle {
+  val value1 = UInt(w.W)
+  val value2 = UInt(w.W)
+}
+
+class GcdOutputBundle(val w: Int) extends Bundle {
+  val value1 = UInt(w.W)
+  val value2 = UInt(w.W)
+  val gcd    = UInt(w.W)
+}
+
+/**
+  * Compute Gcd using subtraction method.
+  * Subtracts the smaller from the larger until register y is zero.
+  * value input register x is then the Gcd.
+  * Unless first input is zero then the Gcd is y.
+  * Can handle stalls on the producer or consumer side
+  */
+class DecoupledGcd(width: Int) extends MultiIOModule {
+  val input  = IO(Flipped(Decoupled(new GcdInputBundle(width))))
+  val output = IO(Decoupled(new GcdOutputBundle(width)))
+
+  val xInitial    = Reg(UInt())
+  val yInitial    = Reg(UInt())
+  val x           = Reg(UInt())
+  val y           = Reg(UInt())
+  val busy        = RegInit(false.B)
+  val resultValid = RegInit(false.B)
+
+  input.ready  := !busy
+  output.valid := resultValid
+  output.bits  := DontCare
+
+  when(busy) {
+    when(x > y) {
+      x := x - y
+    }.otherwise {
+      y := y - x
+    }
+    when(x === 0.U || y === 0.U) {
+      when(x === 0.U) {
+        output.bits.gcd := y
+      }.otherwise {
+        output.bits.gcd := x
+      }
+
+      output.bits.value1 := xInitial
+      output.bits.value2 := yInitial
+      resultValid        := true.B
+
+      when(output.ready && resultValid) {
+        busy        := false.B
+        resultValid := false.B
+      }
+    }
+  }.otherwise {
+    when(input.valid) {
+      val bundle = input.deq()
+      x        := bundle.value1
+      y        := bundle.value2
+      xInitial := bundle.value1
+      yInitial := bundle.value2
+      busy     := true.B
+    }
+  }
+}

playground/src/GCD.scala

@@ -0,0 +1,29 @@
+import chisel3._
+
+/**
+  * Compute GCD using subtraction method.
+  * Subtracts the smaller from the larger until register y is zero.
+  * value in register x is then the GCD
+  */
+class GCD extends Module {
+  val io = IO(new Bundle {
+    val value1        = Input(UInt(16.W))
+    val value2        = Input(UInt(16.W))
+    val loadingValues = Input(Bool())
+    val outputGCD     = Output(UInt(16.W))
+    val outputValid   = Output(Bool())
+  })
+
+  val x = Reg(UInt())
+  val y = Reg(UInt())
+
+  when(x > y) { x := x - y }.otherwise { y := y - x }
+
+  when(io.loadingValues) {
+    x := io.value1
+    y := io.value2
+  }
+
+  io.outputGCD   := x
+  io.outputValid := y === 0.U
+}

playground/test/src/GCDSpec.scala

@@ -0,0 +1,48 @@
+import chisel3._
+import chisel3.tester._
+import chisel3.experimental.BundleLiterals._
+
+import utest._
+
+/**
+  * This is a trivial example of how to run this Specification
+  * From within sbt use:
+  * {{{
+  * testOnly gcd.GcdDecoupledTester
+  * }}}
+  * From a terminal shell use:
+  * {{{
+  * sbt 'testOnly gcd.GcdDecoupledTester'
+  * }}}
+  */
+object GCDSpec extends ChiselUtestTester {
+  val tests = Tests {
+    test("GCD") {
+      testCircuit(new DecoupledGcd(16)) {
+        dut =>
+          dut.input.initSource()
+          dut.input.setSourceClock(dut.clock)
+          dut.output.initSink()
+          dut.output.setSinkClock(dut.clock)
+          val testValues = for {x <- 0 to 10; y <- 0 to 10} yield (x, y)
+          val inputSeq = testValues.map { case (x, y) => (new GcdInputBundle(16)).Lit(_.value1 -> x.U, _.value2 -> y.U) }
+          val resultSeq = testValues.map { case (x, y) =>
+            (new GcdOutputBundle(16)).Lit(_.value1 -> x.U, _.value2 -> y.U, _.gcd -> BigInt(x).gcd(BigInt(y)).U)
+          }
+          fork {
+            // push inputs into the calculator, stall for 11 cycles one third of the way
+            val (seq1, seq2) = inputSeq.splitAt(resultSeq.length / 3)
+            dut.input.enqueueSeq(seq1)
+            dut.clock.step(11)
+            dut.input.enqueueSeq(seq2)
+          }.fork {
+            // retrieve computations from the calculator, stall for 10 cycles one half of the way
+            val (seq1, seq2) = resultSeq.splitAt(resultSeq.length / 2)
+            dut.output.expectDequeueSeq(seq1)
+            dut.clock.step(10)
+            dut.output.expectDequeueSeq(seq2)
+          }.join()
+      }
+    }
+  }
+}