吃透Chisel语言.15.Chisel模块详解（二）——Chisel模块嵌套和ALU实现

Chisel模块详解（二）——Chisel模块嵌套和ALU实现

稍微复杂点的硬件设计就需要用嵌套的模块层级来构建了，上一篇文章中实现的计数器其实就是个例子，计数器内部嵌套了一个寄存器、一个Mux和一个加法器。这一篇文章就仔细讲解模块之间是怎么连接到一起的，又是怎么组合成层级的大规模模块的，最后用Chisel实现一个ALU模块来实际应用一下Chisel模块实现的基本方法。

Chisel模块的连接和层级嵌套

下图就是一个模块嵌套的设计：

模块C有三个输入端口和一个输出端口，而C模块本身由两个子模块A和B组成，他们也都连接到了C的输入和输出上，而A的一个输出连接到了B上。模块D和模块C是同一个层级的，他们之间也是相互连接的。

下面的代码展示了上图中模块A和模块B的定义的示例：

class CompA extends Module {
    val io = IO(new Bundle {
        val a = Input(UInt(8.W))
        val b = Input(UInt(8.W))
        val x = Output(UInt(8.W))
        val y = Output(UInt(8.W))
    })
    
    // function of A
}

class CompB extends Module {
    val io = IO(new Bundle {
        val in1 = Input(UInt(8.W))
        val in2 = Input(UInt(8.W))
        val out = Output(UInt(8.W))
    })
    
    // function of B
}

其中，模块A有两个输入a和b，两个输出x和y，而模块B有两个输入in1和in2以及一个输出out。所有的端口都是八位无符号整数类型。因为这个例子是为了解释模块是怎么连接到一起来构建层级的，所有就不展示模块内部的细节了，就用// function of xxx来代替了。因为我们没有和示例模块相关联的功能，所以我们就随便起的端口名，而在实际应用中应该起有描述性的名字，比如data、valid和ready等。

模块C的代码如下所示：

class CompC extends Module {
    val io = IO(new Bundle {
        val in_a = Input(UInt(8.W))
        val in_b = Input(UInt(8.W))
        val in_c = Input(UInt(8.W))
        val out_x = Output(UInt(8.W))
        val out_y = Output(UInt(8.W))
    })
    
    // 创建模块A和模块B
    val compA = Module(new CompA())
    val compB = Module(new CompB())
    // 连接A
    compA.io.a := io.in_a
    compA.io.b := io.in_b
    io.out_x := compA.io.x
    // 连接B
    compB.io.in1 := compA.io.y
    compB.io.in2 := io.in_c
    io.out_y := compB.io.out
}

可以看到，C模块有三个输入端口和两个输出端口，它是用模块A和模块B构建的。代码中描述了A和B是怎么连接到C的端口的，A和B之间又是怎么连接到一起的。

模块通过new来创建，比如new CompA()，然后需要通过调用Module()来封装，上一篇文章中已经使用过这种用法。对模块的引用存放在局部变量里面，本例中就是val compA = Module(new CompA())。通过这个引用，我们可以通过间接访问该模块的io字段和IO Bundle中的每个单独的字段来访问模块的IO端口。

最后是模块D的代码：

class CompD extends Module {
    val io = IO(new Bundle {
        val in = Input(UInt(8.W))
        val out = Output(UInt(8.W))
    })
    
    // function of D
}

D的模块的代码最简单了，只有一个输入端口in和一个输出端口out。而最后确实的内容就是顶层模块的代码了，它本身通过C模块和D模块组合而成，代码如下：

class TopLevel extends Module {
    val io = IO(new Bundle {
        val in_a = Input(UInt(8.W))
        val in_b = Input(UInt(8.W))
        val in_c = Input(UInt(8.W))
        val out_m = Output(UInt(8.W))
        val out_n = Output(UInt(8.W))
    })
    
    // 创建C模块和D模块
    val c = Module(new CompC())
    val d = Module(new CompD())
    
    // 连接C
    c.io.in_a := io.in_a
    c.io.in_b := io.in_b
    c.io.in_c := io.in_c
    io.out_m := c.io.out_x
    // 连接D
    d.io.in := c.io.out_y
    io.out_n := d.io.out
}

好的模块设计和软件设计中好的方程或方法是类似的。一个最主要的问题就是我们应该在一个模块中放入多少功能，一个模块应该有多大。比如两个极端，一个是极小的模块，比如一个加法器，一个是极大的模块，比如一个完全的处理器。

硬件设计的新手一般从小的模块开始，问题是数字设计相关的书都用的是小的模块来展示基本原理，但是代码行数因为页面限制所以通常不会太多，自然也不会包含太多细节。

模块的接口一般是有点冗长的，因为需要指定类型、命名、方向并构造IO。有个经验之谈，就是模块的核心，也就是功能部分的代码，应该至少跟模块的接口差不多长。

而对于一些比较小规模的常用模块，比如说计数器，Chisel中也内置了相关类型，我们可以用调用函数返回硬件这种简单的方法来描述一个计数器，后面还会对Chisel中已经内置了的常用模块进行讲解。

用Chisel实现一个ALU

微处理器中，用于计算的核心组件之一就是算术逻辑单元（ALU，Arithmetic-Logic Unit），通常在示意图中，ALU的符号是这样的：

图中ALU有两个输入，也就是A和B，一个功能输入，即fn，还有一个输出Y。ALU在输入A和B上执行操作，然后将结果通过输出Y来提供。输入fn用于选择执行的操作，这个操作通常是算术的，比如加法、减法等，也可以是逻辑操作，比如与、或、异或等，因此这个单元叫作ALU，即算术逻辑单元。

输入fn用于选择操作，而ALU通常是个没有任何状态信息的组合电路，不过也有可能不止一个输出，有时候还可以有零输出或符号位输出，这个就看需求了。

下面的代码是一个十六位输入输出的ALU，支持加法、减法、或运算以及与运算，这四种运算通过一个两位的fn信号来选择：

class ALU extends Module {
    val io = IO(new Bundle {
        val a = Input(UInt(16.W))
        val b = Input(UInt(16.W))
        val fn = Input(UInt(2.W))
        val y = Output(UInt(16.W))
    })
    
    // ALU的默认输出值
    io.y := 0.U
    
    // 选择ALU的功能
    switch(io.fn) {
        is(0.U) {io.y := io.a + io.b}
        is(1.U) {io.y := io.a - io.b}
        is(2.U) {io.y := io.a | io.b}
        is(3.U) {io.y := io.a & io.b}
    }
}

在这个例子中，我们使用了一个新的Chisel结构，即switch/is结构，用于描述ALU的选择信号对应的输出，为了使用switch/is结构，应该带入下面的Chisel包：

import chisel3.util._

输出的Verilog代码如下：

module ALU(
  input         clock,
  input         reset,
  input  [15:0] io_a,
  input  [15:0] io_b,
  input  [1:0]  io_fn,
  output [15:0] io_y
);
  wire [15:0] _io_y_T_1 = io_a + io_b; // @[hello.scala 64:31]
  wire [15:0] _io_y_T_3 = io_a - io_b; // @[hello.scala 65:31]
  wire [15:0] _io_y_T_4 = io_a | io_b; // @[hello.scala 66:31]
  wire [15:0] _io_y_T_5 = io_a & io_b; // @[hello.scala 67:31]
  wire [15:0] _GEN_0 = 2'h3 == io_fn ? _io_y_T_5 : 16'h0; // @[hello.scala 60:10 63:19 67:23]
  wire [15:0] _GEN_1 = 2'h2 == io_fn ? _io_y_T_4 : _GEN_0; // @[hello.scala 63:19 66:23]
  wire [15:0] _GEN_2 = 2'h1 == io_fn ? _io_y_T_3 : _GEN_1; // @[hello.scala 63:19 65:23]
  assign io_y = 2'h0 == io_fn ? _io_y_T_1 : _GEN_2; // @[hello.scala 63:19 64:23]
endmodule

可以看到，ALU中对四种运算结果分别进行了计算，然后利用四个Mux选择选择信号对应的操作的计算结果，将输出给io_y，和预期是一致的。

结语

这一篇就是对Chisel中模块的嵌套给出了更详细的说明，还以ALU的例子展现了Chisel模块的实现方法，其中新引入了switch/is结构，这在Chisel中是和Scala中是有所区别的，Scala的match/case结构和这个类型，但并不会映射到硬件，所以在数字设计中应该使用switch/is结构。下一篇文章我们会学习端口的整体连接（Bulk Connection），在连接模块的时候很好用。