CHI 开发备忘 05 记 -- CHI spec 05 互连协议流程

第 5 章 互连协议流程

本章展示了不同事务类型的互连协议流程以及互连冒险条件。协议流程使用时序图进行说明。它包含以下部分：

• 第 5-204 页的读事务流程。

• 第 5-215 页的无数据事务流程。

• 第 5-219 页的写事务流程。

• 第 5-222 页的原子事务流程。

• 第 5-229 页的暂存事务流程。

• 第 5-232 页的冒险处理示例。

关于本规范中用于说明协议流程的惯例的详细信息，请参见第 xiii 页的时序图。

在后续的事务流程图中：

• 存在多个一致性 RN、一个 HN-F 和一个 SN-F。

• 如果 HN-F 接收到多个数据响应，即一个来自被侦测的 RN-F 的响应和另一个来自 SN-F 的响应，那么转发给请求方的数据将用粗体突出显示。

• HN-F 处没有 ICN 缓存，这导致所有发送到 HN-F 的请求都会向 SN-F 发起一个请求。

5.1 读事务流程

本节给出读事务的互连协议流程示例。

5.1.1 使用 DMT 且无侦测的读事务

对于没有侦测的读事务，本规范建议使用直接内存传输 (DMT)。

图 5-1 展示了一个使用 ReadShared 事务的 DMT 事务流程示例。

在此示例中，不需要从 SN-F 到 HN-F 的响应，因为使用来自请求方的 CompAck 来解除归属节点处的请求分配。

ReadShared 事务流程的步骤如下：

1. RN-F 向 HN-F 发送一个读请求。

2. HN-F 向 SN-F 发送一个读请求。

   • 读请求中的 ID 字段值基于数据响应要发送到的位置。数据可以发送给请求方或 HN-F。参见第 2-78 页的图 2-24，该图展示了如何推导 ID 字段值的示例。

3. SN-F 直接向 RN-F 发送数据响应。

4. RN-F 向 HN-F 发送 CompAck，因为该请求是 ReadShared 并且需要 CompAck 来完成事务。

图 5-1 无侦测的 DMT 读事务示例

5.1.2 使用 DMT 且有侦测的读事务

对于带有侦测且数据来自内存的读事务，本规范建议使用 DMT。

图 5-2 展示了一个使用 ReadShared 事务的 DMT 事务流程示例。

在此示例中，不需要从 SN-F 到 HN-F 的响应，因为使用来自请求方的 CompAck 来解除归属节点处的请求分配。

ReadShared 事务流程的步骤如下：

1. RN-F0 向 HN-F 发送一个读请求。

2. HN-F 向 RN-F1 发送一个侦测请求。

3. HN-F 在收到来自 RN-F1 的侦测响应后，向 SN-F 发送一个读请求，这保证了 RN-F1 尚未响应数据。

   • 读请求中的 ID 字段值基于数据响应要发送到的位置。数据可以发送给请求方或 HN-F。参见第 2-78 页的图 2-24，该图展示了如何推导 ID 字段值的示例。

4. SN-F 直接向 RN-F0 发送数据响应。

5. RN-F0 向 HN-F 发送 CompAck，因为该请求是 ReadShared 并且需要 CompAck 来完成事务。

图 5-2 带有侦测且数据来自内存的 DMT 读事务示例

5.1.3 使用 DCT 的读事务

对于带有侦测且数据来自缓存内存的读事务，本规范建议使用直接缓存传输 (DCT)。

来自 UC 状态缓存行的 DCT

第 5-207 页的图 5-3 展示了一个 DCT 事务的示例流程。请求方是 RN-F0，转发缓存位于 RN-F1。

DCT 事务流程的步骤如下：

1. RN-F0 向 HN-F 发送一个 ReadShared 请求。

2. HN-F 向 RN-F1 发送一个 SnpSharedFwd，即一个转发侦测请求。

3. RN-F1 缓存行状态从 UC 转换到 SC。

4. RN-F1 向 RN-F0 转发 CompData_SC 响应。

5. RN-F1 还向 HN-F 发送一个 SnpResp_SC_Fwded_SC 侦测响应，该响应指示：

   • 数据已转发给请求方。

   • 被侦测缓存中缓存行的最终状态是 SC。

   • 请求方可以缓存该缓存行的状态是 SC。

6. 收到 CompData 响应后，RN-F0 向 HN-F 发送一个 CompAck 响应以结束事务。

注

DCT 事务流程中的步骤 4 和 5 可以按任何顺序发生，因为 CompData 和 SnpResp 是在不同的通道上发送的。

图 5-3 来自 UC 状态缓存行的直接缓存传输

DCT 事务中的双数据返回

第 5-208 页的图 5-4 展示了一个 DCT 事务流程示例，该流程将数据发送给 HN-F 并将数据转发给 RN-F0。

DCT 事务流程的步骤如下：

1. RN-F0 向 HN-F 发送一个 ReadShared 请求。

2. HN-F 向 RN-F1 发送一个 SnpSharedFwd 侦测请求。

3. RN-F1 缓存行状态从 UD 转换到 SC。

4. RN-F1 向 RN-F0 发送 CompData_SC 响应。

5. RN-F1 还向 HN-F 发送一个 SnpRespData_SC_PD_Fwded_SC 侦测响应，该响应包含缓存行的一个副本，并将脏缓存行的责任传递给 HN-F：

   • 数据已转发给请求方。

   • 被侦测缓存中缓存行的最终状态是 SC。

   • 请求方可以缓存该缓存行的状态是 SC。

6. RN-F0 在收到数据响应后发送 CompAck 以结束事务。

图 5-4 DCT 事务中的双数据返回

5.1.4 既不使用 DMT 也不使用 DCT 的读事务

图 5-5 展示了使用 ReadNoSnp 事务且不使用 DMT 的流程示例。在此示例中，ReadNoSnp 在原始请求中设置了 ExpCompAck。

该请求不产生任何侦测，并从 HN-F 的内存读取响应中接收数据。ReadNoSnp 事务流程的步骤如下：

1. RN-F0 发出一个 ReadNoSnp 事务。

2. HN-F 接收并分配该请求。
   注

   HN-F 不发送侦测，因为该请求被识别为不可侦测请求类型。

3. HN-F 向 SN-F 发送一个 ReadNoSnp。

4. SN-F 向 HN-F 返回数据响应。

5. HN-F 依次将数据返回给 RN-F0。如果在 ReadNoSnp 请求中没有断言 ExpCompAck，则 HN-F 解除请求分配。

6. 如果在 ReadNoSnp 请求中断言了 ExpCompAck，则 RN-F0 向 HN-F 发送一个 CompAck 响应。

7. RN-F0 解除请求分配。

8. HN-F 收到 CompAck 响应并解除请求分配。

图 5-5 显示了事务流程，正在传输的数据副本用粗体标记。

图 5-5 ReadNoSnp 事务流程

5.1.5 带有部分数据侦测响应且无内存更新的读事务

此类流程的一个示例是 ReadUnique 事务。

RN-F1 的缓存行处于 UDP 状态。RN-F1 以带有部分缓存行数据的侦测响应来响应侦测，并传递更新内存的责任。

HN-F 等待来自内存的数据响应，将部分侦测响应数据与来自内存的数据响应合并，并将结果数据发送给请求方。

HN-F 不更新内存，因为更新内存的责任已传递给请求方。

图 5-6 显示了事务流程，正在传输的数据副本用粗体标记。

图 5-6 带有部分数据侦测响应的 ReadUnique

5.1.6 带有部分数据侦测响应和内存更新的读事务

此类流程的一个示例是 ReadClean 事务。

RN-F1 的缓存行处于 UDP 状态。RN-F1 以带有部分缓存行数据的侦测响应来响应侦测，并传递更新内存的责任。

HN-F 等待来自内存的数据响应，将部分侦测响应数据与来自内存的数据响应合并，并将结果数据发送给请求方。

HN-F 更新内存，因为更新内存的责任没有传递给请求方。

图 5-7 显示了事务流程，正在传输的数据副本用粗体标记。

图 5-7 带有部分数据侦测响应的 ReadClean

5.1.7 带有早期归属节点解除分配的 ReadOnce 和 ReadNoSnp*

图 5-8 展示了无序 ReadOnce 请求的优化流程。

优化的 ReadOnce 事务流程的步骤如下：

1. RN-F0 向 HN-F 发送一个无序的 ReadOnce 请求，Order[1:0] 设置为 0b00。

2. HN-F 向 SN-F 发送一个 DMT ReadNoSnp 请求，Order[1:0] 设置为 0b01。

3. SN-F 向归属节点发送 ReadReceipt。

4. HN-F 在收到 ReadReceipt 响应后解除请求分配。

5. SN-F 直接向 RN-F0 发送 CompData_UC。

图 5-8 无序 ReadOnce 的 DMT 优化

注

在不需要 CompAck 的情况下，使用从归属节点到从属节点的 ReadNoSnp 事务，可以避免从归属节点向请求方发送 RespSepData 响应的需要。

5.1.8 使用 DMT 以及分离的非数据和纯数据响应的 ReadNoSnp 事务

图 5-9 展示了一个使用 DMT 以及分离的非数据和纯数据响应的示例流程。

在此示例中，没有排序要求，RN-F 可以在不等待 DataSepResp 的情况下向 HN-F 发送 CompAck 以解除归属节点处的请求分配。

ReadNoSnp 事务的步骤如下：

1. RN-F 向 HN-F 发送一个 ReadNoSnp 请求。

2. HN-F 向 SN-F 发送一个 ReadNoSnpSep 请求。

   • 这告诉 SN-F 只需要一个纯数据响应。

3. HN-F 向 RN-F 发送一个 RespSepData 响应。

   • 这告诉 RN-F 该请求已在 HN-F 处分配，并且将有一个单独的数据响应。

4. SN-F 向 HN-F 发送一个 ReadReceipt。

   • 这告诉 HN-F 对从属节点的请求已完成，并确保 SN 不会对该请求响应 RetryAck。由于该请求是 Order 字段设置为零的 ReadNoSnp，HN-F 处的请求可以在收到 ReadReceipt 时解除分配。

5. RN-F 在收到 RespSepData 后发送 CompAck。

   • 对于 ReadNoSnp，CompAck 在功能上不是必需的，在收到来自 SN-F 的 ReadReceipt 后解除请求分配的 HN-F 可以直接丢弃 CompAck。

6. SN-F 作为完成者，向 RN-F 发送 DataSepResp，返回读取的数据。

图 5-9 使用 DMT 以及分离的非数据和纯数据响应的读事务示例

5.1.9 使用 DMT 以及带有排序和分离的非数据和纯数据响应的 ReadNoSnp 事务

图 5-10 展示了一个使用 DMT 以及带有排序和分离的非数据和纯数据响应的示例流程。

此示例中，ReadNoSnp 的 Order 字段非零，要求：

• 下一个有序请求只能在收到 RespSepData 后发送。

• RN-F 必须等待 RespSepData 和至少一个 DataSepResp 数据包后才能发送 CompAck。

• HN-F 在收到 CompAck 之前不得向 SN-F 发送下一个有序请求。

图 5-10 使用 DMT 以及带有排序和分离的非数据和纯数据响应的读事务示例

5.2 无数据事务流程

本节给出无数据事务的互连协议流程示例。

5.2.1 无内存更新的无数据事务

此类流程的一个示例是 MakeUnique 事务。

RN-F1 的缓存行处于 UC 状态。RN-F1 以不带数据的侦测响应来响应侦测，并将缓存行状态更改为 I。

HN-F 等待所有侦测响应，然后向请求方发送 Comp_UC 响应。

HN-F 不向 SN-F 发送读请求，因为该请求是一个无数据事务。

图 5-11 显示了事务流程。

图 5-11 无内存更新的 MakeUnique

5.2.2 带有内存更新的无数据事务

此类流程的一个示例是 CleanUnique 事务。

RN-F1 的缓存行处于 SD 状态，并以带数据且断言了 PD 的侦测响应来响应侦测。

HN-F 等待所有侦测响应，然后向请求方发送 Comp_UC 响应。

HN-F 发送一个写请求，以使用从 RN-F1 接收到的数据更新内存。

图 5-12 显示了事务流程。

图 5-12 带有内存更新的 CleanUnique

5.2.3 带有侦测以及分离的 Comp 和 Persist 响应的持久性 CMO

在此 CleanSharedPersistSep 事务流程示例中，持久点 (PoP) 位于 SN-F。

RN-F1 的缓存行处于 SC 状态。RN-F1 以不带数据的侦测响应来响应侦测。

HN-F 等待所有侦测响应，然后向请求方发送 Comp_SC 响应。

HN-F 仅在将所有被侦测的脏数据（如果有）写回 SN-F 完成后，才向 SN-F 发送 CleanSharedPersistSep 请求。SN-F 以 Comp 响应请求。

SNF 向 RN-F0 发送 Persist 响应，以指示请求已达到 PoP，并且来自同一位置的任何先前写入的数据已被推送到 PoP。

图 5-13 显示了事务流程。

图 5-13 CleanSharedPersistSep 事务流程

5.2.4 Evict 事务

图 5-14 显示了 Evict 事务流程。

RN-F0 将缓存行移动到 I 状态并发出一个 Evict 事务。

HN-F 接收并分配该请求。

注

Evict 请求是一个提示。HN-F 可以在不更新侦测过滤器或侦测目录的情况下给出 Comp 响应。

HN-F 返回 Comp 响应并解除请求分配。

RN-F0 解除请求分配。

图 5-14 Evict 事务流程

注

在发送 Evict 消息之前，请求方的缓存状态必须更改为无效。

5.3 写事务流程

本节给出写事务的互连协议流程示例。

5.3.1 无侦测且带分离响应的写事务

此类流程的一个示例是 WriteNoSnp 事务。WriteNoSnp 事务流程的步骤如下：

1. RN-F0 发出一个 WriteNoSnp 事务。

2. HN-F 接收并分配该请求。

3. HN-F 发送不带 Comp 的 DBIDResp。

4. RN-F0 以数据响应。

5. HN-F 在收到来自 SN-F 的 CompDBIDResp 后发送一个 Comp。
   注

   此流程示例显示 Comp 是在收到来自 SN-F 的 CompDBIDResp 后发送的。但是，HN-F 被允许在从 RN-F0 收到 WriteNoSnp 请求后的任何时间发送 Comp。

6. RN-F0 等待来自 HN-F 的 Comp 并解除其请求分配。

图 5-15 显示了流程，正在传输的数据副本用粗体标记。

图 5-15 从 HN 到 RN 带有分离响应的 WriteNoSnp

5.3.2 带有侦测和分离响应的写事务

此类流程的一个示例是 WriteUniquePtl 事务。

当一致性活动在 HN-F 完成时，必须发送来自 HN-F 的 Comp_I 响应。

图 5-16 显示了事务流程，正在传输的数据副本用粗体标记。

图 5-16 带有侦测的 WriteUniquePtl

5.3.3 到内存的 CopyBack 写事务

此类流程的一个示例是 WriteBackFull 事务。

HN-F 使用 WriteNoSnp 事务将从 RN-F0 接收到的数据写入 SN-F。

图 5-17 显示了事务流程，正在传输的数据副本用粗体标记。

图 5-17 返回数据缓冲区标识符的 WriteBackFull

5.4 原子事务流程

本节展示了不同原子事务类型的流程。它包含以下子节：

• 带数据返回的原子事务。

• 第 5-225 页的不带数据返回的原子事务。

• 第 5-227 页的在 SN 处执行的原子操作。

5.4.1 带数据返回的原子事务

此流程适用于：

• AtomicLoad。

• AtomicCompare。

• AtomicSwap。

带有侦测且带数据返回的原子事务

第 5-223 页的图 5-18 展示了在 HN-F 处执行的原子操作。

此事务流程的步骤如下：

1. RN-F0 向 HN-F 发送一个原子事务。

2. 收到原子请求后，HN-F：

   • 向 RN-F0 发送 DBIDResp 以获取原子事务数据。

   • 在确定需要侦测后，向其他 RN-F 发送 SnpUnique 侦测请求。

   • HN-F 被允许向 SN-F 发送推测性的 ReadNoSnp。

3. RN-F2 的缓存行处于 UD 状态，并通过发送数据并使自己的缓存副本无效来响应。

   • 响应是 SnpRespData_I_PD。

   • 该数据在图 5-18 第 5-223 页中标记为 (Old_Data)，以区别于请求方发送的数据以及原子操作执行后写入 SN-F 的数据。

   • HN-F 还收到来自 RN-F1 的第二个侦测响应 SnpResp_I。

4. 收到所有侦测响应后，HN-F 向请求方发送 CompData_I。

   • Comp 发送的数据是数据的旧副本。

   • 该数据不得以一致性状态缓存在 RN-F0 中。

5. 作为对之前发送的 DBIDResp 的响应，HN-F 收到来自请求方的 NonCopyBackWrData_I 响应。

   • 该数据在图 5-18 第 5-223 页中标记为 (Txn_Data)，以区别于 RN-F2 响应 HN-F 的侦测请求而发送的数据。

6. 一旦 HN-F 收到来自请求方的 NonCopyBackWrData_I 响应以及来自 RN-F2 的带数据的侦测响应，它就执行原子操作。

7. 原子操作执行后得到的结果值，在图中标记为 New_Data，被写入 SN-F。

8. 在此示例中，由于推测性读取而接收到的读取数据被 HN-F 丢弃。

图 5-18 在 HN-F 处执行的 AtomicLoad、AtomicSwap 或 AtomicCompare

注

在图 5-18 中，一旦收到所有侦测响应，就可以发送来自 HN-F 的 CompData_I 响应。或者，为了辅助错误报告，可以延迟 CompData_I 直到收到来自请求方的 NCBWrData 并且原子操作被执行。

无侦测且带数据返回的原子事务

图 5-19 展示了在 HN 处执行的原子操作。

图 5-19 在 HN 处执行的 AtomicLoad、AtomicSwap 或 AtomicCompare

5.4.2 不带数据返回的原子事务

此流程适用于 AtomicStore 事务。

带有侦测且不带数据返回的原子事务

图 5-20 展示了在 HN-F 处执行的原子操作。该流程类似于带有侦测且带数据返回的原子事务，不同之处在于对 RN-F0 的 Comp 响应不包含数据。

图 5-20 在 HN-F 处执行的 AtomicStore

无侦测且不带数据返回的原子事务

图 5-21 展示了在 HN 处执行的原子操作。该流程类似于无侦测且带数据返回的原子事务，不同之处在于对 RN 的 Comp 响应不包含数据。

图 5-21 在 HN 处执行的 AtomicStore

注

• 在图 5-21 中，需要从 SN 读取以获取 Old_Data，并且不是推测性的。

• 来自 HN 的 Comp 响应可以与 DBIDResp 响应组合。

5.4.3 在 SN 处执行的原子操作

第 5-228 页的图 5-22 展示了一个原子事务流程示例，其中 SN-F 正在执行原子操作。

此事务流程的步骤如下：

1. RN-F0 向 HN-F 发送一个 AtomicStore 事务。

   • 该原子请求指向一个可侦测地址位置。

2. 收到原子请求后，HN-F：

   • 向 RN-F0 发送 DBIDResp 以获取原子事务数据。

   • 在确定需要侦测后，向其他 RN-F 发送一个 SnpUnique。

3. RN-F2 的缓存行处于 UD 状态，并通过发送数据并使自己的缓存副本无效来响应。

   • 响应是 SnpRespData_I_PD。

   • 该数据在图 5-22 第 5-228 页中标记为 (Old_Data)，以区别于请求方发送的数据以及原子操作执行后写入 SN-F 的数据。

   • HN-F 还收到来自另一个被侦测的 RN-F 的第二个侦测响应 SnpResp_I。

4. HN-F 使用 WriteNoSnp 事务将接收到的数据写入 SN-F。

5. 作为对之前发送的 DBIDResp 的响应，HN-F 收到来自请求方的 NonCopyBackWrData 响应。

6. HN-F 在将侦测响应数据发送给 SN-F 后，向 SN-F 发送一个 AtomicStore 事务请求，并执行完成原子事务所需的消息序列。

7. 一旦 Comp 响应发送给请求方并且从 SN-F 收到原子事务的 Comp 响应，HN-F 就解除请求分配。

   • 一旦收到所有侦测响应，就可以发送来自 HN-F 的 Comp 响应。

图 5-22 在 SN-F 处执行的 AtomicStore

5.5 暂存事务流程

本节展示了两种暂存事务类型的示例互连协议流程：

• 带暂存提示的写操作。

• 第 5-230 页的独立暂存请求。

5.5.1 带暂存提示的写操作

第 5-230 页的图 5-23 展示了一个带有数据拉取的 WriteUniqueStash 事务流程示例。

1. RN 向 HN-F 发送一个 WriteUniqueFullStash 请求，其中暂存目标被标识为 RN-F1。通常，请求 RN 是 RN-I。

2. HN-F 向 RN-F1 发送 SnpMakeInvalidStash，并向 RN-F2 发送 SnpUnique。

3. RN-F1 和 RN-F2 向 HN-F 发送 SnpResp 响应。来自 RN-F1 的侦测响应还包含一个读请求，即数据拉取。

4. HN-F 将来自 RN-F1 的读请求视为 ReadUnique，并向 RN-F1 发送组合的 CompData。CompData 响应包含由 RN 写入的数据。

5. RN-F1 向 HN-F 发送 CompAck 以完成读事务。

图 5-23 带有数据拉取的 WriteUniqueStash

5.5.2 独立暂存请求

第 5-231 页的图 5-24 展示了一个带有数据拉取的 StashOnce 事务流程示例。

1. RN 向 HN-F 发送一个 StashOnceShared 请求，其中暂存目标被标识为 RN-F1。

2. HN-F 在为收到的请求建立处理顺序后发送一个 Comp 响应，该顺序保证了该请求在稍后从任何请求方接收到的对同一地址的请求之前被处理。

3. HN-F 向 RN-F1 发送一个 SnpStashShared 侦测，并向 SN-F 发送一个 ReadNoSnp 请求以获取数据。

4. RN-F1 向 HN-F 发送 SnpResp_I_Read 响应。

5. HN-F 将来自 RN-F1 的读请求视为 ReadNotSharedDirty，并向 RN-F1 发送组合的 CompData。

6. RN-F1 向 HN-F 发送 CompAck 以完成读事务。

图 5-24 带有数据拉取的 StashOnceShared

5.6 冒险处理示例

本节展示了如何在请求方处处理 CopyBack-侦测请求冒险条件，以及如何在 HN-F 处处理各种请求对请求、请求对侦测请求的冒险条件。它包含以下子节：

• RN-F 处的 CopyBack-侦测冒险。

• 第 5-235 页的 HN-F 处的请求冒险。

• 第 5-237 页的 HN-F 处的读 - CopyBack 或无数据 - CopyBack 冒险。

• 第 5-238 页的请求-CompAck 到 HN-F 的竞争冒险。

5.6.1 RN-F 处的 CopyBack-侦测冒险

第 5-233 页的图 5-25 展示了在时间 C 向 RN-F 发送的侦测请求与一个未决的 CopyBack 请求发生冒险。

解决此冒险所需的步骤如下：

1. 在时间 C：

   • SnpShared 事务忽略该冒险并读取缓存行数据。

   • 缓存行状态从 UD 更改为 SC。

2. 在时间 D：

   • 为 CopyBack 发送 CompDBIDResp 给 RN-F0。

   • RN-F0 发回一个 CopyBackWrData_SC 响应。

   • 缓存行状态从 SC 更改为 I。

     数据对于一致性而言是清洁的，并且为了正确功能不需要发送给互连。但是，协议要求 CopyBack 流程保持一致，而不考虑侦测冒险。

     WriteData 响应中的缓存行状态是 SC，因为这是发送 WriteData 响应时缓存行的状态。

图 5-25 RN-F 处的 CopyBack-侦测冒险示例

注

• 对与未决 Evict 发生冒险的侦测请求的响应必须是 SnpResp_I。

• 在从收到侦测请求到发送侦测响应（包括数据，如果适用）期间，如果对同一地址的 CopyBack 请求未决，则能为该 CopyBack 请求接收到的唯一响应是 RetryAck。

第 5-234 页的图 5-26 展示了侦测请求与未决 CopyBack 请求发生冒险的另一个示例。在此示例中，侦测请求是由于 RN-F1 的 ReadOnce 请求而生成的 SnpOnce 请求。SnpOnce 请求通过侦测响应接收数据副本，但不改变缓存行状态。在这种情况下，来自 RN-F0 的最终数据响应指示数据是脏的，并且 HN-F 必须将数据写回内存。

图 5-26 无缓存状态更改的 CopyBack-侦测冒险示例

5.6.2 HN-F 处的请求冒险

如果对同一缓存行的多个请求准备好在 HN-F 处进行处理，那么 HN-F 可以按任何顺序选择下一个请求，除非两个请求有排序要求并且来自同一源，在这种情况下处理顺序必须与到达顺序匹配。

第 5-236 页的图 5-27 展示了一个示例，其中对同一缓存行的 ReadShared 和 ReadUnique 大约同时到达 HN-F。解决此冒险所需的步骤如下：

1. 在时间 A：

   • 来自 RN-F0 的 ReadUnique 到达，并与 HN-F 已发送侦测请求的来自 RN-F2 的 ReadShared 请求发生冒险。

   • ReadUnique 的进程在 HN-F 处被阻塞。

2. 在时间 B：

   • HN-F 已完成来自 RN-F2 的 ReadShared 事务请求。

   • ReadShared 事务被认为已完成，HN-F 解除对来自 RN-F0 的 ReadUnique 事务请求的阻塞。

除了 ReadNoSnp，如果图 5-27 第 5-236 页中显示的两个事务被任何读请求类型或无数据请求类型替换，流程将是类似的：

• 当以下两个条件都成立时，不使用 DMT 或 DCT 或分离的 Comp 和 Data 响应的读事务请求在 HN-F 处完成：

  --- 所有 CompData 已发送，并且如果适用，已收到 CompAck。仅对在原始请求消息中断言了 ExpCompAck 的事务需要 CompAck。

  --- 如果需要，内存更新已完成。

图 5-27 读-读请求冒险示例

5.6.3 HN-F 处的读 - CopyBack 或无数据 - CopyBack 冒险

在 HN-F 处，读或无数据请求与 CopyBack 请求之间的冒险的处理方式类似于第 5-235 页的 HN-F 处的请求冒险中描述的读-读冒险。另请参见第 5-232 页的 RN-F 处的 CopyBack-侦测冒险。

第 5-238 页的图 5-28 展示了对同一缓存行的 ReadShared 和 WriteBack 大约同时到达 HN-F 的情况。解决此冒险所需的步骤如下：

1. 在时间 A：

   • WriteBack 在 HN-F 处遇到冒险条件。冒险的原因是已经有一个 ReadShared 事务正在进行中。

   • 冒险检测导致 WriteBack 被阻塞。

   • ReadShared 事务通过侦测响应接收数据，并且除了向请求方发送数据外，还需要更新内存。

2. 在时间 B：

   • WriteBack 被解除阻塞，因为 HN-F 已经为 ReadShared 事务向请求方发送了数据响应并向内存发送了 WriteData 响应。

如果 ReadShared 请求在 HN-F 开始处理 WriteBack 请求之后到达 HN-F，那么 ReadShared 请求将被阻塞，直到 WriteBack 请求完成。

当以下两个条件都成立时，CopyBack 请求在 HN-F 处完成：

• 收到对应于 CopyBack 请求的数据消息。

• 如果需要，内存更新已完成。

图 5-28 读 - CopyBack 或无数据 - CopyBack 冒险示例

5.6.4 请求-CompAck 到 HN-F 的竞争冒险

完成后，一个请求可能会静默地将缓存行从缓存中逐出，并生成另一个对同一地址的请求。例如：

1. 重新生成的请求在与先前请求关联的 CompAck 响应之前到达 HN-F。

2. HN-F 检测到地址冒险并阻塞新请求的处理，直到收到 CompAck 响应。

在这种场景下，CompAck 响应到达 HN-F 时，会解除 HN-F 中先前请求的分配，并解除对新请求的处理阻塞。