计算机组成原理P6

Cdostan MVP++
  2025-02-09 21:20:31 2025-02-09 21:20:31 Created   2025-02-10 18:18:41 2025-02-10 18:18:41 Updated      3.4k Words  13 Mins  

流水线CPU设计文档（多指令版）

构建思路

本次流水线CPU的搭建在上一次的基础上多增了很多指令，其中包括计算型指令，存储型指令，跳转型指令。对于新增指令，我们其实只需考虑增加这条指令后要修改原来电路的哪些东西，想明白这一点之后，我们对代码的修改便会变得得心应手起来。

数据通路图

再次附上数据通路图和logisim里的单周期CPU电路搭建图。
数据通路：

logisim单周期CPU电路：

通过这两张图，我们对整个架构更加清晰，增加指令的时候也可以对着图来看有哪些信号或者模块需要修改

修改思路

  1. 计算型指令（由于乘除相关指令要求我们模仿实际上的延时，因此乘除相关指令不放在此）：对于这一类指令，通过数据通路我们可以发现，要修改的模块只有alu模块，我们只需对其进行相应的扩展并修改对应的控制信号即可。具体来说，我们可能需要对regwe，regdst，aluslt，aluopt，memreg这些控制信号进行修改。
  2. 存取型指令：对于这一类指令，我们可能需要对alu模块进行一定的修改，因为存取的地址很可能是alu的计算结果，其次由于这次的指令新增了sb，sh，lb，lh四条指令，所以我们需要用一个四位的MEM写信号来控制写入数据的相应位数的数据是否写入存储器。具体来说，我们可能需要对regwe，regdst，aluslt，aluopt，memreg，memwe，loadwe这些控制信号进行修改，而其中memwe需要扩展到四位，而如果后续（如课上）还要新增这一类指令的话，可能涉及到一些新增的算术运算，那我们还需要扩展alu模块。
  3. 跳转型指令：在本次课下设计中新增的跳转型指令只有bne指令，而这条指令的实现与beq几乎一样，因此课下对这类指令的新增没有什么好说的。但我们仍然要明白新增这一类指令基本的修改方向。这类指令既可能涉及到运算，又可能涉及到存储，还一定会涉及到跳转，因此我们要将alu以及npc模块的修改全部纳入考虑范围内，又因为我们设计的是流水线CPU，因此如果涉及运算模块，我们需要将其加到D级，同时还可能需要修改regwe，regdst，alust，aluopt，memreg等控制信号。
  4. 乘除型指令：由于我们需要模拟真正乘除法部件执行乘除法的延迟，因此需要在E级新增一个模块，而hi和lo两个寄存器也放在这个模块里。这次课下要求执行乘法的时间为5个时钟周期，执行除法的时间为10个时钟周期，我们只需要拿一个计数寄存器来记录当前是第几个周期，到达周期之后将相应的数据写入相应寄存器即可（针对纯粹的乘除类指令）。而针对写和读hi或lo指令来说，我们不需要模拟这个延迟，直接写入和读出并参与流水线的其他步骤即可，也因此需要考虑他们的控制信号的变化。

冒险

仍然采用A-T法来解决该问题，只需将新增指令的Tnew和Tuse算出即可。满足A-T的条件，我们就将相应数据进行转发，不满足我们就阻塞一周期。而相应的数据也不会太复杂，其实我们仔细思考可以发现，有写入功能的指令他们写入的数据无非就是四种，一种是mfhi和mflo指令，它会写入从hi或lo寄存器中读取的数据，一种是jal，它会写入下一条指令的地址，一种是ALU计算型，他们回写入ALU的计算结果，一种是lw，会写入MEM的读取值，况且再结合上阻塞会发现，如果我们当前指令是与lw产生冒险，那一定会阻塞到lw流水到M级或W级，而那时便可将MEM读取值转发，因此我们注意将下一条指令的地址以及ALU的结果流水下去即可。
还有一点需要注意的是对于一些不用相关数据的指令例如jr，我们不应把他们的Tuse设为0，而是应该设为一个尽可能大的数，不然会产生无谓的阻塞，使得运行周期加长。

控制器

我们可以采用两种译码方式，一种是分布式译码，一种是集中式译码。集中式译码需要在某一级译码完成后将控制信号流水下去，这样流水的信号数量会很大，因此我采用的是分布式译码的方式，也就是在每一级对在该级的指令译码一次产生我所需要的控制信号即可，因此这样我会将控制器实例化4次。在控制器中除了单周期CPU里对应的控制信号以外，还需要加入转发的控制信号，我对Tuse和Tnew的计算也放进了控制器里。

控制信号

regwe=add|sub|ori|jal|lui|lw|lh|lb|and_|or_|slt|sltu|addi|andi|mfhi|mflo
regdst=(jal)?2:(add|sub|and_|or_|slt|sltu|mfhi|mflo)?1:0
aluslt=add|sub|beq|and_|or_|slt|sltu|bne|mult|multu|div|divu 

1
2
3
4
5
6
7
8
aluopt=(sltu)?6:
        (slt)?5:
        (lui)?4:
        (sub)?3:
        (add|lw|sw|addi|lh|lb|sh|sb)?2:
        (ori|or_)?1:
	    (and_|andi)?0:
        0;
1
2
3
4
memreg=(mfhi|mflo)?3:
       (jal)?2:
       (lw|lh|lb)?1:
		0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
assign D_rs_Tuse=(phase==2&&add)?1:
                 (phase==2&&sub)?1:
				 (phase==2&&and_)?1:
				 (phase==2&&or_)?1:
				 (phase==2&&slt)?1:
				 (phase==2&&sltu)?1:
				 (phase==2&&jr)?0:
				 (phase==2&&addi)?1:
				 (phase==2&&andi)?1:
				 (phase==2&&ori)?1:
				 (phase==2&&lui)?1:
				 (phase==2&&(lw|lh|lb))?1:
				 (phase==2&&(sw|sh|sb))?1:
				 (phase==2&&(beq|bne))?0:
				 (phase==2&&(mult|multu|div|divu|mthi|mtlo))?1:
				 3;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
assign D_rt_Tuse=(phase==2&&add)?1:
                 (phase==2&&sub)?1:
				 (phase==2&&and_)?1:
				 (phase==2&&or_)?1:
				 (phase==2&&slt)?1:
				 (phase==2&&sltu)?1:
				 (phase==2&&jr)?3:
				 (phase==2&&addi)?3:
				 (phase==2&&andi)?3:
				 (phase==2&&ori)?3:
				 (phase==2&&lui)?3:
				 (phase==2&&(lw|lh|lb))?3:
				 (phase==2&&(sw|sh|sb))?2:
				 (phase==2&&(beq|bne))?0:
				 (phase==2&&(mult|multu|div|divu))?1:
				 (phase==2&&(mthi|mtlo|mfhi|mflo))?3:
				 3;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
assign Tnew=(phase==3&&add)?1:
            (add)?0:
			(phase==3&&sub)?1:
			(sub)?0:
			(phase==3&&and_)?1:
			(and_)?0:
			(phase==3&&or_)?1:
			(or_)?0:
			(phase==3&&slt)?1:
			(slt)?0:
			(phase==3&&sltu)?1:
			(sltu)?0:
			(jr)?0:
			(phase==3&&addi)?1:
			(addi)?0:
			(phase==3&&andi)?1:
			(andi)?0:
			(phase==3&&ori)?1:
			(ori)?0:
			(phase==3&&lui)?1:
			(lui)?0:
			(phase==3&&(lw|lh|lb))?2:
			(phase==4&&(lw|lh|lb))?1:
			(phase==3&&(mfhi|mflo))?1:
			(phase==4&&(mfhi|mflo))?0:
			(lw|lh|lb)?0:
			(sw|sh|sb)?0:
			(beq|bne)?0:
			0;

测试方案

基本指令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
ori $1,$0,3
andi $2,$1,0xffff
addi $3,$2,3
lui $4,0x0011
add $5,$3,$4
add $5,$4,$4
add $5,$5,$5
sub $6,$5,$4
sub $6,$4,$5
and $7,$6,$0
and $7,$6,$2
or $8,$7,$0
or $8,$8,$7
slt $9,$8,$7
slt $9,$7,$8
sltu $10,$8,$7
sltu $10,$7,$8
sw $2,1($1)
sh $2,-1($1)
sh $2,-3($1)
lb $11,-2($1)
sb $11,0($1)
sb $11,-1($1)
sb $11,-2($1)
sb $11,-3($1)
lh $12,-1($1)
lh $12,-3($1)
lw $13,-3($1)
mult $12,$13
mfhi $14
add $15,$14,$13
multu $15,$14
mflo $16
ori $17,$16,$0
div $17,$16
mfhi $18
add $18,$18,$18
divu $18,$17
mflo $19
add $19,$19,$19
mthi $19
mtlo $17
mflo $20
add $20,$20,$19
mfhi $21
add $21,$21,$20

跳转：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
ori $1,$0,0x1011
ori $2,$1,0x0111
ori $11,$0,2
lui $3,0
lui $3,0x0111
lui $3,0xffff
ori $4,$3,0xffff
lui $3,0x0111
add $5,$3,$0
add $5,$4,$0
add $5,$3,$1
add $5,$3,$4
add $5,$4,$4
add $5,$5,$5
loop3:add $11,$11,$4
beq $11,$0,loop4
sub $6,$3,$0
sub $6,$4,$0
sub $6,$3,$1
sub $6,$3,$4
ori $7,$0,1
sub $8,$4,$7
sub $6,$4,$8
sub $6,$6,$6
sub $6,$3,$4
loop3:sw $5,4($1)
sw $6,4($2)
lw $9,4($1)
lw $10,4($2)
beq $5,$10,loop1
beq $5,$9,loop2
loop1:sw $10,8($2)
loop2:bne $6,$10,loop3
loop4:sw $9,12($2)
1
2
3
4
5
6
7
8
9
10
11
ori $1,$0,0x301c
sw $1,4($0)
lw $31,4($0)
loop:add $2,$1,$1
jr $ra
add $3,$2,$0
add $2,$2,$2
add $4,$3,$2
jal loop
ori $5,$4,0
ori $6,$4,0

思考题

为什么需要有单独的乘除法部件而不是整合进 ALU？为何需要有独立的 HI、LO 寄存器？

  • 因为我们要模仿真正乘除法部件执行乘除法的延迟，如果整合进了ALU模块，那么因为这个延迟可能会阻塞其他指令多个周期，导致运行的效率十分低，而设计单独的乘除法部件就可以不影响其他指令的执行。
  • 如果不设置单独的HI、LO寄存器，那么因为乘除法的延迟，当乘除模块到达时间想要写入寄存器的时候，这时可能有其他指令也想要写入寄存器，造成矛盾，况且HI、LO寄存器内的值只供读出到某个寄存器里，而非读出来做运算，因此需要独立出来。

真实的流水线 CPU 是如何使用实现乘除法的？请查阅相关资料进行简单说明

真实的流水线CPU中，乘法是由一级一级的门级电路搭建来的，因此是一个周期一个周期的传下去，每个周期计算特定的几位，最后走完整个乘法模块的时候得到最终结果。而除法使用试商法，通过组合逻辑在一个周期内计算4位左右的商，经过8个周期结束计算。

请结合自己的实现分析，你是如何处理 Busy 信号带来的周期阻塞的

当D级指令为乘除模块相关指令（即mult,multu,div,divu,mfhi,mflo,mthi,mtlo）时且E级的Busy信号为1时，阻塞D级。

请问采用字节使能信号的方式处理写指令有什么好处

首先可以很清晰地看到具体是哪几位要写入，并且针对sw、sh、sb都使用同样的写使能信号，不用引进多的使能信号增加模块复杂性。

请思考，我们在按字节读和按字节写时，实际从 DM 获得的数据和向 DM 写入的数据是否是一字节？在什么情况下我们按字节读和按字节写的效率会高于按字读和按字写呢

是同一字节，但不是一字节。在只需要对字节或半字访问时，按字节访问内存性能更由优势。

为了对抗复杂性你采取了哪些抽象和规范手段？这些手段在译码和处理数据冲突的时候有什么样的特点与帮助

首先命名上规范，这样可以让自己的代码较为清晰，容易查错。除此之外，将控制信号按指令的类别来定义和分类，这样考虑某类指令的时候，不需要去考虑其他的控制信号，也不用每个控制信号都要囊括所有指令。

在本实验中你遇到了哪些不同指令类型组合产生的冲突？你又是如何解决的？相应的测试样例是什么样的？

  • 存取和运算指令——转发+阻塞解决
1
2
3
4
5
ori $1,$0,3
ori $2,$0,2
sb $2,0($1)
lh $3,-1($1)
add $3,$3,$3
  • 乘除和存取指令——转发+阻塞解决
1
2
3
4
5
6
ori $1,$0,3
ori $2,$0,2
sb $2,0($1)
lh $3,-1($1)
mult $4,$3,$3
mflo $5
  • 运算（存取）和跳转指令——阻塞+转发解决
1
2
3
4
5
6
7
8
9
10
11
ori $1,$0,0x301c
sw $1,4($0)
lw $31,4($0)
loop:add $2,$1,$1
jr $ra
add $3,$2,$0
add $2,$2,$2
add $4,$3,$2
jal loop
ori $5,$4,0
ori $6,$4,0

如果你是手动构造的样例，请说明构造策略，说明你的测试程序如何保证覆盖了所有需要测试的情况；如果你是完全随机生成的测试样例，请思考完全随机的测试程序有何不足之处；如果你在生成测试样例时采用了特殊的策略，比如构造连续数据冒险序列，请你描述一下你使用的策略如何结合了随机性达到强测的效果

由于数据生成器生成的样例可能前后关联性不够强，因此我手动构造了一些样例。这些样例首先要保证针对每一条指令都将其的所有情况考虑完整，比如对于跳转指令就不能只考虑向后跳转还要考虑向前跳转。除此之外，由于流水线CPU很重要的就是解决冒险，因此还要考虑不同指令间的冒险，而这有可能发生在同类型指令，也可能发生在不同类型指令，因此两种情况我们都需要考虑到。在设计不同类型指令冒险的代码的时候，在保证前面的测试正确的情况下，可以只挑选一个类型里的典型指令出来，不必一个类型里的所有指令都拿出来设计一遍，因为同一类型下的转发和阻塞实现是相同的。

  • Title: 计算机组成原理P6
  • Author: Cdostan
  • Created at : 2025-02-09 21:20:31
  • Updated at : 2025-02-10 18:18:41
  • Link: https://cdostan.github.io/2025/02/09/计组/计组P6/
  • License: This work is licensed under CC BY-NC-SA 4.0.
Comments
On this page
计算机组成原理P6
  1. 1. 流水线CPU设计文档（多指令版）
    1. 1.1. 构建思路
      1. 1.1.1. 数据通路图
      2. 1.1.2. 修改思路
      3. 1.1.3. 冒险
      4. 1.1.4. 控制器
  2. 2. 测试方案
  3. 3. 思考题
    1. 3.1. 为什么需要有单独的乘除法部件而不是整合进 ALU？为何需要有独立的 HI、LO 寄存器？
    2. 3.2. 真实的流水线 CPU 是如何使用实现乘除法的？请查阅相关资料进行简单说明
    3. 3.3. 请结合自己的实现分析，你是如何处理 Busy 信号带来的周期阻塞的
    4. 3.4. 请问采用字节使能信号的方式处理写指令有什么好处
    5. 3.5. 请思考，我们在按字节读和按字节写时，实际从 DM 获得的数据和向 DM 写入的数据是否是一字节？在什么情况下我们按字节读和按字节写的效率会高于按字读和按字写呢
    6. 3.6. 为了对抗复杂性你采取了哪些抽象和规范手段？这些手段在译码和处理数据冲突的时候有什么样的特点与帮助
    7. 3.7. 在本实验中你遇到了哪些不同指令类型组合产生的冲突？你又是如何解决的？相应的测试样例是什么样的？
    8. 3.8. 如果你是手动构造的样例，请说明构造策略，说明你的测试程序如何保证覆盖了所有需要测试的情况；如果你是完全随机生成的测试样例，请思考完全随机的测试程序有何不足之处；如果你在生成测试样例时采用了特殊的策略，比如构造连续数据冒险序列，请你描述一下你使用的策略如何结合了随机性达到强测的效果