Open
UrmaTransport 池化演进:共享 JFR/JFS 资源池、大包单边路径与万级连接扩展 #23
zhangfangzuoAdd on  18 days ago
zhangfangzuoCollaborators
18 days ago Create

关联讨论:

本提案是 #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:

单进程 4 万链路 × 2 jetty/链路 = 8 万 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(示例 96,多容器部署)
单进程需支持链路数 万级(示例 4 万)
单进程内存底噪预算 可配置(示例 ≤ 200 MB)
传输语义 等价 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 私有游标改为 round-robin + sq_inflight 原子计数;④ 建链时 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(发送优先复用统一 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 池使用模型(优先复用统一 JFS + 原子计数)

JFS 池不借用不归还——始终在池中,谁都可以随时取。urma_post_jfs_wr 为线程安全 API,多 bthread 并发 post 同一 JFS 无需加锁。每个 JFS 维护原子计数器:

struct SharedJfs {
    urma_jfs_t*           jfs;
    std::atomic<uint32_t> sq_inflight;  // 当前在途 WR 数
    uint32_t              sq_depth;     // SQ 总容量
};

选取策略:优先复用统一 JFS,而非 round-robin 分散。进程内维护一个当前优先 JFS 指针(如 preferred_idx),发送时优先在同一 JFS 上 CAS 抢 slot,该 JFS 尚有余量就持续复用它;只有当前 JFS 满时才推进指针切换到下一个 JFS。这样把负载集中而不是摊开:

// 发送:优先复用当前 JFS;满了才切换下一个
bool postIoWr(urma_wr_t& wr) {
    while (true) {
        SharedJfs* jfs = &jfs_io_pool_[preferred_idx];
        uint32_t cur = jfs->sq_inflight.load(relaxed);
        if (cur < jfs->sq_depth &&
            jfs->sq_inflight.compare_exchange_weak(cur, cur + 1, acquire)) {
            if (urma_post_jfs_wr(jfs->jfs, &wr) == 0) return true;
            jfs->sq_inflight.fetch_sub(1, release);  // post 失败归还
            continue;                                // post 失败重试同槽
        }
        // 当前 JFS 满,推进指针切换下一个(可加重试上限,
        // 超限则挂 pending 队列等 CQE 归还后唤醒)
        preferred_idx = (preferred_idx + 1) % N_io;
    }
}

// TX CQE:fetch_sub 归还 slot,回收 header buffer

为什么优先复用优于 round-robin 分散:

维度 优先复用统一 JFS round-robin 分散
SQ 利用率 低活跃期少量 JFS 即可承载全部流量,其余 JFS 完全空闲 流量均匀摊到全部 N_io 个 JFS,每个都浅占用
TX CQE 处理 CQE 集中在少数 JFC 上,urma_poll_jfc 批次命中率高、轮询开销低 CQE 分散在全部 JFC,轮询多数空手而归
cache 局部性 WQE ring、JFC 结构体集中热缓存 访问模式发散,cache miss 多
突发吸收 高活跃期自动"扇开"到更多 JFS(满即切换),容量弹性保留 无差别摊开,突发与常态无区分

优先复用本质上是自然的工作集中(work consolidation):低负载 → 自动收敛到少数 JFS,收益是集中轮询与热缓存;高负载 → JFS 依次打满自动扇开,容量上限与 round-robin 完全一致。两种策略共享同一套 sq_inflight CAS 与"满则切换"逻辑,差别仅在指针推进时机,实现与验证成本低。

特点:post 前保证有 slot;全程无 mutex;低活跃集中复用、高活跃自动扇开;极端情况(全部 JFS 满)加重试上限,超过则挂 pending 队列等 CQE 归还后唤醒。

5.5 完整发送流程

发送方 (UrmaEndpoint::sendMessage):
  1. 从 header 池取 64B buffer,填 UrmaMsgHeader{self_socket_id, seq, type}
  2. 构造 SGE: SGE[0]=header, SGE[1..n]=IOBuf blocks
  3. 构造 WR: target=remote_jetty_id, user_ctx=发送上下文
  4. 优先复用统一 JFS  + 原子计数取 JFS,urma_post_jfs_wr
  5. 立即返回

TX CQE (从共享 JFCE 上来):
  1. 读 cqe.user_ctx → 解出发送上下文
  2. 归还 sq_inflight slot
  3. 回收 header buffer 到 header 池
  4. 通知 endpoint 发送完成

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 运维经验的同学反馈。

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

likedislike
ZzhangfangzuoCollaborators
18 days ago changed 领域 from [] to [boost-core]
ZzhangfangzuoCollaborators
18 days ago Change title to "UrmaTransport 池化演进:共享 JFR/JFS 资源池、大包单边路径与万级连接扩展", originally titled "UrmaTransport 池化演进:共享 JFR/JFS 资源池与万级连接扩展".
ZzhangfangzuoCollaborators
16 days ago Modify description of issue
ZzhangfangzuoCollaborators
16 days ago Modify description of issue
ZzhangfangzuoCollaborators
16 days ago Modify description of issue
ZzhangfangzuoCollaborators
16 days ago Modify description of issue
CarbonadoRainCarbonadoRainCollaborators
13 days ago Associated pull request
CarbonadoRainCarbonadoRainCollaborators
2 days ago Associated pull request
CarbonadoRainCarbonadoRainCollaborators
1 day ago Associated pull request