吃透Chisel语言.40.Chisel实战之单周期RISC-V处理器实现（下）—

上一篇文章中我们对本项目的需求进行了分析，并得到了初步的设计，这一篇文章我们就可以基于该设计来实现我们的单周期RISC-V处理器了。实现之后也必须用实际代码来测试一下，至少也得能运行递归版本的斐波那契数列计算。完整项目代码可以在本人的Github仓库获取：github-3rr0r/RV32ISC: A RISC-V RV32I ISA Single Cycle CPU。接下来我们直接进入正题！

实现思路

根据上篇文章的分析，我们设计的CPU中应该至少需要包含以下组件：

模块化思维必须要有，如果把一个复杂的系统全都塞到一个代码文件里面，不管是编写、测试还是调试、迭代，都会有巨大的麻烦在等着你。而模块化的设计可以让模块之间相互独立，可以分别编写、测试各个模块，修改时也不会影响其他模块。

由于我们在设计时已经将系统划分出各个模块，因此分别实现为一个Chisel的Module，然后用一个顶层的Module将它们连接起来就可以了。

全局配置文件

磨刀不误砍柴工，在实现各个模块之前，我们做一件事会对我们很有帮助，那就是创建一个全局配置文件。

为什么要这么做呢？比如，我们实现的是32位的处理器，那么32这个数字肯定在编写过程中经常使用。我们当然可以在所有文件中都使用32这个数字，但是扩展性就会有很大的问题。比如要把项目迁移到64位实现，我们只能一个个数字去修改，而如果有全局配置文件，我们就可以直接在里面用一个对象来存放32这个数，在需要用32的地方使用这个对象，如果需要改成64，那么直接修改该对象的值就行了。

上面的说法可能不太严谨，但适用场合很多，拿我们的项目来说，虽然只是个单周期32位处理器，但也还是有其他东西是可以配置的，比如内存初始化的地址等。复杂的项目可能还可以用于配置Cache的参数、内存的端口数等。总之，这是个好的做法，我们应该形成这种思维。

那么我们在src/main/scala/config文件夹下创建一个Configs.scala文件，内容暂时如下：

注意，config文件夹是自己创建的，使用Configs.scala中的对象时，将文件夹名作为包名使用，导入所有参数即可：

PC寄存器的实现

所以我们可以这么实现PCReg模块（src/main/scala/rv32isc/PCReg.scala）：

注意，这里我们用到了一个常量START_ADDR用于表示起始执行地址，应该在Configs对象中包含：

接着，我们可以创建PCReg模块对应的测试（src/test/scala/rv32isc/PCRegTest.scala）：

PC寄存器将指令地址给了指令内存，指令内存给出这一周期要执行的指令，那么接下来我们就实现指令内存。

指令内存的实现

Mem生成的内存为异步读、同步写的内存，得到地址后输出指令不含时序，为组合电路，所以实现起来也特别简单：

我这里着重解释一下mem.read(io.addr >> INST_BYTE_WIDTH_LOG.U)和常量INST_BYTE_WIDTH_LOG = ceil(log(INST_BYTE_WIDTH) / log(2)).toInt：由于指令的宽度为32位，因此每次读取指令时指令地址都要对齐到4字节。而我们的指令内存的每个数据项都是四字节的，因此应该用输入的指令地址的高30位访问，即右移两位。

不过，在测试上会稍微麻烦一点，我们需要先向内存中写入一些模拟的指令填满内存，在内存初始化的时候用loadMemoryFromFile写入mem。我们在MemInst类中添加初始化相关代码：

得到指令之后，我们就可以对指令进行译码，所以我们下一步要实现译码单元。

译码单元的实现

要对指令进行译码，首先我们需要对指令格式有清晰地了解，再次放上指令格式的图：

接下来我们分析RV32I的指令中，可以如何根据opcode对应到指令格式类型上：

可以用四位二进制数对上面的行为进行编码（空操作归为算术运算）：

操作	类型	信号编码
`NOP`	算术运算	`00_00`
加法	算术运算	`00_01`
减法	算术运算	`00_10`
与	逻辑运算	`01_00`
或	逻辑运算	`01_01`
异或	逻辑运算	`01_11`
逻辑左移	位运算	`10_00`
逻辑右移	位运算	`10_01`
算术右移	位运算	`10_11`
等于	比较运算	`11_00`
不等于	比较运算	`11_01`
小于	比较运算	`11_10`
大于等于	比较运算	`11_11`

通过对opcode、funct3、funct7可以得到上面的编码，在此不做赘述，后面看代码就行。

对于这种硬编码，我们不能每次都照着二进制数去写，有一个好方法就是专门用一个文件来存放这种硬编码，我们这里就创建一个src/main/scala/utils/HardCodes.scala文件，内容如下：

另外，我们还注意到几条末尾是U的指令，它们要求将操作数作为无符号数来进行运算，因此ALU应该还有一个输入用于指示ALU进行无符号运算还是有符号运算，用一位信号ctrlSigned就行。

还有其他的是否分支、是否跳转、是否加载、是否存储、rs1是否为PC、rs2是否为立即数等，都比较简单，分析方法类似，直接放上代码吧。下面就是src/main/scala/rv32isc/Decoder.scala的具体实现：

其中，我们使用了两个Bundle，由于这个Bundle可以在模块之间复用，所以我们将其放到一个单独的Bundle文件中供使用（src/main/scala/utils/Bundles.scala）：

这一部分其实硬写测试并不明智，这里还是放上一个随意的测试代码（src/test/scala/rv32isc/DecoderTest.scala）：

解码单元的信号输出一部分给到寄存器，用于读取寄存器中的数据，下面我们就实现寄存器。

寄存器组的实现

寄存器的实现比较简单，我们前面的文章中也有相应的例子，这里就不分析了，直接放上代码（src/main/scala/rv32isc/Registers.scala）：

数据也有了，控制信号也有了，下面我们就来实现最关键的ALU部分吧。

ALU模块的实现

虽然说ALU模块很关键，但是由于前面打下了较好的基础，所以在实现Alu模块时轻松了很多。现在控制单元到Alu有四个控制信号，所以我们还是用Bundle的方式，在src/main/scala/utils/Bundles.scala中加入：

需要注意到的是，JAL指令需要PC寄存器寄存器的值作为操作数1，所以需要增加一个输入接口。然后就可以轻松实现Alu了，具体代码（src/main/scala/rv32isc/Alu.scala）如下：

测试代码如下（因为赶时间，这里写的是有问题的，大家可以自行认真编写）：

数据内存的实现

Alu的计算结果可以直接给寄存器，也可以先给数据内存。因为LOAD、STORE类指令需要使用ALU计算得到的内存地址，所以我们完全可以把计算结果给数据内存，如果是LOAD或STORE指令，那就以此为地址读写数据，否则将结果直接发送给寄存器。

另外一点在之前的设计中忽略了的是，LOAD、STORE类指令需要区分字、半字和字节，因此我们需要在译码阶段多给控制单元一个信号，来指示操作数。并且，LOAD类指令也区分有符号无符号，因此也需要提供这个信号。

还有，STORE的数据源从哪里来？是rs2，可是我们计算地址用的是imm作为操作数2，因此，这里我们还需要把rs2里面的值给出到数据内存。

控制单元的实现

最后控制单元，但在控制单元之前，我们需要注意到JAL和JALR这两条指令的特殊性，它们存放的寄存器的值是当前的指令的地址+4，所以我们需要对寄存器堆先做一些修改，一个方面是要从控制模块给一个ctrlJump信号，另一方面是要选择写入的数据是PC+4还是数据内存返回的计算结果/加载的数据。修改后如下：

那我们就可以写控制单元了，都是些连线，没什么技术含量：

因为只有连线，就不测试了，我们直接进入最后一步，把各模块连接成一个处理器。

把各模块连接成一个处理器！

这一步仍然没有什么技术含量，把各个模块连接到一起就好了，一定要注意连线不要错连、漏连：

通过sbt run运行，可以得到最终的Verilog代码，限于篇幅，这里就不放上来了，至少可以说明，编译生成Verilog代码是看起来没问题的。

但是具体的处理器的功能验证还需要对Top模块进行测试，下面就着重说一下。

CPU的整体测试

既然是CPU，那就必须得能跑程序，也就是说我们至少能做到这样的事：

写一段C程序，然后用RISC-V的工具链编译出二进制代码，我们的CPU可以运行这样的代码。

我们可以通过loadMemoryFromFile向指令内存的内存中加载十六进制文本格式的代码，所以我们首先需要从C源文件生成这样可以加载到内存的代码。假设你已经装好了rv32i的工具链，源文件为test.c，那么生成过程如下：

但是不是没法看？都是十六进制，也不知道跟汇编指令怎么对应。没关系，一句话，让代码更好懂：

这样我们就有十六进制指令和汇编指令的对应关系了，下面我们看代码。

一个程序在执行的时候是从main函数进入的，在这段程序中，程序入口就是00000084

。对应的，要想正确执行这段程序，我们需要让我们的CPU从0x00000084开始执行。这时候，用Configs.scala存放全局变量的好处就体现出来了，我们只需要将：

val START_ADDR: Long = 0x00000000  // 起始执行地址

修改为：

val START_ADDR: Long = 0x00000084  // 起始执行地址

就行了。

有程序入口就行了嘛？当然不是。我们看第一条语句：

addi	sp,sp,-32

这对sp寄存器减了32，这个sp就是栈指针，程序进行函数调用都需要保护现场，将一些数据压栈，方便调用返回的时候恢复现场。然而这个栈应该是提前分配好空间的，栈底的地址比栈顶的地址要大。sp寄存器其实对应x2寄存器，所以在我们的处理器中初始值是0，那么减32之后就成负数了，我们1024大小的数据内存在索引数据时就会有问题。所以，我们要手动完成栈空间分配这个工作，只需要在程序入口处添加一条指令就行：

addi	sp,sp,1024 # 对应十六进制指令40010113

这里的1024作为地址是字节，相当于我们在1024*4大小的数据内存上分配了1024字节的空间，即可存放256个32位数据的栈，如果觉得不够，可以放4条该指令，刚好完全用完数据内存。

另外，程序的结束处是个返回指令，如果让它返回，它就会返回到调用main函数的地方，但当时栈是空的，所以会返回到地址0处开始执行，陷入无限循环。因此，我们还需要将最后一条指令替换为00000000，用于提示测试模块程序已经结束了。

于是，修改之后的十六进制指令序列如下：

这些工作一般由loader完成，我们这里临时手动完成就行，不用编写程序加载器。

下面我们就可以将代码放到MemInst.hex文件中，然后编写测试程序。测试代码如下：

package rv32isc

import chisel3._
import chiseltest._
import chisel3.util._
import org.scalatest.flatspec.AnyFlatSpec

import java.io.PrintWriter
import java.io.File

import config.Configs._

trait TopTestFunc {

    def testFn(dut: Top): Unit = {
        dut.clock.setTimeout(0)
        while (dut.io.inst.peekInt() != 0) {	// 运行到程序结束处停止运行
                println("PC", dut.io.addr.peekInt().toLong.toHexString)
                println("INST", dut.io.inst.peekInt().toLong.toHexString)
            if (dut.io.addr.peekInt() == 0xb8) {	// 调用返回的下一条指令对应的地址是0xa8，加上4条添加的指令，0xa8+0x10=0xb8，此时的rs2就是计算结果
                println("RES", dut.io.result.peekInt())
                println("RESALU", dut.io.resultALU.peekInt())
                println("RESBRANCH", dut.io.resultBranch.peek())
                println("RESJUMP", dut.io.bundleCtrl.ctrlJump.peek())
                println("SRCCCCC", dut.io.bundleCtrl.ctrlALUSrc.peek())
                println("STORE", dut.io.bundleCtrl.ctrlStore.peek())
                println("LOAD", dut.io.bundleCtrl.ctrlLoad.peek())
                println("RESJAL", dut.io.bundleCtrl.ctrlJAL.peek())
                println("OP:\t", dut.io.bundleCtrl.ctrlOP.peek())
                println("isBranch:\t", dut.io.bundleCtrl.ctrlBranch.peek())
                println("IMM:\t", dut.io.imm.peekInt())
                println("RS1:\t", dut.io.rs1.peekInt())
                println("RS2:\t", dut.io.rs2.peekInt())
                println("PC", dut.io.addr.peekInt().toLong.toHexString)
                println("INST", dut.io.inst.peekInt().toLong.toHexString)
                println("++++++++++++++++++++")
            }
            dut.clock.step(1)
        }
    }
}

class TopTest extends AnyFlatSpec with ChiselScalatestTester with TopTestFunc {
    "Top" should "pass" in {
        test(new Top) { dut =>
            testFn(dut)
        }
    }
}

运行测试，最后一部分输出如下：

(PC,b8)
(INST,fea42423)
(RES,4040)
(RESALU,4040)
(RESBRANCH,Bool(false))
(RESJUMP,Bool(false))
(SRCCCCC,Bool(true))
(STORE,Bool(true))
(LOAD,Bool(false))
(RESJAL,Bool(false))
(OP:	,UInt<4>(1))
(isBranch:	,Bool(false))
(IMM:	,4294967272)
(RS1:	,4064)
(RS2:	,55)
(PC,b8)
(INST,fea42423)
++++++++++++++++++++
(PC,bc)
(INST,fe842783)
(PC,c0)
(INST,78513)
(PC,c4)
(INST,1c12083)
(PC,c8)
(INST,1812403)
(PC,cc)
(INST,2010113)

可以看到，第16行显示rs2值为55，确实是第十项斐波那契数，测试通过。

说明和结语

文中的代码并非最终版本的代码，一些在调试过程中的修改未体现在文中。

完整项目代码可以在本人的Github仓库获取：github-3rr0r/RV32ISC: A RISC-V RV32I ISA Single Cycle CPU。

由于写得很仓促，也没有使用什么复杂的Chisel语法，很多好用的特性也没用上，甚至很多地方风格跟屎山一样，又懒得改，所以希望有兴趣的读者可以帮忙维护一下这个仓库。虽然最后测试通过了，但并不严谨，没有覆盖所有指令和边界情况，如果有不对的地方欢迎大家提出修改意见或直接git commit。

虽然只是个单周期的CPU，但编写起来并没有看起来那么顺利，有些脑抽写出来的错误逻辑找了很久。不过好在用的是Chisel，有更加直观的调试方法，如果用波形图可能就没那么顺利了。

本系列的Chisel实战部分到这里就完结了，本系列后续可能看情况更新一些Chisel的高阶内容，但不承诺一定会有。

下一步的计划是开辟一个新的专栏，还是实现一个RISC-V处理器，但是会更全面、更深入。会包括一些现代处理器的基本特性，比如流水线、乱序、多发射、分支预测、Cache等等，还有外设啥的，届时欢迎大家关注。

吃透Chisel语言.40.Chisel实战之单周期RISC-V处理器实现（下）——具体实现和最终测试

Chisel实战之单周期RISC-V处理器实现（下）——具体实现和最终测试