Mips 如何找到流水线机器的执行时间？

我们正在一台机器上执行以下指令

如果机器采用管道连接，则大约需要200 ps*3=600 ps

---

如果流水线机器运行1000003条指令，我想知道执行时间是多少？它是1000000*200 ps+600 ps吗？

该图适用于经典的5级MIPS流水线体系结构。现代芯片使用超标量设计，但让我们忽略这一点[至少目前如此]

这里的问题是，该图显示了各种类型的指令[对于每个T状态T1-T5]的时间，但是没有要执行的示例程序，除非该图也是循环的一个示例。如果是这样，请继续

另一个问题是管道“危险”。也就是说，特定指令的特定阶段（T状态）必须“暂停”，因为它取决于先前指令的输出。例如：

L1: add $t1,$t2,$t3
L2: add $t6,$t4,$t1

第二条指令必须暂停其“寄存器读取”（T2），因为它必须等待前一条指令的“寄存器写入”（T5）阶段完成[因为它需要

$t1

]的最终值]

因此，不是一个行为良好的管道，比如：

1:      L1:T1
2:      L1:T2       L2:T1
3:      L1:T3       L2:T2
4:      L1:T4       L2:T3
5:      L1:T5       L2:T4
6:                  L2:T5

我们最终得到：

1:      L1:T1
2:      L1:T2       L2:T1
3:      L1:T3       L2:stall
4:      L1:T4       L2:stall
5:      L1:T5       L2:stall
6:                  L2:T2
7:                  L2:T3
8:                  L2:T4
9:                  L2:T5

在现代实现中，有一些体系结构技术可以避免这种情况（例如“转发”，无序执行），但我们必须知道特定的体系结构实现，才能知道它有哪些工具来改善危害

---

我最好的猜测如下

同样，如果我们忽略危险，我们需要一个特定的程序/序列来进行计算

如果我们假设程序是图，对于1000000条指令，其循环迭代次数为

1000000/4

或

250000

。而且。。。我们也忽略了分支延迟槽

单循环迭代的时序图如下所示：

label   inst    start   exec    end
                time    time    time
-----   ----    -----   ----    ----

L1:     lw      0       800     800
L2:     sw      200     700     900
L3:     R       400     600     1000
L4:     beq     600     500     1100

请注意，所有说明都在L4完成之前完成。所以，主导时间是L4的结束时间。因此，

250000*1100 ps

或275 us，或多或少

---

更新：

---

但我的教授告诉我答案是1000000*200ps+1400ps

嗯，你应该[显然；-）]相信你的教授，而不是我[我确实强调了“猜测”]

但是，同样，我们必须知道实现：分支预测，等等。我假设第二个循环的L1在第1个循环的L4完成之前不能启动

如果循环/序列完全展开[并且没有分支]，例如

lw、sw、R、R

重复250000次，则它将是

1000000*200 ps

，IMO

我认为，教授的分析假设，对于循环2，L1的T1可以与对于循环1，L4的T2同时开始

例如，有用的序列可以是源/目的重叠的

memmove

序列[寄存器已预设]：

L1:     lw      $t0,4($t1)
L2:     sw      $t0,0($t1)
L3:     addu    $t1,$t1,$t2
L4:     bne     $t1,$t3,L1

同样，这假定没有分支延迟槽。为了使这项工作与他们一起工作，而不仅仅是附加一个

nop

，序列应该是

L1、L2、L4、L3

然而，我只是重新阅读了这篇文章：这个计算假设多路复用器、控制单元、PC访问和符号扩展单元没有延迟

---

因此，这可能是造成差异的关键。再一次，当有疑问时，请相信您的教授。

该图适用于经典的5阶段MIPS流水线体系结构。现代芯片使用超标量设计，但让我们忽略这一点[至少目前如此]

这里的问题是，该图显示了各种类型的指令[对于每个T状态T1-T5]的时间，但是没有要执行的示例程序，除非该图也是循环的一个示例。如果是这样，请继续

另一个问题是管道“危险”。也就是说，特定指令的特定阶段（T状态）必须“暂停”，因为它取决于先前指令的输出。例如：

L1: add $t1,$t2,$t3
L2: add $t6,$t4,$t1

第二条指令必须暂停其“寄存器读取”（T2），因为它必须等待前一条指令的“寄存器写入”（T5）阶段完成[因为它需要

$t1

]的最终值]

因此，不是一个行为良好的管道，比如：

1:      L1:T1
2:      L1:T2       L2:T1
3:      L1:T3       L2:T2
4:      L1:T4       L2:T3
5:      L1:T5       L2:T4
6:                  L2:T5

我们最终得到：

1:      L1:T1
2:      L1:T2       L2:T1
3:      L1:T3       L2:stall
4:      L1:T4       L2:stall
5:      L1:T5       L2:stall
6:                  L2:T2
7:                  L2:T3
8:                  L2:T4
9:                  L2:T5

在现代实现中，有一些体系结构技术可以避免这种情况（例如“转发”，无序执行），但我们必须知道特定的体系结构实现，才能知道它有哪些工具来改善危害

---

我最好的猜测如下

同样，如果我们忽略危险，我们需要一个特定的程序/序列来进行计算

如果我们假设程序是图，对于1000000条指令，其循环迭代次数为

1000000/4

或

250000

。而且。。。我们也忽略了分支延迟槽

单循环迭代的时序图如下所示：

label   inst    start   exec    end
                time    time    time
-----   ----    -----   ----    ----

L1:     lw      0       800     800
L2:     sw      200     700     900
L3:     R       400     600     1000
L4:     beq     600     500     1100

请注意，所有说明都在L4完成之前完成。所以，主导时间是L4的结束时间。因此，

250000*1100 ps

或275 us，或多或少

---

更新：

---

但我的教授告诉我答案是1000000*200ps+1400ps

嗯，你应该[显然；-）]相信你的教授，而不是我[我确实强调了“猜测”]

但是，同样，我们必须知道实现：分支预测，等等。我假设第二个循环的L1在第1个循环的L4完成之前不能启动

如果循环/序列完全展开[并且没有分支]，例如

lw、sw、R、R

重复250000次，则它将是

1000000*200 ps

，IMO

我认为，教授的分析假设，对于循环2，L1的T1可以与对于循环1，L4的T2同时开始

例如，有用的序列可以是源/目的重叠的

memmove

序列[寄存器已预设]：

L1:     lw      $t0,4($t1)
L2:     sw      $t0,0($t1)
L3:     addu    $t1,$t1,$t2
L4:     bne     $t1,$t3,L1

同样，这假定没有分支延迟槽。让这项工作与他们合作，而不仅仅是