refactor: 引入 OOO Completion Fabric 建模完成反压

将原先面向 CDB 队列的执行完成边界迁移为 CompletionEvent/CompletionFabric，作为后续结构约束模拟的统一落点。

第一版 fabric 只负责 completion 事件的带宽仲裁、队列保留和 fanout，WritebackStage 继续复用现有 RS wakeup、物理寄存器写回和 ROB complete 消费者。

执行完成路径现在在 completion bandwidth 用尽时保持 execution unit busy，并记录 completion_port_busy stall；memory inflight 回来时也会在下游 completion backpressure 下保留 entry，避免重复统计 miss latency。

补充 CompletionFabric、ExecuteStage backpressure、ExecuteMemoryInflight backpressure、Writeback/OooRecovery 迁移测试，并更新 CONTEXT、ADR 和 ARCHITECTURE。

验证：cmake --build build -j；ctest --test-dir build -R "CompletionFabric|ExecuteStage|WritebackStage|OooRecovery|ExecuteMemoryInflight|ExecuteMemoryOrder" --output-on-failure；ctest --test-dir build --output-on-failure（400/400）。

Author: jensen-yan

ARCHITECTURE.md

@@ -123,7 +123,9 @@ flowchart LR
 ```mermaid
 flowchart TD
   subgraph Execute["Execute path"]
-    ES["ExecuteStage\n调度 / execution-unit ticking / complete to CDB"]
+    ES["ExecuteStage\n调度 / execution-unit ticking / submit completion"]
+    CF["CompletionFabric\ncompletion arbitration / backpressure / fanout"]
+    WS["WritebackStage\nwakeup / PRF write / ROB complete"]
     ELC["ExecuteLoadCompletion\nready load 完成状态机"]
     ELH["ExecuteLoadHazard\nROB older store hazard replay"]
     ELA["ExecuteLoadAccess\nforwarding / memory read / D$ read / exception"]
@@ -147,6 +149,7 @@ flowchart TD
   REC["OooRecovery\nshared flush / younger cleanup / restart"]
 
   ES --> ELC
+  ES --> CF
   ELC --> ELH
   ELC --> ELA
   ELA --> ELV
@@ -157,6 +160,8 @@ flowchart TD
   ESA --> EMI
   ESA --> EMO
   ES --> ECR
+  EMI --> CF
+  CF --> WS
   ECR --> REC
   EMO --> REC
 
@@ -181,8 +186,10 @@ flowchart TD
   优先看 `ExecuteStoreAccess`。
 - 改 D$ hit/miss/blocking/outstanding/stall counter：
   优先看 `ExecuteDCacheAccess`。
-- 改已发出的 load/store miss 如何等待和回到 CDB：
-  优先看 `ExecuteMemoryInflight`。
+- 改已发出的 load/store miss 如何等待并提交完成事件：
+  优先看 `ExecuteMemoryInflight` 和 `CompletionFabric`。
+- 改执行完成带宽、completion backpressure、写回 fanout：
+  优先看 `CompletionFabric`、`ExecuteStage` 和 `WritebackStage`。
 - 改 addr-unknown store speculation、Bad Addr-Unknown Pair、load-store violation recovery trigger：
   优先看 `ExecuteMemoryOrder`。
 - 改执行阶段早恢复、branch/JALR younger cleanup、rename checkpoint restore：
@@ -221,7 +228,7 @@ flowchart TD
 - 一个性能实验需要替换或比较不同策略，现有模块没有合适落点。
 
 不满足这些条件时，优先把逻辑留在现有模块或补文档导航。
-例如 ALU/FP/BRANCH 的简单 ticking、CDB enqueue 的统一收尾、dispatch loop 的基本形状，暂时保留在 `ExecuteStage` 更直观。
+例如 ALU/FP/BRANCH 的简单 ticking、Completion Fabric 之外的 dispatch loop 基本形状，暂时保留在 `ExecuteStage` 更直观。
 
 ### 性能探索入口索引
 

CONTEXT.md

@@ -45,6 +45,18 @@ _Avoid_: syscall, normal memory-mapped device
 The CPU mode that models instruction flow through fetch, decode, issue, execute, writeback, and commit with speculative execution and in-order retirement.
 _Avoid_: OOO blob, pipeline code
 
+**Structural Constraint Simulator**:
+The modeling role for the out-of-order CPU: capture the timing and resource constraints that explain performance behavior without attempting cycle-accurate RTL reproduction.
+_Avoid_: full RTL replica, teaching-only Tomasulo model, functional-only simulator
+
+**Completion Fabric**:
+The out-of-order pipeline's result-completion boundary that arbitrates when executed work becomes visible to wakeup, physical-register writeback, and ROB completion.
+_Avoid_: treating the Common Data Bus as the long-term domain boundary
+
+**Completion Backpressure**:
+The structural constraint where an execution unit that has produced a result must keep holding it when the Completion Fabric cannot accept another completion event in the current cycle.
+_Avoid_: silently buffering every completed result in an unbounded queue
+
 **Stage Context**:
 A stage-specific adapter that exposes only the state and actions a pipeline stage needs for one execution step.
 _Avoid_: passing raw `CPUState` as the stage interface
@@ -124,6 +136,9 @@ _Avoid_: blacklist entry
 ## Relationships
 
 - An **Out-of-Order Pipeline** executes each stage through a **Stage Context**.
+- A **Structural Constraint Simulator** should model performance-visible resource contention while keeping implementation detail below full RTL fidelity.
+- A **Completion Fabric** replaces the Common Data Bus as the domain concept for execution-result completion; any CDB-like queue is only a legacy or migration detail.
+- **Completion Backpressure** keeps completed execution units occupied when completion bandwidth is exhausted.
 - The **Simulator** owns the run lifecycle and may create a **Reference Execution Context** when **DiffTest** is enabled for an out-of-order run.
 - A **Checkpoint Runner** drives the **Simulator** over an **Instruction Window** after importing a workload slice.
 - **Address Translation** delegates Sv39-specific page-table traversal to the **SV39 Page Walker** and is constrained by **Privilege State**.
@@ -153,5 +168,8 @@ _Avoid_: blacklist entry
 ## Flagged Ambiguities
 
 - Use **Execute Memory Order** for the decision and accounting around memory-order speculation. Use **OOO Recovery** for the shared pipeline cleanup rules.
+- Use **Structural Constraint Simulator** for the intended OOO modeling fidelity; do not describe this direction as full RTL reproduction or as a purely functional simulator.
+- Use **Completion Fabric** for the future result-completion boundary; use Common Data Bus only when referring to legacy implementation or migration work.
+- Use **Completion Backpressure** when completion bandwidth stalls a completed execution unit; do not model this as an always-available result queue.
 - Use **Address Translation** for the fetch/load/store translation boundary. Use **SV39 Page Walker** only for the Sv39 page-table walk inside that boundary.
 - Use **DiffTest** for commit-time reference comparison, not for ordinary unit tests or benchmark result checks.

docs/adr/0004-retire-cdb-as-domain-boundary.md

@@ -0,0 +1,19 @@
+# Retire CDB as the OOO Completion Boundary
+
+The out-of-order CPU will use **Completion Fabric** as the domain concept for execution-result completion instead of continuing to treat the Common Data Bus as the architecture boundary. Existing CDB-shaped code may remain during migration, but the design direction is to reduce or remove it because a single global bus hides performance-visible distinctions between wakeup, physical-register writeback, and ROB completion.
+
+**Status**: accepted
+
+**Considered Options**
+
+- Keep CDB as the primary concept and add more limits around it.
+- Retire CDB as a domain concept and migrate toward a Completion Fabric with separate completion consumers.
+
+**Consequences**
+
+- New design docs and tests should describe completion behavior in terms of Completion Fabric rather than CDB.
+- Migration can be incremental; existing CDB queues do not need to disappear in the first patch.
+- The first implementation should focus on completion-event arbitration and fanout to existing wakeup, physical-register writeback, and ROB-completion consumers.
+- More realistic bypass, wakeup, and select networks are deferred until the Completion Fabric boundary is established.
+- The first implementation should model completion backpressure: a completed execution unit keeps holding its result when completion bandwidth is exhausted instead of placing every result into an unbounded queue.
+- IPC improvement is not an acceptance criterion for the first implementation. A lower IPC is acceptable when it follows from modeling a previously missing structural constraint more realistically.

include/cpu/ooo/completion_fabric.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "cpu/ooo/ooo_types.h"
+
+#include <cstddef>
+#include <queue>
+
+namespace riscv {
+
+class CompletionFabric {
+public:
+    explicit CompletionFabric(size_t completion_width = OOOPipelineConfig::COMPLETION_WIDTH);
+
+    void beginCycle();
+    bool trySubmit(const CompletionEvent& event);
+
+    bool empty() const { return ready_events_.empty(); }
+    size_t size() const { return ready_events_.size(); }
+    size_t completionWidth() const { return completion_width_; }
+    size_t usedCompletionSlots() const { return accepted_this_cycle_; }
+    size_t availableCompletionSlots() const;
+
+    CompletionEvent popReadyEvent();
+    uint64_t clear();
+    uint64_t flushYoungerThan(uint64_t instruction_id);
+
+private:
+    size_t completion_width_;
+    size_t accepted_this_cycle_;
+    std::queue<CompletionEvent> ready_events_;
+};
+
+} // namespace riscv

include/cpu/ooo/cpu_state.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "common/types.h"
+#include "cpu/ooo/completion_fabric.h"
 #include "core/memory.h"
 #include "core/decoder.h"
 #include "cpu/ooo/register_rename.h"
@@ -67,6 +68,7 @@ struct ExecutionUnit {
     uint64_t result;
     bool has_exception;
     std::string exception_msg;
+    bool completion_pending;
     // 跳转指令相关字段
     uint64_t jump_target;
     bool is_jump;
@@ -147,6 +149,7 @@ inline void resetExecutionUnitState(ExecutionUnit& unit) {
     unit.result = 0;
     unit.has_exception = false;
     unit.exception_msg.clear();
+    unit.completion_pending = false;
     unit.jump_target = 0;
     unit.is_jump = false;
     unit.load_address = 0;
@@ -253,7 +256,7 @@ struct CPUState {
 
     // 流水线缓冲区
     std::queue<FetchedInstruction> fetch_buffer;  // 取指缓冲区
-    std::queue<CommonDataBusEntry> cdb_queue;    // 通用数据总线队列
+    CompletionFabric completion_fabric;          // 执行完成事件仲裁与缓冲
 
     // 核心组件（共享引用）
     std::shared_ptr<Memory> memory;

include/cpu/ooo/execute_memory_inflight.h

@@ -8,7 +8,7 @@ namespace riscv {
 
 class ExecuteMemoryInflight {
 public:
-    using CompletionCallback = std::function<void(ExecutionUnit&, ExecutionUnitType)>;
+    using CompletionCallback = std::function<bool(ExecutionUnit&, ExecutionUnitType)>;
 
     static bool hasAny(const CPUState& state);
     static bool tryMove(ExecutionUnit& unit,

include/cpu/ooo/ooo_recovery.h

@@ -39,7 +39,7 @@ class OooRecovery {
     struct Result {
         uint64_t flushed_rob_entries = 0;
         uint64_t fetch_buffer_dropped = 0;
-        uint64_t flushed_cdb_entries = 0;
+        uint64_t flushed_completion_events = 0;
         bool flushed_l1d_inflight = false;
     };
 
@@ -49,7 +49,7 @@ class OooRecovery {
 
 private:
     static void recordFlushCounters(CPUState& state, Reason reason, uint64_t flushed_rob_entries);
-    static uint64_t flushYoungerCdbEntries(CPUState& state, uint64_t instruction_id);
+    static uint64_t flushYoungerCompletionEvents(CPUState& state, uint64_t instruction_id);
     static bool flushYoungerExecutionUnits(CPUState& state, const YoungerThanRequest& request);
     static void restoreRenameCheckpointForSurvivingWork(CPUState& state,
                                                         uint64_t instruction_id,

include/cpu/ooo/ooo_types.h

@@ -38,13 +38,13 @@ enum class ExecutionUnitType {
 class DynamicInst;
 using DynamicInstPtr = std::shared_ptr<DynamicInst>;
 
-// 公共数据总线项 - 使用DynamicInst指针保持数据一致性
-struct CommonDataBusEntry {
+// 执行完成事件 - 使用DynamicInst指针保持数据一致性
+struct CompletionEvent {
     DynamicInstPtr instruction;    // 直接使用DynamicInst指针作为数据源
     bool valid;
 
-    CommonDataBusEntry() : instruction(nullptr), valid(false) {}
-    explicit CommonDataBusEntry(DynamicInstPtr inst) : instruction(inst), valid(true) {}
+    CompletionEvent() : instruction(nullptr), valid(false) {}
+    explicit CompletionEvent(DynamicInstPtr inst) : instruction(inst), valid(true) {}
 };
 
 // 分支预测结果
@@ -75,6 +75,7 @@ struct OOOPipelineConfig {
     static constexpr size_t ISSUE_WIDTH = 4;
     static constexpr size_t DISPATCH_WIDTH = 4;
     static constexpr size_t WRITEBACK_WIDTH = 2;
+    static constexpr size_t COMPLETION_WIDTH = WRITEBACK_WIDTH;
     static constexpr size_t COMMIT_WIDTH = 4;
     static constexpr size_t STORE_COMMIT_WIDTH = 1;
     static constexpr size_t RECOVERY_REDIRECT_LATENCY = 2;

include/cpu/ooo/perf_counter_defs.inc

@@ -20,8 +20,8 @@ PERF_COUNTER_DEF(TOPDOWN_SLOTS_RESOURCE_BLOCKED, "cpu.topdown.slots.resource_blo
 PERF_COUNTER_DEF(TOPDOWN_SLOTS_NO_UNIT, "cpu.topdown.slots.no_unit", "Execute slots selected work but found no execution unit")
 PERF_COUNTER_DEF(TOPDOWN_SLOTS_AMO_WAIT, "cpu.topdown.slots.amo_wait", "Execute slots selected AMO work delayed by older store-like operations")
 PERF_COUNTER_DEF(TOPDOWN_SLOTS_OTHER, "cpu.topdown.slots.other", "Execute slots not classified by the slot topdown-lite categories")
-PERF_COUNTER_DEF(CDB_ENQUEUED, "cpu.execute.cdb_enqueued", "Execution results enqueued to CDB")
-PERF_COUNTER_DEF(WRITEBACKS, "cpu.writeback.count", "CDB entries consumed in writeback stage")
+PERF_COUNTER_DEF(COMPLETION_ACCEPTED, "cpu.completion.accepted", "Execution completion events accepted by the completion fabric")
+PERF_COUNTER_DEF(WRITEBACKS, "cpu.writeback.count", "Completion events consumed in writeback stage")
 PERF_COUNTER_DEF(COMMIT_SLOTS, "cpu.commit.slots", "Total commit stage slots available")
 PERF_COUNTER_DEF(COMMIT_UTILIZED_SLOTS, "cpu.commit.utilized_slots", "Commit slots that successfully retired an instruction")
 PERF_COUNTER_DEF(STALL_COMMIT_STORE_PORT_BUSY, "cpu.stall.commit_store_port_busy", "Commit stopped because store memory write ports were exhausted")
@@ -85,6 +85,7 @@ PERF_COUNTER_DEF(STALL_EXECUTE_DEPENDENCY_BLOCKED, "cpu.stall.execute_dependency
 PERF_COUNTER_DEF(STALL_EXECUTE_RESOURCE_BLOCKED, "cpu.stall.execute_resource_blocked", "Execute stalled because ready instructions wait for resources")
 PERF_COUNTER_DEF(STALL_EXECUTE_NO_UNIT, "cpu.stall.execute_no_unit", "Execute stage had ready instruction but no execution unit")
 PERF_COUNTER_DEF(STALL_EXECUTE_AMO_WAIT, "cpu.stall.execute_amo_wait", "AMO delayed by older uncommitted store-like operations")
+PERF_COUNTER_DEF(STALL_COMPLETION_PORT_BUSY, "cpu.stall.completion_port_busy", "Execution result held because completion fabric bandwidth was exhausted")
 PERF_COUNTER_DEF(STALL_MEMORY_REPLAY_PORT_BUSY, "cpu.stall.memory_replay_port_busy", "Memory inflight completion delayed because replay ports were exhausted")
 
 PERF_COUNTER_DEF(LOAD_REPLAYS, "cpu.memory.load_replays", "Load instructions replayed due to memory ordering")

include/cpu/ooo/reservation_station.h

@@ -19,7 +19,7 @@ using ReservationStationEntry = DynamicInst;
  * 
  * 功能：
  * 1. 管理等待执行的指令
- * 2. 监听公共数据总线(CDB)，更新操作数状态
+ * 2. 监听完成事件，更新操作数状态
  * 3. 选择准备好的指令发射到执行单元
  * 4. 支持不同类型的执行单元（ALU、分支、访存）
  */
@@ -80,8 +80,8 @@ class ReservationStation {
         size_t limit,
         const std::function<bool(const DynamicInstPtr&)>& can_dispatch = {});
 
-    // 更新操作数（来自CDB）
-    void update_operands(const CommonDataBusEntry& cdb_entry, StoreBuffer* store_buffer);
+    // 更新操作数（来自完成事件）
+    void update_operands(const CompletionEvent& completion_event, StoreBuffer* store_buffer);
 
     // 释放保留站表项
     void release_entry(RSEntry rs_entry);