深圳大学-计算机系统(3)-实验五处理器结构实验二

于 2025-01-23 14:45:51 发布
阅读量1.2k 收藏 28
点赞数 32
分类专栏： 深圳大学-计算机系统(3)实验 文章标签： 计组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73179413/article/details/145322962
版权

实验目的

  1. 了解控制冒险分支预测的概念
  2. 了解多种分支预测的方法，动态分支预测更要深入了解
  3. 理解什么是BTB（Branch Target Buffer），并且学会用BTB来优化所给程序
  4. 利用BTB的特点，设计并了解在哪种状态下BTB无效
  5. 了解循环展开，并于BTB功能进行对比
  6. 对WinMIPS64的各个窗口和操作更加熟悉

实验内容

按照下面的实验步骤及说明，完成相关操作记录实验过程的截图：
首先，给出一段矩阵乘法的代码，通过开启BTB功能对其进行优化，并且观察流水线的细节，解释BTB在其中所起的作用；
其次，自行设计一段使得即使开启了BTB也无效的代码。
第三，使用循环展开的方法，观察流水因分支停顿的次数减少的现象，并对比采用BTB结构时流水因分支而停顿的次数。

实验环境

硬件：桌面PC
软件：Windows

实验步骤及说明

背景知识

在遇到跳转语句的时候，我们往往需要等到MEM阶段才能确定这条指令是否跳转（通过硬件的优化，可以极大的缩短分支的延迟，将分支执行提前到ID阶段，这样就能够将分支预测错误代价减小到只有一条指令），这种为了确保预取正确指令而导致的延迟叫控制冒险（分支冒险）。
为了降低控制冒险所带来的性能损失，一般采用分支预测技术。分支预测技术包含编译时进行的静态分支预测，和执行时进行的动态分支预测。这里，我们着重介绍动态分支预测中的BTB（Branch Target Buffer）技术。
BTB即为分支目标缓冲器，它将分支指令（对应的指令地址）放到一个缓冲区中保存起来，当下次再遇到相同的指令（跳转判定）时，它将执行和上次一样的跳转（分支或不分支）预测。
一种可行的BTB结构示意图如下：
在这里插入图片描述
在采用了BTB之后，在流水线各个阶段所进行的相关操作如下：
在这里插入图片描述
注意，为了填写BTB，需要额外一个周期。

（一） 矩阵乘法及优化

在这一阶段，我们首先给出矩阵乘法的例子，接着将流水线设置为不带BTB功能（configure->enable branch target buffer）直接运行，观察结果进行记录；然后，再开启BTB功能再次运行，观察实验结果。将两次的实验结果进行对比，观察BTB是否起作用，如果有效果则进一步观察流水线执行细节并且解释BTB起作用原因。
矩阵乘法的代码如下：

		.data
str:  .asciiz "the data of matrix 3:\n"
mx1:   .space 512
mx2:   .space 512
mx3:   .space 512

			.text
initial:     daddi r22,r0,mx1	#这个initial模块是给三个矩阵赋初值
             daddi r23,r0,mx2
			daddi r21,r0,mx3
input:		daddi r9,r0,64
			daddi r8,r0,0
loop1:		dsll r11,r8,3
			dadd r10,r11,r22
			dadd r11,r11,r23
			daddi r12,r0,2
			daddi r13,r0,3
			sd r12,0(r10)
			sd r13,0(r11)

			daddi r8,r8,1
			slt r10,r8,r9
			bne r10,r0,loop1

mul:			daddi r16,r0,8
			daddi r17,r0,0
loop2:		daddi r18,r0,0	#这个循环是执行for(int i = 0, i < 8; i++)的内容
loop3:		daddi r19,r0,0	#这个循环是执行for(int j = 0, j < 8; j++)的内容
			daddi r20,r0,0	#r20存储在计算result[i][j]过程中每个乘法结果的叠加值
loop4:		dsll r8,r17,6		#这个循环的执行计算每个result[i][j]
			dsll r9,r19,3
			dadd r8,r8,r9
			dadd r8,r8,r22
			ld r10,0(r8)		#取mx1[i][k]的值
			dsll r8,r19,6
			dsll r9,r18,3
			dadd r8,r8,r9
			dadd r8,r8,r23
			ld r11,0(r8)		#取mx2[k][j]的值
			dmul r13,r10,r11	#mx1[i][k]与mx2[k][j]相乘
			dadd r20,r20,r13	#中间结果累加

			daddi r19,r19,1
			slt r8,r19,r16
			bne r8,r0,loop4

			dsll r8,r17,6
			dsll r9,r18,3
			dadd r8,r8,r9
			dadd r8,r8,r21	#计算result[i][j]的位置
			sd r20,0(r8)		#将结果存入result[i][j]中

			daddi r18,r18,1
			slt r8,r18,r16
			bne r8,r0,loop3

			daddi r17,r17,1
			slt r8,r17,r16
			bne r8,r0,loop2			

			halt

不设置BTB功能，运行该程序，观察Statistics窗口的结果截屏并记录下来。不设置BTB功能的程序运行结果如下：
在这里插入图片描述
出现574次Branch Taken Stalls的原因如下：
（1）initial 部分（给矩阵赋初值）: 给三个8 × 8的矩阵赋初值, WinMIPS64默认预测不跳转, 所以只有最后一次循环正确, 所以这个部分发生8 × 8 – 1 = 63次Branch Taken Stalls
（2）mul 部分（矩阵乘法部分）：在这部分里面，一共有三层循环；
① 在最外层循环（loop2）里面：
在这里插入图片描述
r17从0到8，每次加1，循环结束时预测正确，其他7次循环预测错误，所以这个部分发生7次Branch Taken Stalls
② 在第二层循环（loop3）里面：
在这里插入图片描述
loop3在loop2中执行，每次loop2循环中，loop3执行8次，每次循环（8次）仅最后一次预测正确，其它7次预测错误，所以这个部分发生8 × 7 = 56次Branch Taken Stalls
③ 在最里层循环（loop4）里面：
在这里插入图片描述
loop4在loop3中执行，每次loop3循环中，loop4执行8次，每次循环（8次）仅最后一次预测正确，其余7次预测错误，所以这个部分发生8 × 8 × 7 = 448次Branch Taken Stalls
所以整个程序一共出现63 + 7 + 56 + 448 = 574次Branch Taken Stalls。

接着，设置BTB功能（在菜单栏处选择Configure项，然后在下拉菜单中为Enable Branch Target Buffer选项划上钩）。并在此运行程序，观察Statistics窗口的结果并截屏记录下来。
在这里，我们仅仅观察比较Stalls中的最后两项------Branch Taken Stalls和Branch Misprediction Stalls。
启用BTB功能之后，运行程序，统计结果如下：
在这里插入图片描述
接下来，对比其结果。我们就结合流水线执行细节分析造成这种情况发生的原因。
可以看到启用BTB功能之后，发生了148次Branch Taken Stalls，同时发生148次Branch Misprediction Stalls。
由 BTB 的原理: 对每个循环, 开始时发生1次Branch Taken Stall , 将分支预测结果写入BTB中; 结束时, 发生1次Branch Misprediction Stall, 并删除BTB中的对应项。所以Branch Taken Stall的次数 = Branch Misprediction Stall的次数.
出现148次Branch Taken Stalls分析如下：
(1) initial 部分: 开启BTB后，分支指令bne在第一次执行时，BTB 未缓存该分支的历史信息，因此预测失败一次。从第二次循环开始，BTB记住了该分支的跳转模式，预测成功。只有最后一次（r8 == 64）跳转退出时，预测失败。故发生2次Branch Taken Stalls
(2) mul部分:
① 最外层循环：开启 BTB 后，第一次预测失败（BTB 未缓存），其余7次预测成功。最后一次（r17 == 8）跳转退出时，预测失败。故发生2次Branch Taken Stalls
② 第二层循环：同理可得，此阶段发生8 × 2 = 16次Branch Taken Stalls
③ 最里层循环：同理可得，此阶段发生8 × 8 × 2 = 128次Branch Taken Stalls
故总发生2 + 2 + 16 + 128 = 148次Branch Taken Stalls

BTB功能起作用的原因：对比没开启BTB功能之前，可以看出分支造成的冒险明显减少。首先在给矩阵赋值的部分中，如果不开启BTB，则会自动向下执行，实际上会往回跳，这时候使用BTB，记录下上次的选择，就可以大大减少对应的分支预测错误造成的冒险。矩阵乘法运算部分，在一次循环内大量的beq跳转是指向同一个目标，执行同一种跳转，这时候使用BTB就能大量减少分支冒险。

（二）设计使BTB无效的代码

在这个部分，我们要设计一段代码，这段代码包含了一个循环。根据BTB的特性，我们设计的这个代码将使得BTB的开启起不到相应的优化作用，反而会是的性能大大降低。
提示：一定要利用BTB的特性，即它的跳转判定是根据之前跳转成功与否来决定的。
给出所用代码以及设计思路，给出运行结果的截屏证明代码实现了目标。
设计的代码如下：

.text
    # 初始化寄存器
    and r24, r24, r0          # r24 = 0
    and r25, r25, r0          # r25 = 0
    and r27, r27, r0          # r27 = 0
    daddi r27, r27, 100       # r27 = 100
    daddi r25, r25, 1         # r25 = 1

loop:
    daddi r24, r24, 1         # r24 = r24 + 1

    # 通过与操作模拟乘法 r28 = r25 * r24
    and r28, r28, r0          # 清除 r28
    and r29, r25, r24         # r29 = r25 & r24
    beq r29, r0, label_A      # 如果 r29 == 0，跳转到 label_A

    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1
    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1

label_A:
    beq r29, r0, label_B      # 如果 r29 == 0，跳转到 label_B

    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1
    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1

label_B:
    beq r29, r0, label_C      # 如果 r29 == 0，跳转到 label_C

    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1
    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1

label_C:
    beq r29, r0, label_D      # 如果 r29 == 0，跳转到 label_D

    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1
    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1

label_D:
    beq r29, r0, label_End    # 如果 r29 == 0，跳转到 label_End

    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1
    and r25, r25, r0          # 清除 r25
    daddi r25, r25, 1         # r25 = r25 + 1

label_End:
    and r30, r30, r0          # 清除 r30
    slt r30, r27, r24         # 如果 r27 < r24，则 r30 = 1，否则 r30 = 0
    beq r30, r0, loop         # 如果 r27 >= r24，跳转到 loop

halt

设计思路：
这个代码通过循环和条件判断来模拟一些运算过程。通过频繁的条件跳转（beq指令），尤其是在标签之间的跳转（如 label_A, label_B, label_C等）来增加分支预测的复杂性，从而达到扰乱BTB功能的效果。具体原因如下：
①频繁的分支跳转：代码在每次计算时都进行条件判断，并且根据判断结果跳转到不同的标签。每个标签下的代码路径不同，导致预测的目标地址不确定。
②不规律的分支行为：分支跳转是基于r29的值，这个值在每次迭代中都会改变，并且通过一些复杂的计算条件决定。这种不规律的分支模式会让BTB难以准确预测分支目标。
此段代码未开启BTB功能前：
在这里插入图片描述
开启BTB功能后：
在这里插入图片描述
可以看到BTS次数从350次增加到了502次，说明代码实现了目标。

（三）循环展开与BTB的效果比对

首先，我们需要对循环展开这个概念有一定的了解。
什么是循环展开呢？所谓循环展开就是通过在每次迭代中执行更多的数据操作来减小循环开销的影响。其基本思想是设法把操作对象线性化，并且在一次迭代中访问线性数据中的一个小组而非单独的某个。这样得到的程序将执行更少的迭代次数，于是循环开销就被有效地降低了。
接下来，我们就按照这种思想对上述的矩阵乘法程序进行循环展开。要求将上述的代码通过循环展开将最里面的一个执行迭代8次的循环整个展开了，也就是说，我们将矩阵相乘的三个循环通过代码的增加，减少到了两个循环。
比较，通过对比循环展开（未启用BTB）、循环展开（启用BTB）使用BTB（未进行循环展开）以及未使用BTB且未作循环展开的运行结果。比较他们的Branch Tanken Stalls和Branch Misprediction Stalls的数量，并尝试给出评判。
循环展开代码如下：

.data
str: .asciiz "the data of matrix 3:\n"
mx1: .space 512
mx2: .space 512
mx3: .space 512

    .text
initial:    
    daddi r22, r0, mx1
    daddi r23, r0, mx2
    daddi r21, r0, mx3
input:		
    daddi r9, r0, 64
    daddi r8, r0, 0
loop1:		
    dsll r11, r8, 3
    dadd r10, r11, r22
    dadd r11, r11, r23
    daddi r12, r0, 2
    daddi r13, r0, 3
    sd r12, 0(r10)
    sd r13, 0(r11)

    daddi r8, r8, 1
    slt r10, r8, r9
    bne r10, r0, loop1

mul:		
    daddi r16, r0, 8
    daddi r17, r0, 0

# for (int i = 0; i < 8; i++)
loop2:		
    daddi r18, r0, 0

# for (int j = 0; j < 8; ji++)
loop3:		
    daddi r19, r0, 0  # k = 0
    daddi r20, r0, 0  # r20 存计算 result[i][j] 过程中每个乘法结果的叠加值

# 循环展开
    # k = 0
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23
    ld r11, 0(r8)
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1 
	
    # k = 1
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23
    ld r11, 0(r8)
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1

    # k = 2
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23
    ld r11, 0(r8)
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1

    # k = 3
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23
    ld r11, 0(r8)
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1

    # k = 4
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23 
    ld r11, 0(r8)	
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1
	
    # k = 5
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23
    ld r11, 0(r8)
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1

    # k = 6
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23
    ld r11, 0(r8)
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1

    # k = 7
    dsll r8, r17, 6
    dsll r9, r19, 3
    dadd r8, r8, r9
    dadd r8, r8, r22
    ld r10, 0(r8)
    dsll r8, r19, 6
    dsll r9, r18, 3
    dadd r8, r8, r9       
    dadd r8, r8, r23
    ld r11, 0(r8)
    dmul r13, r10, r11
    dadd r20, r20, r13
    daddi r19, r19, 1
# 循环展开结束

    dsll r8, r17, 6
    dsll r9, r18, 3
    dadd r8, r8, r9
    dadd r8, r8, r21  # 计算 result[i][j] 的位置
    sd r20, 0(r8)  # 将结果存入 result[i][j] 中

    daddi r18, r18, 1
    slt r8, r18, r16
    bne r8, r0, loop3

    daddi r17, r17, 1
    slt r8, r17, r16
    bne r8, r0, loop2    

    halt

运行上述程序（循环展开，未启用BTB），结果如下：
在这里插入图片描述循环展开，启用BTB，结果如下：

在这里插入图片描述
使用BTB（未进行循环展开）：
在这里插入图片描述
未使用BTB且未作循环展开：
在这里插入图片描述
四者的BTS次数分别如下：
① 循环展开，未启用BTB：126次
② 循环展开，启用BTB：20次
③ 未循环展开，启用BTB：148次
④ 未循环展开，未启用BTB：574次
分析如下：
① 循环展开，未启用BTB：循环展开减少分支指令频率，尽管没有BTB，依然提升性能。
② 循环展开，启用BTB：循环展开减少分支指令+BTB优化分支预测，性能大幅提升。
③ 未循环展开，启用BTB：BTB 优化了分支预测，但未展开的循环限制了性能，分支指令执行频率仍然较高。
④ 未循环展开，未启用BTB：未循环展开导致分支指令频率高，且无BTB优化，频繁清空流水线，执行周期大幅增加。

实验结果

1. 矩阵乘法及优化

在这里插入图片描述

2. 设计使BTB无效的代码

在这里插入图片描述

3. 循环展开与BTB的效果比对

（1）循环展开：
在这里插入图片描述
（2）未循环展开：
在这里插入图片描述

实验总结与体会

  1. BTB的重要性：
    • 对于循环中存在大量分支指令的程序，启用BTB能够显著提高分支预测的准确性，减少流水线清空，提升性能。
    • BTB的效果依赖于分支指令的规律性，规律越明显，优化效果越好。
  2. 循环展开的优势：
    • 循环展开通过减少分支指令的频率，间接降低了对BTB的依赖。
    • 特别是在 BTB 功能受限的硬件环境中，循环展开是一种有效的性能优化手段。
  3. BTB的局限性：
    • BTB 的预测依赖于历史行为，当分支跳转模式不规律或随机性较大时，BTB 的预测效果显著下降，反而可能降低性能。
  4. 优化的协同作用：
    • 实验结果表明，循环展开和BTB各自都有优化效果，但两者结合时，能够达到性能的最优水平。
    • 硬件优化（如BTB）和软件优化（如循环展开）的配合，是提升程序性能的关键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值