Gemmini测试test文件chisel源码详解（一）

DMACommandTrackerTest.scala

源码如下：

package gemminiimport scala.collection.mutable.ArrayBufferimport chisel3._
import chisel3.iotesters.{ChiselFlatSpec, PeekPokeTester}class DMACommandTrackerTester(c: DMAReadCommandTracker[UInt]) extends PeekPokeTester(c) {case class AllocatedCmd(id: Int, tag: Int, requestsSent: Int)var max_cycles = 100000000var cmdsToAllocate = 100val cmdIdsAllocated: ArrayBuffer[AllocatedCmd] = ArrayBuffer() // TODO use a map insteadwhile ((cmdsToAllocate > 0 || cmdIdsAllocated.size > 0) && max_cycles > 0) {val can_allocate = cmdsToAllocate > 0 && rnd.nextBoolean()poke(c.io.alloc.valid, can_allocate)val tag = rnd.nextInt(100)poke(c.io.alloc.bits.tag, tag)val can_read_cmd = rnd.nextBoolean()poke(c.io.cmd_completed.ready, can_read_cmd)if (rnd.nextBoolean() || cmdIdsAllocated.size == 0) {poke(c.io.request_returned.valid, false)} else {val cmd_buf_id = rnd.nextInt(cmdIdsAllocated.size)val id = cmdIdsAllocated(cmd_buf_id).idval requestsSent = cmdIdsAllocated(cmd_buf_id).requestsSentif (requestsSent < c.nRequests) {poke(c.io.request_returned.valid, true)poke(c.io.request_returned.bits.cmd_id, id)cmdIdsAllocated(cmd_buf_id) = cmdIdsAllocated(cmd_buf_id).copy(requestsSent=requestsSent+1)} else {poke(c.io.request_returned.valid, false)}}val alloc_fire = can_allocate && peek(c.io.alloc.ready) != 0if (alloc_fire) {cmdsToAllocate -= 1val cmd_id = peek(c.io.alloc.bits.cmd_id).toIntassert(!cmdIdsAllocated.exists(_.id == cmd_id), s"$cmd_id already allocated")cmdIdsAllocated += AllocatedCmd(cmd_id, tag, 0)}val cmd_completed_fire = can_read_cmd && peek(c.io.cmd_completed.valid) != 0if (cmd_completed_fire) {val cmd_id = peek(c.io.cmd_completed.bits.cmd_id).toIntval cmd_buf_id = cmdIdsAllocated.zipWithIndex.collectFirst { case (AllocatedCmd(id, _, _), i) if id == cmd_id => i }.getval tag = peek(c.io.cmd_completed.bits.tag).toIntif (cmdIdsAllocated(cmd_buf_id).tag != tag) {println(s"wrong tag, $tag, ${cmdIdsAllocated(cmd_buf_id).tag}")max_cycles = 0}assert(cmdIdsAllocated(cmd_buf_id).tag == tag, "tag is incorrect")assert(cmdIdsAllocated(cmd_buf_id).requestsSent == c.nRequests, "returned after wrong number of requests returned")cmdIdsAllocated.remove(cmd_buf_id)}step(1)max_cycles -= 1}assert(max_cycles > 0, "reached max_cycles")
}class DMACommandTrackerUnitTest extends ChiselFlatSpec {val testerArgs = Array("--backend-name", "treadle",// "--generate-vcd-output", "on","--target-dir", "test_run_dir/dmacommandtracker")behavior of "DMACommandTracker"it should "work" in {chisel3.iotesters.Driver.execute(testerArgs, () => new DMAReadCommandTracker(2, 16, UInt(29.W))) {c => new DMACommandTrackerTester(c)} should be (true)}
}

这段代码是用于测试 DMAReadCommandTracker 模块的功能和正确性。DMAReadCommandTracker 模块是一个用于跟踪 DMA 读取命令的状态的硬件模块，它可以分配和回收命令 id 和 tag，并在所有请求都返回后输出完成信号。

这段代码包含两个类，DMACommandTrackerTester 和 DMACommandTrackerUnitTest。DMACommandTrackerTester 类是一个用于对 DMAReadCommandTracker 模块进行输入输出操作和断言检查的测试类。

DMACommandTrackerUnitTest 类是一个用于运行 DMACommandTrackerTester 的测试类，它继承自 ChiselFlatSpec 类，并指定了一些测试参数，如后端名称，目标目录等。

这段代码的目的是验证 DMAReadCommandTracker 模块是否能正确地分配和回收命令 id 和 tag，并在所有请求都返回后输出完成信号。

• DMACommandTrackerTester 类是一个继承自 PeekPokeTester 的测试器类，它接受一个 DMAReadCommandTracker 类型的参数 c。

  • AllocatedCmd 是一个 case class，它用于存储已分配命令的 id、tag 和 requestsSent，id是命令编号、tag是标签（记录版本类型等）、requestsSent记录命令的进度。
  • max_cycles 是一个整数变量，它表示最大的执行周期数，用于限制测试的时间。
  • cmdsToAllocate 是一个整数变量，它表示要分配的命令数量，初始值为 100。
  • cmdIdsAllocated 是一个 ArrayBuffer 类型的变量，它用于存储已分配命令的 AllocatedCmd 对象。
  • while 循环是测试的主要逻辑，它在 cmdsToAllocate 大于 0 或 cmdIdsAllocated 不为空，并且 max_cycles 大于 0 的条件下执行。循环中包含以下步骤：
    • 随机决定是否可以分配新的命令，并将结果赋值给 can_allocate 变量，然后将其 poke 给 c.io.alloc.valid 输入端口。
    • 随机生成一个 0 到 99 之间的整数作为 tag，并将其 poke 给 c.io.alloc.bits.tag 输入端口。
    • 随机决定是否可以读取已完成的命令，并将结果赋值给 can_read_cmd 变量，然后将其 poke 给 c.io.cmd_completed.ready 输入端口。
    • 如果随机决定不返回请求或 cmdIdsAllocated 为空，则将 false poke 给 c.io.request_returned.valid 输入端口；否则，从 cmdIdsAllocated 中随机选择一个已分配命令，获取其 id 和 requestsSent，如果 requestsSent 小于 c.nRequests，则将 true poke 给 c.io.request_returned.valid 输入端口，并将 id poke 给 c.io.request_returned.bits.cmd_id 输入端口，同时将 cmdIdsAllocated 中对应的 AllocatedCmd 对象的 requestsSent 增加 1；否则，将 false poke 给 c.io.request_returned.valid 输入端口。
    • 判断是否发生了 alloc_fire 事件，即 can_allocate 为 true 并且 c.io.alloc.ready 输出端口为 true。如果是，则将 cmdsToAllocate 减 1，并从 c.io.alloc.bits.cmd_id 输出端口读取分配的 cmd_id，断言 cmdIdsAllocated 中不存在相同的 id，并将新建的 AllocatedCmd 对象添加到 cmdIdsAllocated 中。
    • 判断是否发生了 cmd_completed_fire 事件，即 can_read_cmd 为 true 并且 c.io.cmd_completed.valid 输出端口为 true。如果是，则从 c.io.cmd_completed.bits.cmd_id 和 c.io.cmd_completed.bits.tag 输出端口读取完成的 cmd_id 和 tag，并在 cmdIdsAllocated 中找到对应的 AllocatedCmd 对象和索引。如果对象中的 tag 不等于输出端口中的 tag，则打印错误信息并将 max_cycles 设为 0；否则，断言对象中的 tag 等于输出端口中的 tag，并断言对象中的 requestsSent 等于 c.nRequests，然后从 cmdIdsAllocated 中移除该对象。
    • 调用 step(1) 方法执行一个时钟周期，并将 max_cycles 减 1。
  • 在 while 循环结束后，断言 max_cycles 大于 0，表示测试没有超时。

• DMACommandTrackerUnitTest 类是一个继承自 ChiselFlatSpec 的单元测试类，它定义了一些变量和方法。

  • testerArgs 是一个字符串数组，它存储了一些测试参数，如后端名称、目标目录等。
  • behavior of “DMACommandTracker” 是一个字符串字面量，它表示要测试的类名。
  • it should “work” 是一个方法，它表示要测试的功能。方法中包含以下步骤：
    • 调用 chisel3.iotesters.Driver.execute 方法，传入 testerArgs 和一个匿名函数，该函数返回一个新建的 DMAReadCommandTracker 对象，其参数为 2、16 和 UInt(29.W)。
    • 在 execute 方法的第二个参数中，传入一个匿名函数，该函数接受一个 DMAReadCommandTracker 类型的参数 c，并返回一个新建的 DMACommandTrackerTester 对象，其参数为 c。
    • 在 execute 方法的返回值上调用 should be (true) 方法，断言测试结果为 true。

注释版：

package gemminiimport scala.collection.mutable.ArrayBufferimport chisel3._
import chisel3.iotesters.{ChiselFlatSpec, PeekPokeTester}//测试 DMAReadCommandTracker 模块的功能和正确性。
//DMAReadCommandTracker 模块是一个用于跟踪 DMA 读取命令的状态的硬件模块，它可以分配和回收命令 id 和 tag，并在所有请求都返回后输出完成信号。
//包含两个类，DMACommandTrackerTester 和 DMACommandTrackerUnitTest。
//DMACommandTrackerTester 类是一个用于对 DMAReadCommandTracker 模块进行输入输出和断言检查的测试类。
//DMACommandTrackerUnitTest 类是一个用于运行 DMACommandTrackerTester 的测试类
//这段代码的目的是验证 DMAReadCommandTracker 模块是否能正确地分配和回收命令 id 和 tag，并在所有请求都返回后输出完成信号。class DMACommandTrackerTester(c: DMAReadCommandTracker[UInt]) extends PeekPokeTester(c) {
//用于存储已分配命令的 id、tag 和 requestsSent，id是命令编号、tag是标签（记录版本类型等）、requestsSent记录命令的进度。case class AllocatedCmd(id: Int, tag: Int, requestsSent: Int)
//最大的执行周期数var max_cycles = 100000000
//要分配的命令数量，初始值为 100；cmdIdsAllocated存储已分配命令的 AllocatedCmd 对象var cmdsToAllocate = 100val cmdIdsAllocated: ArrayBuffer[AllocatedCmd] = ArrayBuffer() // TODO use a map instead
//循环条件：1.还有剩余的周期数可执行 2.待分配命令数不是0或者已分配命令不为空while ((cmdsToAllocate > 0 || cmdIdsAllocated.size > 0) && max_cycles > 0) {
//当还有命令可以分配的时候，随机决定是否可以分配新的命令，并将结果赋值给 can_allocate 变量，然后将其 poke 给 c.io.alloc.valid 输入端口。val can_allocate = cmdsToAllocate > 0 && rnd.nextBoolean()poke(c.io.alloc.valid, can_allocate)
//随机生成一个 0 到 99 之间的整数作为 tag，并将其 poke 给 c.io.alloc.bits.tag 输入端口。val tag = rnd.nextInt(100)poke(c.io.alloc.bits.tag, tag)
//随机决定是否可以读取已完成的命令，并将结果赋值给 can_read_cmd 变量，然后将其 poke 给 c.io.cmd_completed.ready 输入端口。
//当 can_read_cmd 为 true 时，表示允许读取已完成的命令，即表明模块已准备好接收命令完成的信号。当 can_read_cmd 为 false 时，表示不允许读取已完成的命令，即表明模块不准备接收命令完成的信号。val can_read_cmd = rnd.nextBoolean()poke(c.io.cmd_completed.ready, can_read_cmd)
//如果随机决定不返回请求或 cmdIdsAllocated 为空，则将 false poke 给 c.io.request_returned.valid 输入端口if (rnd.nextBoolean() || cmdIdsAllocated.size == 0) {poke(c.io.request_returned.valid, false)} else {
//从 cmdIdsAllocated 中随机选择一个已分配命令，获取其 id 和 requestsSentval cmd_buf_id = rnd.nextInt(cmdIdsAllocated.size)val id = cmdIdsAllocated(cmd_buf_id).idval requestsSent = cmdIdsAllocated(cmd_buf_id).requestsSent//nRequests 用于表示每个已分配的命令所需的请求次数。在这个上下文中，当已分配的命令的请求次数达到 nRequests 时，该命令将被认为是完成的。
//如果 requestsSent 小于 c.nRequests，则将 true poke 给 c.io.request_returned.valid 输入端口
//将 id poke 给 c.io.request_returned.bits.cmd_id 输入端口，同时将 cmdIdsAllocated 中对应的 AllocatedCmd 对象的 requestsSent 增加 1；否则，将 false poke 给 c.io.request_returned.valid 输入端口。//说白了就是判断这个命令是否完成了，然后作相应操作if (requestsSent < c.nRequests) {poke(c.io.request_returned.valid, true)poke(c.io.request_returned.bits.cmd_id, id)cmdIdsAllocated(cmd_buf_id) = cmdIdsAllocated(cmd_buf_id).copy(requestsSent=requestsSent+1)} else {poke(c.io.request_returned.valid, false)}}
//检查是否可以分配命令，（即 can_allocate 为 true 并且 c.io.alloc.ready 输出端口为 true）
//如果是，则将 cmdsToAllocate 减 1，并从 c.io.alloc.bits.cmd_id 输出端口读取分配的 cmd_id，断言 cmdIdsAllocated 中不存在相同的 id，并将新建的 AllocatedCmd 对象添加到 cmdIdsAllocated 中。val alloc_fire = can_allocate && peek(c.io.alloc.ready) != 0if (alloc_fire) {cmdsToAllocate -= 1val cmd_id = peek(c.io.alloc.bits.cmd_id).toIntassert(!cmdIdsAllocated.exists(_.id == cmd_id), s"$cmd_id already allocated")cmdIdsAllocated += AllocatedCmd(cmd_id, tag, 0)}
//检查是否可以读取完成的命令，（即 can_read_cmd 为 true 且 c.io.cmd_completed.valid 输出端口的值不为 0）
//如果是，则读取id和tag，并在 cmdIdsAllocated 中找到对应的 AllocatedCmd 对象和索引。
//如果原tag与输出端口的tag不同就报错，相同就删除这个命令val cmd_completed_fire = can_read_cmd && peek(c.io.cmd_completed.valid) != 0if (cmd_completed_fire) {val cmd_id = peek(c.io.cmd_completed.bits.cmd_id).toIntval cmd_buf_id = cmdIdsAllocated.zipWithIndex.collectFirst { case (AllocatedCmd(id, _, _), i) if id == cmd_id => i }.getval tag = peek(c.io.cmd_completed.bits.tag).toIntif (cmdIdsAllocated(cmd_buf_id).tag != tag) {println(s"wrong tag, $tag, ${cmdIdsAllocated(cmd_buf_id).tag}")max_cycles = 0}assert(cmdIdsAllocated(cmd_buf_id).tag == tag, "tag is incorrect")assert(cmdIdsAllocated(cmd_buf_id).requestsSent == c.nRequests, "returned after wrong number of requests returned")cmdIdsAllocated.remove(cmd_buf_id)}
//每次循环周期减少step(1)max_cycles -= 1}
//判断有没有超市assert(max_cycles > 0, "reached max_cycles")
}class DMACommandTrackerUnitTest extends ChiselFlatSpec {
//存取测试参数val testerArgs = Array("--backend-name", "treadle",// "--generate-vcd-output", "on","--target-dir", "test_run_dir/dmacommandtracker")
//表示要测试的是 DMACommandTracker 模块behavior of "DMACommandTracker"it should "work" in {chisel3.iotesters.Driver.execute(testerArgs, () => new DMAReadCommandTracker(2, 16, UInt(29.W))) {c => new DMACommandTrackerTester(c)} should be (true)//测试参数与断言测试结果}
}