第四部分 Intel 网络处理器

主要内容 Intel 网络处理器概述 XScale 核 微引擎 其它功能单元 编程模型 参考设计

Internet eXchange Architecture (IXA) IXA ：泛指 Intel 网络处理器架构以及相关的支持芯片，

包括网络处理器硬件及软件体系结构。 IXA 包括控制面和数据面处理，定义了硬件抽象、应用编

程接口和互连机制，但没有给出细节。 IXA 的三个重要组成部分：

微引擎（ Microengine ， ME ）： Intel 网络处理器的核心部件，在其它功能单元的支持下执行快路径上的操作。

XScale Core ： Intel 网络处理器的高层控制和管理单元，负责控制面及异常包处理，运行嵌入式实时操作系统。

IXA 可移植框架：为基于 Intel 网络处理器的软件开发提供应用编程接口和硬件抽象。

IXA 的特性 灵活性：

微引擎完全可编程，在低层硬件设备的支持下可实现许多复杂的网络处理功能，具有较好的功能灵活性。

高性能（高可扩放性）： 使用多个可并行操作的微引擎，通过增加微引擎的数目、提高微

引擎及 XScale 核的时钟频率、采用各种减小访存延迟的技术及增加专用的硬件功能单元，可支持高达 OC-192 的高端处理速度。

可移植性： IXA 可移植框架提供了应用编程接口和硬件抽象，使得基于该框

架开发的软件与底层硬件实现松耦合，具有良好的可移植性和重用性。

Internet eXchange Processor (IXP) IXP ：指实现了 IXA 架构的网络处理器芯片。 IXP 典型地包括：

一个 XScale 核 多个微引擎 片上存储单元 若干硬件功能单元 与各种外部连接的接口 内部总线

第二代 IXP 网络处理器

IXP2400 ： 8 个微引擎，主要面向网络接入和边缘网应用，可用于 WAN多服务交换、 DSLAM 、基站控制器和网关、 4~7 层交换、 VoIP 网关、多服务接入平台等。

IXP2800 ： 16 个微引擎，主要面向边缘网和核心网应用，可用于骨干网的路由与交换、无线设备、 10Gbps 的企业交换和路由等。

IXP2850 ：在 IXP2800 的基础上增加了加密单元，可达到 10Gb/s 的加解密速度，用于 IPSec 、 VPN 、 QoS Router 等场合。

IXP2xxx ：泛指任何一种第二代 IXP 网络处理器芯片。

IXP2xxx 的主要部件 一个 IXP 网络处理器是一块独立的芯片，包含一组复杂的可编程及不

可编程的处理器和功能单元： 一个嵌入式 RISC 处理器（ XScale Core ） 8 到 16 个可编程包处理器（微引擎） 多条独立的片上总线：提供芯片内部各功能单元之间的高速通道 处理器同步机制 共享和不共享的片上存储器 一个低速串行接口：连接到 XScale Core ，用于控制和管理 多个外部存储器接口：连接外部 SRAM 、 DRAM 及 ROM 等 多个外部 I/O 总线接口 计算哈希和加密的协处理器 其它功能单元

IXP 的外部连接 串行接口：连接到 XSca

le Core ，用于控制和管理。

PCI 总线接口：连接 I/O设备及传统 CPU。

MSF接口：连接外部物理层设备及交换结构，是数据出入 IXP 的窗口。

DRAM 总线接口：提供1条或多条 DRAM 总线。

SRAM 总线接口：提供多条 SRAM 总线。

慢端口连接：访问 ROM/FlashROM 等外部硬件单元。

IXP2400 外部连接的速度

IXP2xxx 的内部组件数量 组件 目的

1 嵌入式 RISC 处理器 控制、高层协议和例外处理8/16 包处理引擎 I/O 、基本包处理和包转发1+ SRAM 访问单元 协调对外部 SRAM 总线的访问1+ DRAM 访问单元 协调对外部 DRAM 总线的访问1 MSF访问单元 协调对外部 I/O 设备的访问1 PCI 总线访问单元 协调对外部 PCI 总线的访问1 SHaC 单元 存储中间结果、计算哈希值等1 加密单元 加 / 解密操作1 系统底盘（ chassis ） 提供内部控制及数据传输通道

IXP2xxx 的概念组织

IXP2400 硬件结构框图MSF SHaC

SRAM0控 制 器

SRAM1控 制 器

DRAM控 制 器

S Push0总 线

S Pul l0总 线

S Push1总 线

S Pul l1总 线

命 令 总 线

D Push总 线

D Pul l总 线

PCI单 元

I nt elXScal e

ME0x01

ME0x00

ME0x03

ME0x02

ME0x10

ME0x11

ME0x12

ME0x13

ME Cl ust er 0 ME Cl ust er 1

Chasi s

硬件体系结构：多主控 + 系统底盘 + 多目标

IXP2400 硬件结构特征 采用了多主控 +系统底盘 +多目标的分布式硬件体系结构，

增强了 IXP2400 的并行处理能力。 具体而言，

采用分立的内部总线结构，将不同存储单元的数据总线、数据读 /写总线分开，可以同时对不同存储单元进行双向读 /写操作。

引入命令总线仲裁器对各主控单元发出的命令进行排队判优，保证指令的优先级，避免指令的冲突和拥塞。

采用分布式的硬件结构（即多主控 +多目标），不同的硬件功能单元各司其职，负责专门的数据处理，可以并行操作。

采用多微引擎并行的硬件结构，所有微引擎可同时工作；而且微引擎被进一步分成两个簇，每个簇使用独立的 SRAM 数据总线，有效地缓解了总线冲突。

IXP2xxx 的处理器体系 处理器类型 是否在芯片上？ 是否可编程？

通用处理器 否 是嵌入式 RISC 处理器 是 是I/O 处理器 是 是协处理器 是 否物理接口硬件 否 否

通用处理器（ GPP ）：不是 IXP2xxx 的一部分，用于执行整体控制和管理功能。

物理接口硬件：不是 IXP2xxx 的一部分， Intel 提供专门的芯片实现第一层和第二层的处理。

IXP2xxx 处理器体系（续） 嵌入式 RISC 处理器（ XScale Core ）：不是快路径的一部分，用于

管理微引擎、提供一个可以下载程序和配置芯片的接口、处理高层协议及例外的包，运行常规嵌入式操作系统。

I/O 处理器（ MicroEngine ）：只提供少量基本指令的低级设备，不运行操作系统，用于处理 I/O 设备与存储器之间的低层数据传输及基本包处理，是快路径处理的基础。

协处理器和功能单元：有一些构成了快路径的一部分，如 SHaC 单元、加 / 解密单元等。

IXP2xxx 使用的存储器存储器类型 最大容量 是否在 典型用途

芯片上？

GP Registers 256×4bytes 是 中间运算Inst. Cache 32Kbytes 是 最近使用过的指令Data Cache 32Kbytes 是 最近使用过的数据Mini Cache 2Kbytes 是 重用过一次的数据Write buffer 未指定 是 写缓冲区Local memory 2560bytes/ 微引擎 是 本地缓存Scratchpad 16Kbytes 是 进程间通信和同步Inst. Store 4Kbytes/ 微引擎 是 存放微引擎指令FlashROM 未指定 否 用于启动SRAM 64Mbytes/ 通道 否 存放表或包头DRAM 2Gbytes/ 通道 否 存储包

四种主要存储器的特性类型 访问单位 相对访问 特性

（字节） 延时Local 4 1 用 LM_ADDR寄存器访问Scratchpad 4 10 支持原子操作、进程间通信、微引擎之间的 通信SRAM 4 150 支持原子操作、队列和环、比特操作DRAM 8 300 连接到 XScale 、微引擎和 PCI 总线控制

器 LM ：提供最小的访存时间 Scratchpad和 SRAM ：支持原子操作，可用来同步并行处理器 SRAM ：支持队列和环，适合于存放包头或包链表 DRAM ：有对 I/O 设备的直接传输路径，容量大，带宽高，适合存放

包。

数据访问单位 每种物理存储器都定义了访问单位的长度（也称可寻址

数据单位）： 字（ word）： 2字节的单位（ 16比特） 长字（ longword）： 4字节的单位（ 32比特） 四倍长字（ Quadword）： 8字节的单位（ 64比特）

尽管微引擎和 XScale 可以为每个字节产生地址，但是底层机制总是一次读 /写一个访问单位长度的数据。

程序员必须了解存储器的组织，仔细规划数据的布局以最小化访存时间。

基于 IXP2xxx 的典型系统结构

单片 IXP2xxx 的系统架构

主要内容 Intel 网络处理器概述 XScale 核 微引擎 其它功能单元 编程模型 参考设计

IXP2xxx 在网络系统中的使用方法

两种可能的网络系统设计方法

嵌入式处理器的作用 嵌入式 RISC 处理器可以被分配以下一些或全部的任务：

自举：包括片上存储器和处理器的初始化 控制微引擎：如启动 /停止包处理 内存分配 诊断和日志 交互程序调试（ Interactive debugging ） 用户接口和 /或到通用处理器的接口 其它管理功能：如创建 /修改微引擎使用的数据结构，维护本地转发表，描述配置细节（如每个网络接口的地址）等。

异常处理：不匹配任何分类规则的包，产生出错消息的包 高层协议处理：负责处理发给本地系统的包（如 TCP ） 应用程序（需要的话）

XScale 的主要特性 精简指令集计算（ RISC ）：

包含较少的指令，指令被设计为能够很快执行，依靠寄存器获得高速度，保证每个时钟周期能够完成一条指令。

可配置大端 / 小端模式的的 32位算术运算： 处理器引导时配置端模式。

由协处理器提供的矢量浮点运算 字节可寻址内存：

接口硬件按照底层存储器的访问单元长度存取，当与处理器通信时只传输需要的字节。

XScale 使用的地址空间 虚拟存储支持：

所有的外部存储器及部分片上存储器、 PCI 总线、其它存储器映射的 I/O 设备均被映射到一个大小为 232字节的线性地址空间， XScale 硬件包括一个提供虚存的存储管理单元。

有一些存储器是 XScale 和微引擎共享的，如 Scratchpad、 SRAM 、 DRAM ，可以用来在 XScale 和微引擎之间传递数据。

微引擎不使用 XScale 的地址空间， XScale必须处理所有的地址转换。

其它 I/O: XScale 可以访问设备的 CSR ，可以访问和控制

PCI 总线上的任何一个设备

XScale 的主要特性（续） 内部外设单元（只能由 XScale 使用）：

作为控制台设备的串口 四个 32位倒计数定时器：这意味着 XScale必须处理所有涉及超时的协议处理任务。

四个通用 I/O 管脚：通过 MSF访问，连接到另外的硬件或用于调试 Slowport 接口：用于系统引导

支持内核化操作系统的硬件设施 系统控制协处理器 15 ：

只能由 XScale 使用，用于配置和控制 IXP2xxx 上的几个硬件单元，如MMU、读 /写缓冲器、时钟、高速缓存等。

性能监视单元： 监视指令 cache不命中率、 TLB不命中率、指令流水线中的停顿、软件

引起的分支指令数目。

主要内容 Intel 网络处理器概述 XScale 核 微引擎 其它功能单元 编程模型 参考设计

微引擎的用途 在 IXP2xxx 的处理器体系中，微引擎构成了最低层的可编

程处理器。 微引擎被设计用来执行快路径上的处理，包括 Ingress 和

Egress协议处理任务： 从物理层硬件接收包 检查校验和 包头处理和分类 包缓存 查表和转发 包头修改 校验和计算 从物理层硬件发送包

微引擎架构的特点 一种可编程微控制器（微引擎不是一个传统的 CPU） 采用 RISC 设计 本地的控制存储器：微引擎的指令存储器 执行数据通路（ Execution Datapath）：微引擎的指令执行单元

一个算术逻辑单元 ALU 一个 16 入口的 CAM ，每个入口 32比特 8 个线程和上下文切换的硬件支持

数据通道寄存器 256 个通用寄存器 512 个传输寄存器 128 个 Next Neighbor寄存器 640 个字的本地内存

一个 CRC 计算单元 可直接访问片上各种功能单元

微序列控制器 微引擎不是一个传统的 CPU，而是一个可编程微控制器。 微引擎不包含每一种操作的本地指令，运行在微引擎上的程序控制

和使用芯片上的功能单元来完成指令。 例 1 ：算术运算

传统 CPU上的指令： add R2, R3 微引擎上的指令： alu [dest, A_op, alu_op, B_op] alu_op 包括 12 种运算符（ +、 +16 、 +8 、 +carry、 B-A 、 B、 ~B、

AND 、 ~AND 、 AND~ 、 OR 、 XOR ） 例 2 ：内存引用

传统 CPU上的指令： load R3, X 微引擎上的指令： sram [cmd, xfer, src_op1, src_op2, ref_cnt], opt_tok

微引擎指令集 微引擎指令集的操作码不到 64 个，分为以下四类：

通用指令：算术，循环，移位 分支和跳转指令：某一位置位 /清零跳转，字节相等 /不等跳转，根据事件状态跳转，…

CAM 指令：查找，清除入口，读标签 /状态，写标签 /状态 I/O 和线程交换指令：读 /写 DRAM ，读 /写 SRAM ，读 /写队列描述符（ SRAM ），入队 / 出队，存储器环操作，访问 Scratchpad ，……

分离的存储器地址空间 微引擎硬件不将存储器或 I/O 设备映射到一个线性地址空间，程序必须说明数据传输所涉及的存储器，因此每一类存储器和每一类 I/O 设备都有专门的指令。

例如： sram [cmd, xfer, src_op1, src_op2, ref_cnt], opt_tok dram [cmd, xfer, src_op1, src_op2, ref_cnt], sig1, sig2 scratch [cmd, xfer, src_op1, src_op2, ref_cnt], opt_tok

程序员必须为每个数据项选择将要放入的存储器。

执行流水线 RISC 架构： RISC 处理器将一个指令的执行分成若干个阶段，通过同时执行几条指令的不同阶段来重叠多条指令的执行。

执行流水线：重叠不同阶段执行的硬件。

指令执行在各个级的划分

执行流水线停顿 指令间的相互依赖可能导致执行流水线停顿，如：

K: alu [R2, R2,+,R1]K+1 ： alu [R3, R3,+,R2]

条件分支也可能造成执行流水线停顿。通常情况下，微引擎硬件继续取下一条指令装入流水线，就好像没有分支一样。

微引擎的执行数据通道 微引擎的指令执行单元也称执行数据通道（ Execution Data Path），

可执行移位、加 / 减、逻辑运算、乘法、字节对齐、比特操作、 CAM查找等。

微引擎要执行的代码存放在本地的控制存储器中，源 / 目标操作数均为微引擎内部的存储单元（称数据通道寄存器）。

执行数据通道采用 5级流水线结构：取指令、指令译码、取操作数、指令运算、写运算结果。

控制存储器和数据通道寄存器均位于微引擎内部，取指令或取操作数都在单个时钟周期内完成，所以执行数据通道执行一条指令只需要一个时钟周期。

微引擎的执行数据通道（续） 字节对齐：从连续的 8 个字节中取出任意偏移量（ 0~3 ）的连续 4 个字节。 CAM 用于快速查找：

16 个入口 每个入口包括 32位标签（查找关键字）和 4位状态 可以写 CAM中的任意一行，可以分别写标签和状态 程序提供一个 32比特的查找关键字， CAM 硬件报告查找结果（ 0~15 的值）：

cam_lookup[dest_reg, src_reg] ，其中 src_reg 为查找关键字，结果放在 dest_reg中。

CRC 单元 CRC 单元不是执行数据通道的一部分，它与执行

数据通道并行工作。 支持 16比特和 32比特的 CRC 运算。 用于计算 ATM或以太网等 2 层数据包的校验和。

存储器访问延迟和多线程

6? 6?

存储器访问对系统性能影响很大，一次外部存储器访问相当于微引擎执行上百条指令。

隐藏存储器访问延迟的最好方法是使用多线程。

硬件线程和上下文切换 每个微引擎支持 8 个执行线程 硬件为每个线程维护不同的状态信息（如一个程序计数器，一组信号事件） 硬件可以在线程之间迅速切换而不需要软件的支持，上下文切换为零开销或最多一个时钟周期的开销

概念上，微引擎线程就像传统操作系统中的线程一样操作。

线程状态转移 未激活状态：不执行任何操作。 执行状态：正在执行控制存储器中的程序，同一时刻最多只有一个上下文处于该状态。 就绪状态：具备了继续执行数据处理任务的所有外部条件，等待获得微引擎的控制权。 休眠状态：等待某个外部事件的到来。 上下文切换由软件控制，处于执行状态的线程执行一条线程交换指令后转入休眠状态，

微引擎对当前处于就绪状态的所有上下文进行仲裁判优，将控制权交给优先级最高的上下文。

事件信号 IXP2xxx 使用称为事件信号的软件机制同步微引擎的内部操作和外

部事件的完成。 可以在指令中指定事件信号，令从属单元在完成指令规定的操作后

向微引擎发送该事件信号，如： sram [cmd, xfer, src_op1, src_op2, ref_cnt], opt_tok dram [cmd, xfer, src_op1, src_op2, ref_cnt], sig1, sig2

每个线程可以使用 15 个事件信号，这些信号将线程从休眠状态唤醒。 每个线程有两个本地寄存器，分别记录需要等待的事件信号和已经

到来的事件信号。 在线程交换指令中，可以使用 AND 、 OR 等逻辑运算符指令线程需

要等待的多个事件信号。

指令存储器（控制存储器） IXP2xxx 使用单独的存储器系统（即不使用 SRAM 和 DRAM ）存储微

引擎指令。 指令存储器的组织方式：

共享指令存储器：代码共享，节省空间，但有竞争。 专用指令存储器：无竞争，要求较多空间。

IXP2xxx 提供折衷方案： 每个微引擎使用一个私有的指令存储器，避免竞争。 每个指令存储器的容量限制为 4096条指令，避免使用较多的空间。

控制存储器属于微引擎的内部存储资源，因而可单周期地读取其中的程序指令。

控制存储器中的程序从 IXP2xxx 的 ROM中读入，在 XScale 控制下完成。

数据通道寄存器 微引擎需要与许多硬件设备交互，许多交互是通

过硬件寄存器发生的。 微引擎使用的数据通道寄存器包括：

通用寄存器 传输寄存器 邻居寄存器 本地存储器

通用寄存器（ GPR ） 每个微引擎有 256 个通用寄存器，每个为 32比特，一般用作指令的源和目的寄存器。

通用寄存器的两种使用方法： 8 个线程共享整个寄存器组：需要处理互斥。 每个线程分配 32 个专用的寄存器：不需要互斥。

寄存器寻址方式： 绝对寻址：唯一指定一个寄存器。 相对寻址：指定当前上下文的一个寄存器。

通用寄存器分为两个 bank ，绝对和相对寄存器地址都必须指明 bank

及 bank中的一个寄存器。 指令的两个源操作数分别来自 A Bank 和 B Bank 。

寄存器绝对编址

传输寄存器 微引擎使用传输寄存器缓存与外部设备交换的数据，以协调微引擎与外部设备之间的速度差异。

每个微引擎有 512 个传输寄存器，按外部总线和传输方向分为四类： D Xfer in reg 及 D Xfer out reg ：用作微引擎与 DRAM 控制器的

数据交换窗口。 S Xfer in reg 及 S Xfer out reg ：用作微引擎与 SRAM 控制器、 M

SF及 SHaC之间的数据交换窗口。 传输寄存器可以使用绝对地址或相对地址进行编址。

邻居寄存器与软件流水线 微引擎硬件被设计为支持软件流水线模型，软件流水线可

以包含来自多个微引擎的模块。 邻居寄存器用来在相邻的两个微引擎之间传递数据。 每个微引擎含有 128 个邻居寄存器，可以被 8 个线程共享，也可均分为 8份。

邻居寄存器可由上一个邻居微引擎写入数据，也可由自身微引擎写入数据。

邻居机制只用来传递少量的数据，如数据项的地址。 邻居寄存器机制类似于一个环缓冲器，微引擎硬件包含了协调发送者与接收者的原语。

访问邻居寄存器环的原语

本地存储器 专用：每个微引擎有一个本地存储器。 容量小： 2560字节。 低延迟：建立之后只需要一个指令周期，适合存放临时结果。 通过特殊寄存器访问：每个线程被分配一对 LM_ADDR寄

存器， LM_ADDR0 和 LM_ADDR1 。首先将要访问的地址装入其中一个寄存器，然后用这个寄存器去访问地址。

改变存储器地址需要三个指令周期，地址建立后存 /取操作只需一条指令，递增 /递减寻址模式允许快速顺序访问。因此，当一个位置被反复引用或相邻位置被顺序引用时，本地存储器访问可以得到优化。

主要内容 Intel 网络处理器概述 XScale 核 微引擎 其它功能单元 编程模型 参考设计

SHaC 单元 SHaC 单元包括三个组成部分：

一个 ScratchPad存储器 一个哈希单元 一个控制状态寄存器访问代理（ CAP ）

SHaC 单元处理 scratch、 cap 、 hash和 reflect指令。

SHaC 单元独立操作，当命令执行完时通知微引擎。

SHaC 单元的概念组织SHaC 单元与芯片其余部分的主要连接：• 到控制总线的连接，接收命令。• 到推 /拉总线的连接，传递参数及计算结果。• 到推 /拉仲裁单元的连接，控制推/拉总线上的传输。

入口队列

译码

Scratchpad 存储器 为 IXP2XXX 片内存储资源，由 SHaC 控制访问。 容量为 16KB ，组织成 4K长字。 提供一般的数据读 /写操作，一次可从 Scratch中读 /写 64

个字节（ 16 个长字）的数据，可用作本地数据存储器。 提供两种可由微引擎线程用来进行协调的操作，因而常用于

线程间通信： 提供原子操作，用于设置 /清除比特、增量 / 减量、加 / 减、交换数值等。

提供实现通信环的逻辑，支持环缓冲器的自动管理和操作，可容纳 16 个环缓冲器，允许在不相邻的一对微引擎之间传递信息（使用 pull/push reflector 指令）。

Scratchpad 的读 /写过程 以将微引擎中的数据写入 Scratchpad 为例：

微引擎将数据写入传输寄存器，将指令“ scratch [wr, xfer, src_op1, src_op

2, ref_cnt], opt_tok” 发送到命令总线。 SHaC 单元从命令总线接收命令，控制逻辑检查命令的 Target_ID ，若为

Scratch则将指令缓存在入口队列中。 控制逻辑对指令进行译码，发送信号通知 Pull 总线仲裁器将数据从传输寄存器中读入 pull_fifo中。

当数据读入完成后，将 pull_fifo中的数据写入 Scratchpad 。 SHaC 单元向微引擎发送信号，告知操作完成。

使用 Pull/Push Reflector 在不相邻的微引擎间传输数据： 首先通过 Pull 总线从源微引擎中将数据读入 Scratchpad

再通过 Push 总线将数据写入目的微引擎。

哈希单元 哈希单元用于执行查表和其它需要乘法或除法的任务。 支持 48比特、 64比特和 128比特哈希操作。 哈希单元有两个输入缓冲器，微引擎可以用一条指令发射

1~3 个哈希请求， SHaC顺序地将请求传递给哈希单元。 启动哈希操作的过程：

微引擎将 1~3 个数据值放在一组连续的 SRAM传输寄存器中，然后将哈希运算指令发送到命令总线。

哈希单元接收命令，利用 Pull 总线从微引擎的传输寄存器中读取源操作数，执行哈希运算，然后通过 Push 总线将运算结果推送到微引擎的传输寄存器中。

操作结束后，哈希单元向微引擎发送信号。

CAP 操作 设备的控制状态寄存器（ CSR ）被映射到 XScale 的地址空间，但其中的一部分 CSR是本地的（并不对应一个外部设备），本地 CSR 用于控制微引擎及记录微引擎的状态。

硬件定义了四十多个微引擎 CSR ，每个 CSR 控制处理的一个方面。 XScale 使用本地 CSR将指令装入微引擎并控制微引擎。 每个微引擎只能访问自己的本地 CSR 。 SHaC集成了许多 CSR ，对这些 CSR 的访问是通过 SHaC中的 CAP进行的。

Cap 指令用于读 /写 CSR ，如： Cap [read, xfer, csr_addr], opt_tok Cap [write, xfer, csr_addr], opt_tok Cap [fast_wr, xfer, csr_addr], opt_tok.

处理器间通信 微引擎与 XScale 通信（ context-to-XScale ）：

中断：微引擎可使用 SHaC 单元向 XScale 发出中断 共享存储器：与 polling 机制一起使用 存储器环机制：用于转发数据

线程之间的通信（ context-to-context ）： 事件信号 Scratchpad或 SRAM环机制：任意线程 邻居寄存器：相邻微引擎上的线程 反射总线机制：任意微引擎上的线程

IXP2xxx之间： CBUS 机制：不同 IXP2xxx 上的线程相互通信。

DRAM 控制器 DRAM 控制器位于主控单元与 DRAM 存储设备之间，负责控制、

管理主控单元对 DRAM 存储设备的访问。 DRAM 控制器通过命令总线、 Push 总线和 Pull 总线与主控单元相

连。

DRAM 控制器的特点 支持 1 个 DRAM 通道， 64比特数据宽度， 2GB 存储空间。

以 8字节为单位进行读 /写，一条指令可以读 /写连续的8~128 个字节，特别适合大数据量传输。

支持 4 个 DRAM bank 及交织操作： 交织：通过地址映射将连续的存储地址分布到 4 个 bank 上，一次

操作可读 /写相邻的两个 bank中的数据。 地址映射完全由硬件完成，对软件是透明的。

访问 DRAM 的指令格式： dram [cmd, xfer, src_op1, src_op2, ref_cnt], sig1, sig2

DRAM读指令的执行过程 微引擎发送指令至命令总线， DRAM 控制器从命令总线接收指令。 检查指令的 Target_ID ，若为 DRAM则将指令缓存在 cmd_fifo队列中。 确定是否需要访问相邻的 2 个 bank，若需要则根据指令提供的地址及

数据字节数产生在相邻 2 个 bank的 bank操作及地址；否则直接使用指令中提供的地址。

将各相应的 DRAM 地址装入指定的 bank 队列，将 bank 队列中的 DRAM 地址发送到 FSM 管脚上。

FSM 管脚检查 bank操作符及 DRAM 地址是否符合规范，若符合，驱动相应的地址引脚，将数据从 DRAM 存储器中读出。

数据先缓存在 push_fifo中，然后通过 D Push总线将数据推送到 xfer指定的传输寄存器，并给微引擎发送 sig1 和 sig2 指定的信号。

SRAM 控制器 SRAM 控制器用于管理和控制主控单元对 SRAM 存储设备

的访问，以及用于连接符合 QDR规范的协处理器。 以长字为单位访问，一条指令可以读 /写连续 1~16 个长字

的数据。 SRAM 控制器具有复杂的硬件功能结构，支持：

一般的数据读 /写操作 原子操作：设置 /清除比特位，递增 /递减，数据交换 支持对链表、环缓冲器等复杂数据结构的自动操作

SRAM 存储设备通常用于存储如发送队列、数据包描述符、缓冲区链表等重要而复杂的数据结构。

链表和环缓冲器 链表和环缓冲器是网络数据处理中非常重要的数据结构，

链表：由位于不连续的存储空间中的若干 buffer 组成， buffer 的个数不限。链表主要用作包队列，每个 buffer 存放一个包描述符。

环缓冲区：由位于连续存储空间中的若干存储单元组成，创建时即确定了位置和大小。

如果用软件实现以上数据结构，比如将一个数据包放入发送队列： 先从 SRAM中读该发送队列的描述符（队列头指针及尾指针） 修改尾指针使指向新的数据包 将修改后的队列描述符写回 SRAM

软件实现的缺点： 操作复杂 涉及多次 SRAM读写，延迟大，效率低 这些数据结构需要被频繁使用，影响处理速度。

Q-Array SRAM 控制器集成了称为 Q-Array 的硬件结构来

支持上述的数据结构： 每个 SRAM 通道有一个 Q-Array 。 每个 Q-Array 有 64 个存储单元，每个单元存储一个队列描述符或一个环缓冲器描述符。

Q-Array 支持入队和出队操作。 微引擎只需向 SRAM 控制器发送指令，具体的数

据读 /写操作由 SRAM 控制器完成。

MSF 接口 MSF 是 IXP2XXX 上的一个复杂单元，提供与外部设备进行高速包传输

的主要接口。 MSF单元有相互独立的接收和发送接口，每个接口可被配置为处理标准的 MAC 接口和交换结构接口。

所有与外部的输入 /输出均通过 MSF 中的一组硬件缓冲器（称BUF）进行， BUF构成了外设与微引擎之间的唯一通道。

BUF按照传输方向分为 RBUF和 TBUF。 每个 BUF包含 8KB，可以被划分为大小为 64字节、 128字节或 256字节的单元。微引擎可以选择任意一个或一些单元用于一次传输。

较大的包划分成若干mpacket ，每个mpacket装入一个 BUF单元。MAC 硬件及微引擎软件负责将包划分成mpacket 。

MSF 接收单元

MSF 数据包接收流程 当某一个线程完成指定的数据包处理任务后，将自己加入到 Receive_T

hread_Freelist 。 当数据包到达 MSF 的接收逻辑单元时， MSF 为数据包分配合适的 RB

UF 单元，并将数据包移入。 将该 RBUF 单元标识为 Full Element ，加入 Full Element List 。 控制单元从 Full Element List中取出一个 RBUF 单元，从 Receive_Thre

ad_Freelist中取出一个空闲线程，创建该单元的接收状态字，送到空闲线程的传输寄存器，然后通知空闲线程处理数据包。

在将 RBUF 单元中的内容读入传输寄存器或 DRAM 存储器之后，线程将 RBUF 单元释放。

MSF 发送单元

MSF 数据包发送流程 线程取出一个空闲的 TBUF 单元，分配给要发送的数据包。 线程将数据包从传输寄存器或 DRAM 存储器中移入 TBUF

单元。 TBUF 单元中的数据包由附加数据和净荷数据组成，附加数据一般由线程创建，作为数据包的包头，净荷数据来自于 DRAM 存储设备，作为数据包的包体。

线程创建发送控制字。 MSF将 TBUF 单元中的数据包按发送控制字指定的方式发送出去。

加密单元 加密单元提供了高速处理数据加 / 解密的硬件。 每个 IXP2850 包含两个相同的、独立运行的硬件单元，由程序员决定如何使用这两个硬件单元。

每个硬件单元包含了可执行多种加密标准的硬件： 两个 3DES/DES 核 一个 AES 核，可以使用 128 、 192或 256比特的密钥 两个用于认证的 SHA-1 核 支持一些常见的标准，如 ECB和 CBC

所有加密信息（如密钥）包含在两个加密硬件单元中，不会保存在共享存储器中。

从程序员的角度来看，加密单元是用一个 API来访问的。

总结 提高并行处理能力是 IXP2xxx 的主要设计考虑：

包含多个微引擎，每个微引擎有自己的专用资源 每个微引擎包含多个硬件线程，每个硬件线程有自己的专用资源 并行操作的功能单元，每个功能单元有自己的命令缓存队列、指令译码和指令逻辑

多条分立的总线，且读 /写总线分开 通用寄存器组分成两个 bank 传输寄存器按总线及方向划分 MSF包含独立的接收和发送接口 DRAM 支持多个 bank及交织操作

主要内容 Intel 网络处理器概述 XScale 核 微引擎 其它功能单元 编程模型 参考设计

网络应用结构

数据面：高速处理和转发数据包，对性能影响最大。 快路径：微引擎，处理绝大部分的数据包。 慢路径： XScale Core ，处理例外包。

控制面：处理协议消息，并负责建立、配置和更新由数据面所使用的表及其它数据结构。

管理面：负责系统配置、收集和报告统计信息、根据用户输入或来自其它应用的消息停止或启动应用。

为微引擎和 XScale 编码区分微引擎和 XScale对程序员来说很重要：

为微引擎编写的代码经编译后下载到裸露的硬件上执行，因此程序员必须直接处理硬件的所有方面；

为 XScale 编写的代码编译后运行在操作系统下，程序员不需要描写所有的低层操作，必须使用操作系统功能来执行底层任务。

由于访问微引擎的所有 API位于内核地址空间，因此 XScale 上的代码必须被设计为是可装载内核模块的一部分。

Intel IXA中的网络处理本质上就是作用到一个持续的数据包流或信元流上的一系列任务。

这些任务被分布到若干个微引擎上，每个微引擎执行一个特定的任务。当一个微引擎完成它的任务后，将处理上下文传给下一个微引擎继续处理。

Intel IXA 包括三个部分：微引擎、 XScale 和 IXA 可移植框架。 IXA 可移植框架为基于 Intel IXP 的软件开发提供应用编程接口和硬件抽象。

IXA 可移植框架是用微引擎和 XScale Core 上的一个分层结构实现的。

IXA 应用的逻辑单元

由常用的低层 C语言函数和微代码宏组成，专门针对高性能和代码空间最小化而设计。

用低层库写的宏或函数；多个微块可连接成微块组。

内核组件：微块在 XScale Core 上的对应部分。

微块（ microblock ） 微引擎上的快路径处理被划分成一些称为微块的逻辑功能，每个微块是用低层库（包括优化的数据面库和微块基础结构库）写的宏或函数。

微块是粗粒度的，每个微块完成一个功能。 微块可以重用，可以通过微块组合实现所需要的应用。 两种类型的微块：

包处理微块：对数据包执行高层处理功能，如 IP 包分类、转发等。 驱动微块：执行与底层硬件密切相关的处理功能。

可以用 Dispatch Loop将多个微块连接起来形成一个微块组，运行在一个微引擎上。每个微块组独立完成一个数据包的处理功能，形成一个相对独立、完整的处理环节。

微引擎编程模型 -- 软件流水线

微引擎在快路径上使用软件流水线模型 有三种方法将流水线级组合起来并映射到微引擎上：上下文流水线，功

能流水线，混合流水线。

上下文流水线（ context pipeline ） 每个 pipe-stage被映射到一个微引擎上，负责数据包处理的一个子任务。 微引擎中的每个线程被分配一个包，执行相同的处理。 数据包严格按顺序分配给各个线程。 优点：适合需要较多代码空间和需要保存较多状态的子任务。 缺点：不适合传递较大的上下文，功能均匀划分很困难。

功能流水线（ functional pipeline ） 微引擎的执行时间被分成 n 个流水线级，每级实现一个处理子任务。 数据包严格按顺序分配给各个线程。 多个微引擎并行地执行相同的功能流水线。 优点：不需要在流水线级之间传递上下文，处理速度快 缺点：控制存储器必须能够支持多个子任务，互斥的解决比较复杂。

功能流水线（续） 多个微引擎并行执行

相同的功能流水线。 相邻微引擎之间的包

处理步调错开一个子任务时间（称 task staggering ），解决不同微引擎之间的互斥问题。

流水线级的数目必须与微引擎数相等。

微引擎之间的延迟错位通过线程间信号机制实现。

混合流水线

流水线级之间的通信机制 --环缓冲器

多生产者 - 单消费者

使用 Scratch ring或 SRAM ring

单生产者 - 多消费者

使用 Scratch ring或 SRAM ring

单生产者 - 单消费者

使用 Neighbor ring

串行数据流处理与 RMW 操作 串行数据流处理问题：多个线程需要访问同一个数据结构时，必须串

行地进行。 RMW是串行数据流处理问题中最重要的一种情形，往往需要进行多次外部存储器访问，且操作的数据结构往往比较复杂，造成很大的访存延迟。

读 -修改 -写临界区数据的过程：1 ）检查数据是否处于锁定状态；2 ）若处于锁定状态，返回第 1步，否则锁定该数据；3 ）将数据从外部存储器读入微引擎；4 ）修改数据；5 ）将修改过的数据写回外部存储器；6 ）将数据解除锁定。

RMW 的访存延迟主要来自两个方面： 在 RMW 操作前后访问外部存储器，对数据进行加锁和解锁 在 RMW 操作中多次读 /写外部存储器

减小 RMW 操作的访存延迟 将数据的编号及锁定状态缓存在 CAM中，利用 CAM 单元

的并行比较功能快速确定数据的锁定状态。 将数据本身缓存在本地存储器或 SRAM 控制器的 Q-Array

硬件中，减少对外部存储器的访问操作。 改进后的 RMW 操作，线程先用数据标识符查找 CAM ：

命中： CAM查找返回一个 hit标志和数据在本地存储器中的位置，直接对数据进行快速的 RMW 操作。

锁住状态：等待一会再测试。 不命中： CAM查找返回一个 miss标识和一个最近最少使用的 CA

M 入口号；线程锁住 CAM 入口，将本地存储器中与 LRU对应的数据写回 SRAM ，向 SRAM 发送读命令；将从 SRAM取回的数据放入本地存储器中处理，在 CAM中创建相应的编号，解锁 CAM入口。

折叠（ folding ）当同一个微引擎中有多个线程需要对同一个数据

结构执行 RMW 操作时，只需第一个进入临界区的线程将外部存储器中的数据读入，修改后缓存在本地存储器中，后续的线程可直接对缓存在本地的数据结构执行 RMW 操作，最后一个线程将修改后的数据结构写回外部存储器。

这种技术称为折叠，即将多次的 RMW 操作折叠为一次读 - 多次修改 - 一次或多次写操作。

无折叠的串行 RMW 操作

采用折叠技术的串行数据流访问

线程交织 当线程的指令执行时间 / 访存延迟 =1/ ( 线程数 -1) 时，可

以将访存延迟完全隐藏在程序执行时间之后。 时延超限（ latency bound ）：访存延迟大于微引擎中所有

线程的程序执行时间。 计算超限（ compute bound ）：访存延迟小于微引擎中所有

线程的程序执行时间。 实际应用中时延超限情形居多，可以通过增加微引擎中的

线程数来平衡计算和访存时间。 线程交织（ interleaving threading ）：通过增加每个线程处

理数据包的数量来平衡计算时间和访存时间。 线程交织解决了时延超限的问题，但在本地存储器或 Scrat

ch中需要缓存更多的状态，包处理过程更复杂。

微块与流水线组织 微块是粗粒度、有状态的实体，负责执行主要的包处理任务。

一个典型的网络系统至少包括三个连接成一条流水线的微块（输入、处理、输出），复杂的系统可以加入更多的微块。

微块之间的连接在运行时形成。

微块组与 dispatch loop 几个微块可以组合成一个微块组，形成数据包处理流程中一个相对独立、完整的处理环节（如功能流水线）。

每个微块组有一个 dispatch loop ，定义微块组内数据包流动的方向。

一个微块组可以在一个或多个微引擎上实例化，但两个微块组不能使用相同的微引擎。

编程模型定义了三类微块： 源微块：运行在 dispatch loop 的起点（微块组中的第一个微块），负

责获取流水线要处理的数据包。 转换微块：处理一个包，并将包传给下一个微块。 接收器（ sink）微块：运行在 dispatch loop 的终点（微块组中的最后

一个微块），负责将数据包排队发往不同微引擎上的另一个微块组或媒体接口。

微块与流水线级 一般而言，

一个上下文流水线级被映射到一个微引擎中的一个微块以及 XScale Core中一个相关联的内核组件， dispatch loop 一般不需要。

在功能流水线中，一个微块及相应的内核组件被关联到一个或多个流水线级。

微块的组成 一个微块要包括两部分代码：

初始化微块的代码：启动时调用一次。 包处理代码：每收到一个包时调用一次。

用微代码编写的微块： 初始化宏 包处理宏

用 MicroC 编写的微块： 初始化函数 包处理函数

微块的名字和 ID 每个微块在系统内都有一个唯一的名字和一个 8比特的 ID 。 写微块时不需要知道其上游及下游微块是什么，微块 ID 的值及流水线中下一个微块的 ID值可在编译时分配并保存在系统头文件中。

每个微块可有一个或多个逻辑输出，表明数据包下一步应走哪条处理路径。微块的逻辑输出是通过设置dispatch loop 的变量dl_next_block的值来向下传递的。

为使微块具有一般性，逻辑输出用符号名字表示，定义在头文件中，并赋以适当的微块 ID 。

以下符号名字保留： IX_EXCEPTION ：指示数据包应被送往 XScale Core 。 IX_EXCEPTION_PRIORITY ：指示数据包应在高优先级队列中送往 XScal

e Core 。 IX_DROP ：指示数据包应当被丢弃。 IX_NULL ：指示正在处理的是一个空数据包。

Dispatch loop ：作用一 作用一：将一个微引擎中的几个微块组织起来，实现这些微块之间的数据流动。 从概念上说，微块以及微块之间的逻辑调用构成一张图。 事实上，由于临界区的互斥访问以及折叠技术的使用，线程必须严格按顺序执行，因此所有线程必须通过微引擎中的全部微块，即dispatch loop中的数据流是一个串行的流水线。

微块的逻辑调用图

拉平的微块调用图

Dispatch loop （续） Dispatch loop 提供两个系统微块：

DL_Source[]：该微块是一个源微块，从 scratch ring中取一个包。 DL_Sink[] ：该微块是一个接收器微块，根据 dispatch loop 的状态，可能：

将数据包放入一个 scratch ring ，发送给另一个微引擎 丢弃数据包 将数据包放入一个 scratch/SRAM ring ，发送给 XScale Core

Dispatch loop是微块的串行流水线，第一个微块是 DL_Source[] ，最后一个微块是 DL_Sink[] ，每个微块设置 dl_next_block变量指出下一个处理数据包的微块。

Dispatch loop 开始时调用每个微块的初始化函数（或宏）来初始化每个微块，然后在一个无限循环中依次调用每个微块的处理函数（或宏）。

Dispatch loop ：作用二 作用二：

在寄存器或本地存储器中维护全局状态 提供本微块组与 XScale Core 以及本微块组与其它微块组之间的数

据包交换。 例如，微块要将数据包发送给 XScale Core 时，

调用 dl_set_exception[]，给出微块 ID 、异常代码和 dl_next_block等参数。

其它微块检查dl_next_block的值并只向下传递数据包，直到到达DL_Sink[]。

DL_Sink[] 将数据包放入通往 XScale Core 的一个 scratch/SRAM ring 。

目前的框架提供两个通往 XScale Core 的环，一个用于高优先级的包，一个用于低优先级的包，这两个环由所有的微引擎共享。

Mpacket 输入和输出微块与 MSF 连接，需要处理到内存的实际传输。 从 IXP2xxx 的角度来看，数据包是以固定大小的块（ mpacket ）进行存

储和传输的： 硬件将输入分组划分成若干个 mpacket ，依次传输给 IXP2xxx； 输出机制将一个个 mpacket 发送给硬件，硬件将它们组装成一个包。

Mpacket 的长度可以被配置为 64字节、 128字节或 256字节，但一经配置就不能改变。

Mpacket大小的选择通常是在内存空间利用率和计算开销之间的权衡。芯片制造商建议的 mpacket大小为 128字节。

Mpacket （续） 输入微块（ RX ）负责组装 mpacket ：

每当一个 mpacket 到达， RX将其从MSF 的 RBUF中拷贝到 DRAM缓冲器。 如果是一个新的数据包的第一个 mpacket ， RX 为该数据包分配一个 DRA

M缓冲器。 当一个完整的数据包被放入缓冲器后， RX将缓冲器的地址传递给流水线中的下一个微块。

输出微块（ TX ）负责将分组从内存发送到物理输出端口，并回收相应的 DRAM缓冲器： TX将分组划分成一系列 mpacket ，将每个 mpacket从内存拷贝到 MSF 的 T

BUF中。 释放 DRAM缓冲器。

一个 RX或 TX 微块可以处理多个物理接口，这时 RX或 TX必须从分组流中区分出对应各个物理接口的包，可以将 RX或 TX所在微引擎的8 个线程在分组流之间划分。

包缓冲器机制 Intel SDK 软件提供了一种包缓冲器机制，一般情况下可获得较好的性

能。 包缓冲器机制从 DRAM 的一个较大的连续地址空间中分配一组固定大

小（典型值为 2048字节）的缓冲器，每个缓冲器用来存放一个包。 包并不总是从缓冲器的开头放起，而是在包的前面随机加上一段长度为

0 、 128字节、 256字节或 384字节的填充字节，以提高整体的吞吐量。 随机填充的原因：

DRAM被组织成 4 个 bank ，每个 bank 的宽度为 128字节； DRAM 控制器提供 4条并行的数据通路，当每个处理器访问一个不同的 bank 时，访存可以并行执行。

随机填充可将包头分布到 4 个 bank中。

缓冲器队列与缓冲器分配 如何管理空闲的包缓冲器：

空闲包缓冲器的信息存放在什么地方？ 如何最小化包缓冲器分配和回收的开销？

IXP2xxx依靠硬件支持实现高速处理： 在 SRAM中使用一个单链表（ FIFO队列）管理空闲包缓冲器，链表中的一个元素对应 DRAM中的一个空闲缓冲器。

利用 SRAM 控制器硬件（ Q-Array ）实现 FIFO 操作。

缓冲器队列与缓冲器分配（续） 举例：

欲从 DRAM 的地址 B 开始分配 32 个连续的包缓冲器； 软件在 SRAM中分配一个具有 32 个连续元素的队列（空闲缓冲器链表），链表的起始位置为 F；

若出队操作返回一个链表元素的地址为 A ，那么 DRAM中对应的缓冲器地址为：

预先计算以下两个值：DL_DS_RATIO = buffer size / free list element sizeDL_REL_BASE = B – F×DL_DS_RATIO

缓冲器地址为：buffer address = A×DL_DS_RATIO + DL_REL_BASE

若 DL_DS_RATIO 为 2 的幂次，则乘法可以用移位代替。

缓冲器句柄 由于空闲链表单元地址与 DRAM中的缓冲器地址一一对应，因此空闲链表单元地址就被用来标识缓冲器。

软件总是使用空闲链表单元地址来标识缓冲器，并只在需要时转换成对应的 DRAM 地址。

Intel 使用缓冲器句柄来表示对应了一个空闲链表单元的 SRAM 地址。为传输一个包，微块将包的缓冲器句柄传递给另一个微块。

缓冲器句柄由 4 个字节组成， 3 个字节的 SRAM 地址以及 1 个字节的附加信息（缓冲器中是否包含了包的开头或结尾，一个包使用的缓冲器个数）。

将一个缓冲器句柄插入空闲链表意味着相应的包缓冲器被释放，因而丢弃数据包是一个开销很小的操作。

包转发和存储器环 IXP2xxx 使用存储器环支持处理器之间的通信：

存储器环提供一种基本的生产者 -消费者机制。 存储器控制器实现对环的互斥操作（插入和删除）原语。

使用存储器环的优点： 插入和删除操作很快，开销不比常规的存储器操作大很多 免去了程序员解决互斥访问的责任

Scratchpad 和 SRAM中都存在环，但 Scratch ring 的操作更快。因此，建议使用 Scratch ring 作为处理器之间传递数据包的机制， SRAM rin

g 用于对操作速度要求不高的通信场合或别的用途。 典型地，在流水线的每一对相邻级之间以及微引擎和 XScale Core之间都存在一个 Scratch ring 。

Scratch ring

用 Scratch ring 连接流水线级以及微引擎和 XScale Core

队列数组（ Q-Array ） IXP2xxx 使用 Q-Array 硬件结构实现对链表和环缓冲器的自动快速操作： Q-Array位于 SRAM 控制器中，每个入口包含一个队列（环）描

述符，能自动快速完成队列（环）的入队和出队操作。 每个 Q-Array只包含 64 个入口，只能将最常使用的队列（环）入

口放置在 Q-Array中，其它入口保存在 SRAM中，需要时换入。 Q-Array 常用于缓存以下 3 种数据结构：

长期驻留的队列描述符：如空闲缓冲器链表、丢包队列等。 长期驻留的环缓冲器描述符：也是包处理过程中经常要用到的。 缓存的队列描述符：队列描述符本身缓存在 Q-Array中，但它们

在 Q-Array中的位置及状态缓存在 CAM中。

对缓存的队列描述符进行操作 当需要使用队列描述符时，微引擎先进行 CAM查找。 若查找成功，微引擎利用返回的队列描述符位置，直接对缓存的队列描述符进行操作。

若查找失败，表明队列描述符尚示缓存在 Q-Array 中，微引擎利用返回的 LRU，命令 SRAM将该 LRU写回外部存储器，然后读入所需的队列描述符，缓存在 Q-Array 中，对其进行操作，修改后的队列描述符仍缓存在 Q-Array 中。

主要内容 Intel 网络处理器概述 XScale 核 微引擎 其它功能单元 编程模型 参考设计

POS 应用的硬件配置

POS ： Packet over SONET/SDH或称 PPP over SONET/SDH，指使用PPP封 装将 IP 数据报映射到 SONET/SDH帧上。

POS IPv4转发的软件组件

X1 X4 X1

X1

X1

X1

X1

X1

X1X？

Packet RX 将从媒体接口收到的 mpacket 重组，将重组后的包传给流水线的下一级：

判断 mpacket是否为包的第一个或最后一个 mpacket ，通过将属于同一个包的所有mpacket依次存放在 DRAM缓冲器中得到完整的包；

将包缓冲器句柄及包的元数据（偏移量、大小等）通过微引擎 - 微引擎 Scratch ring

传递给下一级。 使用微引擎中的全部 8 个线程，每个线程一次处理一个 mpacket 。 为保持包的顺序，线程严格按顺序执行。 最多支持 16 个虚拟端口，所有这些端口的重组上下文保存在本地存储器。 数据包从 Packet RX被传递给一个应用特定的系统微块 DL_Sink[] 。

PPP 解封装和分类

DL_Source[]从 scratch ring取出包缓冲器句柄，读入包元信息，从 DRAM中将 32 个字节的包头读入到由传输寄存器维护的 header cache中。

线程严格按顺序从 scratch ring中读数据包，并发信号通知下一个线程接收。 PPP 解封装 / 分类微块通过更新数据包元信息中的偏移量和大小从数据包中去掉 PPP头。

根据 PPP头将数据包分成 IPv4 、 IPv6或 PPP 控制包（ LCP 、 IPCP 等）。 如果数据包是一个 PPP 控制包或 IPv6 包，该包被标记为 IX_EXCEPTION ，否则沿流水线往下传。

IPv4转发

按照 RFC 1812检查 IP头的有效性，若 IP头无效，将数据包标记为 IX_DROP；否则 对目的 IP 地址执行最长前缀匹配查找，查找结果为一个下一跳 ID 、一个交换结构 bl

ade ID 和一个输出端口，这三个域保存在包元数据中；若没有找到匹配项或其它情形，数据包被标记为 IX_EXCEPTION 。

系统微块 DL_QM_Sink[]检查包是否要丢弃或发给 XScale Core ，如果不是， DL_QM

_Sink[] 通过一个 scratch ring 向队列管理器 QM 发送一个入队请求，并将缓存的包头写入 DRAM ，将包的元信息写入 SRAM 。

基于 Cell 的队列管理器（ Cell QM ） 负责对发送队列执行入队和出队操作，发送队列用硬件 SRAM链表实现。 通过 scratch ring 接收功能流水线的入队请求（以包为单位），接收 CSIX调

度器的离队请求（以 cell ）为单位。 每当队列状态发生转移， QM 通过邻居环向 CSIX调度器发送一个消息。 在每一次离队操作后， QM 通过一个 scratch ring 向 CSIX TX 微块发送一个传输请求（每次传输一个 cell ）。

QM 上的线程利用本地线程间信令机制严格按顺序执行。

CSIX调度器 调度将要发送给 CSIX 交换结构的数据包，对交换结构端口采用 r

ound robin ，对同一端口上的各队列采用加权 round robin 。 调度和发送均以 cframe 为单位进行：

接收从交换结构来的流控消息（控制到每一个输出 IXP2400 的流量） 接收来自 QM 的队列状态转移消息 检查 TX流水线中的 cframe长度是否在门限内 确定一个要调度的队列（ Round Robin ） 向 QM 发送一个离队消息

CSIX TX从 QM 接收发送请求消息，每接收一个发送请求就将一个 cframe 移入一个 TBUF ： 数据包的分片状态以及包的元数据被缓存在本地存储

器中并用 CAM进行查找； 在每个 cframe前加上 CSIX头和 TM （流量管理）头； 数据包发送完毕后，释放相应的缓冲器。

使用折叠技术严格按顺序执行。

CSIX RX

从 CSIX 交换结构接收 cframe ，并将它们重组成 IP 包。 支持高达 64K 个 VOQ （ Virtual Output Queue ），这意味着重组上下文存

放在 SRAM中，折叠技术用来优化上下文的读 -修改 -写。 本地存储器中缓存了 16 个上下文， CAM被用来查找上下文。输入 blade I

D 和 QoS类被用来唯一地标识一个上下文，并用作查找 CAM 的关键字。 包重组结束后，建立包的元信息，并将元信息传递给流水线的下一级。

PPP封装根据包的元数据中的下一跳 ID ，将一个 PPP头加

到数据包上，并将数据包传递到流水线的下一级。如果一跳 ID被设置为一个非法的值（ -1 ），那么该微块假设 PPP头已经加上了，只是将包传递到下一级。

基于包的队列管理器 和基于 cell 的队列管理器基本相同，只是对包而不是对 cf

rame进行操作。 对于调度器的每个离队请求，返回一个离队响应消息，消息中包含调度器实现 DRR算法所需要的包长度。

包调度器 调度将要从 POS 接口上发送的 POS 分组。 在不同端口间采用 WRR算法，在同一端口的不同队列间采用 DRR算法。

调度器利用 Packet TX 微块的反馈信息监视每个端口上已调度但尚未发送的包的数量。如果数量超过一个预定的值，调度器停止调度该端口。

Packet TX 通过媒体接口发送数据包：

将数据包分割成 mpacket ，并将 mpacket 移入 TBUF 。 最多支持 16 个虚拟端口，发送上下文保存在本地存储器。 监视MSF中对应每个端口的 TBUF利用率是否超出了一个门限，若是则停止向那个端口发送，所有向该端口发送数据包的请求在本地存储器中排队。

定期向调度器反馈已发送了多少数据包。 支持 SPHY 1×32 （一个 OC-48 端口）、 MPHY-4 （四个 OC-12 端

口）和 MPHY-16 （最多 16 个虚拟端口）三种配置。 对前两种配置，微块运行在一个微引擎上；对于 MPHY-16 模式，微块

运行在两个微引擎上。