fixed compile errors, made problem templates match solutions, trimmed unneeded imports, fixed testcase logic for DynamicMemorySearch

Author: sbeamer

problems/Accumulator.scala

@@ -1,7 +1,6 @@
 package TutorialProblems
 
 import Chisel._
-import Node._
 
 class Accumulator extends Module {
   val io = new Bundle {
@@ -19,7 +18,7 @@ class AccumulatorTests(c: Accumulator) extends Tester(c) {
     val in = rnd.nextInt(2)
     poke(c.io.in, in)
     step(1)
-    expect(c.io.out, tot)
     if (in == 1) tot += 1
+    expect(c.io.out, tot)
   }
 }

problems/Counter.scala

@@ -1,7 +1,6 @@
 package TutorialProblems
 
 import Chisel._
-import Node._
 import Counter._
 
 object Counter {
@@ -14,7 +13,7 @@ object Counter {
   // amt only when en is asserted
   // ---------------------------------------- \\
 
-  def counter(max: UInt, en: Bool, amt: UInt) = {
+  def counter(max: UInt, en: Bool, amt: UInt): UInt = {
     val x = Reg(init=UInt(0, max.getWidth))
     x := wrapAround(x + UInt(1), max)
     x
@@ -44,7 +43,7 @@ class CounterTest(c: Counter) extends Tester(c) {
 
   // let it spin for a bit
   for (i <- 0 until 5) {
-    step(vars, isTrace = false)
+    step(1)
   }
 
   for (i <- 0 until 10) {
@@ -53,8 +52,8 @@ class CounterTest(c: Counter) extends Tester(c) {
     poke(c.io.inc, if (inc) 1 else 0)
     poke(c.io.amt, amt)
     step(1)
-    expect(c.io.tot, curCnt)
     curCnt = if(inc) intWrapAround(curCnt + amt, 255) else curCnt
+    expect(c.io.tot, curCnt)
   }
 }
 

problems/DynamicMemorySearch.scala

@@ -12,8 +12,9 @@ class DynamicMemorySearch extends Module {
     val done   = Bool(OUTPUT)
   }
   val index  = Reg(init = UInt(0, width = 3))
-  val memVal = UInt(0) // TODO REPLACE HERE WITH MEM
+  val memVal = UInt(0) // TODO replace here with mem
   val done   = !io.en && ((memVal === io.data) || (index === UInt(7)))
+  // TODO handle writes to memory (isWr, wrAddr, data)
   when (io.en) {
     index := UInt(0)
   } .elsewhen (done === Bool(false)) {
@@ -24,19 +25,19 @@ class DynamicMemorySearch extends Module {
 }
 
 class DynamicMemorySearchTests(c: DynamicMemorySearch) extends Tester(c) {
-  val list  = Array.fill(8){ 0 }
+  val list = Array.fill(8){ 0 }
   for (k <- 0 until 16) {
     // WRITE A WORD
-    poke(c.io.en,   0)
+    poke(c.io.en, 0)
     poke(c.io.isWr, 1)
-    val wrAddr   = rnd.nextInt(8-1)
-    val data     = rnd.nextInt(16)
+    val wrAddr = rnd.nextInt(8-1)
+    val data = rnd.nextInt(15) + 1 // can't be 0
     poke(c.io.wrAddr, wrAddr)
     poke(c.io.data,   data)
     step(1)
     list(wrAddr) = data
     // SETUP SEARCH
-    val target   = rnd.nextInt(16)
+    val target = if (k>12) rnd.nextInt(16) else data
     poke(c.io.isWr, 0)
     poke(c.io.data, target)
     poke(c.io.en, 1)
@@ -46,7 +47,9 @@ class DynamicMemorySearchTests(c: DynamicMemorySearch) extends Tester(c) {
       step(1)
     } while (peek(c.io.done) == 0)
     val addr = peek(c.io.target).toInt
-    expect(addr == list.length || list(addr) == target, 
-           "LOOKING FOR " + target + " FOUND " + addr)
+    if (list contains target)
+      expect(list(addr) == target, "LOOKING FOR " + target + " FOUND " + addr)
+    else
+      expect(addr==(list.length-1), "LOOKING FOR " + target + " FOUND " + addr)
   }
 }

problems/LFSR16.scala

@@ -17,10 +17,10 @@ class LFSR16Tests(c: LFSR16) extends Tester(c) {
     val inc = rnd.nextInt(2)
     poke(c.io.inc, inc)
     step(1)
-    expect(c.io.out, res)
     if (inc == 1) {
       val bit = ((res >> 0) ^ (res >> 2) ^ (res >> 3) ^ (res >> 5) ) & 1;
       res = (res >> 1) | (bit << 15);
     }
+    expect(c.io.out, res)
   }
 }

problems/MaxN.scala

@@ -7,10 +7,10 @@ class MaxN(val n: Int, val w: Int) extends Module {
   private def Max2(x: UInt, y: UInt) = Mux(x > y, x, y)
 
   val io = new Bundle {
-    val in  = Vec.fill(n){ UInt(INPUT, w) }
+    val ins = Vec.fill(n){ UInt(INPUT, w) }
     val out = UInt(OUTPUT, w)
   }
-  io.out := io.in.reduceLeft(Max2)
+  io.out := io.ins.reduceLeft(Max2)
 }
 
 class MaxNTests(c: MaxN) extends Tester(c) {

problems/Mux4.scala

@@ -1,7 +1,6 @@
 package TutorialProblems
 
 import Chisel._
-import scala.math._
 
 class Mux4 extends Module {
   val io = new Bundle {

problems/RealGCD.scala

@@ -23,19 +23,21 @@ class RealGCDTests(c: RealGCD) extends Tester(c) {
 
   var i = 0
   do {
+    var transfer = false
     do {
       poke(c.io.in.bits.a, inputs(i)._1)
       poke(c.io.in.bits.b, inputs(i)._2)
       poke(c.io.in.valid,  1)
+      transfer = (peek(c.io.in.ready) == 1)
       step(1)
-    } while (t < 100 && peek(c.io.in.ready) == 0);
+    } while (t < 100 && !transfer)
 
     do {
       poke(c.io.in.valid, 0)
       step(1)
-    } while (t < 100 && peek(c.io.out.valid) == 0);
+    } while (t < 100 && (peek(c.io.out.valid) == 0))
     expect(c.io.out.bits, outputs(i))
     i += 1;
-  } while (t < 100 && i < 3);
-  if (t >= 100) ok = false;
+  } while (t < 100 && i < 3)
+  if (t >= 100) ok = false
 }

problems/VendingMachine.scala

@@ -17,16 +17,23 @@ class VendingMachine extends Module {
 }
 
 class VendingMachineTests(c: VendingMachine) extends Tester(c) {  
-  var money   = 0
+  var money = 0
+  var isValid = false
   for (t <- 0 until 20) {
     val coin     = rnd.nextInt(3)*5
     val isNickel = coin == 5
     val isDime   = coin == 10
+
+    // Advance circuit
     poke(c.io.nickel, Bool(isNickel).litValue())
-    poke(c.io.dime, Bool(isDime).litValue())
+    poke(c.io.dime,   Bool(isDime).litValue())
     step(1)
-    val isValid = money >= 20
-    expect(c.io.valid, Bool(isValid).litValue())
+
+    // Advance model
     money = if (isValid) 0 else (money + coin)
+    isValid = money >= 20
+
+    // Compare
+    expect(c.io.valid, Bool(isValid).litValue())
   }
 }

solutions/Counter.scala

@@ -2,7 +2,6 @@ package TutorialSolutions
 
 import Chisel._
 import Counter._
-import scala.collection.mutable.ArrayBuffer
 
 object Counter {
 

solutions/DynamicMemorySearch.scala

@@ -8,15 +8,13 @@ class DynamicMemorySearch extends Module {
     val wrAddr = UInt(INPUT, 3)
     val data   = UInt(INPUT, 4)
     val en     = Bool(INPUT)
-    val elt    = UInt(OUTPUT, 4)
-    val target = UInt(OUTPUT, 4)
+    val target = UInt(OUTPUT, 3)
     val done   = Bool(OUTPUT)
   }
-  val index = Reg(init = UInt(0, width = 3))
-  val list  = Mem(UInt(width = 4), 8)
-  val elt   = list(index)
-  io.elt   := elt
-  val done  = !io.en && ((elt === io.data) || (index === UInt(7)))
+  val index  = Reg(init = UInt(0, width = 3))
+  val list = Mem(UInt(width = 4), 8)
+  val memVal = list(index)
+  val done   = !io.en && ((memVal === io.data) || (index === UInt(7)))
   when (io.isWr) {
     list(io.wrAddr) := io.data
   } .elsewhen (io.en) {
@@ -32,28 +30,28 @@ class DynamicMemorySearchTests(c: DynamicMemorySearch) extends Tester(c) {
   val list = Array.fill(8){ 0 }
   for (k <- 0 until 16) {
     // WRITE A WORD
-    poke(c.io.en,   0)
+    poke(c.io.en, 0)
     poke(c.io.isWr, 1)
     val wrAddr = rnd.nextInt(8-1)
-    val data   = rnd.nextInt(16)
+    val data = rnd.nextInt(15) + 1 // can't be 0
     poke(c.io.wrAddr, wrAddr)
     poke(c.io.data,   data)
     step(1)
     list(wrAddr) = data
     // SETUP SEARCH
-    // val target   = rnd.nextInt(16)
-    val target   = data
+    val target = if (k>12) rnd.nextInt(16) else data
     poke(c.io.isWr, 0)
     poke(c.io.data, target)
-    poke(c.io.en,   1)
+    poke(c.io.en, 1)
     step(1)
     do {
       poke(c.io.en, 0)
       step(1)
-      peek(c.index); peek(c.io.elt)
     } while (peek(c.io.done) == 0)
     val addr = peek(c.io.target).toInt
-    expect(addr == list.length || list(addr) == target, 
-           "LOOKING FOR " + target + " FOUND " + addr)
+    if (list contains target)
+      expect(list(addr) == target, "LOOKING FOR " + target + " FOUND " + addr)
+    else
+      expect(addr==(list.length-1), "LOOKING FOR " + target + " FOUND " + addr)
   }
 }