Data Dependence#

data dependence（数据相关） 指后面的指令真正需要前面指令产生的数据。

典型形式：

1
FLD     F0, 0(R1)
2
FADD.D  F4, F0, F2

第二条指令要读取 F0，而 F0 由第一条指令产生。这里存在真实的数据流动。

对应的 hazard 是：

• RAW（Read After Write）
• 后读前写
• 后面的读必须等前面的写产生结果

RAW 是真实数据相关，不能靠简单改寄存器名字消除。常见解决方式是：

• forwarding / bypassing；
• stall / bubble；
• 动态调度中等待操作数 ready。

Name Dependence#

name dependence（名相关） 指两条指令复用了同一个寄存器名字，但它们之间没有真实数据传递。

它分成两类。

第一类是 anti-dependence（反相关），对应 WAR（Write After Read）：

1
FDIV.D  F2, F6, F4
2
FADD.D  F6, F0, F12

第一条指令要读 F6，第二条指令要写 F6。如果第二条在第一条读走 F6 前先写了 F6，第一条会读到错误值。

第二类是 output-dependence（输出相关），对应 WAW（Write After Write）：

1
FDIV.D  F2, F0, F4
2
FSUB.D  F2, F6, F14

两条指令都写 F2。如果后写和前写的顺序被打乱，最终 F2 的值可能错误。

name dependence 的本质是“名字冲突”。它可以通过 register renaming（寄存器重命名） 消除。

TIP

RAW 代表真实的数据流动，不能随便改名消掉。
WAR / WAW 多数来自寄存器名字复用，可以通过重命名解决。

Control Dependence#

control dependence（控制相关） 来自分支指令。

例如：

1
if (p1) {
2
    Statement 1;
3
}
4
Statement;
5
if (p2) {
6
    Statement 2;
7
}

某些语句是否执行，取决于前面的分支条件。流水线中对应的问题是 branch hazard / control hazard。

Example#

1
FLD F6, 34（R2）
2
FLD F2, 45（R3）
3
FMUL.D F0, F2, F4
4
FSUB.D F8, F6, F2
5
FDIV.D F10, F0, F6
6
FADD.D F6, F8, F2

基本思想#

Scoreboard algorithm（记分牌算法） 是早期用于动态调度和乱序执行的经典方法。

它的直觉很简单：

• 用一个中心化的记分牌记录当前所有功能部件、寄存器、指令的状态；
• 每条指令进入时，先检查是否有结构冲突；
• 操作数没有 ready 时先等待；
• 操作数 ready 后就可以执行；
• 写回前还要检查是否会破坏前面指令尚未完成的读操作。

Scoreboard 的目标是：允许部分指令乱序执行，同时由硬件检测 hazard，保证结果正确。

从 ID 拆成 IS 和 RO#

在简单五级流水线中，ID 阶段通常同时完成：

• decode；
• structural hazard 检查；
• data hazard 检查；
• register read。

如果所有检查都放在 ID 中，那么前面一条指令卡住时，后面的指令没有机会进入不同功能部件等待。

为了支持乱序执行，需要把 ID 拆成两个阶段：

1. Issue（IS）

   • decode instruction；
   • 检查 structural hazard；
   • 按程序顺序 issue；
   • 如果目标功能部件忙，则当前指令不能进入，后续指令也不能跳过它。

2. Read Operands（RO）

   • 等待数据 hazard 消失；
   • 操作数 ready 后读取操作数；
   • 可以乱序发生。

TIP

IS 阶段仍然是顺序的。
真正允许乱序的是 RO / EX 之后的推进过程。

Scoreboard 的四个阶段#

Scoreboard 中每条指令大致经过四个阶段：

1
FMUL.D  F0, F2, F4

1
FDIV.D  F10, F0, F6
2
FADD.D  F6,  F8, F2

三张状态表#

Scoreboard 需要维护三类信息。

Scoreboard 的局限#

Scoreboard 可以实现乱序执行，但它的处理方式偏保守。

它能做到：

• 检测 structural hazard；
• 检测 RAW；
• 检测 WAR / WAW；
• 允许无关指令提前执行。

但它还做不到：

• 通过硬件寄存器重命名消除 WAR / WAW；
• 从根本上解决 name dependence 带来的等待；
• 自然保证精确异常。

因此当它发现 WAR / WAW 时，通常只能等待。

后续 Tomasulo 算法会引入 reservation station、CDB、硬件寄存器重命名，用更主动的方式减少这些等待。

Scoreboard 时序填写#

1
FLD     F6, 34(R2)
2
FLD     F2, 45(R3)
3
FMUL.D  F0, F2, F4
4
FSUB.D  F8, F2, F6
5
FDIV.D  F10, F0, F6
6
FADD.D  F6, F8, F2

答案#

Instruction	IS	RO	EX	WB
FLD F6, 34(R2)	1	2	3	4
FLD F2, 45(R3)	5	6	7	8
FMUL.D F0, F2, F4	6	9	10–19	20
FSUB.D F8, F2, F6	7	9	10–11	12
FDIV.D F10, F0, F6	8	21	22–61	62
FADD.D F6, F8, F2	13	14	15–16	22

1
IS = 6, RO = 9, EX = 10–19, WB = 20

1
IS = 7, RO = 9, EX = 10–11, WB = 12

1
IS = 8, RO = 21, EX = 22–61, WB = 62

1
FDIV.D  F10, F0, F6

1
IS = 13, RO = 14, EX = 15–16, WB = 22

从 Scoreboard 到 Tomasulo#

回顾一个 name dependence 的例子：

1
FDIV.D  F0, F2, F4
2
FADD.D  F6, F0, F8
3
FSD     F6, 0(R1)
4
FSUB.D  F8, F10, F14
5
FMUL.D  F6, F10, F8

这里存在两个名字相关：

• F6 被 FADD.D 写，又被后面的 FMUL.D 写，容易形成 WAW；
• F8 被前面的 FADD.D 读，又被 FSUB.D 写，容易形成 WAR。

如果手工重命名，可以改成：

1
FDIV.D  F0, F2, F4
2
FADD.D  S,  F0, F8
3
FSD     S,  0(R1)
4
FSUB.D  T,  F10, F14
5
FMUL.D  F6, F10, T

其中：

• 原来 FADD.D 写的 F6 改成临时名 S；
• 原来 FSUB.D 写的 F8 改成临时名 T；
• 真正的数据流仍然保留，比如 FMUL.D 依赖 FSUB.D 的结果。

TIP

Tomasulo 要解决的问题就是：这件“看代码后手工改名”的事情，能不能让 CPU 在运行时自动完成。

硬件结构：Reservation Station 与 CDB#

Tomasulo 在 Scoreboard 的基础上改变了硬件组织方式。它减少对单一集中式控制表的依赖，在功能部件前面加入多个 reservation stations（保留站）。

整体结构可以理解为：

• 上方是 instruction queue，指令仍然按程序顺序进入；
• load / store 指令进入 load buffer / store buffer；
• 加法、乘法等浮点运算进入对应的 reservation station；
• 结果通过 **CDB（Common Data Bus，公共数据总线）**广播给所有需要它的位置。

保留站的作用不只是缓存指令。它同时完成三件事：

1. 扩展功能部件前的等待空间
   例如只有一个加法器，但前面可以有 3 个加法保留站，所以最多可以有 3 条加法类指令先进入流水线等待。

2. 保存操作数的值或生产者名字
   如果操作数已经 ready，保留站中直接保存值；如果还没有 ready，保留站保存“将来由哪个保留站产生”。

3. 完成寄存器重命名
   指令进入保留站以后，源操作数和目的操作数不再单纯依赖架构寄存器名，改用保留站名或具体值表示。

和 Scoreboard 相比，Tomasulo 的关键差别是：

这里要特别注意：

• Tomasulo 的 IS 阶段仍然是 in-order issue；
• 进入保留站之后，谁的操作数 ready、谁的功能部件空闲，谁就可以先执行；
• 因此执行和写回可以乱序。

Tomasulo 的三个阶段#

Tomasulo 把指令执行分成三个主要阶段。

Example：硬件如何自动重命名#

老师用两条指令说明 Tomasulo 怎样自动消除 WAR，同时保留 RAW。

1
MUL.D  F0, F2, F4
2
ADD.D  F2, F0, F6

假设初始寄存器中：

1
F2 = a
2
F4 = b
3
F6 = c

这两条指令之间有两种关系：

• ADD.D 要读 F0，而 F0 由 MUL.D 产生，这是 RAW，必须保留；
• MUL.D 要读 F2，而 ADD.D 后面要写 F2，这是 WAR，只是名字相关，可以消除。

执行过程如下。

1. MUL.D F0, F2, F4 issue 到 MULT1

因为 F2 和 F4 都已经有值，所以保留站中直接存：

1
MULT1: MUL, Vj = a, Vk = b

同时 register status table 记录：

1
Qi[F0] = MULT1

意思是：F0 将来由 MULT1 产生。

此时 MUL.D 已经把旧的 F2 = a 读入保留站。后面即使有人写 F2，也不会影响这条乘法指令。

2. ADD.D F2, F0, F6 issue 到 ADD1

F6 = c 已经 ready，所以直接读入；F0 还没 ready，但 register status table 说明它将来由 MULT1 产生，所以记录：

1
ADD1: ADD, Qj = MULT1, Vk = c

同时这条加法要写 F2，所以：

1
Qi[F2] = ADD1

这里 F2 的 WAR 已经被消除：

• MUL.D 需要的旧 F2 已经变成保留站里的值 a；
• ADD.D 将来写的 F2 对应内部名字 ADD1；
• 两者不再争用同一个“名字”。

3. MULT1 计算完成并 broadcast

假设：

1
e = a × b

MULT1 通过 CDB 广播 e。

于是：

• F0 得到 e；
• 所有等待 MULT1 的保留站也得到 e；
• ADD1 从 Qj = MULT1 变成 Vj = e。

此后 ADD1 可以执行：

1
F2 = e + c

这个例子的核心是：

• RAW 通过 Qj/Qk 保留下来；
• WAR / WAW 通过保留站名和 Qi 表被消除。

Tomasulo 的三张状态表#

Tomasulo 需要记录三类状态。

1
某个寄存器将来由哪个保留站产生

1
Qi[F0] = MULT1

Example：状态表变化#

沿用六条指令：

1
FLD     F6, 34(R2)
2
FLD     F2, 45(R3)
3
FMUL.D  F0, F2, F4
4
FSUB.D  F8, F6, F2
5
FDIV.D  F10, F0, F6
6
FADD.D  F6, F8, F2

1
FLD F6, 34(R2)

Tomasulo 的贡献与局限#

Tomasulo 的主要贡献：

1. 提供了成熟的动态调度机制；
2. 通过硬件 register renaming 消除 WAR / WAW；
3. 对 RAW 用 tag 保留真实数据依赖；
4. 比 Scoreboard 更适合现代乱序处理器；
5. 引入了 load/store disambiguation 的思想。

其中 load/store 指令是否能乱序，要看地址关系：

• 如果 load 和 store 访问不同地址，可以安全乱序；
• 如果 load 在前、store 在后，交换顺序会让 store 先写、load 后读，可能形成 WAR；
• 如果 store 在前、load 在后，交换顺序会让 load 先读、store 后写，可能形成 RAW；
• 如果两个 store 访问同一地址，交换顺序会形成 WAW。

Tomasulo 的局限也很明显：

1. 硬件结构复杂
   需要保留站、load/store buffer、CDB、register status 等结构。

2. CDB 容易成为瓶颈
   所有结果都要通过 CDB 广播。如果多个功能部件同一周期完成，就需要仲裁或多条 CDB。

3. 访存相关仍然难处理
   load/store 依赖地址计算，只有知道地址后才能判断是否可以安全乱序。

4. 不能自然保证 precise exception
   Tomasulo 允许乱序执行和乱序写回。这样可能出现：后面的指令已经修改了机器状态，前面的指令却发生异常。此时程序员看到的状态可能不像按顺序执行那样干净。

Tomasulo 时序填写#

假设：

• Add / Sub 执行需要 2 个 clock cycles；
• Multiply 执行需要 10 个 clock cycles；
• Division 执行需要 40 个 clock cycles；
• Load 的访存执行需要 1 个 clock cycle；
• 指令按顺序 issue；
• 结果通过 CDB 写回。

1
FLD     F6, 34(R2)
2
FLD     F2, 45(R3)
3
FMUL.D  F0, F2, F4
4
FSUB.D  F8, F2, F6
5
FDIV.D  F10, F0, F6
6
FADD.D  F6, F8, F2

时序表为：

几个关键点：

1. 第二条 load 为什么可以第 2 拍 IS ？

和 Scoreboard 不同，Tomasulo 检查的是 load buffer 是否有空位。只要 load buffer 有空，第二条 FLD 就可以进入流水线，不必等第一条 load 完全写回。

2. FMUL.D 和 FSUB.D 为什么都可以第 6 拍开始 EX ？

第二条 load 在第 5 拍通过 CDB 写回 F2。FMUL.D 和 FSUB.D 都在等待这个结果。

CDB 广播的特点是：一个结果可以在同一拍被多个等待者同时收到。

所以第 6 拍：

• FMUL.D 拿到 F2，可以开始乘法；
• FSUB.D 也拿到 F2，可以开始减法。

3. FADD.D 为什么第 11 拍就能 WB ？

FADD.D 需要 F8 和 F2。

• F2 第 5 拍已经 ready；
• F8 由 FSUB.D 产生，FSUB.D 第 8 拍 WB；
• 因此 FADD.D 第 9–10 拍执行，第 11 拍写回。

在 Scoreboard 中，FADD.D 写 F6 会因为前面的 FDIV.D 还没读完 F6 而发生 WAR 等待；在 Tomasulo 中，FDIV.D issue 时已经把旧 F6 的值读到保留站，所以 FADD.D 可以直接写回新的 F6。

因此 Tomasulo 的写回顺序是：

1
1 → 2 → 4 → 6 → 3 → 5

这体现了乱序执行和乱序写回。

Issue#

从 instruction queue 中按顺序取指令。

如果对应 reservation station 有空位，并且 ROB 有空位，就可以 issue。

Issue 时会同时分配：

• 一个 reservation station；
• 一个 ROB entry。

register status table 记录的内容从 reservation station 名改为 ROB entry 编号。

Execute#

和 Tomasulo 一样：

• 等源操作数 ready；
• 等功能部件可用；
• ready 的指令可以乱序执行。

Writeback#

执行完成后，通过 CDB 把结果写到 ROB 对应 entry 中，也会广播给等待该结果的保留站。

区别是：此时还没有真正修改架构寄存器。

Commit#

ROB 按程序顺序检查队首指令。

只有当队首指令已经完成，才允许 commit：

• 普通计算指令：把 ROB 中的结果写入架构寄存器；
• store 指令：在 commit 时真正写内存；
• 分支预测错误：从 ROB 中清除错误路径上的结果，并恢复到正确路径；
• 异常：在 commit 时处理，从而保证 precise exception。

TIP

Writeback 是“结果算完并写入 ROB”。
Commit 是“这个结果正式成为程序可见状态”。
这两个阶段不能混在一起。

Superscalar#

Superscalar（超标量） 处理器每周期可发射的指令数目是不固定的：处理器设定一个发射上限，实际能发射几条取决于当前指令是否独立、资源是否可用。

若一个处理器每周期最多发射 $n$ 条指令，则称为 $n$-issue superscalar。

其特点是：

• 每个 cycle 的实际发射数量可以从 0 到上限变化；
• 指令仍以普通标量指令形式存在，处理器在运行时判断哪些指令可以并行发射；
• 可以采用静态调度，也可以结合 Tomasulo、ROB 等机制进行动态调度和推测执行；
• 二进制程序对微结构较透明，旧程序仍可运行，只是未必充分利用更宽的发射能力。

Superscalar 是通用处理器中最成功的多发射实现方式。

VLIW：Very Long Instruction Word#

VLIW（Very Long Instruction Word，超长指令字） 把若干个能够并行执行的操作在编译阶段打包成一条很长的指令，通常也称为一个 instruction packet。

其特点是：

• 每条长指令包含固定数目的 operation slots；
• 每个 slot 通常直接控制一个功能部件，例如两个访存槽、两个浮点槽和一个整数/分支槽；
• 指令之间的并行关系由编译器显式决定；
• 硬件不需要在运行时进行同样复杂的动态发射判断；
• 更适合 DSP、多媒体等执行模式规则、并行性容易被编译器识别的应用。

TIP

Superscalar 的核心是：硬件在运行时寻找并行性。
VLIW 的核心是：编译器在编译时把并行性写进指令包。

MIPS 式双发射#

用一个较简单的静态双发射方案说明硬件需求：

1
每个 cycle 最多同时发射：
2
1 条 integer instruction + 1 条 floating-point instruction

其中：

• load、store、branch 均归入 integer 类；
• IF 需要一次取出 64 bit，即两条 32-bit 指令；
• ID / Issue 需要同时译码两条指令，并判断能否同时进入各自功能部件；
• 浮点加法假设需要两个 EX cycle，整数指令只需要一个 EX cycle。

这种“1 integer + 1 floating-point”方案的优点是硬件增长相对可控；但仍然需要付出代价：

• 浮点 load / store 需要使用整数地址计算部件，会增加资源冲突；
• 浮点寄存器文件需要增加读写端口；
• 流水线中同时存在的指令增多，forwarding / bypass 通路必须扩展。

Extended Tomasulo：双发射#

将 Tomasulo 扩展到双发射处理器时，采用了一个简化模型：

1
每个 cycle 最多同时 issue：
2
1 条 integer instruction + 1 条 floating-point instruction

关键设计原则为：

• 指令仍需按程序顺序进入 reservation station，否则可能破坏程序语义；
• 整数操作与浮点操作可以分别维护表结构，使一条 integer 指令和一条 FP 指令能在同周期进入各自的 reservation station；
• 已经进入保留站的指令，只要操作数 ready 且功能部件可用，就可以乱序执行。

这相当于把两种思想叠加起来：

1
Multiple Issue：每个 cycle 放入更多候选指令
2
Dynamic Scheduling：从候选指令中动态挑选可执行者

Example：向量元素加标量#

给出如下循环：把常数 1（标量）加到向量的每个元素上。

1
Loop:
2
  LD      X2, 0(X1)       // X2 = array element
3
  ADDI    X2, X2, 1        // increment X2
4
  SD      X2, 0(X1)        // store result
5
  ADDI    X1, X1, 8        // increment pointer by 8
6
  BNE     X2, X3, Loop     // branch if not last

分析时采用以下假设：

• 每周期可以 issue 一条 integer 指令和一条 floating-point 指令，即使二者之间存在依赖；
• 有独立的整数 ALU / 地址计算部件，以及独立流水化的浮点功能部件；
• Instruction flow 与 Write Result 各占一个 cycle；
• 有动态分支预测部件，并带独立的分支条件计算部件；
• 不使用延迟分支；分支预测完美；在分支完成前，后续指令只允许取出与 issue，不能执行；
• 由于 Write Result 占一个 cycle，结果生成延迟为：integer operation 1 cycle、load 2 cycles、floating-point addition 3 cycles。

本例只涉及 integer / load / store，因此浮点槽位处于空闲状态。

不带 ROB：分支之后的指令不能提前执行#

首先考虑使用 Tomasulo，但不加入 ROB，也不进行推测执行。
此时下一轮循环的 LD 虽然可以被取出和 issue，但必须等待上一轮 BNE 的执行结果确认之后才能真正开始执行。

前三轮执行时序如下（Without speculation）：

可以看出：

• 三轮共 15 条指令在 19 cycles 内完成，平均 $IPC=\frac{15}{19}\approx 0.79$。
• 主要瓶颈是数据相关分支与整数 ALU 争用：地址计算与整数运算挤在同一部件上。
• 改进思路是增加一个 adder，把地址计算功能从 ALU 中分离。

带 ROB 与推测执行：跨过分支继续执行#

若在双发射 Tomasulo 上进一步加入 ROB 与 branch prediction，则处理器可以在分支尚未最终提交前，对后续循环迭代进行推测执行：

• 下一轮 LD 不需要等上一轮 BNE 完成后才执行；
• 执行结果先写入 ROB，不直接改变架构状态；
• 若预测正确，按程序顺序 commit；
• 若预测错误，则丢弃错误路径上的 ROB 项，恢复精确状态。

带硬件推测（With hardware speculation）的前三轮时序如下：

由表可得：三轮共 15 条指令在 14 cycles 内提交，平均 $IPC=\frac{15}{14}\approx 1.07$。
按全部指令完成的口径，推测执行带来的加速比约为：

从这个例子可以看到：

• 分支可能成为关键性能瓶颈，硬件推测可以显著改善。
• 非推测流水线的完成速率很快落后于发射速率，继续发射更多迭代会出现明显停顿。
• 推测执行的收益依赖分支预测准确性；预测错误会降低性能并显著损耗能效。

这里的核心并是：

1
提前执行分支后的工作，
2
同时用 ROB 保证最终仍按顺序提交。

Example：循环展开后的 VLIW 打包#

以循环展开后的向量加标量程序为例：一次处理 7 个元素。

展开前的原始循环指令序列：

1
Loop:
2
  L.D F0, 0(R1)
3
  ADD.D F4, F0, F2
4
  S.D F4, 0(R1)
5
  DADDIU R1, R1, #-8
6
  BNE R1, R2, Loop

循环展开后的指令序列（按程序顺序）：

1
Loop:
2
  L.D F0, 0(R1)
3
  L.D F6, -8(R1)
4
  L.D F10, -16(R1)
5
  L.D F14, -24(R1)
6
  L.D F18, -32(R1)
7
  L.D F22, -40(R1)
8
  L.D F26, -48(R1)
9
  ADD.D F4, F0, F2
10
  ADD.D F8, F6, F2
11
  ADD.D F12, F10, F2
12
  ADD.D F16, F14, F2
13
  ADD.D F20, F18, F2
14
  ADD.D F24, F22, F2
15
  ADD.D F28, F26, F24
16
  S.D F4, 0(R1)
17
  S.D F8, -8(R1)
18
  S.D F12, -16(R1)
19
  S.D F16, -24(R1)
20
  S.D F20, -32(R1)
21
  S.D F24, -40(R1)
22
  S.D F28, -48(R1)
23
  DADDIU R1, R1, #-56
24
  BNE R1, R2, Loop

VLIW 指令包安排如下，每一行代表一个 clock cycle：

第 8～9 行的 S.D F20, 24(R1)、S.D F24, 16(R1)、S.D F28, 8(R1) 需要特别注意：第 7 行已经执行 R1 = R1 - 56，所以相对更新后指针的 24/16/8(R1) 分别对应原始指针的 -32/-40/-48(R1)。

这份安排的性能为：

• 7 个原始循环迭代在 9 cycles 内完成；
• 平均每个元素耗时：

• 共执行 23 个有效操作，平均有效操作数为：

• 总 operation slots 为 9 × 5 = 45，有效槽位利用率为：

VLIW 的局限#

VLIW 将调度压力转移给编译器，硬件可以较简单，但也带来明显限制：

• 代码长度增加：为了暴露更多并行性，编译器往往需要大量 loop unrolling；
• 操作槽浪费：程序中并非始终存在足够独立操作，很多 slot 可能为空；
• Lockstep 机制：若某个功能部件因等待而暂停，整个长指令包往往都要暂停；
• 二进制兼容性较差：VLIW 代码依赖功能部件数量和执行延迟，不同微结构之间较难直接复用同一份机器代码；
• 程序本身 ILP 有限：存在真实数据依赖的操作不能简单打包并行执行。

因此，多发射处理器最终都受到三类因素影响：

1. 程序本身固有的 instruction-level parallelism；
2. 实现多发射、冲突检测和并行通路的硬件复杂度；
3. Superscalar 或 VLIW 各自技术路线的固有限制。

MIPS R4000：八段 Superpipeline#

SGI MIPS R4000 作为典型超流水处理器。其整数核心采用 8 段流水：

1
IF → IS → RF → EX → DF → DS → TC → WB

其中各阶段含义如下：

R4000 中与该结构相关的硬件包括：

• 分离的 Instruction Cache 与 Data Cache；
• 两个 Cache 容量均为 8 KB；
• 每个 Cache 数据宽度为 64 bit；
• 整数核心含 32 × 32-bit 通用寄存器组、ALU 和独立乘除法部件。

深流水仍然存在 Load Delay#

Superpipeline 可以提高流水吞吐率，但不能消除数据依赖。

在 R4000 中，load 结果需要经过：

1
EX → DF → DS → TC → WB

依赖该结果的下一条运算指令，即使已经进入流水线，也必须等待 load 数据真正可用。课件用 LD R1 后紧接 ADD.D R2, R1 的例子展示了 two clock cycles for load delay。

TIP

更深的流水线提高的是潜在 throughput；如果依赖关系、分支或 Cache Miss 造成等待，实际 IPC 仍会下降。
因此 Superpipelining、Multiple Issue 与 Dynamic Scheduling 常常需要协同使用。