PL Kernels Packet Processing 模块深度解析

一句话概括

本模块是 Versal ACAP 平台上数据包交换(Packet Switching)架构的 PL 侧核心实现，通过 HLS 实现的报文收发器将多个独立的数据流复用到单一物理通道，解决了 AIE 阵列与 PL 之间多路并发数据传输的瓶颈问题。

1. 问题空间：为什么需要这个模块？

1.1 背景：AIE-PL 数据交互的挑战

在 Versal ACAP 架构中，AI Engine (AIE) 阵列通过 AXI4-Stream 接口与可编程逻辑(PL)通信。当应用需要多路独立数据流并发传输时，传统的电路交换(Circuit Switching)方式面临严峻挑战：

电路交换的问题	具体表现
物理通道浪费	每路数据流独占一条物理通路，即使带宽利用率低也无法共享
连线复杂度爆炸	N 路输入 + M 路输出需要 N×M 条物理连接
时隙刚性	通道一旦建立，即使无数据传输也保持占用

1.2 数据包交换：从"专用车道"到"智能快递"

想象一下城市物流系统：

电路交换 = 为每对收发点修建专用高速公路，无论是否有货都保持畅通
包交换 = 所有货物统一装入标准化快递箱，通过共享的物流网络智能路由，根据收件地址(报文头)自动分拣

本模块就是 PL 侧的"智能分拣中心"：

发送端(hls_packet_sender)：将来自多个 MM2S 的独立数据流封装成带路由信息的报文
接收端(hls_packet_receiver)：解析报文头，按目的地分发到对应的 S2MM 通道

2. 心智模型：理解模块的三把钥匙

2.1 抽象层次：从物理信号到逻辑数据流

┌─────────────────────────────────────────────────────────────┐
│  应用视角：4 路独立的数据通道 (mm2s_1~4  →  s2mm_1~4)        │
├─────────────────────────────────────────────────────────────┤
│  逻辑视角：报文交换网络                                      │
│          ┌──────────────┐      ┌──────────────┐             │
│          │Packet Sender │─────▶│   AIE Array  │             │
│          │  (复用器)     │      │  (交换核心)   │             │
│          └──────────────┘      └──────────────┘             │
│                                         │                    │
│          ┌──────────────┐               │                    │
│          │Packet Receiver│◀─────────────┘                    │
│          │   (解复用器)  │                                   │
│          └──────────────┘                                   │
├─────────────────────────────────────────────────────────────┤
│  物理视角：AXI4-Stream 信号线                                 │
│           时钟(250MHz)、有效信号、数据总线(32/64bit)           │
└─────────────────────────────────────────────────────────────┘

2.2 数据流拓扑：多对一的收敛与一对多的发散

发送端拓扑 - 多路汇聚(Many-to-One)：

mm2s_1.s ──┐
mm2s_2.s ──┼──▶ hls_packet_sender_1 ──▶ ai_engine_0.Datain0
mm2s_3.s ──┤    (复用 + 封装报文头)
mm2s_4.s ──┘

接收端拓扑 - 一路分发(One-to-Many)：

ai_engine_0.Dataout0 ──▶ hls_packet_receiver_1 ──┬──▶ s2mm_1.s
                                                  ├──▶ s2mm_2.s
                                                  ├──▶ s2mm_3.s
                                                  └──▶ s2mm_4.s

2.3 报文格式：隐式的路由契约

虽然代码片段中没有展示报文头的具体定义，但从架构可以推断报文包含的关键字段：

┌─────────────────┬─────────────────┬─────────────────────────────┐
│   报文头字段    │     位宽        │          说明              │
├─────────────────┼─────────────────┼─────────────────────────────┤
│  Destination ID │     2-4 bits   │ 目标 S2MM 通道 (0~3)       │
│  Packet Type    │     2 bits     │ 数据/控制/同步报文类型       │
│  Payload Length │     8-16 bits  │ 有效载荷字节数              │
│  Sequence Num   │     8-16 bits  │ 用于保序和丢包检测           │
│  CRC/Checksum   │     16-32 bits │ 可选的数据完整性校验         │
└─────────────────┴─────────────────┴─────────────────────────────┘

3. 架构详解：组件与数据流

3.1 系统概览图

flowchart TB subgraph PL[PL Domain - 250MHz] direction TB MM2S1[mm2s_1
MM2S Kernel]:::dma MM2S2[mm2s_2
MM2S Kernel]:::dma MM2S3[mm2s_3
MM2S Kernel]:::dma MM2S4[mm2s_4
MM2S Kernel]:::dma PSENDER[hls_packet_sender_1
Packet Encoder]:::hls PRECV[hls_packet_receiver_1
Packet Decoder]:::hls S2MM1[s2mm_1
S2MM Kernel]:::dma S2MM2[s2mm_2
S2MM Kernel]:::dma S2MM3[s2mm_3
S2MM Kernel]:::dma S2MM4[s2mm_4
S2MM Kernel]:::dma end subgraph AIE[AIE Array - 1GHz] AIE0[ai_engine_0
Packet Switch Core]:::aie end subgraph HOST[Host Domain] HOSTAPP[Host Application
XRT Control]:::host end %% Data Flow - Send Path MM2S1 -->|AXI4-Stream| PSENDER MM2S2 -->|AXI4-Stream| PSENDER MM2S3 -->|AXI4-Stream| PSENDER MM2S4 -->|AXI4-Stream| PSENDER PSENDER -->|AXI4-Stream
Packetized| AIE0 %% Data Flow - Receive Path AIE0 -->|AXI4-Stream
Packetized| PRECV PRECV -->|AXI4-Stream| S2MM1 PRECV -->|AXI4-Stream| S2MM2 PRECV -->|AXI4-Stream| S2MM3 PRECV -->|AXI4-Stream| S2MM4 %% Host Control HOSTAPP -.->|XRT API| PL HOSTAPP -.->|XRT API| AIE classDef dma fill:#e1f5fe,stroke:#01579b,stroke-width:2px classDef hls fill:#fff3e0,stroke:#e65100,stroke-width:2px classDef aie fill:#f3e5f5,stroke:#4a148c,stroke-width:2px classDef host fill:#e8f5e9,stroke:#1b5e20,stroke-width:2px

3.2 核心组件剖析

3.2.1 DMA 端点 (MM2S/S2MM)

┌────────────────────────────────────────────────────────────────┐
│  MM2S Kernel (Memory-to-Stream)                                │
├────────────────────────────────────────────────────────────────┤
│  职责: 从 DDR/HBM 读取数据块，通过 AXI4-Stream 输出            │
│  接口: m_axi (DDR) → hls::stream → axis (PL/AIE)               │
│  配置: 4 个实例 (mm2s_1~4)，对应 4 路独立数据源                │
└────────────────────────────────────────────────────────────────┘

┌────────────────────────────────────────────────────────────────┐
│  S2MM Kernel (Stream-to-Memory)                                │
├────────────────────────────────────────────────────────────────┤
│  职责: 从 AXI4-Stream 接收数据，写入 DDR/HBM                   │
│  接口: axis (PL/AIE) → hls::stream → m_axi (DDR)               │
│  配置: 4 个实例 (s2mm_1~4)，对应 4 路独立数据目的地            │
└────────────────────────────────────────────────────────────────┘

3.2.2 报文发送器 (hls_packet_sender)

架构角色：多路复用器 + 报文封装器

数据流处理链：

输入阶段 (4 路并行):
┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐
│ mm2s_1  │  │ mm2s_2  │  │ mm2s_3  │  │ mm2s_4  │
└────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘
     │            │            │            │
     ▼            ▼            ▼            ▼
┌───────────────────────────────────────────────────┐
│          轮询/仲裁逻辑 (Round-Robin)               │
│  策略: 公平轮询，避免单路流饿死                     │
│  缓冲: 每路独立 FIFO，解耦生产者/消费者速率         │
└───────────────────────────────────────────────────┘
                          │
                          ▼
┌───────────────────────────────────────────────────┐
│          报文封装 (Packet Framing)                 │
│  - 插入报文头 (目标ID、序列号、长度)               │
│  - 计算 CRC/Checksum (可选)                        │
│  - 添加帧边界标记                                   │
└───────────────────────────────────────────────────┘
                          │
                          ▼
┌───────────────────────────────────────────────────┐
│       AXI4-Stream 输出 → ai_engine_0.Datain0     │
│  特性: 单一物理通道，逻辑多路复用                   │
└───────────────────────────────────────────────────┘

3.2.3 报文接收器 (hls_packet_receiver)

架构角色：解复用器 + 报文解析器

数据流处理链：

输入阶段:
┌───────────────────────────────────────────────────┐
│       AXI4-Stream 输入 ← ai_engine_0.Dataout0    │
│  特性: 单一物理通道承载多路逻辑流                   │
└───────────────────────────────────────────────────┘
                          │
                          ▼
┌───────────────────────────────────────────────────┐
│          报文解析 (Packet Parsing)                   │
│  - 检测帧边界，提取完整报文                         │
│  - 解析报文头 (Destination ID, Length, Seq)         │
│  - 验证 CRC/Checksum (可选)                         │
│  - 错误处理: 丢包、错序、CRC 失败                   │
└───────────────────────────────────────────────────┘
                          │
                          ▼
┌───────────────────────────────────────────────────┐
│          路由分发 (Demultiplexing)                 │
│  逻辑: 根据 Destination ID 选择输出通道               │
│  - ID=0 → s2mm_1                                  │
│  - ID=1 → s2mm_2                                  │
│  - ID=2 → s2mm_3                                  │
│  - ID=3 → s2mm_4                                  │
│  缓冲: 每路独立 FIFO，吸收速率不匹配                │
└───────────────────────────────────────────────────┘
                          │
     ┌────────────────────┼────────────────────┐
     ▼                    ▼                    ▼
┌─────────┐          ┌─────────┐          ┌─────────┐
│ s2mm_1  │          │ s2mm_2  │          │ s2mm_3  │   + s2mm_4
└─────────┘          └─────────┘          └─────────┘

4. 设计决策与权衡

4.1 为什么选择包交换而非电路交换？

维度	电路交换 (Circuit Switching)	包交换 (Packet Switching) - 本方案
资源占用	N×M 条物理连接	N+M 条连接 + 报文处理逻辑
带宽利用率	低 (空闲时通道浪费)	高 (统计复用)
延迟确定性	高 (固定通路)	中 (排队和调度引入抖动)
复杂度	低 (硬连线)	高 (需要报文封装/解析)
扩展性	差 (新增流需重布线)	好 (软件配置路由表)

本模块的取舍逻辑：

接受更高的实现复杂度和轻微的延迟不确定性
换取物理通道数量的大幅减少 (4+4=8 条 vs 4×4=16 条)
获得动态流调度的灵活性 (可在运行时调整路由)

4.2 为什么选择 4 路复用？

从配置看，系统选择了 4 路 MM2S 汇聚到 1 路报文通道，再从 1 路报文通道分发到 4 路 S2MM。这个数字的选择反映了以下权衡：

AIE 阵列的并行度：典型的 AIE 设计采用 4、8、16 的并行粒度，4 路是一个自然的起点
报文开销的摊销：每包需要额外的报文头(可能 8-16 字节)，4 路复用时开销占比合理
FIFO 资源平衡：更多路数需要更大的缓冲 FIFO，4 路在典型 BRAM 预算内

4.3 HLS vs RTL 的实现选择

本模块使用 HLS (High-Level Synthesis) 实现报文收发器，而非手工编写 RTL：

方面	HLS (本方案)	手工 RTL
开发效率	高 (C++ 抽象)	低 (Verilog 细节)
时序收敛	依赖工具 (通常 400MHz 可达)	手工优化更可控
代码可维护性	高 (算法意图清晰)	低 (时序逻辑交织)
资源优化	工具决定，可能冗余	可精确到门级

关键配置：freqhz=400000000 (400MHz)

这是 PL 侧 HLS 核的目标时钟
与 AIE 阵列的 1GHz 形成跨时钟域，但 AXI4-Stream 的握手协议天然处理速率匹配

5. 依赖关系与系统集成

5.1 模块依赖图

┌─────────────────────────────────────────────────────────────────────┐
│                    pl_kernels_packet_processing                    │
│                     (本模块 - PL 侧报文处理)                          │
├─────────────────────────────────────────────────────────────────────┤
│  依赖项:                                                              │
│  ├─► AIE_ML_Feature_Tutorials.buffer_aie.aie_kernels               │
│  │    (AIE 侧报文处理核 - 报文路由核心)                              │
│  │    关系: AIE 接收 PL 发送的报文，处理后返回                      │
│  │                                                                          │
│  ├─► AIE_ML_Feature_Tutorials.buffer_aie.host_control              │
│  │    (主机控制程序 - XRT 运行时)                                    │
│  │    关系: 配置 DMA 描述符、启动数据传输                            │
│  │                                                                          │
│  └─► AIE_Design_System_Integration.baseline_aie_pl_integration   │
│       (AIE-PL 基础集成模式)                                          │
│       关系: 继承基础集成架构，添加报文交换层                         │
└─────────────────────────────────────────────────────────────────────┘

5.2 数据流时序图

Host Control                    PL Kernels                    AIE Array
    │                               │                              │
    │  1. XCL_MAP_BUFFER            │                              │
    │───────────────────────────────▶│                              │
    │                               │                              │
    │  2. START MM2S DMA            │                              │
    │───────────────────────────────▶│                              │
    │                               │                              │
    │                               │  3. READ FROM DDR              │
    │                               │◀─────────────────────────────│
    │                               │                              │
    │                               │  4. AXI4-STREAM TO SENDER    │
    │                               │────┬────────────────────────▶  │
    │                               │    │                         │
    │                               │  5. PACKET ENCODING         │
    │                               │◀───┘                         │
    │                               │                              │
    │                               │  6. PACKET TO AIE           │
    │                               │─────────────────────────────▶│
    │                               │                              │
    │                               │  7. AIE PROCESSING          │
    │                               │◀─────────────────────────────│
    │                               │                              │
    │                               │  8. PACKET FROM AIE         │
    │                               │─────────────────────────────▶│
    │                               │                              │
    │                               │  9. PACKET DECODING         │
    │                               │────┬───────────────────────▶ │
    │                               │    │                        │
    │                               │ 10. DEMUX TO S2MM          │
    │                               │◀───┘                        │
    │                               │                             │
    │                               │ 11. WRITE TO DDR           │
    │                               │────────────────────────────▶│
    │                               │                             │
    │  12. SYNC/READBACK           │                             │
    │◀─────────────────────────────│                             │
    │                               │                             │

Legend:
  ───▶ 控制流/配置
  ──▶  数据流 (AXI4-Stream)
  ◀──▶ 双向交互

6. 关键设计权衡与决策分析

6.1 为什么采用 4 路复用？

设计约束空间:
                    带宽利用率
                       ▲
                       │
          理论最优 ─────┼───── 实际折中
           (16路)      │      (本设计: 4路)
                       │
                       │
   资源消耗 ◀──────────┼──────────▶ 复杂度
   (BRAM/FIFO)        │           (时序收敛)
                       │
          资源极限 ─────┼───── 复杂度爆炸
           (1路独占)   │      (16路全交换)
                       │
                       ▼
                    延迟确定性

选择 4 路的核心逻辑：

AIE 架构对齐：AIE 计算单元通常以 4、8、16 为并行粒度组织，4 路是 AIE-PL 接口的自然宽度
报文开销摊销：假设报文头 16 字节，载荷 256 字节，开销比例为 6%；若降为 2 路，为保持吞吐量需增加包频，开销比例上升至不理想水平
FIFO 资源平衡：每路需要独立的缓冲 FIFO 吸收速率波动，4 路在典型 BRAM (18Kb/36Kb) 预算内可配置合理的 FIFO 深度 (如 4KB/路)

6.2 时钟域交叉策略

时钟域架构:

   Host Domain (PCIe)          PL Domain              AIE Domain
        │                        │                       │
    ~100MHz                 250MHz (本模块)            1GHz
        │                        │                       │
        │    ┌───────────────────┘                       │
        │    │                                           │
        ▼    ▼                                           ▼
   [XRT Runtime] ──────► [MM2S/S2MM] ──────► [AIE Array]
   (控制面)              (数据面 250MHz)       (计算面 1GHz)
                            │
                            └────► [Packet Sender/Receiver]
                                   (本模块核心)

跨时钟域交互点:
1. XRT ↔ PL: 通过 PCIe BAR 寄存器 + DMA 描述符，标准 XRT 驱动处理
2. PL (250MHz) ↔ AIE (1GHz): AXI4-Stream 接口天然支持异步时钟，通过 FIFO 缓冲

为何 250MHz 是合理选择：

400MHz 是 HLS 综合目标，但实际运行配合 AIE 的 1GHz，选择 1/4 分频 (250MHz) 简化时钟树
AXI4-Stream 的 TVALID/TREADY 握手机制天然处理速率匹配，无需额外同步逻辑

6.3 HLS 实现的关键优化

#pragma HLS 优化策略映射:

┌───────────────────────────────────────────────────────────────────┐
│  DATAFLOW - 任务级流水线                                           │
│  ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐             │
│  │ Read    │──▶│ Frame   │──▶│ Process │──▶│ Write   │             │
│  │ Input   │   │ Header  │   │ Payload │   │ Output  │             │
│  └─────────┘   └─────────┘   └─────────┘   └─────────┘             │
│       │            │            │            │                     │
│       └────────────┴────────────┴────────────┘                     │
│                     并发执行 (并发度=4)                              │
└───────────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────────┐
│  PIPELINE - 循环级流水线                                           │
│                                                                   │
│  for (int i = 0; i < PACKET_SIZE; i++) {                         │
│      #pragma HLS PIPELINE II=1                                    │
│      process_word(input[i], output[i]);                           │
│  }                                                                │
│                                                                   │
│  目标: Initiation Interval = 1 周期                                 │
│  效果: 每周期输出一个处理后的字，吞吐量 = 时钟频率 × 数据宽度          │
└───────────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────────┐
│  INTERFACE - 端口协议定义                                          │
│                                                                   │
│  #pragma HLS INTERFACE axis port=input_stream                     │
│  #pragma HLS INTERFACE axis port=output_stream                    │
│  #pragma HLS INTERFACE s_axilite port=ctrl_reg bundle=control   │
│                                                                   │
│  效果:                                                            │
│  - input/output: AXI4-Stream 协议 (TVALID/TREADY/TDATA/TLAST)       │
│  - ctrl_reg: AXI4-Lite 寄存器接口，用于主机配置                     │
└───────────────────────────────────────────────────────────────────┘

7. 新贡献者指南：避坑与最佳实践

7.1 隐式契约与假设

时序假设：

// 隐式契约 1: AXI4-Stream 握手必须在一个时钟周期内完成
// 危险代码：
if (valid) {  // 假设 valid 只持续一周期
    data = read();
}
// 安全代码：
if (valid && ready) {  // 完整握手
    data = read();
}

// 隐式契约 2: TLAST 必须在包的最后一个字上置位
// 违规后果：接收端无法正确识别包边界，导致后续包解析错位

资源假设：

BRAM 预算契约:
- Packet Sender: 4 × 2KB FIFO = 8KB BRAM
- Packet Receiver: 4 × 2KB FIFO = 8KB BRAM
- 总计: 16KB (约 8 个 18Kb BRAM)
- 假设: 器件为 xcve2802，可用 BRAM ~600 个，占比 <2%

7.2 常见陷阱

陷阱 1: 报文头字段对齐

// 错误: 未考虑字节序和对齐
struct PacketHeader {
    uint8_t dest_id;      // 偏移 0
    uint16_t payload_len; // 偏移 1 (非对齐！某些 HLS 版本可能警告)
    uint8_t seq_num;      // 偏移 3
}; // 总大小 4 字节

// 正确: 显式填充和对齐
struct PacketHeader {
    ap_uint<8> dest_id;       // 8 bits
    ap_uint<8> reserved;      // 填充，确保 16-bit 对齐
    ap_uint<16> payload_len;  // 16 bits
    ap_uint<8> seq_num;       // 8 bits
    ap_uint<8> crc;           // 8 bits
} __attribute__((packed)); // 或 #pragma pack(1)

陷阱 2: 背压传播

// 问题: 下游阻塞未正确传播到上游，导致 FIFO 溢出
void packet_sender(...) {
    #pragma HLS INTERFACE axis port=in0
    #pragma HLS INTERFACE axis port=in1
    #pragma HLS INTERFACE axis port=out
    
    // 错误: 只检查当前输入，不检查输出是否就绪
    if (!in0.empty()) {
        out.write(in0.read()); // 可能阻塞！
    }
    
    // 正确: 完整握手检查
    if (!in0.empty() && !out.full()) {
        out.write(in0.read());
    }
}

陷阱 3: 跨时钟域数据一致性

场景: Packet Sender 运行在 400MHz，但 AIE 接口运行在 250MHz
危险: 数据在跨时钟域时可能被采样到不稳定状态

解决方案:
1. AXI4-Stream 协议天然包含握手机制，FIFO 插入 CDC (Clock Domain Crossing)
2. 使用 tool-generated 的 AXI Stream FIFO IP，自动处理 CDC
3. 确保 depth 足够吸收速率差异 (250MHz vs 400MHz 需要至少 16 深度)

7.3 调试与验证策略

仿真验证层次：

Level 1: HLS C-Simulation
- 验证算法逻辑正确性
- 快速迭代，无需综合
- 工具: vitis_hls -csim

Level 2: HLS RTL Co-Simulation  
- 验证 HLS 生成的 RTL 与 C 模型行为一致
- 检查时序和握手协议
- 工具: vitis_hls -cosim

Level 3: System-Level Emulation (hw_emu)
- 完整系统软硬件协同仿真
- 验证 AIE-PL 交互、DMA 传输
- 工具: v++ -t hw_emu

Level 4: Hardware Validation (hw)
- 实际板卡运行
- 性能 profiling, 吞吐量/延迟测量

关键检查点：

# 伪代码: 验证报文完整性的自检逻辑
def verify_packet_integrity(tx_data, rx_data):
    """
    检查发送和接收的报文是否一致
    """
    errors = []
    
    # 1. 包数量匹配
    if len(tx_data) != len(rx_data):
        errors.append(f"Packet count mismatch: TX={len(tx_data)}, RX={len(rx_data)}")
    
    # 2. 每包内容匹配
    for i, (tx_pkt, rx_pkt) in enumerate(zip(tx_data, rx_data)):
        if tx_pkt.payload != rx_pkt.payload:
            errors.append(f"Payload mismatch at packet {i}")
        if tx_pkt.header.seq_num != rx_pkt.header.seq_num:
            errors.append(f"Sequence number mismatch at packet {i}")
    
    # 3. 顺序检查
    rx_seq_nums = [p.header.seq_num for p in rx_data]
    if rx_seq_nums != sorted(rx_seq_nums):
        errors.append("Out-of-order packets detected")
    
    return errors

8. 相关模块导航

8.1 上游依赖 (被本模块依赖)

模块	关系	说明
AIE_ML_Feature_Tutorials-buffer_aie-aie_kernels	数据消费方	AIE 侧报文处理核，接收/发送 PL 侧的报文
AIE_ML_Feature_Tutorials-buffer_aie-host_control	控制方	主机 XRT 程序，配置 DMA 描述符、启动数据传输

8.2 下游依赖 (依赖本模块)

模块	关系	说明
AIE_ML_Feature_Tutorials-buffer_aie-system_config	集成方	系统集成配置，实例化本模块的核并连接拓扑

8.3 同级相关模块

模块	关系	说明
AIE_ML_Feature_Tutorials-pktstream_aie-pl_kernels	变体	基于 pktstream 接口的 PL 报文处理，本模块基于 buffer 接口

9. 总结：模块的架构角色

┌─────────────────────────────────────────────────────────────────────┐
│                        架构定位卡片                                 │
├─────────────────────────────────────────────────────────────────────┤
│  模块名称: pl_kernels_packet_processing                             │
│  架构层级: PL 侧数据平面 (Data Plane)                                │
│  核心职责: 多路数据流的报文封装、复用、解复用、解析                  │
├─────────────────────────────────────────────────────────────────────┤
│  输入接口: 4× AXI4-Stream (from MM2S)                               │
│  输出接口: 1× AXI4-Stream (to AIE)                                  │
│  返回路径: 1× AXI4-Stream (from AIE) → 4× AXI4-Stream (to S2MM)    │
├─────────────────────────────────────────────────────────────────────┤
│  关键设计模式:                                                       │
│  • 统计复用 (Statistical Multiplexing)                              │
│  • 轮询仲裁 (Round-Robin Arbitration)                                 │
│  • 报文交换 (Packet Switching)                                        │
│  • 流控背压 (Backpressure Flow Control)                              │
├─────────────────────────────────────────────────────────────────────┤
│  性能特征:                                                          │
│  • 目标频率: 400MHz (HLS 综合), 运行 250MHz                         │
│  • 吞吐能力: 每路最大 100MB/s (32-bit @ 250MHz)                     │
│  • 聚合吞吐: 400MB/s (4路复用)                                       │
│  • 延迟特性: 微秒级 (取决于包大小和仲裁)                             │
└─────────────────────────────────────────────────────────────────────┘

文档信息

模块路径: AI_Engine_Development/AIE/Feature_Tutorials/04-packet-switching/buffer_aie/pl_kernels
核心组件: config.cfg.s2mm, system.cfg.mm2s_1~4, system.cfg.hls_packet_receiver_1, system.cfg.hls_packet_sender_1
相关模块: buffer_aie-aie_kernels, buffer_aie-host_control