UrmaTransport 池化:共享 JFR/JFS 资源池、大包单边路径与万级连接扩展

Abierto
#3,707 3 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 2 días

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
5/5
Tiempo estimado
Más de una semana
Aptitud para principiantes
20/100
Tipo de issue
Nueva funcionalidad
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
cpp

Línea de trabajo

Read the linked design issues #3401 and #3167 first; this proposal describes a broad redesign of UrmaTransport, including shared JFR/JFS pools, CQE routing, and large-message READ transfers. The body names no implementation files or tests, so locate the current UrmaTransport entry points and tests before estimating a starting change. Done means implementing the agreed pool design while preserving the stated TCP-equivalent byte-stream semantics; the proposal leaves flow control to a separate follow-up.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

enhancement

关联讨论:

本提案是 #3401(UrmaTransport)的后续演进方案:在已落地的 per-connection UrmaEndpoint 基础上,引入 JFR/JFS 资源池化、消息级 CQE 路由与大包单边 READ,使单进程在 URMA 设备资源受限的条件下支撑万级长连接。

Is your feature request related to a problem?

当前 UrmaTransport(#3401)沿用 RDMA 的 per-connection 资源模型:每条连接独占 1 个 Jetty(内含 JFS)+ 1 个 JFR + 1 个 JFC。在 URMA/UB 设备上,单 FE 可创建的 jetty/jfs/jfr/jfc 数量存在硬件上限(可通过 urma_query_device 查询),节点内多进程部署时每进程配额进一步缩小。按该模型,单进程可支撑的连接数上限只有数百量级,无法满足超节点场景下单进程万级长连接的目标。本提案给出资源池化的完整设计,并逐章标注对当前社区实现的改造要求。


1. 背景与动机

1.1 当前社区实现的连接模型

#3401 落地的 UrmaTransport 采用与 RdmaTransport 对称的两层结构:

组件 模型
UrmaResource 每连接独占:1 JFCE + 1 JFC + 1 JFR + 1 Jetty(内含 JFS),另含导入的对端 jetty/seg
流控 双窗口:_remote_rq_window_size(对端 RQ 深度)+ _sq_window_size(本地 SQ 深度),credit 通过空 payload SEND_IMM 的 imm_data 批量回填
内存 单一 mmap 大池一次 urma_register_seg,切 8KB buffer,劫持 blockmem_allocate
大消息 纯 SEND 字节流:按对端 recv block size 循环切多个 WR,依赖 RM 语义 + RNR 重试
CQE 路由 不需要:per-connection JFC/JFCE,completion 天然归属本连接
1.2 per-connection 模型的资源爆炸问题

URMA 设备单 FE 的 jetty/jfs/jfr/jfc 资源存在硬件上限。以典型设备为例(量级参考,实际以 urma_query_device 返回为准):

单 FE 资源上限(示例):
  max_jfc   : ~65528
  max_jfs   : ~65532
  max_jfr   : ~65532
  max_jetty : ~65532

节点内多进程部署时(示例:每节点 P=96 个服务进程),每进程配额 = 设备总量 / P:

每进程上限(示例): jetty/jfs/jfr/jfc 各 ~1365

per-connection 模型下,若每条连接独占 1 个 IO jetty + 1 个 FC jetty:

单进程 1 万链路 × 2 jetty/链路 = 2 万 jetty >> 1365  ❌ 资源爆炸

即使只算 JFS/JFR 同样超限。

更关键的是预注册内存随连接数线性增长。URMA 要求收发 buffer 必须预注册(urma_register_seg),且每条连接的 RQ 接收 buffer 被提前放置、独占占用、无法跨连接复用——对端随时可发送,本端必须常备该连接的接收队列。因此社区方案的 recv 预注册内存 = rq_size × buffer_size × W,随连接数 W 严格线性增长,内存同比例膨胀,进程内存底噪完全失控。硬件配额还有上限约束可查可估,而这种线性内存增长是持续性的成本,是 per-connection 模型更根本的扩展性障碍。

结论:在 FE 资源受限的 URMA 设备上,per-connection 模型无法支撑万级链路,必须做 JFR/JFS 池化——per 进程维护一组共享 JFR 池 + 共享 JFS 池,多条连接复用同一组资源,把资源消耗与连接数解耦。

1.3 本提案的目标
  1. 连接数与资源解耦:单进程以 O(池规模) 的资源支撑 O(万级) 连接。
  2. 内存底噪可控:接收队列固定预算可配置(示例目标 ≤ 200 MB/进程)。
  3. 传输语义不变:向 brpc 提供与 TCP 等价的连续、有序、无缺字节流。
  4. 演进式落地:握手协议与 #3401 保持兼容并做扩展,分阶段改造,不破坏现有 TCP fallback 语义。

2. 设计目标与约束

2.1 部署目标(示例形态)
项 值
单节点进程数 P
单进程需支持链路数 万级
单进程内存底噪预算 可配置
传输语义 等价 TCP:连续、有序、无缺字节流
2.2 负载特征:海量连接,活跃稀疏

本提案面向的数据中心 RPC 负载有一个关键特征:连接规模海量,但任一时刻的活跃连接是稀疏的——万级长连接常态在线,同时刻有数据在途的只是少数。这一特征已被业界系统论文广泛验证并作为设计前提:

  • eRPC("Datacenter RPCs can be General and Fast", NSDI 2019):面向单节点 2 万、集群级 200 万连接的 RPC 负载,其 "Scalable connection state" 设计的核心依据是——任一时刻只有少数连接在活跃收发,因此 NIC 侧只保留常量空间的接收队列,连接状态移到 CPU 内存按需管理,避免网卡内存随连接数增长。
  • SRNIC("A Scalable Architecture for RDMA NICs", NSDI 2023, 字节跳动+港科大):商用 RNIC 上万级 QP 因 per-connection 片上状态导致缓存崩溃,其 Cache-free QP Scheduler 的前提同样是——万级连接中同一时刻只有少数在活跃发包,调度器按需批量拉取 WQE、用完即弃,不为每条连接常驻硬件状态。

对本方案的含义:既然活跃连接稀疏,为全部 W 条连接常驻预注册 per-connection 接收缓冲(对端随时可发的最坏假设)就是按最坏情况买单、按平均情况浪费——这正是 §1.2 所述线性内存增长的负载侧根源。正确模型是:接收缓冲与 JFR/JFS 池化为一组固定规模的共享资源,活跃连接按需取用(§5),连接数与活跃度的解耦交给上层机制,使资源消耗由"活跃连接数 × 峰值在途量"决定,而非"总连接数 × 常驻配额"。

2.3 设备资源约束

目标设备每节点 FE 数量有限(示例:2 个)。单 FE 资源上限通过 urma_query_device 查询,每进程配额按下式推导:

每进程配额 = 单 FE 资源总量 × 每节点 FE 数 / 节点内进程数 P
2.4 传输模式约束:CTP

目标设备当前使用 CTP 传输模式(URMA_CTP,URMA 公开 API 语义)。CTP 带来三个通用约束,方案设计不依赖特定设备:

约束 说明 影响
MTU = 4K 单次 SEND 最大 4K 消息 大包走单边 READ;recv buffer ≤ 4K
TP 层无法保序 传输层不保证报文到达顺序 应用层按 seq 自保序
无 SC 无 Sequence Check 资源 WRITE with imm 的 ROT 保序模式不可用
2.5 池化引入的核心难题

池化后 JFCE(完成队列事件)共享,CQE 上来只知道来自哪个 JFS/JFR,不知道是哪条连接。必须解决:

  1. CQE 路由:把 CQE 路由回对应的 UrmaEndpoint(§4)
  2. SQ 竞争:多连接共享 SQ 的 slot 分配与公平性(§5)

流控在池化下的重新设计(credit pool、IO/FC 通道隔离、自适应 credit)将作为独立流控提案另行讨论,本 issue 先不展开(见 §9.2 合入计划批次 4)。


3. 方案优势:内存资源与连接数解耦

3.1 核心优势:内存消耗不随连接数线性增长

社区现有 per-connection 模型(#3401 当前实现)中,每条连接独占一个 JFR,每个 JFR 独占一组接收资源:RQ 深度 × recv buffer 的接收缓冲、JFC/CQE ring、驱动上下文。这些资源必须为每条连接提前放置且不可跨连接复用(对端随时可发送,RQ 中在途 WR 的 buffer 被该连接独占),因此内存随连接数 W 线性增长,O(W)。

本方案把 JFR/JFS 池化为进程级固定规模资源池:一条连接只是"池上的一条记录"(绑定一个 jetty_id 与发送窗口状态的 UrmaEndpoint),接收缓冲由 M_io × rx_depth 个共享 recv WR 组成。内存消耗 O(池规模),与 W 无关——这正是线性增长与常数驻留的本质区别。

W 级连接(W = 10,000)理论内存消耗对比(社区方案取默认参数 urma_sq_size=128、urma_rq_size=128、urma_buffer_size=8192;CQE 按 64B 估算):

内存项 社区方案(per-connection,每连接每 JFR) 本方案(池化,共享 JFR)
RQ 接收缓冲 rq_size × 8KB × W = 128 × 8KB × 10⁴ ≈ 10.24 GB(随 W 线性增长;buffer 池必须按此扩容) M_io × rx_depth × 4160B = 64 × 780 × 4160 ≈ 198 MB(固定,见 §5.6)
SQ 发送在途缓冲 上限 sq_size × 8KB × W ≈ 10.24 GB(需按 W 扩容共享池,实际受 512MB 默认池限制成为吞吐瓶颈) 共享 8K/64K 池按需(固定配置,与 W 无关)
JFC CQE ring (sq+rq) × 64B × W = 256 × 64B × 10⁴ ≈ 16 MB 池级(N_io+M_io 个 JFC)≈ 数十 MB
驱动/SDK 上下文(jetty/JFR/JFC 对象、WQE ring、DMA 一致性内存) 经验值 ~64-256KB × W ≈ 0.6-2.6 GB 池级 ~1365 个对象,< 100 MB
合计 ≈ 11-13 GB,且随 W 线性增长 ≈ 0.3-0.4 GB,与 W 无关

结论:

  • W = 1 万时,本方案内存约为社区方案的 1/30 ~ 1/40;
  • W 增长到 10 万时,per-connection 仅 RQ 接收缓冲就需要 ~102 GB(不可行),本方案内存保持不变;
  • 池规模由设备配额与内存预算推导(§2.2),与连接数解耦后可独立规划调优。
3.2 次级优势
  1. 建链开销摊销:共享池资源进程启动时一次性创建,建链仅需 round-robin 选定 JFR 并交换 jetty_id;连接建立从"创建 + 销毁一组硬件资源"降为 O(1) 记录操作,短连接/频繁重连场景收益明显。
  2. 故障恢复快:连接断开只需回收记录,无需等待硬件资源销毁与重建。
  3. 容量可预期:资源水位(recv slot、SQ 容量、内存底噪)固定,容量规划与监控指标不随 W 波动。
3.3 单边 READ 在大包场景的性能优势

大包路径采用单边 READ(§7),相对双边 SEND 切片有四方面优势:

  1. 数据面绕过对端 CPU:SEND 模式下每个字节都要经过对端"NIC DMA → 内存 → 软中断 → 协议搬运"的完整软件栈;READ 模式只有 KB 级控制消息(PULL_MEM/FREE)经过对端,数据由 NIC DMA 直写本端目标 buffer,对端 CPU 在数据面零参与。
  2. 接收资源消耗与包长解耦:CTP 下 SEND 单次 ≤ 4K,4 MB 大包需切 1024 片,占用 1024 个对端 recv buffer(接收队列压力与 RNR 丢包风险随包长线性放大);READ 单次传输长度仅受设备能力限制,接收端接收队列只承受 2 条小控制消息(PULL_MEM + FREE),共享 recv slot 不被大包突发挤占。
  3. 带宽与尾延迟稳定:数据路径不经过对端软件栈,消除对端负载抖动向传输的传导,尾延迟更稳。
  4. CPU 让渡业务:两端 CPU 只处理控制面与协议逻辑,字节搬运完全交给 NIC DMA。

4. CQE 路由:64B Header Seg

对当前社区实现的影响:需要修改。 当前实现 per-connection JFC,CQE 天然归属本连接,无需路由;JFR 创建时 max_sge=1,无 header seg 位置;user_ctx 仅用于区分 pure-ack 与数据 WR。池化后需:① JFR max_sge ≥ 2;② 新增 64B header 池与收发两侧的 header 填充/解析/回收;③ user_ctx 承载发送上下文用于 TX CQE 回收。

4.1 TX CQE vs RX CQE

TX CQE(发送完成):发送方 post WR 时 user_ctx(64 位,发送方自管)即可携带路由/回收上下文,池化不影响。

RX CQE(接收完成):需要知道消息来自哪条连接才能路由到对应 UrmaEndpoint,这是池化路由的真正难题。

4.2 可用路由信息载体
  1. user_data(JFR 级,jetty 创建时绑定):per-jetty,池化后一个 JFR 被多连接共享,无法区分连接。此路不通。
  2. 报文内容本身:发送方在数据里携带身份标识,接收方解析。这是池化下唯一途径。
4.3 定案方案:独立 header seg

核心机制:发送方 SGE[0] 单独放 64B header 携带完整路由标识,接收方 SGE[0] 固定 64B 切走 header。利用 URMA 的 SGE 不对称特性——发送方与接收方 SGE 划分可以不同,数据按字节流连续拼接后按接收方 SGE 大小切分。

header 大小固定 64B,不可更改,无需建链协商:预留 reserved 字段供扩展,两端硬编码。

SGE 布局(受设备 max_jfs_sge/max_jfr_sge 约束):

发送方 SGE (max_jfs_sge=13 为例):
  SGE[0] = header (64B)        ← URMA 层自管小缓冲(非 IOBuf block)
  SGE[1] = IOBuf block0        ← brpc 零拷贝
  ...
  SGE[n] = IOBuf blockN
  (1 header + 最多 12 data block,受 CTP 4K 限制总 data ≤ 4K)

接收方 recv WR (max_jfr_sge=4 为例):
  SGE[0] = header buffer (64B)  ← 固定头,URMA 层解析路由
  SGE[1] = 4K data block        ← data 连续落入
  (固定 2 个 SGE)

字节流切分对齐:

发送方字节流: [header 64B][data block0][data block1]...[data blockN]
接收方按 SGE 大小顺序切分:
  SGE[0] = 64B → 切走 header(天然对齐)
  SGE[1] = 4K  → data(CQE.byte_len - 64 = data 总长)

对齐前提:① header 固定 64B;② header 是发送方 SGE[0];③ 接收方 SGE[0] 也是 64B。满足后接收方无需知道发送方 SGE 划分。

header 内容:

struct UrmaMsgHeader {
    uint32_t magic;           // 魔数校验
    SocketId src_socket_id;   // 64 bit,接收方据此路由
    uint16_t seq;             // 保序 + 大包匹配
    uint8_t  type;            // 消息类型
    uint8_t  reserved1;
    uint32_t data_size;       // data SGE 总字节数
    uint32_t data_sge_count;  // data SGE 个数(校验用)
    uint8_t  reserved2[32];   // 预留扩展,凑齐 64B
};
// 固定 64 字节,不可更改

完整路由链路:

发送方:
  1. 从 header 池取 64B buffer,填 UrmaMsgHeader{src_socket_id, seq, type}
  2. SGE[0] = header, SGE[1..n] = IOBuf blocks
  3. post SEND(非 SEND_WITH_IMM,imm_data 不用)
  4. user_ctx 编码发送上下文(TX CQE 回收用)

接收方:
  1. recv WR 固定 SGE[0]=64B header, SGE[1]=4K data block
  2. CQE 上来,从 SGE[0] 读 header
  3. Socket::Address(header.src_socket_id) → UrmaEndpoint(一级路由,无查表)
  4. data 从 SGE[1] 取,交给 brpc
  5. header buffer 回收,重新 post recv

路由时序图:

image.png

权衡:

  • 优点:64 位 SocketId 完整传输(自带 version 防错配);一级路由无 conn_table;位宽不受限可扩展;不用 SEND_WITH_IMM。
  • 代价:每消息 64B 开销(小包比例明显,大包可忽略);接收侧 recv post 稍复杂;header 缓冲需独立池管理(不能走 IOBuf block 池,避免生命周期冲突)。

5. JFR/JFS 池化设计

对当前社区实现的影响:核心重构。 需要将 per-connection UrmaResource(JFCE/JFC/JFR/Jetty 独占)改为进程级共享池:① 进程启动创建共享 JFS/JFR 池;② JFCE/JFC 由每连接一个改为每池成员一个;③ 发送路径从 _sq_current 私有游标改为固定首选+随机备选选路、每 JFS MPSC 队列与单 owner 批量提交;④ 建链时 round-robin 选共享 JFR 并在 Hello 中交换 jetty_id;⑤ CQE 分发从 per-connection PollCq 改为共享 JFCE 上的统一 poll + 按连接分发。现有 prepared jetty 池(一次性预创建)可退役或改造为池化实现的基础。

5.1 池化模型总览

JFS(发送)与 JFR(接收)各自独立创建、互不绑定。本 issue 聚焦数据通道池化;流控通道(FC)的池化与 IO/FC 通道隔离随流控方案另行提案(§9.2 合入计划批次 4):

进程启动时创建(数据通道):

  JFS 池: N_io 个共享 JFS(链路固定首选,容量不足时随机选择备选,非独占)
  JFR 池: M_io 个共享 JFR,每个 JFR 对外暴露独立 jetty_id
  JFC:    每个 JFS/JFR 使用 1 个 JFC

池化架构图:

image.png

5.2 JFR 的组织方式(不用 jetty group)

每个 JFR 独立创建并对外暴露独立 jetty_id。不用 jetty group:jetty group 内部自动路由到具体 JFR,发送方与流控方无法知道报文落到哪个 JFR,per-JFR 的 credit 流控无法工作。建链时 round-robin 选定具体 JFR,把 jetty_id 交换给对端,连接 → JFR 映射明确。

5.3 建链时 round-robin 选 JFR
建链协商:
  本端 round-robin 选一个共享 JFR → jetty_id
  握手报文携带 jetty_id 发给对端

对端记录:
  remote_jetty_id = jetty_id   ← 后续 SEND target

每条连接的 UrmaEndpoint 记录:

struct UrmaEndpoint {
    SocketId   self_socket_id;   // 本端 SocketId(放进 header 给对端)
    uint32_t   remote_jetty_id;  // 对端共享 JFR 的 jetty_id
    // ...
};
5.4 JFS 池使用模型(链路亲和、随机备选与 MPSC 批量提交)

JFS 为进程级共享资源,多个逻辑链路复用少量硬件发送队列。通过固定首选与动态备选选路,并使用每 JFS 的 MPSC 请求链表和单 owner 提交机制组织并发发送。

JFS 选择与负载分流

  • 根据完整 socketid hash 确定链路首选 JFS,正常情况下优先复用,保持链路亲和。
  • 首选容量不足时,先接收其能够容纳的连续 WR 前缀;剩余部分随机抽取 4 个不同备选,排除首选,选择 inflight 最小的一个。
  • 选中的备选尽可能接收剩余 WR;未被接收的尾部留给 Socket 后续重试,不继续扫描全池。
  • 随机数使用 xoshiro256++,状态保存于 pthread TLS,避免共享生成器的同步开销。JFS 数量较少时直接检查首选之外的全部队列。

并发入队与批量提交

生产者在 owner 外准备 WR、SGE、context 和数据引用,再将请求发布到目标 JFS 的 MPSC 链表。每个 JFS 仅允许一个 owner 操作待提交队列和执行 post。

owner 将已准备好的 WR 串成链,单次最多提交 32 个;32 是上限,不等待凑满。owner 持续推进,直到队列为空或设备 SQ 配额耗尽。

请求发布参考 Socket::WriteRequest 的 exchange+link 方式;提交权使用独立的 RUNNING/KICK 原子状态管理:

  • RUNNING 表示当前已有执行者。
  • 新请求发布或 CQE 释放配额时,通过 KICK 留下推进通知。
  • 当前 owner 退出前检查通知;若有通知则重新检查队列和配额。
  • owner 已退出时,生产者或 CQE 处理者可直接接管。

该机制避免 SQ 满退出与 CQE 配额释放之间丢失通知,不增加专用 JFS bthread。

容量计数与背压

每个 JFS 分别维护:

  • sq_inflight:已接收但未完成的 WR 总量,包含软件排队,用于选路。
  • sq_device_inflight:post 中预占及设备在途配额,用于严格限制硬件 SQ 占用。

选路采用计数快照,允许并发窗口造成少量软件超量,由 JFS 队列保留;真实 post 不超过设备配额。设备计数在 post 前增加,CQE 到来时归还,post 返回后回退未被接受的后缀,覆盖 CQE 早于 post 返回的情况。

部分接收时返回实际字节数,KeepWrite 继续尝试剩余数据;零进展时返回 EAGAIN。进入等待后,只登记到固定首选 JFS,由该 JFS 上任意链路的 CQE 释放配额后触发通知。优先推进已接收队列,再根据接纳空间通知等待者。

Context 与错误处理

每个 WR 独立持有 context,通过 CQE 的 user_ctx 直接定位,移除 TX context pending 集合。批次引用与原子状态协调 post 返回和 CQE 完成,确保数据及描述符不会提前释放。

暂时无法提交的后缀保留重试;不可恢复错误异步失败受影响 Socket。已被设备接受的 WR 按完成或设备关闭后的安全回收路径处理。

初期保留 UMDK 内部队列保护,lock_free=false。

发送与唤醒流程

可接受前缀必须成功发布到目标队列并发出推进通知,才向 Socket 返回实际接收长度;未接收尾部由后续写调用重试。

Socket / KeepWrite
        │
        ▼
在 owner 外准备 WR、SGE、context 和数据引用
        │
        ▼
固定首选 JFS 接收尽可能多的连续 WR
        │
        ├─ 全部接收 ──────────────────────┐
        │                                 │
        └─ 仍有剩余                       │
              │                           │
              ▼                           │
      随机抽取 4 个不同备选               │
      选择 inflight 最小的一个             │
      接收尽可能多的剩余连续 WR            │
              │                           │
              └─────────────┬─────────────┘
                            │
              ┌─────────────┴──────────────┐
              ▼                            ▼
      存在可接受的连续前缀           零进展返回 EAGAIN
      准备发布到目标队列             等待固定首选 JFS
              │                            ▲
              ▼                            │
    发布到目标 JFS 的 MPSC 链表            │
              │                            │
              ▼                            │
          KickDrain                        │
              │                            │
       ┌──────┴──────┐                     │
       ▼             ▼                     │
   已有 owner     当前线程取得 owner        │
   留下 KICK         │                     │
       │             ▼                     │
       └─────> owner 持续排空               │
                     │                     │
                     ▼                     │
          链式 post,单次最多 32 个         │
                     │                     │
                     ▼                     │
            CQE 完成并归还配额             │
                     │                     │
                     ▼                     │
                KickDrain                  │
                     │                     │
                     ▼                     │
          优先继续推进已接收队列           │
                     │                     │
                     └─ 有接纳空间时 ──────┘

owner 退出:
    有 KICK → 重新检查并继续推进
    无 KICK → 原子释放提交权,等待下一次通知
5.5 完整发送流程
发送方 (UrmaEndpoint):
  1. 从 header 池取 64B buffer,填 UrmaMsgHeader{self_socket_id, seq, type}
  2. 构造 SGE: SGE[0]=header, SGE[1..n]=IOBuf blocks
  3. 准备 WR、context 和数据引用,target=remote_jetty_id
  4. 按固定首选+随机备选选择 JFS,将已接受前缀发布到对应 MPSC 队列
  5. 调用 KickDrain;部分接受返回实际长度,零进展无容量返回 EAGAIN

JFS owner:
  1. 取得提交权,处理已有待提交请求并接入新发布的请求
  2. 按设备配额组成最多 32 个 WR 的链,不等待凑满
  3. post 前增加设备配额计数;post 返回后回退未接受后缀
  4. 持续提交至队列空或 SQ 满,通过 RUNNING/KICK 完成交接

TX CQE:
  1. 读 cqe.user_ctx → 定位 WR context
  2. 归还设备配额和已接收计数,记录完成结果
  3. post 结果与 CQE 都确认后回收该 WR 资源;错误按 Socket 失败路径处理
  4. 调用 KickDrain 继续推进;有接纳空间时通知等待该首选 JFS 的 KeepWrite
5.6 资源配额与示例配置
每进程配额约束(§2.2 公式推导):
  JFC 总数 = N_io + M_io ≤ 每进程 jfc 配额
  JFS 总数 = N_io ≤ 每进程 jfs 配额
  JFR 总数 = M_io ≤ 每进程 jfr 配额

内存底噪:
  recv buffer = M_io × rx_depth × (64B header + 4K data)
  (JFS 的 SQ 不预注册,不占内存底噪)

示例配置(按示例配额 ~1365 与 200MB 预算推导,实际按设备配额公式计算):

M_io=64, rx_depth=780, N_io=1229, tx_depth=1024

内存核算:
  recv = 64 × 780 × 4160 ≈ 198.0 MB ≤ 200 MB ✓

容量评估:
  总 recv slot = 64 × 780 = 49,920(万级连接共享接收缓冲)
  总 SQ 容量   = 1229 × 1024 ≈ 1.26M

6. 内存池设计:4K / 8K / 64K / 64B 四池

对当前社区实现的影响:需要修改。 当前实现为单一 mmap 大池 + 单次 urma_register_seg(URMA_TOKEN_NONE,无 token 管理)+ 8KB 固定 buffer + shard free-list;GetPoolSegFor 只返回唯一 segment。需改造为:① 四种 block 池各自独立注册 Region(多 Region + token 管理);② 按地址反查 token 的 GetUrmaRegionId;③ 4K/64B 池独立分配接口(不走 blockmem_allocate);④ 64K 池供大包 READ 连续段;⑤ 分配路径 TLS 缓存 → 桶锁 → 扩 Region 三级结构。当前单池可作为 8K 池的实现基础。

6.1 设计目标

UB 需要先把内存注册(urma_register_seg)才能 RDMA 访问,注册操作耗时,因此预先注册大块内存作为池,block 粒度只做切分与回收。池化设计需要四种独立 block 大小:

block 池 大小 用途 是否劫持 IOBuf
4K 池 4096B RQ recv buffer(接收侧专用) 否,独立分配接口
8K 池 8192B(可配 8K/16K/32K) 替换 brpc IOBuf block(序列化/发送/READ 源端) 是,替换 blockmem_allocate
64K 池 65536B 大 body 序列化及大包 READ 的连续源/目标 block 是,按序列化大小选择
64B 池 64B header seg buffer(发送 + 接收) 否,独立分配接口
  • 4K block 含 IOBuf::Block header(32B),data 区 4064B:接收侧经 IOBufAsZeroCopyOutputStream 暴露给网卡写入,收完后 block 作为 IOBuf BlockRef 零拷贝交给 brpc。
  • 64K block 来自独立注册的 64K region——不能把 8K region 中相邻 block 当作连续大地址段;有效容量需扣除管理头。
  • 64B block 是裸内存、不是 IOBuf block,不走 blockmem_allocate(从 block_pool 分配会被 IOBuf 当普通 block 管理导致生命周期冲突)。

四池结构图:

image.png

6.2 核心数据结构
struct UrmaRegion {
    uintptr_t    start;      // 内存起始地址
    size_t       size;
    uint32_t     token_id;   // urma_register_seg 返回的 token
    uint8_t      eid[16];
    uint32_t     uasid;
    uint64_t     va;
};

enum BlockType : uint32_t {
    BLOCK_4K  = 0,   // RQ recv buffer
    BLOCK_8K  = 1,   // IOBuf block(可配置 8K/16K/32K)
    BLOCK_64K = 2,   // 大 body 连续 IOBuf block
    BLOCK_64B = 3,   // header seg buffer
};

struct UrmaBlockPool {
    std::vector<IdleNode*>  idle_list[4];   // 4 种 block × buckets 个桶
    std::vector<butil::Mutex*> lock[4];
    std::vector<size_t>     idle_size[4];
    int                     region_num[4];
    butil::Mutex            extend_lock;    // 扩容全局锁
};

static const size_t BLOCK_SIZES[4] = {4096, 8192, 65536, 64};
6.3 分配接口与初始化
// IOBuf 池:按请求 block_size 选择 8K 或 64K 池
void* UrmaBlockAllocate(size_t size);
void  UrmaBlockDeallocate(void* buf);

// 4K 池:RQ 预投专用
void* AllocRqBuffer();
void  FreeRqBuffer(void* buf);

// 64B 池:header seg 专用
void* AllocHeaderBuffer();
void  FreeHeaderBuffer(void* buf);
UrmaInit()
  ├─ 读取 gflags: block_8k_size_kb (8/16/32)
  ├─ 创建 UrmaBlockPool(4 种 block × buckets)
  ├─ 劫持 butil::iobuf::blockmem_allocate/deallocate → UrmaBlockAllocate/...
  ├─ ExtendBlockPool(BLOCK_4K,  initial_size_mb)
  ├─ ExtendBlockPool(BLOCK_8K,  initial_size_mb)
  ├─ ExtendBlockPool(BLOCK_64K, configured_size)
  └─ ExtendBlockPool(BLOCK_64B, initial_size_mb)
6.4 Region 查找与 RQ 预投
// 发送/READ 构造 SGE 时按地址反查 token_id
static int GetUrmaRegionId(void* buf, uint32_t* token_id) {
    // 按 [start, start+size) 扫描四种 block 池的 Region 列表
}
postRecvWr(jfr):
  block  = AllocRqBuffer();        // 4K,含 IOBuf header
  header = AllocHeaderBuffer();    // 64B
  sge[0] = {header, 64,   token(header)}
  sge[1] = {block+32, 4064, token(block)}   // 跳过 32B IOBuf header
  wr.user_ctx = 编码(block, header)          // CQE 回收用
  urma_post_jetty_recv(jfr, &wr);
6.5 接收侧零拷贝对接 IOBuf
1. CQE 上来,从 SGE[0] 读 header → Socket::Address 路由到 endpoint
2. CQE.byte_len - 64 = data 实际字节数
3. 4K block 作为 IOBuf BlockRef 挂载(IOBufAsZeroCopyOutputStream 机制)
4. cutn(data_len) 切出实际字节 append 到 _read_buf
5. header buffer 回收到 64B 池
6. 重新分配 4K block + 64B header,post 下一个 recv WR

block 生命周期通过 IOBuf nshared 引用计数管理:上层消费完 → nshared=0 → block 回 4K 池。

6.6 内存预算
接收队列固定预算 = M_io × rx_depth × 4160B
                 (示例配置下 ≈ 198 MB,见 §5.6)
总内存 = 接收队列固定预算 + 8K 池容量 + 64K 池容量 + 其他独立池容量

64K region 的 block 数量按最大并发大消息和每消息所需 block 数确定,不适用"总量 ≤ 200MB"的接收队列口径。


7. 大包单边 READ 设计(PULL_MEM / FREE)

对当前社区实现的影响:纯新增。 当前实现无任何 READ 路径:大消息按对端 recv block size 循环切多个 SEND WR,依赖 RM 语义 + RNR 重试硬扛。本节新增:① SerializeRpcMessage 按 ByteSizeLong() 选择 8K/64K block;② PULL_MEM/FREE 控制消息(数据通道 + header seg);③ READ WR 提交(源 seg=1、目标 seg≤6);④ 按 seq 的 reorder_queue 连续交付;⑤ 源/目标 buffer 生命周期表。不影响现有小包 SEND 路径。

7.1 范围与字节流语义

大包采用 READ 单边读取,控制流程使用 PULL_MEM / FREE。传输层向 brpc 提供连续、有序字节流;seq 标识字节流中的数据分片(不等于一条 RPC)。小包 SEND 数据、控制包内联数据、READ 完成数据统一按 seq 重排后交付。header+meta 与 body 可用独立 seq;header+meta 可先交付,brpc 等待 body 补齐消息。首期覆盖无 attachment、无压缩 PB 的大包路径,其余另行确定。

7.2 硬件约束与路径选择
操作 源 seg 目标 seg 说明
SEND 按 SGE 能力 按接收方布局切分 64B header + 控制内容总长 ≤ 单次 SEND 上限
READ 1 ≤ 6 远端源必须是单个连续地址段
场景 路径
完整报文可放入一次 SEND SEND
超过 SEND 上限 PULL_MEM → 接收端按描述发起一个或多个 READ
body 来自多个不连续 BlockRef 每个连续区间单独形成 READ 描述,可批量携带

READ 源 seg 上限为 1,多个不连续 BlockRef 不能拼成一个远端地址段。64K region 让较大 body 直接序列化进单个连续 block,减少 READ 数量。

7.3 body 序列化与 block 选择

序列化前通过 message.ByteSizeLong() 获取 body 大小 B:

body 大小 B 输出 block
B ≤ 8K 8K block
8K < B ≤ 32K 8K block,按有效容量形成多个 BlockRef
B > 32K 64K block,超单 block 有效容量时分配多个 64K block

8K/64K 是 block 总大小,选择与拆分按扣除管理头后的有效容量计算。典型布局:BlockRef 0 = [协议 header + meta],BlockRef 1 = [连续 body]。

7.4 数据分片与 seq

先按实际连续区间、目标容量和单次 READ 长度规划分片,再为每个数据分片分配连续 seq;控制消息本身不占数据 seq。

seq=N     header+meta,可随 PULL_MEM 内联携带
seq=N+1   body 连续源区间 A,由 READ 获取
seq=N+2   body 连续源区间 B,由 READ 获取
7.5 PULL_MEM / FREE 控制消息

沿用 64B UrmaMsgHeader,type 区分 PULL_MEM/FREE,走数据通道(共享 JFS 池)SEND:

控制 SEND: [64B header][描述数量 + 描述列表][可选 header+meta]

PULL_MEM 携带一批 {seq, src_addr, length, memory_info} READ 源描述;FREE 携带一批已完成读取的源分片标识。总长受限:header+meta 放得下时随 PULL_MEM 内联(独立 seq),否则作为 READ 描述;描述过多拆多条控制消息;一条控制消息可触发多个 READ。

7.6 READ 正常流程

image.png

  • 发送端:在远端 READ 完成前持有源 IOBuf 引用;控制 SEND 的 TX CQE 只回收控制包资源,不释放等待 READ 的源数据。
  • 接收端:一条 PULL_MEM 可连续提交多个 READ;READ CQE 成功后目标 IOBuf 按 seq 入重排队列并尝试连续交付。
7.7 按 seq 重排与完成路由
随 PULL_MEM 的 header+meta ─┐
小包 SEND 数据 ────────────┼→ reorder_queue[seq] → 从 deliver_base
READ 完成数据 ─────────────┘    连续交付,append 到 brpc 读缓冲

控制消息到达不代表其描述的数据已完成,不能据此推进数据 seq;多个 READ CQE 可乱序,只有前序 seq 连续就绪才能交付。

事件 路由/上下文 资源动作
控制 SEND RX 64B header SocketId 解析描述/内联数据,回收并补投控制接收 buffer
控制 SEND TX user_ctx → 控制发送上下文 回收 header、描述 buffer 和 SQ slot
READ TX CQE user_ctx → ReadCompletionCtx 取出目标 IOBuf、按 seq 汇合交付,回收 SQ slot

READ 完成上下文至少关联:本端 SocketId、数据 seq、所用 JFS、源分片标识、目标 IOBuf。

7.8 buffer 生命周期(正常路径)
资源 持有者 释放/转移时机
控制包 header 与描述 控制 SEND 上下文 本地控制 SEND TX CQE
READ 源数据 发送端待释放分片记录 收到对应 FREE
READ 目标数据 READ 上下文 → 重排 IOBuf → brpc READ 完成转移所有权,上层消费且引用归零后回池

失败、取消、断链场景下仍可能被 DMA 访问的 buffer 生命周期单独设计(见 §10 讨论点)。


8. 建链与协议兼容

对当前社区实现的影响:小幅扩展,核心已对齐。 当前实现的单轮 Hello(v2 二进制 URMA / v3 protobuf URM3)、import_seg 先于 import_jetty、版本不匹配降级 TCP(FALLBACK_TCP)、4B ACK 后置 URMA_ON、TCP fd 保留作 liveness,与本节设计一致。需要的扩展:① ParsedHello/UrmaHello 增加 socket_id 字段(池化消息级路由依赖);② v2 尾部 SEG1 扩展段 / v3 segments 字段通告多注册段(8K 与 64K 池);③ 通告 round-robin 选定的共享 JFR 标识替代现有单 jetty_id。

8.1 单轮 Hello 资源交换

不执行独立的"阶段 1 协商":协议标识、版本校验与本端资源信息放在同一条 Hello;版本匹配后直接导入对端资源,再以 ACK 确认。握手在独立 bthread 中通过已有 TCP fd 执行。

image.png

版本不匹配时不继续资源导入,连接回到 TCP 路径;不发送空 body 的 NegotiateMsg。

8.2 Hello 消息结构
字段 用途
协议标识 区分 URMA 二进制 Hello(URMA)或 protobuf Hello(URM3)
消息长度 限制读取范围,支持固定前缀 + 扩展段解析
hello/implementation version 校验双方握手与资源语义兼容
buffer_size、recv_buffer_cnt 对端接收 buffer 大小与共享 JFR 深度
jfr_id、EID、uasid、tp_type 导入对端接收资源、建立通信路径
socket_id 对端接收端完整 SocketId,用于池化消息级路由
seg_eid、seg_uasid、seg_va、seg_len、seg_token_id 对端注册内存段信息
segments 扩展注册段列表;分别通告 8K 与 64K 数据池 region

v2 使用 HelloMessage 固定前缀 + 尾部 SEG1 扩展(内存池列表、大包能力);v3 使用 UrmaHello 的 segments 字段。64K region 作为独立注册段通告,远端按地址范围和 token 选择对应 segment。

8.3 版本校验、TCP 降级与 ACK 时机
  • 仅当协议标识与版本均匹配且字段校验通过,才执行 urma_import_seg / urma_import_jfr;不兼容一律降级 TCP,不做字段猜测。
  • 客户端导入服务端 segment/JFR 后发 ACK;服务端收到并校验 ACK 后置 URMA_ON;JFC fd 注册到 brpc 事件处理路径,TCP fd 保留 liveness。
  • 建链时本端从共享 JFR 池 round-robin 选定接收 JFR,把 jetty_id 写入 jfr_id;流控通道的 JFR 标识随流控提案扩展。
  • Hello 携带接收端完整 socket_id;消息级控制包仍携带目标 SocketId 用于每消息路由,两者不互相替代。

9. 改造点总览与落地计划

9.1 对当前社区实现的影响总览
章节 主题 影响 改造要点
§4 CQE 路由(64B header seg) 需要修改 JFR max_sge≥2;header 池;收发路径 header 填充/解析/回收;user_ctx 承载发送上下文
§5 JFR/JFS 池化 核心重构 per-connection UrmaResource → 进程级共享池;JFCE/JFC 共享化;sq_inflight 原子计数;建链 round-robin 选 JFR;共享 CQE 分发
§6 四池内存池 需要修改 单池单 Region → 4 池多 Region + token 管理;4K/64B 独立接口;地址反查 token;64K 池新增
§7 大包 READ 纯新增 PULL_MEM/FREE、READ WR、seq 重排队列、8K/64K 序列化选择、生命周期管理
§8 建链 小幅扩展 Hello 增加 socket_id、segments 扩展段、共享 JFR 标识;状态机/降级/ACK 已对齐
§1-3 目标/约束/优势 无代码改动 设计前提与收益论证

兼容性说明:新握手字段全部放在扩展段/新增字段,旧版本收到不认识的协议标识或版本号按现有逻辑降级 TCP,双向兼容。

9.2 合入计划

性能优化部分与主线开发同步合入(不设独立长分支),按以下四批交付,每批独立可测、可回退:

批次 内容 说明
1 建链、池化、内存池(RDMA or URMA 通用;内存池需支持 64K 分片与 64B 分片) §4 CQE 路由 + §5 JFR/JFS 池化 + §6 四池内存池 + §8 握手扩展。资源模型不绑定具体后端:URMA 用共享 JFR/JFS 实现,RDMA 可用 QP + SRQ 实现同构池化,两端传输共享同一套内存池(64K 连续分片供大包 READ/序列化,64B 分片供 header seg)
2 单边:大包单边 READ 路径(§7) PULL_MEM/FREE 控制消息、READ WR 提交、8K/64K 序列化选择、按 seq 重排交付;依赖批次 1 的 64K 连续分片与握手 segments 通告
3 可靠性:保序、重连、降级、RNR 重试等故障处理 seq 重排完备化(乱序/丢失/重复场景)、断链重连时共享资源状态恢复与 header/recv buffer 回收、握手失败与版本不匹配的 TCP 降级路径(复用现有 FALLBACK_TCP)、RNR 场景兜底重试

10. 待社区讨论的问题

  1. 握手扩展的版本策略:socket_id/segments 放 v2 扩展尾段还是仅 v3 protobuf?建议 v3 优先,v2 保持只读兼容。
  2. header 大小与字节序:64B header 的多字节字段建议统一网络序,magic 取值与现有 URMA/URM3 magic 区分。
  3. 池规模参数化:N_io/M_io/rx_depth 全部以 gflags 暴露并按设备配额自动推导上限,还是提供 preset?
  4. 失败/断链下的 DMA 生命周期:READ 源 buffer 在对端未 FREE 前断链,如何保证不被回收复用(建议引入 wait-free 的分片引用表 + 断链广播失效)。
  5. 与 UBRing 的协同边界:本方案聚焦 URMA 大包/跨节点路径(路线 C 双后端格局不变),单连接内按包分流仍作为远期方向。
  6. CTP 之外的传输模式:若后续设备支持 ROT/SC 等保序模式,§4 的 seq 重排与 §7 的 READ 流程如何按能力裁剪。
  7. RDMA 后端的池化对等实现:批次 1 计划同时覆盖 RDMA(QP+SRQ)与 URMA(共享 JFR/JFS)两种后端,SRQ 的 credit 管理粒度与共享 JFR 是否对齐,欢迎有 RDMA 运维经验的同学反馈。

欢迎 @zchuango @chenBright @wwbmmm 及各位社区同学评审讨论。

Lenguaje dominante
C++
Estrellas
17.6k
Forks
4.2k
Merge medio
3 d 17 h
PR fusionados (30 d)
72

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de apache/brpc

Todos los issues de apache/brpc

Issues similares

Más issues de C++

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.